prpm 0.0.1 → 0.0.2

package/dist/core/claude-config.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Claude agent configuration utilities
+ * Handles applying user config to Claude agent YAML frontmatter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasClaudeHeader = hasClaudeHeader;
+exports.applyClaudeConfig = applyClaudeConfig;
+exports.parseClaudeFrontmatter = parseClaudeFrontmatter;
+/**
+ * Check if content has Claude agent YAML frontmatter
+ */
+function hasClaudeHeader(content) {
+    return content.startsWith('---\n') && content.includes('name:');
+}
+/**
+ * Apply user's Claude agent config to agent file
+ * Merges user config with existing frontmatter, with user config taking precedence
+ */
+function applyClaudeConfig(content, config) {
+    if (!hasClaudeHeader(content)) {
+        return content;
+    }
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match) {
+        return content;
+    }
+    const [, frontmatterText, body] = match;
+    // Parse existing frontmatter
+    const frontmatter = {};
+    frontmatterText.split('\n').forEach(line => {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.substring(0, colonIndex).trim();
+            const value = line.substring(colonIndex + 1).trim();
+            frontmatter[key] = value;
+        }
+    });
+    // Apply user config overrides
+    if (config.tools !== undefined) {
+        frontmatter.tools = config.tools;
+    }
+    if (config.model !== undefined) {
+        frontmatter.model = config.model;
+    }
+    // Rebuild frontmatter
+    const lines = ['---'];
+    // Ensure required fields come first
+    if (frontmatter.name) {
+        lines.push(`name: ${frontmatter.name}`);
+    }
+    if (frontmatter.description) {
+        lines.push(`description: ${frontmatter.description}`);
+    }
+    // Add optional fields
+    const optionalFields = ['icon', 'tools', 'model'];
+    for (const field of optionalFields) {
+        if (frontmatter[field] && field !== 'name' && field !== 'description') {
+            lines.push(`${field}: ${frontmatter[field]}`);
+        }
+    }
+    // Add any other fields that might exist
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (!['name', 'description', 'icon', 'tools', 'model'].includes(key)) {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    lines.push('---');
+    return lines.join('\n') + '\n' + body;
+}
+/**
+ * Parse Claude agent frontmatter
+ */
+function parseClaudeFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    const [, frontmatterText, body] = match;
+    // Simple YAML parsing (for basic key: value pairs)
+    const frontmatter = {};
+    frontmatterText.split('\n').forEach(line => {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            const key = line.substring(0, colonIndex).trim();
+            const value = line.substring(colonIndex + 1).trim();
+            frontmatter[key] = value;
+        }
+    });
+    return { frontmatter, body };
+}

