prpm 1.2.1 → 2.1.0

package/dist/commands/install.js

@@ -1,477 +0,0 @@
-"use strict";
-/**
- * Install command - Install packages from registry
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleInstall = handleInstall;
-exports.createInstallCommand = createInstallCommand;
-const commander_1 = require("commander");
-const registry_client_1 = require("@pr-pm/registry-client");
-const user_config_1 = require("../core/user-config");
-const filesystem_1 = require("../core/filesystem");
-const telemetry_1 = require("../core/telemetry");
-const tar = __importStar(require("tar"));
-const lockfile_1 = require("../core/lockfile");
-const cursor_config_1 = require("../core/cursor-config");
-const claude_config_1 = require("../core/claude-config");
-/**
- * Get icon for package type
- */
-function getTypeIcon(type) {
-    const icons = {
-        'claude-skill': '🎓',
-        'claude-agent': '🤖',
-        'claude-slash-command': '⚡',
-        'claude': '🤖',
-        'cursor': '📋',
-        'cursor-agent': '🤖',
-        'cursor-slash-command': '⚡',
-        'windsurf': '🌊',
-        'continue': '➡️',
-        'mcp': '🔗',
-        'generic': '📦',
-        // Legacy mappings
-        skill: '🎓',
-        agent: '🤖',
-        rule: '📋',
-        plugin: '🔌',
-        prompt: '💬',
-        workflow: '⚡',
-        tool: '🔧',
-        template: '📄',
-    };
-    return icons[type] || '📦';
-}
-/**
- * Get human-readable label for package type
- */
-function getTypeLabel(type) {
-    const labels = {
-        'claude-skill': 'Claude Skill',
-        'claude-agent': 'Claude Agent',
-        'claude-slash-command': 'Claude Slash Command',
-        'claude': 'Claude Agent',
-        'cursor': 'Cursor Rule',
-        'cursor-agent': 'Cursor Agent',
-        'cursor-slash-command': 'Cursor Slash Command',
-        'windsurf': 'Windsurf Rule',
-        'continue': 'Continue Rule',
-        'mcp': 'MCP Server',
-        'generic': 'Package',
-        // Legacy mappings
-        skill: 'Skill',
-        agent: 'Agent',
-        rule: 'Rule',
-        plugin: 'Plugin',
-        prompt: 'Prompt',
-        workflow: 'Workflow',
-        tool: 'Tool',
-        template: 'Template',
-    };
-    return labels[type] || type;
-}
-async function handleInstall(packageSpec, options) {
-    const startTime = Date.now();
-    let success = false;
-    let error;
-    try {
-        // Parse package spec (e.g., "react-rules" or "react-rules@1.2.0" or "@pr-pm/pkg@1.0.0")
-        // For scoped packages (@scope/name), the first @ is part of the package name
-        let packageId;
-        let specVersion;
-        if (packageSpec.startsWith('@')) {
-            // Scoped package: @scope/name or @scope/name@version
-            const match = packageSpec.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
-            if (!match) {
-                throw new Error('Invalid package spec format. Use: @scope/package or @scope/package@version');
-            }
-            packageId = match[1];
-            specVersion = match[2];
-        }
-        else {
-            // Unscoped package: name or name@version
-            const parts = packageSpec.split('@');
-            packageId = parts[0];
-            specVersion = parts[1];
-        }
-        // Read existing lock file
-        const lockfile = await (0, lockfile_1.readLockfile)();
-        const lockedVersion = (0, lockfile_1.getLockedVersion)(lockfile, packageId);
-        // Determine version to install
-        let version;
-        if (options.frozenLockfile) {
-            // Frozen lockfile mode - must use exact locked version
-            if (!lockedVersion) {
-                throw new Error(`Package ${packageId} not found in lock file. Run without --frozen-lockfile to update.`);
-            }
-            version = lockedVersion;
-        }
-        else {
-            // Normal mode - use specified version or locked version or latest
-            version = options.version || specVersion || lockedVersion || 'latest';
-        }
-        // Check if package is already installed
-        if (lockfile && lockfile.packages[packageId]) {
-            const installedPkg = lockfile.packages[packageId];
-            const requestedVersion = options.version || specVersion;
-            // If no specific version requested, or same version requested
-            if (!requestedVersion || requestedVersion === 'latest' || requestedVersion === installedPkg.version) {
-                console.log(`\n✨ Package already installed!`);
-                console.log(`   📦 ${packageId}@${installedPkg.version}`);
-                console.log(`   🔄 Format: ${installedPkg.format || installedPkg.type || 'unknown'}`);
-                console.log(`\n💡 To reinstall or upgrade:`);
-                console.log(`   prpm upgrade ${packageId}     # Upgrade to latest version`);
-                console.log(`   prpm uninstall ${packageId}   # Uninstall first, then install`);
-                success = true;
-                return;
-            }
-            else if (requestedVersion !== installedPkg.version) {
-                // Different version requested - allow upgrade/downgrade
-                console.log(`📦 Upgrading ${packageId}: ${installedPkg.version} → ${requestedVersion}`);
-            }
-        }
-        console.log(`📥 Installing ${packageId}@${version}...`);
-        const config = await (0, user_config_1.getConfig)();
-        const client = (0, registry_client_1.getRegistryClient)(config);
-        // Check if this is a collection first (by trying to fetch it)
-        // Collections can be: name, scope/name, or @scope/name
-        let isCollection = false;
-        try {
-            // Try to parse as collection
-            let scope;
-            let name_slug;
-            const matchWithScope = packageId.match(/^@?([^/]+)\/([^/@]+)$/);
-            if (matchWithScope) {
-                [, scope, name_slug] = matchWithScope;
-            }
-            else {
-                // No scope, assume 'collection' scope
-                scope = 'collection';
-                name_slug = packageId;
-            }
-            // Try to fetch as collection
-            await client.getCollection(scope, name_slug, version === 'latest' ? undefined : version);
-            isCollection = true;
-            // If successful, delegate to collection install handler
-            const { handleCollectionInstall } = await Promise.resolve().then(() => __importStar(require('./collections.js')));
-            return await handleCollectionInstall(packageId, {
-                format: options.as,
-                skipOptional: false,
-                dryRun: false,
-            });
-        }
-        catch (err) {
-            // Not a collection, continue with package install
-            isCollection = false;
-        }
-        // Get package info
-        const pkg = await client.getPackage(packageId);
-        const typeIcon = getTypeIcon(pkg.type);
-        const typeLabel = getTypeLabel(pkg.type);
-        console.log(`   ${pkg.name} ${pkg.official ? '🏅' : ''}`);
-        console.log(`   ${pkg.description || 'No description'}`);
-        console.log(`   ${typeIcon} Type: ${typeLabel}`);
-        // Determine format preference - use package type if no explicit conversion requested
-        const format = options.as || pkg.type;
-        if (options.as && format !== 'canonical') {
-            console.log(`   🔄 Converting to ${format} format...`);
-        }
-        // Determine version to install
-        let tarballUrl;
-        if (version === 'latest') {
-            if (!pkg.latest_version) {
-                throw new Error('No versions available for this package');
-            }
-            tarballUrl = pkg.latest_version.tarball_url;
-            console.log(`   📦 Installing version ${pkg.latest_version.version}`);
-        }
-        else {
-            const versionInfo = await client.getPackageVersion(packageId, version);
-            tarballUrl = versionInfo.tarball_url;
-            console.log(`   📦 Installing version ${version}`);
-        }
-        // Download package in requested format
-        console.log(`   ⬇️  Downloading...`);
-        const tarball = await client.downloadPackage(tarballUrl, { format });
-        // Extract tarball and save files
-        console.log(`   📂 Extracting...`);
-        // Determine effective type based on format and original package type
-        let effectiveType;
-        if (format === 'cursor') {
-            // Map package types to cursor equivalents
-            if (pkg.type === 'claude-slash-command' || pkg.type === 'cursor-slash-command') {
-                effectiveType = 'cursor-slash-command';
-            }
-            else if (pkg.type === 'claude-agent' || pkg.type === 'cursor-agent') {
-                effectiveType = 'cursor-agent';
-            }
-            else {
-                effectiveType = 'cursor';
-            }
-        }
-        else if (format === 'claude') {
-            // Map package types to claude equivalents
-            if (pkg.type === 'cursor-slash-command' || pkg.type === 'claude-slash-command') {
-                effectiveType = 'claude-slash-command';
-            }
-            else if (pkg.type === 'cursor-agent' || pkg.type === 'claude-agent') {
-                effectiveType = 'claude-agent';
-            }
-            else if (pkg.type === 'claude-skill') {
-                effectiveType = 'claude-skill';
-            }
-            else {
-                effectiveType = 'claude-agent';
-            }
-        }
-        else if (format === 'continue' || format === 'windsurf') {
-            effectiveType = format;
-        }
-        else {
-            effectiveType = (options.type || pkg.type);
-        }
-        const destDir = (0, filesystem_1.getDestinationDir)(effectiveType);
-        // Extract all files from tarball
-        const extractedFiles = await extractTarball(tarball, packageId);
-        // Track where files were saved for user feedback
-        let destPath;
-        let fileCount = 0;
-        // Check if this is a multi-file package
-        if (extractedFiles.length === 1) {
-            // Single file package
-            let mainFile = extractedFiles[0].content;
-            // Determine file extension based on effective type
-            // Cursor rules use .mdc, but slash commands and other files use .md
-            const fileExtension = (effectiveType === 'cursor' && format === 'cursor') ? 'mdc' : 'md';
-            const packageName = (0, filesystem_1.stripAuthorNamespace)(packageId);
-            destPath = `${destDir}/${packageName}.${fileExtension}`;
-            // Handle cursor format - add header if missing for .mdc files
-            if (format === 'cursor' && effectiveType === 'cursor') {
-                if (!(0, cursor_config_1.hasMDCHeader)(mainFile)) {
-                    console.log(`   ⚠️  Adding missing MDC header...`);
-                    mainFile = (0, cursor_config_1.addMDCHeader)(mainFile, pkg.description);
-                }
-                // Apply cursor config if available
-                if (config.cursor) {
-                    console.log(`   ⚙️  Applying cursor config...`);
-                    mainFile = (0, cursor_config_1.applyCursorConfig)(mainFile, config.cursor);
-                }
-            }
-            // Apply Claude config if downloading in Claude format
-            if (format === 'claude' && (0, claude_config_1.hasClaudeHeader)(mainFile)) {
-                if (config.claude) {
-                    console.log(`   ⚙️  Applying Claude agent config...`);
-                    mainFile = (0, claude_config_1.applyClaudeConfig)(mainFile, config.claude);
-                }
-            }
-            await (0, filesystem_1.saveFile)(destPath, mainFile);
-            fileCount = 1;
-        }
-        else {
-            // Multi-file package - create directory for package
-            const packageName = (0, filesystem_1.stripAuthorNamespace)(packageId);
-            const packageDir = `${destDir}/${packageName}`;
-            destPath = packageDir;
-            console.log(`   📁 Multi-file package - creating directory: ${packageDir}`);
-            for (const file of extractedFiles) {
-                const filePath = `${packageDir}/${file.name}`;
-                await (0, filesystem_1.saveFile)(filePath, file.content);
-                fileCount++;
-            }
-        }
-        // Update or create lock file
-        const updatedLockfile = lockfile || (0, lockfile_1.createLockfile)();
-        const actualVersion = version === 'latest' ? pkg.latest_version?.version : version;
-        (0, lockfile_1.addToLockfile)(updatedLockfile, packageId, {
-            version: actualVersion || version,
-            tarballUrl,
-            type: pkg.type,
-            format,
-            installedPath: destPath,
-        });
-        (0, lockfile_1.setPackageIntegrity)(updatedLockfile, packageId, tarball);
-        await (0, lockfile_1.writeLockfile)(updatedLockfile);
-        // Update lockfile (already done above via addToLockfile + writeLockfile)
-        // No need to call addPackage again as it would be redundant
-        // Track download analytics
-        await client.trackDownload(packageId, {
-            version: actualVersion || version,
-            client: 'cli',
-            format,
-        });
-        // Display the incremented download count
-        const newDownloadCount = pkg.total_downloads + 1;
-        console.log(`\n✅ Successfully installed ${packageId}`);
-        console.log(`   📁 Saved to: ${destPath}`);
-        console.log(`   🔒 Lock file updated`);
-        console.log(`\n💡 This package has been downloaded ${newDownloadCount.toLocaleString()} times`);
-        success = true;
-    }
-    catch (err) {
-        error = err instanceof Error ? err.message : String(err);
-        console.error(`\n❌ Installation failed: ${error}`);
-        console.log(`\n💡 Tips:`);
-        console.log(`   - Check package name: prpm search <query>`);
-        console.log(`   - Get package info: prpm info <package>`);
-        process.exit(1);
-    }
-    finally {
-        await telemetry_1.telemetry.track({
-            command: 'install',
-            success,
-            error,
-            duration: Date.now() - startTime,
-            data: {
-                packageId: packageSpec.split('@')[0],
-                version: options.version || 'latest',
-                type: options.type,
-            },
-        });
-        await telemetry_1.telemetry.shutdown();
-    }
-}
-async function extractTarball(tarball, packageId) {
-    const files = [];
-    const zlib = await Promise.resolve().then(() => __importStar(require('zlib')));
-    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-    const os = await Promise.resolve().then(() => __importStar(require('os')));
-    const path = await Promise.resolve().then(() => __importStar(require('path')));
-    return new Promise((resolve, reject) => {
-        // Decompress gzip first
-        zlib.gunzip(tarball, async (err, result) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-            // Check if this is a tar archive by looking for tar header
-            const isTar = result.length > 257 && result.toString('utf-8', 257, 262) === 'ustar';
-            if (!isTar) {
-                // Not a tar archive, treat as single gzipped file
-                files.push({
-                    name: `${packageId}.md`,
-                    content: result.toString('utf-8')
-                });
-                resolve(files);
-                return;
-            }
-            // Create temp directory for extraction
-            const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'prpm-'));
-            try {
-                // Write tar data to temp file
-                const tarPath = path.join(tmpDir, 'package.tar');
-                await fs.promises.writeFile(tarPath, result);
-                // Extract using tar library
-                await tar.extract({
-                    file: tarPath,
-                    cwd: tmpDir,
-                });
-                // Read all extracted files
-                const extractedFiles = await fs.promises.readdir(tmpDir, { withFileTypes: true, recursive: true });
-                for (const entry of extractedFiles) {
-                    if (entry.isFile() && entry.name !== 'package.tar') {
-                        const filePath = path.join(entry.path || tmpDir, entry.name);
-                        const content = await fs.promises.readFile(filePath, 'utf-8');
-                        const relativePath = path.relative(tmpDir, filePath);
-                        files.push({
-                            name: relativePath,
-                            content
-                        });
-                    }
-                }
-                if (files.length === 0) {
-                    // No files found, fall back to single file
-                    files.push({
-                        name: `${packageId}.md`,
-                        content: result.toString('utf-8')
-                    });
-                }
-                // Cleanup
-                await fs.promises.rm(tmpDir, { recursive: true, force: true });
-                resolve(files);
-            }
-            catch (tarErr) {
-                // Cleanup and fall back to single file
-                await fs.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
-                files.push({
-                    name: `${packageId}.md`,
-                    content: result.toString('utf-8')
-                });
-                resolve(files);
-            }
-        });
-    });
-}
-/**
- * Detect project format from existing directories
- */
-function detectProjectFormat() {
-    const fs = require('fs');
-    if (fs.existsSync('.cursor/rules') || fs.existsSync('.cursor'))
-        return 'cursor';
-    if (fs.existsSync('.claude/agents') || fs.existsSync('.claude'))
-        return 'claude';
-    if (fs.existsSync('.continue'))
-        return 'continue';
-    if (fs.existsSync('.windsurf'))
-        return 'windsurf';
-    return null;
-}
-function createInstallCommand() {
-    const command = new commander_1.Command('install');
-    command
-        .description('Install a package from the registry')
-        .argument('<package>', 'Package to install (e.g., react-rules or react-rules@1.2.0)')
-        .option('--version <version>', 'Specific version to install')
-        .option('--type <type>', 'Override package type (cursor, claude, continue)')
-        .option('--as <format>', 'Download in specific format (cursor, claude, continue, windsurf)')
-        .option('--frozen-lockfile', 'Fail if lock file needs to be updated (for CI)')
-        .action(async (packageSpec, options) => {
-        if (options.type && !['cursor', 'claude', 'continue', 'windsurf', 'generic'].includes(options.type)) {
-            console.error('❌ Type must be one of: cursor, claude, continue, windsurf, generic');
-            process.exit(1);
-        }
-        if (options.as && !['cursor', 'claude', 'continue', 'windsurf', 'canonical'].includes(options.as)) {
-            console.error('❌ Format must be one of: cursor, claude, continue, windsurf, canonical');
-            process.exit(1);
-        }
-        await handleInstall(packageSpec, {
-            type: options.type,
-            as: options.as,
-            frozenLockfile: options.frozenLockfile
-        });
-    });
-    return command;
-}

