prpm 0.0.1 → 0.0.3

package/dist/commands/install.js

@@ -42,14 +42,28 @@ const commander_1 = require("commander");
 const registry_client_1 = require("@prpm/registry-client");
 const user_config_1 = require("../core/user-config");
 const filesystem_1 = require("../core/filesystem");
-const config_1 = require("../core/config");
 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: '📋',
@@ -58,7 +72,6 @@ function getTypeIcon(type) {
         workflow: '⚡',
         tool: '🔧',
         template: '📄',
-        mcp: '🔗',
     };
     return icons[type] || '📦';
 }
@@ -67,6 +80,18 @@ function getTypeIcon(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',
@@ -75,7 +100,6 @@ function getTypeLabel(type) {
         workflow: 'Workflow',
         tool: 'Tool',
         template: 'Template',
-        mcp: 'MCP Server',
     };
     return labels[type] || type;
 }
@@ -84,8 +108,25 @@ async function handleInstall(packageSpec, options) {
     let success = false;
     let error;
     try {
-        // Parse package spec (e.g., "react-rules" or "react-rules@1.2.0")
-        const [packageId, specVersion] = packageSpec.split('@');
+        // Parse package spec (e.g., "react-rules" or "react-rules@1.2.0" or "@prpm/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);
@@ -102,21 +143,72 @@ async function handleInstall(packageSpec, options) {
             // 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);
-        // Determine format preference
-        const format = options.as || config.defaultFormat || detectProjectFormat() || 'cursor';
-        if (format !== 'canonical') {
-            console.log(`   🔄 Converting to ${format} format...`);
+        // 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.display_name} ${pkg.official ? '🏅' : ''}`);
+        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') {
@@ -136,37 +228,116 @@ async function handleInstall(packageSpec, options) {
         const tarball = await client.downloadPackage(tarballUrl, { format });
         // Extract tarball and save files
         console.log(`   📂 Extracting...`);
-        const type = options.type || pkg.type;
-        const destDir = (0, filesystem_1.getDestinationDir)(type);
-        // For MVP, assume single file in tarball
-        // TODO: Implement proper tar extraction
-        const mainFile = await extractMainFile(tarball, packageId);
-        const destPath = `${destDir}/${packageId}.md`;
-        await (0, filesystem_1.saveFile)(destPath, mainFile);
+        // 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,
+            type: pkg.type,
             format,
+            installedPath: destPath,
         });
         (0, lockfile_1.setPackageIntegrity)(updatedLockfile, packageId, tarball);
         await (0, lockfile_1.writeLockfile)(updatedLockfile);
-        // Update configuration
-        const packageRecord = {
-            id: packageId,
-            type,
-            url: tarballUrl,
-            dest: destPath,
-            version: actualVersion,
-        };
-        await (0, config_1.addPackage)(packageRecord);
+        // 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 ${pkg.total_downloads.toLocaleString()} times`);
+        console.log(`\n💡 This package has been downloaded ${newDownloadCount.toLocaleString()} times`);
         success = true;
     }
     catch (err) {
@@ -175,7 +346,6 @@ async function handleInstall(packageSpec, options) {
         console.log(`\n💡 Tips:`);
         console.log(`   - Check package name: prpm search <query>`);
         console.log(`   - Get package info: prpm info <package>`);
-        console.log(`   - Install from URL: prpm add <url> --as <type>`);
         process.exit(1);
     }
     finally {
@@ -190,26 +360,77 @@ async function handleInstall(packageSpec, options) {
                 type: options.type,
             },
         });
+        await telemetry_1.telemetry.shutdown();
     }
 }
-/**
- * Extract main file from tarball
- * TODO: Implement proper tar extraction with tar library
- */
-async function extractMainFile(tarball, packageId) {
-    // Placeholder implementation
-    // In reality, we need to:
-    // 1. Extract tar.gz
-    // 2. Find main file (from manifest or naming convention)
-    // 3. Return file contents
-    // For now, assume tarball is just gzipped content
+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) => {
-        zlib.gunzip(tarball, (err, result) => {
-            if (err)
+        // Decompress gzip first
+        zlib.gunzip(tarball, async (err, result) => {
+            if (err) {
                 reject(err);
-            else
-                resolve(result.toString('utf-8'));
+                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);
+            }
         });
     });
 }
@@ -246,7 +467,11 @@ function createInstallCommand() {
             console.error('❌ Format must be one of: cursor, claude, continue, windsurf, canonical');
             process.exit(1);
         }
-        await handleInstall(packageSpec, options);
+        await handleInstall(packageSpec, {
+            type: options.type,
+            as: options.as,
+            frozenLockfile: options.frozenLockfile
+        });
     });
     return command;
 }

package/dist/commands/list.js

@@ -2,43 +2,119 @@
 /**
  * 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 config_1 = require("../core/config");
+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
  */
-function displayPackages(packages) {
+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, ...packages.map(p => p.id.length));
-    const typeWidth = Math.max(6, ...packages.map(p => p.type.length));
-    const urlWidth = Math.max(20, ...packages.map(p => p.url.length));
-    const destWidth = Math.max(15, ...packages.map(p => p.dest.length));
+    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),
-        'URL'.padEnd(urlWidth),
-        'DESTINATION'.padEnd(destWidth)
+        'LOCATION'.padEnd(locationWidth)
     ].join(' | ');
     console.log(header);
     console.log('-'.repeat(header.length));
     // Rows
-    packages.forEach(pkg => {
+    packagesWithLocations.forEach(pkg => {
         const row = [
             pkg.id.padEnd(idWidth),
-            pkg.type.padEnd(typeWidth),
-            pkg.url.padEnd(urlWidth),
-            pkg.dest.padEnd(destWidth)
+            pkg.version.padEnd(versionWidth),
+            (pkg.type || '').padEnd(typeWidth),
+            (pkg.location || 'N/A').padEnd(locationWidth)
         ].join(' | ');
         console.log(row);
     });
@@ -54,9 +130,9 @@ async function handleList() {
     let error;
     let packageCount = 0;
     try {
-        const packages = await (0, config_1.listPackages)();
+        const packages = await (0, lockfile_1.listPackages)();
         packageCount = packages.length;
-        displayPackages(packages);
+        await displayPackages(packages);
         success = true;
     }
     catch (err) {
@@ -75,6 +151,7 @@ async function handleList() {
                 packageCount,
             },
         });
+        await telemetry_1.telemetry.shutdown();
     }
 }
 /**