package/dist/core/cursor-config.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Cursor MDC header configuration utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCursorConfig = applyCursorConfig;
+exports.hasMDCHeader = hasMDCHeader;
+exports.addMDCHeader = addMDCHeader;
+/**
+ * Apply cursor config to MDC header in content
+ * Replaces configurable fields in the YAML frontmatter
+ */
+function applyCursorConfig(content, config) {
+    // Check if content has MDC header (YAML frontmatter)
+    if (!content.startsWith('---')) {
+        return content;
+    }
+    const lines = content.split('\n');
+    const headerEndIndex = lines.findIndex((line, index) => index > 0 && line === '---');
+    if (headerEndIndex === -1) {
+        // Malformed header, return as-is
+        return content;
+    }
+    // Extract header lines (excluding the --- markers)
+    const headerLines = lines.slice(1, headerEndIndex);
+    const bodyLines = lines.slice(headerEndIndex + 1);
+    // Parse and update header
+    const updatedHeaderLines = [];
+    let i = 0;
+    while (i < headerLines.length) {
+        const line = headerLines[i];
+        // Check for fields that should be replaced by config
+        if (line.startsWith('version:') && config.version) {
+            updatedHeaderLines.push(`version: "${config.version}"`);
+            i++;
+        }
+        else if (line.startsWith('globs:') && config.globs) {
+            // Replace globs array
+            updatedHeaderLines.push('globs:');
+            config.globs.forEach((glob) => {
+                updatedHeaderLines.push(`  - "${glob}"`);
+            });
+            // Skip existing globs in the original header
+            i++;
+            while (i < headerLines.length && headerLines[i].startsWith('  - ')) {
+                i++;
+            }
+        }
+        else if (line.startsWith('alwaysApply:') && config.alwaysApply !== undefined) {
+            updatedHeaderLines.push(`alwaysApply: ${config.alwaysApply}`);
+            i++;
+        }
+        else if (line.startsWith('author:') && config.author) {
+            // Replace existing author
+            updatedHeaderLines.push(`author: "${config.author}"`);
+            i++;
+        }
+        else if (line.startsWith('tags:') && config.tags) {
+            // Replace tags array
+            updatedHeaderLines.push('tags:');
+            config.tags.forEach((tag) => {
+                updatedHeaderLines.push(`  - "${tag}"`);
+            });
+            // Skip existing tags in the original header
+            i++;
+            while (i < headerLines.length && headerLines[i].startsWith('  - ')) {
+                i++;
+            }
+        }
+        else {
+            // Keep existing line
+            updatedHeaderLines.push(line);
+            i++;
+        }
+    }
+    // Add new fields if they don't exist
+    const hasAuthor = updatedHeaderLines.some(line => line.startsWith('author:'));
+    const hasTags = updatedHeaderLines.some(line => line.startsWith('tags:'));
+    if (config.author && !hasAuthor) {
+        updatedHeaderLines.push(`author: "${config.author}"`);
+    }
+    if (config.tags && !hasTags) {
+        updatedHeaderLines.push('tags:');
+        config.tags.forEach((tag) => {
+            updatedHeaderLines.push(`  - "${tag}"`);
+        });
+    }
+    // Reconstruct content
+    return ['---', ...updatedHeaderLines, '---', ...bodyLines].join('\n');
+}
+/**
+ * Check if content has valid MDC header (YAML frontmatter)
+ * A valid MDC header must:
+ * 1. Start with ---
+ * 2. Have a closing --- on its own line
+ * 3. Have at least a description field
+ */
+function hasMDCHeader(content) {
+    if (!content.startsWith('---\n')) {
+        return false;
+    }
+    const lines = content.split('\n');
+    const headerEndIndex = lines.findIndex((line, index) => index > 0 && line === '---');
+    // Must have closing ---
+    if (headerEndIndex === -1) {
+        return false;
+    }
+    // Extract header lines (excluding the --- markers)
+    const headerLines = lines.slice(1, headerEndIndex);
+    // Must have at least one valid YAML field (typically description)
+    const hasValidField = headerLines.some(line => {
+        const trimmed = line.trim();
+        return trimmed.length > 0 && trimmed.includes(':') && !trimmed.startsWith('#');
+    });
+    return hasValidField;
+}
+/**
+ * Add MDC header to content if missing
+ * Creates a basic YAML frontmatter with description
+ */
+function addMDCHeader(content, packageDescription) {
+    const description = packageDescription || 'Cursor rule for coding standards and best practices';
+    const header = [
+        '---',
+        `description: "${description}"`,
+        '---',
+        '',
+    ].join('\n');
+    return header + content;
+}

package/dist/core/filesystem.js

@@ -12,6 +12,7 @@ exports.saveFile = saveFile;
 exports.deleteFile = deleteFile;
 exports.fileExists = fileExists;
 exports.generateId = generateId;