package/dist/commands/list.js

@@ -1,166 +0,0 @@
-"use strict";
-/**
- * List command implementation
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleList = handleList;
-exports.createListCommand = createListCommand;
-const commander_1 = require("commander");
-const lockfile_1 = require("../core/lockfile");
-const telemetry_1 = require("../core/telemetry");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-/**
- * Get destination directory based on package type
- */
-function getDestinationDir(type) {
-    switch (type) {
-        case 'cursor':
-            return '.cursor/rules';
-        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';
-        case 'mcp':
-            return '.mcp';
-        default:
-            return '.prompts';
-    }
-}
-/**
- * Find the actual file location for a package
- */
-async function findPackageLocation(id, type) {
-    if (!type)
-        return null;
-    const baseDir = getDestinationDir(type);
-    // Try direct file: <dir>/<id>.md
-    const directPath = path_1.default.join(baseDir, `${id}.md`);
-    try {
-        await fs_1.promises.access(directPath);
-        return directPath;
-    }
-    catch {
-        // File doesn't exist, try subdirectory
-    }
-    // Try subdirectory: <dir>/<id>/SKILL.md or <dir>/<id>/AGENT.md
-    if (type === 'claude-skill') {
-        const skillPath = path_1.default.join(baseDir, id, 'SKILL.md');
-        try {
-            await fs_1.promises.access(skillPath);
-            return skillPath;
-        }
-        catch {
-            // Not found
-        }
-    }
-    if (type === 'claude') {
-        const agentPath = path_1.default.join(baseDir, id, 'AGENT.md');
-        try {
-            await fs_1.promises.access(agentPath);
-            return agentPath;
-        }
-        catch {
-            // Not found
-        }
-    }
-    return null;
-}
-/**
- * Display packages in a formatted table
- */
-async function displayPackages(packages) {
-    if (packages.length === 0) {
-        console.log('📦 No packages installed');
-        return;
-    }
-    console.log('📦 Installed packages:');
-    console.log('');
-    // Find file locations
-    const packagesWithLocations = await Promise.all(packages.map(async (pkg) => ({
-        ...pkg,
-        location: await findPackageLocation(pkg.id, pkg.type)
-    })));
-    // Calculate column widths
-    const idWidth = Math.max(8, ...packagesWithLocations.map(p => p.id.length));
-    const versionWidth = Math.max(7, ...packagesWithLocations.map(p => p.version.length));
-    const typeWidth = Math.max(6, ...packagesWithLocations.map(p => (p.type || '').length));
-    const locationWidth = Math.max(8, ...packagesWithLocations.map(p => (p.location || 'N/A').length));
-    // Header
-    const header = [
-        'ID'.padEnd(idWidth),
-        'VERSION'.padEnd(versionWidth),
-        'TYPE'.padEnd(typeWidth),
-        'LOCATION'.padEnd(locationWidth)
-    ].join(' | ');
-    console.log(header);
-    console.log('-'.repeat(header.length));
-    // Rows
-    packagesWithLocations.forEach(pkg => {
-        const row = [
-            pkg.id.padEnd(idWidth),
-            pkg.version.padEnd(versionWidth),
-            (pkg.type || '').padEnd(typeWidth),
-            (pkg.location || 'N/A').padEnd(locationWidth)
-        ].join(' | ');
-        console.log(row);
-    });
-    console.log('');
-    console.log(`Total: ${packages.length} package${packages.length === 1 ? '' : 's'}`);
-}
-/**
- * Handle the list command
- */
-async function handleList() {
-    const startTime = Date.now();
-    let success = false;
-    let error;
-    let packageCount = 0;
-    try {
-        const packages = await (0, lockfile_1.listPackages)();
-        packageCount = packages.length;
-        await displayPackages(packages);
-        success = true;
-    }
-    catch (err) {
-        error = err instanceof Error ? err.message : String(err);
-        console.error(`❌ Failed to list packages: ${error}`);
-        process.exit(1);
-    }
-    finally {
-        // Track telemetry
-        await telemetry_1.telemetry.track({
-            command: 'list',
-            success,
-            error,
-            duration: Date.now() - startTime,
-            data: {
-                packageCount,
-            },
-        });
-        await telemetry_1.telemetry.shutdown();
-    }
-}
-/**
- * Create the list command
- */
-function createListCommand() {
-    const command = new commander_1.Command('list');
-    command
-        .description('List all installed prompt packages')
-        .action(handleList);
-    return command;
-}