prpm 0.0.1

package/dist/commands/index.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Index command implementation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleIndex = handleIndex;
+exports.createIndexCommand = createIndexCommand;
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const filesystem_1 = require("../core/filesystem");
+/**
+ * Scan directory for files and return file information
+ */
+async function scanDirectory(dirPath, type) {
+    try {
+        const files = await fs_1.promises.readdir(dirPath, { withFileTypes: true });
+        const results = [];
+        for (const file of files) {
+            if (file.isFile()) {
+                const filePath = path_1.default.join(dirPath, file.name);
+                const id = (0, filesystem_1.generateId)(file.name);
+                results.push({
+                    filePath,
+                    filename: file.name,
+                    id
+                });
+            }
+        }
+        return results;
+    }
+    catch (error) {
+        // Directory doesn't exist or can't be read
+        return [];
+    }
+}
+/**
+ * Check if a package is already registered
+ */
+function isPackageRegistered(packages, id, filePath) {
+    return packages.some(pkg => pkg.id === id || pkg.dest === filePath);
+}
+/**
+ * Handle the index command
+ */
+async function handleIndex() {
+    try {
+        console.log('🔍 Scanning for existing prompt files...');
+        // Get currently registered packages
+        const existingPackages = await (0, config_1.listPackages)();
+        console.log(`📋 Found ${existingPackages.length} already registered packages`);
+        let totalFound = 0;
+        let totalAdded = 0;
+        // Scan .cursor/rules directory
+        console.log('\n📁 Scanning .cursor/rules/...');
+        const cursorFiles = await scanDirectory('.cursor/rules', 'cursor');
+        totalFound += cursorFiles.length;
+        for (const file of cursorFiles) {
+            if (!isPackageRegistered(existingPackages, file.id, file.filePath)) {
+                const pkg = {
+                    id: file.id,
+                    type: 'cursor',
+                    url: `file://${path_1.default.resolve(file.filePath)}`, // Use file:// URL for local files
+                    dest: file.filePath
+                };
+                await (0, config_1.addPackage)(pkg);
+                console.log(`  ✅ Added: ${file.filename} (${file.id})`);
+                totalAdded++;
+            }
+            else {
+                console.log(`  ⏭️  Skipped: ${file.filename} (already registered)`);
+            }
+        }
+        // Scan .claude/agents directory
+        console.log('\n📁 Scanning .claude/agents/...');
+        const claudeFiles = await scanDirectory('.claude/agents', 'claude');
+        totalFound += claudeFiles.length;
+        for (const file of claudeFiles) {
+            if (!isPackageRegistered(existingPackages, file.id, file.filePath)) {
+                const pkg = {
+                    id: file.id,
+                    type: 'claude',
+                    url: `file://${path_1.default.resolve(file.filePath)}`, // Use file:// URL for local files
+                    dest: file.filePath
+                };
+                await (0, config_1.addPackage)(pkg);
+                console.log(`  ✅ Added: ${file.filename} (${file.id})`);
+                totalAdded++;
+            }
+            else {
+                console.log(`  ⏭️  Skipped: ${file.filename} (already registered)`);
+            }
+        }
+        // Summary
+        console.log('\n📊 Index Summary:');
+        console.log(`   📁 Total files found: ${totalFound}`);
+        console.log(`   ➕ New packages added: ${totalAdded}`);
+        console.log(`   ⏭️  Already registered: ${totalFound - totalAdded}`);
+        if (totalAdded > 0) {
+            console.log(`\n✅ Successfully indexed ${totalAdded} new packages!`);
+        }
+        else {
+            console.log('\n✨ All existing files are already registered.');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to index packages: ${error}`);
+        process.exit(1);
+    }
+}
+/**
+ * Create the index command
+ */
+function createIndexCommand() {
+    const command = new commander_1.Command('index');
+    command
+        .description('Scan existing .cursor/rules/ and .claude/agents/ directories and register unregistered files')
+        .action(handleIndex);
+    return command;
+}

package/dist/commands/info.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Info command - Display detailed package information
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInfo = handleInfo;
+exports.createInfoCommand = createInfoCommand;
+const commander_1 = require("commander");
+const registry_client_1 = require("@prpm/registry-client");
+const user_config_1 = require("../core/user-config");
+const telemetry_1 = require("../core/telemetry");
+async function handleInfo(packageId) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        console.log(`📦 Fetching package info for "${packageId}"...`);
+        const config = await (0, user_config_1.getConfig)();
+        const client = (0, registry_client_1.getRegistryClient)(config);
+        const pkg = await client.getPackage(packageId);
+        console.log('\n' + '='.repeat(60));
+        console.log(`  ${pkg.display_name} ${pkg.verified ? '✓ Verified' : ''}`);
+        console.log('='.repeat(60));
+        // Description
+        if (pkg.description) {
+            console.log(`\n📝 ${pkg.description}`);
+        }
+        // Stats
+        console.log('\n📊 Stats:');
+        console.log(`   Downloads: ${pkg.total_downloads.toLocaleString()}`);
+        if (pkg.rating_average) {
+            console.log(`   Rating: ${'⭐'.repeat(Math.round(pkg.rating_average))} (${pkg.rating_average.toFixed(1)}/5)`);
+        }
+        // Latest version
+        if (pkg.latest_version) {
+            console.log(`\n🏷️  Latest Version: ${pkg.latest_version.version}`);
+        }
+        // Tags
+        if (pkg.tags && pkg.tags.length > 0) {
+            console.log(`\n🏷️  Tags: ${pkg.tags.join(', ')}`);
+        }
+        // Type
+        console.log(`\n📂 Type: ${pkg.type}`);
+        // Installation
+        console.log('\n💻 Installation:');
+        console.log(`   prpm install ${pkg.id}`);
+        console.log(`   prpm install ${pkg.id}@${pkg.latest_version?.version || 'latest'}`);
+        console.log('\n' + '='.repeat(60));
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Failed to fetch package info: ${error}`);
+        console.log(`\n💡 Tips:`);
+        console.log(`   - Check the package ID spelling`);
+        console.log(`   - Search for packages: prpm search <query>`);
+        console.log(`   - View trending: prpm trending`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'info',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                packageId,
+            },
+        });
+    }
+}
+function createInfoCommand() {
+    const command = new commander_1.Command('info');
+    command
+        .description('Display detailed package information')
+        .argument('<package>', 'Package ID to get information about')
+        .action(async (packageId) => {
+        await handleInfo(packageId);
+    });
+    return command;
+}