+exports.stripAuthorNamespace = stripAuthorNamespace;
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 /**
@@ -21,8 +22,24 @@ function getDestinationDir(type) {
     switch (type) {
         case 'cursor':
             return '.cursor/rules';
+        case 'cursor-agent':
+            return '.cursor/agents';
+        case 'cursor-slash-command':
+            return '.cursor/commands';
         case 'claude':
             return '.claude/agents';
+        case 'claude-agent':
+            return '.claude/agents';
+        case 'claude-skill':
+            return '.claude/skills';
+        case 'claude-slash-command':
+            return '.claude/commands';
+        case 'continue':
+            return '.continue/rules';
+        case 'windsurf':
+            return '.windsurf/rules';
+        case 'generic':
+            return '.prompts';
         default:
             throw new Error(`Unknown package type: ${type}`);
     }
@@ -92,3 +109,16 @@ function generateId(filename) {
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '');
 }
+/**
+ * Strip author namespace from package ID and return just the package name
+ * @example
+ * stripAuthorNamespace('@community/git-workflow-manager') // 'git-workflow-manager'
+ * stripAuthorNamespace('community/git-workflow-manager') // 'git-workflow-manager'
+ * stripAuthorNamespace('@wshobson/commands/agent-orchestration/improve-agent') // 'improve-agent'
+ * stripAuthorNamespace('git-workflow-manager') // 'git-workflow-manager'
+ */
+function stripAuthorNamespace(packageId) {
+    // Split by '/' and get the last segment (the actual package name)
+    const parts = packageId.split('/');
+    return parts[parts.length - 1];
+}

package/dist/core/lockfile.js

@@ -14,6 +14,10 @@ exports.getLockedVersion = getLockedVersion;
 exports.isLockfileOutOfSync = isLockfileOutOfSync;
 exports.mergeLockfiles = mergeLockfiles;
 exports.pruneLockfile = pruneLockfile;
+exports.addPackage = addPackage;
+exports.removePackage = removePackage;
+exports.listPackages = listPackages;
+exports.getPackage = getPackage;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const crypto_1 = require("crypto");
@@ -70,6 +74,7 @@ function addToLockfile(lockfile, packageId, packageInfo) {
         dependencies: packageInfo.dependencies,
         type: packageInfo.type,
         format: packageInfo.format,
+        installedPath: packageInfo.installedPath,
     };
     lockfile.generated = new Date().toISOString();
 }
@@ -180,3 +185,55 @@ function pruneLockfile(lockfile, requiredPackages) {
     pruned.generated = new Date().toISOString();
     return pruned;
 }
+/**
+ * Add package to lock file (convenience wrapper)
+ */
+async function addPackage(packageInfo) {
+    const lockfile = (await readLockfile()) || createLockfile();
+    addToLockfile(lockfile, packageInfo.id, {
+        version: packageInfo.version,
+        tarballUrl: packageInfo.tarballUrl,
+        dependencies: packageInfo.dependencies,
+        type: packageInfo.type,
+        format: packageInfo.format,
+        installedPath: packageInfo.installedPath,
+    });
+    await writeLockfile(lockfile);
+}
+/**
+ * Remove package from lock file
+ */
+async function removePackage(packageId) {
+    const lockfile = await readLockfile();
+    if (!lockfile || !lockfile.packages[packageId]) {
+        return null;
+    }
+    const removed = lockfile.packages[packageId];
+    delete lockfile.packages[packageId];
+    lockfile.generated = new Date().toISOString();
+    await writeLockfile(lockfile);
+    return removed;
+}
+/**
+ * List all packages in lock file
+ */
+async function listPackages() {
+    const lockfile = await readLockfile();
+    if (!lockfile) {
+        return [];
+    }
+    return Object.entries(lockfile.packages).map(([id, pkg]) => ({
+        id,
+        ...pkg,
+    }));
+}
+/**
+ * Get a specific package from lock file
+ */
+async function getPackage(packageId) {
+    const lockfile = await readLockfile();
+    if (!lockfile || !lockfile.packages[packageId]) {
+        return null;
+    }
+    return lockfile.packages[packageId];
+}