package/dist/commands/install.js

@@ -0,0 +1,252 @@
+"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("@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 lockfile_1 = require("../core/lockfile");
+/**
+ * Get icon for package type
+ */
+function getTypeIcon(type) {
+    const icons = {
+        skill: '🎓',
+        agent: '🤖',
+        rule: '📋',
+        plugin: '🔌',
+        prompt: '💬',
+        workflow: '⚡',
+        tool: '🔧',
+        template: '📄',
+        mcp: '🔗',
+    };
+    return icons[type] || '📦';
+}
+/**
+ * Get human-readable label for package type
+ */
+function getTypeLabel(type) {
+    const labels = {
+        skill: 'Skill',
+        agent: 'Agent',
+        rule: 'Rule',
+        plugin: 'Plugin',
+        prompt: 'Prompt',
+        workflow: 'Workflow',
+        tool: 'Tool',
+        template: 'Template',
+        mcp: 'MCP Server',
+    };
+    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")
+        const [packageId, specVersion] = packageSpec.split('@');
+        // 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';
+        }
+        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...`);
+        }
+        // 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.description || 'No description'}`);
+        console.log(`   ${typeIcon} Type: ${typeLabel}`);
+        // 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...`);
+        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);
+        // 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,
+            format,
+        });
+        (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);
+        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`);
+        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>`);
+        console.log(`   - Install from URL: prpm add <url> --as <type>`);
+        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,
+            },
+        });
+    }
+}
+/**
+ * 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
+    const zlib = await Promise.resolve().then(() => __importStar(require('zlib')));
+    return new Promise((resolve, reject) => {
+        zlib.gunzip(tarball, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result.toString('utf-8'));
+        });
+    });
+}
+/**
+ * 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, options);
+    });
+    return command;
+}

package/dist/commands/list.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * List command implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleList = handleList;
+exports.createListCommand = createListCommand;
+const commander_1 = require("commander");
+const config_1 = require("../core/config");
+const telemetry_1 = require("../core/telemetry");
+/**
+ * Display packages in a formatted table
+ */
+function displayPackages(packages) {
+    if (packages.length === 0) {
+        console.log('📦 No packages installed');
+        return;
+    }
+    console.log('📦 Installed packages:');
+    console.log('');
+    // 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));
+    // Header
+    const header = [
+        'ID'.padEnd(idWidth),
+        'TYPE'.padEnd(typeWidth),
+        'URL'.padEnd(urlWidth),
+        'DESTINATION'.padEnd(destWidth)
+    ].join(' | ');
+    console.log(header);
+    console.log('-'.repeat(header.length));
+    // Rows
+    packages.forEach(pkg => {
+        const row = [
+            pkg.id.padEnd(idWidth),
+            pkg.type.padEnd(typeWidth),
+            pkg.url.padEnd(urlWidth),
+            pkg.dest.padEnd(destWidth)
+        ].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, config_1.listPackages)();
+        packageCount = packages.length;
+        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,
+            },
+        });
+    }
+}
+/**
+ * Create the list command
+ */
+function createListCommand() {
+    const command = new commander_1.Command('list');
+    command
+        .description('List all installed prompt packages')
+        .action(handleList);
+    return command;
+}