package/dist/core/marketplace-converter.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * Converter for Claude marketplace.json format to PRPM manifest
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketplaceToManifest = marketplaceToManifest;
+exports.validateMarketplaceJson = validateMarketplaceJson;
+/**
+ * Convert marketplace.json to PRPM manifest format
+ *
+ * Strategy:
+ * - If multiple plugins exist, create a manifest for the first plugin (user can publish others separately)
+ * - If the plugin has agents/skills/commands, prefer those over the root plugin info
+ * - Map marketplace fields to PRPM manifest fields
+ *
+ * @param marketplace - The marketplace.json content
+ * @param pluginIndex - Which plugin to convert (default: 0, for the first plugin)
+ * @returns PRPM manifest
+ */
+function marketplaceToManifest(marketplace, pluginIndex = 0) {
+    if (!marketplace.plugins || marketplace.plugins.length === 0) {
+        throw new Error('marketplace.json must contain at least one plugin');
+    }
+    if (pluginIndex >= marketplace.plugins.length) {
+        throw new Error(`Plugin index ${pluginIndex} out of range. Found ${marketplace.plugins.length} plugins.`);
+    }
+    const plugin = marketplace.plugins[pluginIndex];
+    // Determine package type based on what the plugin contains
+    let type = 'claude';
+    if (plugin.agents && plugin.agents.length > 0) {
+        type = 'claude';
+    }
+    else if (plugin.skills && plugin.skills.length > 0) {
+        type = 'claude';
+    }
+    else if (plugin.commands && plugin.commands.length > 0) {
+        type = 'claude';
+    }
+    // Generate package name from plugin name
+    // Format: @owner/plugin-name
+    const packageName = generatePackageName(marketplace.owner, plugin.name);
+    // Collect all files that should be included
+    const files = collectFiles(plugin);
+    // Determine the main file
+    const main = determineMainFile(plugin);
+    // Collect keywords from both marketplace and plugin
+    const keywords = [
+        ...(marketplace.keywords || []),
+        ...(plugin.keywords || []),
+    ].slice(0, 20); // Max 20 keywords
+    // Extract tags from keywords (first 10)
+    const tags = keywords.slice(0, 10);
+    const manifest = {
+        name: packageName,
+        version: plugin.version || marketplace.version || '1.0.0',
+        description: plugin.description || marketplace.description,
+        type,
+        author: plugin.author || marketplace.owner,
+        files,
+        tags,
+        keywords,
+    };
+    // Add optional fields if available
+    if (marketplace.githubUrl) {
+        manifest.repository = marketplace.githubUrl;
+    }
+    if (marketplace.websiteUrl) {
+        manifest.homepage = marketplace.websiteUrl;
+    }
+    if (plugin.category) {
+        manifest.category = plugin.category;
+    }
+    if (main) {
+        manifest.main = main;
+    }
+    return manifest;
+}
+/**
+ * Generate PRPM-compatible package name from owner and plugin name
+ */
+function generatePackageName(owner, pluginName) {
+    // Sanitize owner and plugin name
+    const sanitizedOwner = owner.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const sanitizedName = pluginName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    // Remove leading/trailing hyphens
+    const cleanOwner = sanitizedOwner.replace(/^-+|-+$/g, '');
+    const cleanName = sanitizedName.replace(/^-+|-+$/g, '');
+    return `@${cleanOwner}/${cleanName}`;
+}
+/**
+ * Collect all files referenced in the plugin
+ */
+function collectFiles(plugin) {
+    const files = new Set();
+    // Add plugin source if it's a file path
+    if (plugin.source && !plugin.source.startsWith('http')) {
+        files.add(plugin.source);
+    }
+    // Add agent files
+    if (plugin.agents) {
+        for (const agent of plugin.agents) {
+            if (agent.source && !agent.source.startsWith('http')) {
+                files.add(agent.source);
+            }
+        }
+    }
+    // Add skill files
+    if (plugin.skills) {
+        for (const skill of plugin.skills) {
+            if (skill.source && !skill.source.startsWith('http')) {
+                files.add(skill.source);
+            }
+        }
+    }
+    // Add command files
+    if (plugin.commands) {
+        for (const command of plugin.commands) {
+            if (command.source && !command.source.startsWith('http')) {
+                files.add(command.source);
+            }
+        }
+    }
+    // Add standard files if they're not already included
+    const standardFiles = ['README.md', 'LICENSE', '.claude/marketplace.json'];
+    for (const file of standardFiles) {
+        files.add(file);
+    }
+    return Array.from(files);
+}
+/**
+ * Determine the main entry file for the package
+ * Only set main if there's a single clear entry point
+ */
+function determineMainFile(plugin) {
+    const agentCount = plugin.agents?.length || 0;
+    const skillCount = plugin.skills?.length || 0;
+    const commandCount = plugin.commands?.length || 0;
+    // Only set main if there's exactly one item total
+    const totalCount = agentCount + skillCount + commandCount;
+    if (totalCount !== 1) {
+        // Multiple items or no items - no clear main file
+        return undefined;
+    }
+    // Single agent
+    if (agentCount === 1) {
+        const source = plugin.agents[0].source;
+        if (source && !source.startsWith('http')) {
+            return source;
+        }
+    }
+    // Single skill
+    if (skillCount === 1) {
+        const source = plugin.skills[0].source;
+        if (source && !source.startsWith('http')) {
+            return source;
+        }
+    }
+    // Single command
+    if (commandCount === 1) {
+        const source = plugin.commands[0].source;
+        if (source && !source.startsWith('http')) {
+            return source;
+        }
+    }
+    // Otherwise, use plugin source if available
+    if (plugin.source && !plugin.source.startsWith('http')) {
+        return plugin.source;
+    }
+    return undefined;
+}
+/**
+ * Validate marketplace.json structure
+ */
+function validateMarketplaceJson(data) {
+    if (!data || typeof data !== 'object') {
+        return false;
+    }
+    const marketplace = data;
+    // Check required fields
+    if (!marketplace.name || typeof marketplace.name !== 'string') {
+        return false;
+    }
+    if (!marketplace.owner || typeof marketplace.owner !== 'string') {
+        return false;
+    }
+    if (!marketplace.description || typeof marketplace.description !== 'string') {
+        return false;
+    }
+    if (!Array.isArray(marketplace.plugins) || marketplace.plugins.length === 0) {
+        return false;
+    }
+    // Validate first plugin has required fields
+    const plugin = marketplace.plugins[0];
+    if (!plugin.name || !plugin.description || !plugin.version) {
+        return false;
+    }
+    return true;
+}

package/dist/core/schema-validator.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * JSON Schema validation for PRPM manifests
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateManifestSchema = validateManifestSchema;
+exports.getManifestSchema = getManifestSchema;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+// Load the JSON schema
+const schemaPath = (0, path_1.join)(__dirname, '../../schemas/prpm-manifest.schema.json');
+let schema;
+try {
+    schema = JSON.parse((0, fs_1.readFileSync)(schemaPath, 'utf-8'));
+}
+catch (error) {
+    // Schema file not found, validation will be skipped
+    console.warn('⚠️  Could not load manifest schema, skipping schema validation');
+}
+/**
+ * Validate manifest against JSON schema
+ */
+function validateManifestSchema(manifest) {
+    if (!schema) {
+        // Schema not loaded, skip validation
+        return { valid: true };
+    }
+    const ajv = new ajv_1.default({
+        allErrors: true,
+        verbose: true,
+    });
+    (0, ajv_formats_1.default)(ajv);
+    const validate = ajv.compile(schema);
+    const valid = validate(manifest);
+    if (!valid && validate.errors) {
+        const errors = validate.errors.map(err => {
+            const path = err.instancePath || 'manifest';
+            const message = err.message || 'validation failed';
+            // Format error messages to be more user-friendly
+            if (err.keyword === 'required') {
+                const missingProp = err.params.missingProperty;
+                return `Missing required field: ${missingProp}`;
+            }
+            if (err.keyword === 'pattern') {
+                return `${path}: ${message}. Value does not match required pattern.`;
+            }
+            if (err.keyword === 'enum') {
+                const allowedValues = err.params.allowedValues;
+                return `${path}: ${message}. Allowed values: ${allowedValues.join(', ')}`;
+            }
+            if (err.keyword === 'minLength' || err.keyword === 'maxLength') {
+                const limit = err.params.limit;
+                return `${path}: ${message} (${err.keyword}: ${limit})`;
+            }
+            if (err.keyword === 'oneOf') {
+                return `${path}: must match exactly one schema (check if files array uses either all strings or all objects, not mixed)`;
+            }
+            return `${path}: ${message}`;
+        });
+        return { valid: false, errors };
+    }
+    return { valid: true };
+}
+/**
+ * Get the JSON schema (for documentation/export purposes)
+ */
+function getManifestSchema() {
+    return schema;
+}

package/dist/core/telemetry.js

@@ -126,11 +126,16 @@ class Telemetry {
     async shutdown() {
         if (this.posthog) {
             try {
+                // Flush any pending events before shutdown
+                await this.posthog.flush();
                 await this.posthog.shutdown();
             }
             catch (error) {
                 // Silently fail
             }
+            finally {
+                this.posthog = null;
+            }
         }
     }
     // Send to PostHog

package/dist/index.js

@@ -5,9 +5,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const add_1 = require("./commands/add");
 const list_1 = require("./commands/list");
-const remove_1 = require("./commands/remove");
+const uninstall_1 = require("./commands/uninstall");
 const index_1 = require("./commands/index");
 const telemetry_1 = require("./commands/telemetry");
 const search_1 = require("./commands/search");
@@ -18,16 +17,16 @@ const publish_1 = require("./commands/publish");
 const login_1 = require("./commands/login");
 const whoami_1 = require("./commands/whoami");
 const collections_1 = require("./commands/collections");
-const deps_1 = require("./commands/deps");
 const outdated_1 = require("./commands/outdated");
 const update_1 = require("./commands/update");
 const upgrade_1 = require("./commands/upgrade");
+const schema_1 = require("./commands/schema");
 const telemetry_2 = require("./core/telemetry");
 const program = new commander_1.Command();
 program
     .name('prpm')
     .description('Prompt Package Manager - Install and manage prompt-based files')
-    .version('1.2.0');
+    .version('0.0.1');
 // Registry commands (new)
 program.addCommand((0, search_1.createSearchCommand)());
 program.addCommand((0, install_1.createInstallCommand)());
@@ -37,16 +36,16 @@ program.addCommand((0, publish_1.createPublishCommand)());
 program.addCommand((0, login_1.createLoginCommand)());
 program.addCommand((0, whoami_1.createWhoamiCommand)());
 program.addCommand((0, collections_1.createCollectionsCommand)());
-program.addCommand((0, deps_1.createDepsCommand)());
 program.addCommand((0, outdated_1.createOutdatedCommand)());
 program.addCommand((0, update_1.createUpdateCommand)());
 program.addCommand((0, upgrade_1.createUpgradeCommand)());
 // Local file commands (existing)
-program.addCommand((0, add_1.createAddCommand)());
 program.addCommand((0, list_1.createListCommand)());
-program.addCommand((0, remove_1.createRemoveCommand)());
+program.addCommand((0, uninstall_1.createUninstallCommand)());
 program.addCommand((0, index_1.createIndexCommand)());
 program.addCommand((0, telemetry_1.createTelemetryCommand)());
+// Utility commands
+program.addCommand((0, schema_1.createSchemaCommand)());
 // Parse command line arguments
 program.parse();
 // Cleanup telemetry on exit

package/dist/types/registry.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Registry API types for CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });