prpm 0.0.1

package/dist/commands/search.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Search command - Search for packages in the registry
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSearch = handleSearch;
+exports.createSearchCommand = createSearchCommand;
+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");
+/**
+ * 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;
+}
+/**
+ * Map user-friendly CLI types to registry schema
+ */
+function mapTypeToRegistry(cliType) {
+    const typeMap = {
+        rule: { type: 'cursor', tags: ['cursor-rule'] },
+        skill: { type: 'claude', tags: ['claude-skill'] },
+        agent: { type: 'claude' },
+        mcp: { type: 'generic', tags: ['mcp', 'mcp-server'] },
+        plugin: { type: 'generic', tags: ['plugin'] },
+        prompt: { type: 'generic', tags: ['prompt'] },
+        workflow: { type: 'generic', tags: ['workflow'] },
+        tool: { type: 'generic', tags: ['tool'] },
+        template: { type: 'generic', tags: ['template'] },
+    };
+    return typeMap[cliType] || {};
+}
+async function handleSearch(query, options) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    let result = null;
+    try {
+        // Allow empty query when filtering by type
+        if (query) {
+            console.log(`🔍 Searching for "${query}"...`);
+        }
+        else if (options.type) {
+            console.log(`🔍 Listing ${options.type} packages...`);
+        }
+        else {
+            console.log('❌ Please provide a search query or use --type to filter by package type');
+            console.log('\n💡 Examples:');
+            console.log('   prpm search react');
+            console.log('   prpm search --type skill');
+            console.log('   prpm search react --type rule');
+            return;
+        }
+        const config = await (0, user_config_1.getConfig)();
+        const client = (0, registry_client_1.getRegistryClient)(config);
+        // Map CLI type to registry schema
+        const searchOptions = {
+            limit: options.limit || 20,
+        };
+        if (options.type) {
+            const mapped = mapTypeToRegistry(options.type);
+            if (mapped.type) {
+                searchOptions.type = mapped.type;
+            }
+            if (mapped.tags) {
+                searchOptions.tags = mapped.tags;
+            }
+        }
+        result = await client.search(query || '', searchOptions);
+        if (result.packages.length === 0) {
+            console.log('\n❌ No packages found');
+            console.log(`\nTry:`);
+            console.log(`  - Broadening your search terms`);
+            console.log(`  - Checking spelling`);
+            console.log(`  - Browsing trending: prpm trending`);
+            return;
+        }
+        console.log(`\n✨ Found ${result.total} package(s):\n`);
+        // Display results
+        result.packages.forEach((pkg) => {
+            const badges = [];
+            if (pkg.featured || pkg.official)
+                badges.push('Official');
+            if (pkg.verified && !pkg.featured && !pkg.official)
+                badges.push('Verified');
+            const badgeStr = badges.length > 0 ? `[${badges.join(', ')}] ` : '';
+            const rating = pkg.rating_average ? `⭐ ${pkg.rating_average.toFixed(1)}` : '';
+            const downloads = pkg.total_downloads >= 1000
+                ? `${(pkg.total_downloads / 1000).toFixed(1)}k`
+                : pkg.total_downloads;
+            const typeIcon = getTypeIcon(pkg.type);
+            const typeLabel = getTypeLabel(pkg.type);
+            console.log(`${badgeStr}${pkg.display_name} ${rating}`);
+            console.log(`    ${pkg.description || 'No description'}`);
+            console.log(`    📦 ${pkg.id} | ${typeIcon} ${typeLabel} | 📥 ${downloads} | 🏷️  ${pkg.tags.slice(0, 3).join(', ')}`);
+            console.log();
+        });
+        console.log(`\n💡 Install a package: prpm install <package-id>`);
+        console.log(`   Get more info: prpm info <package-id>`);
+        if (result.total > result.packages.length) {
+            console.log(`\n   Showing ${result.packages.length} of ${result.total} results`);
+        }
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Search failed: ${error}`);
+        console.log(`\n💡 Tip: Make sure you have internet connection`);
+        console.log(`   Registry: ${process.env.PRPM_REGISTRY_URL || 'https://registry.prpm.dev'}`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'search',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                query: query.substring(0, 100),
+                type: options.type,
+                resultCount: success && result ? result.packages.length : 0,
+            },
+        });
+    }
+}
+function createSearchCommand() {
+    const command = new commander_1.Command('search');
+    command
+        .description('Search for packages in the registry')
+        .argument('[query]', 'Search query (optional when using --type)')
+        .option('--type <type>', 'Filter by package type (skill, agent, rule, plugin, prompt, workflow, tool, template, mcp)')
+        .option('--limit <number>', 'Number of results to show', '20')
+        .action(async (query, options) => {
+        const type = options.type;
+        const limit = parseInt(options.limit, 10);
+        const validTypes = ['skill', 'agent', 'rule', 'plugin', 'prompt', 'workflow', 'tool', 'template', 'mcp'];
+        if (options.type && !validTypes.includes(type)) {
+            console.error(`❌ Type must be one of: ${validTypes.join(', ')}`);
+            console.log(`\n💡 Examples:`);
+            console.log(`   prpm search postgres --type skill`);
+            console.log(`   prpm search debugging --type agent`);
+            console.log(`   prpm search react --type rule`);
+            console.log(`   prpm search --type skill  # List all skills`);
+            process.exit(1);
+        }
+        await handleSearch(query || '', { type, limit });
+    });
+    return command;
+}

package/dist/commands/telemetry.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTelemetryCommand = createTelemetryCommand;
+const commander_1 = require("commander");
+const telemetry_1 = require("../core/telemetry");
+function createTelemetryCommand() {
+    return new commander_1.Command('telemetry')
+        .description('Manage telemetry and analytics settings')
+        .addCommand(createStatusCommand(), { hidden: true })
+        .addCommand(createEnableCommand())
+        .addCommand(createDisableCommand())
+        .addCommand(createStatsCommand(), { hidden: true })
+        .addCommand(createTestCommand(), { hidden: true });
+}
+function createStatusCommand() {
+    return new commander_1.Command('status')
+        .description('Show current telemetry status')
+        .action(async () => {
+        const enabled = telemetry_1.telemetry.isEnabled();
+        const stats = await telemetry_1.telemetry.getStats();
+        console.log('📊 Telemetry Status:');
+        console.log(`   Status: ${enabled ? '✅ Enabled' : '❌ Disabled'}`);
+        console.log(`   Analytics: 📈 PostHog`);
+        console.log(`   Total events: ${stats.totalEvents}`);
+        if (stats.lastEvent) {
+            console.log(`   Last event: ${stats.lastEvent}`);
+        }
+        if (enabled) {
+            console.log('\n💡 Telemetry helps us improve the tool by collecting anonymous usage data.');
+            console.log('   Data is sent to PostHog for analysis.');
+            console.log('   Run "prpm telemetry disable" to opt out.');
+        }
+        else {
+            console.log('\n💡 Telemetry is disabled. Run "prpm telemetry enable" to help improve the tool.');
+        }
+    });
+}
+function createEnableCommand() {
+    return new commander_1.Command('enable')
+        .description('Enable telemetry and analytics')
+        .action(async () => {
+        await telemetry_1.telemetry.enable();
+        console.log('✅ Telemetry enabled');
+        console.log('📊 Anonymous usage data will be collected to help improve the tool.');
+    });
+}
+function createDisableCommand() {
+    return new commander_1.Command('disable')
+        .description('Disable telemetry and analytics')
+        .action(async () => {
+        await telemetry_1.telemetry.disable();
+        console.log('❌ Telemetry disabled');
+        console.log('📊 No usage data will be collected.');
+    });
+}
+function createStatsCommand() {
+    return new commander_1.Command('stats')
+        .description('Show telemetry statistics')
+        .action(async () => {
+        const stats = await telemetry_1.telemetry.getStats();
+        console.log('📊 Telemetry Statistics:');
+        console.log(`   Total events: ${stats.totalEvents}`);
+        if (stats.lastEvent) {
+            console.log(`   Last event: ${stats.lastEvent}`);
+        }
+    });
+}
+function createTestCommand() {
+    return new commander_1.Command('test')
+        .description('Send a test event to PostHog')
+        .action(async () => {
+        console.log('🧪 Sending test event to PostHog...');
+        try {
+            await telemetry_1.telemetry.track({
+                command: 'test',
+                success: true,
+                duration: 100,
+                data: {
+                    testType: 'manual',
+                    message: 'This is a test event from PPM CLI',
+                    timestamp: new Date().toISOString(),
+                    uniqueId: Math.random().toString(36).substring(7),
+                },
+            });
+            console.log('✅ Test event sent successfully!');
+            console.log('📈 Check your PostHog dashboard for the event: prpm_test');
+            console.log('🔗 Dashboard: https://app.posthog.com');
+            console.log('⏰ Note: Events may take 1-2 minutes to appear in the dashboard');
+            // Wait a moment for the event to be sent
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            const stats = await telemetry_1.telemetry.getStats();
+            console.log(`📊 Total events now: ${stats.totalEvents}`);
+            console.log('\n🔍 Troubleshooting tips:');
+            console.log('1. Check the "Live Events" section in PostHog');
+            console.log('2. Look for events with name "prpm_test"');
+            console.log('3. Make sure you\'re in the correct PostHog project');
+            console.log('4. Events may take 1-2 minutes to appear');
+        }
+        catch (error) {
+            console.error('❌ Failed to send test event:', error);
+        }
+    });
+}

package/dist/commands/trending.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Trending command - Show trending packages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTrending = handleTrending;
+exports.createTrendingCommand = createTrendingCommand;
+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 handleTrending(options) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        console.log(`🔥 Fetching trending packages...`);
+        const config = await (0, user_config_1.getConfig)();
+        const client = (0, registry_client_1.getRegistryClient)(config);
+        const packages = await client.getTrending(options.type, options.limit || 10);
+        if (packages.length === 0) {
+            console.log('\n❌ No trending packages found');
+            return;
+        }
+        console.log(`\n✨ Trending packages (last 7 days):\n`);
+        packages.forEach((pkg, index) => {
+            const verified = pkg.verified ? '✓' : ' ';
+            const rating = pkg.rating_average ? `⭐ ${pkg.rating_average.toFixed(1)}` : '';
+            const downloads = pkg.total_downloads >= 1000
+                ? `${(pkg.total_downloads / 1000).toFixed(1)}k`
+                : pkg.total_downloads;
+            console.log(`${index + 1}. [${verified}] ${pkg.display_name} ${rating}`);
+            console.log(`   ${pkg.description || 'No description'}`);
+            console.log(`   📦 ${pkg.id} | 📥 ${downloads} downloads`);
+            console.log();
+        });
+        console.log(`💡 Install a package: prpm install <package-id>`);
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Failed to fetch trending packages: ${error}`);
+        console.log(`\n💡 Tip: Check your internet connection`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'trending',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                type: options.type,
+                limit: options.limit || 10,
+            },
+        });
+    }
+}
+function createTrendingCommand() {
+    const command = new commander_1.Command('trending');
+    command
+        .description('Show trending packages')
+        .option('--type <type>', 'Filter by package type (cursor, claude, continue)')
+        .option('--limit <number>', 'Number of packages to show', '10')
+        .action(async (options) => {
+        const type = options.type;
+        const limit = parseInt(options.limit, 10);
+        if (options.type && !['cursor', 'claude', 'continue', 'windsurf', 'generic'].includes(type)) {
+            console.error('❌ Type must be one of: cursor, claude, continue, windsurf, generic');
+            process.exit(1);
+        }
+        await handleTrending({ type, limit });
+    });
+    return command;
+}

package/dist/commands/update.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Update command - Update packages to latest compatible versions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdate = handleUpdate;
+exports.createUpdateCommand = createUpdateCommand;
+const commander_1 = require("commander");
+const registry_client_1 = require("@prpm/registry-client");
+const user_config_1 = require("../core/user-config");
+const config_1 = require("../core/config");
+const install_1 = require("./install");
+const telemetry_1 = require("../core/telemetry");
+/**
+ * Update packages to latest minor/patch versions
+ */
+async function handleUpdate(packageName, options = {}) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    let updatedCount = 0;
+    try {
+        const config = await (0, user_config_1.getConfig)();
+        const client = (0, registry_client_1.getRegistryClient)(config);
+        const installedPackages = await (0, config_1.listPackages)();
+        if (installedPackages.length === 0) {
+            console.log('No packages installed.');
+            success = true;
+            return;
+        }
+        // Determine which packages to update
+        let packagesToUpdate = installedPackages;
+        if (packageName) {
+            // Update specific package
+            packagesToUpdate = installedPackages.filter(p => p.id === packageName);
+            if (packagesToUpdate.length === 0) {
+                throw new Error(`Package ${packageName} is not installed`);
+            }
+        }
+        console.log('🔄 Checking for updates...\n');
+        for (const pkg of packagesToUpdate) {
+            try {
+                // Get package info from registry
+                const registryPkg = await client.getPackage(pkg.id);
+                if (!registryPkg.latest_version || !pkg.version) {
+                    continue;
+                }
+                const currentVersion = pkg.version;
+                const latestVersion = registryPkg.latest_version.version;
+                // Only update if it's a minor or patch update (not major)
+                const updateType = getUpdateType(currentVersion, latestVersion);
+                if (updateType === 'major') {
+                    console.log(`⏭️  Skipping ${pkg.id} (major update ${currentVersion} → ${latestVersion}, use upgrade)`);
+                    continue;
+                }
+                if (currentVersion === latestVersion) {
+                    console.log(`✅ ${pkg.id} is already up to date (${currentVersion})`);
+                    continue;
+                }
+                console.log(`\n📦 Updating ${pkg.id}: ${currentVersion} → ${latestVersion}`);
+                // Install new version
+                await (0, install_1.handleInstall)(`${pkg.id}@${latestVersion}`, {
+                    type: pkg.type,
+                });
+                updatedCount++;
+            }
+            catch (err) {
+                console.error(`   ❌ Failed to update ${pkg.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        if (updatedCount === 0) {
+            console.log('\n✅ All packages are up to date!\n');
+        }
+        else {
+            console.log(`\n✅ Updated ${updatedCount} package(s)\n`);
+        }
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Update failed: ${error}`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'update',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                packageName,
+                updatedCount,
+            },
+        });
+    }
+}
+/**
+ * Determine update type based on semver
+ */
+function getUpdateType(current, latest) {
+    const currentParts = current.split('.').map(Number);
+    const latestParts = latest.split('.').map(Number);
+    const [currMajor = 0, currMinor = 0, currPatch = 0] = currentParts;
+    const [latestMajor = 0, latestMinor = 0, latestPatch = 0] = latestParts;
+    if (latestMajor > currMajor)
+        return 'major';
+    if (latestMinor > currMinor)
+        return 'minor';
+    return 'patch';
+}
+/**
+ * Create the update command
+ */
+function createUpdateCommand() {
+    return new commander_1.Command('update')
+        .description('Update packages to latest compatible versions (minor/patch only)')
+        .argument('[package]', 'Specific package to update (optional)')
+        .option('--all', 'Update all packages')
+        .action(handleUpdate);
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Upgrade command - Upgrade packages to latest versions (including major)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpgrade = handleUpgrade;
+exports.createUpgradeCommand = createUpgradeCommand;
+const commander_1 = require("commander");
+const registry_client_1 = require("@prpm/registry-client");
+const user_config_1 = require("../core/user-config");
+const config_1 = require("../core/config");
+const install_1 = require("./install");
+const telemetry_1 = require("../core/telemetry");
+/**
+ * Upgrade packages to latest versions (including major updates)
+ */
+async function handleUpgrade(packageName, options = {}) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    let upgradedCount = 0;
+    try {
+        const config = await (0, user_config_1.getConfig)();
+        const client = (0, registry_client_1.getRegistryClient)(config);
+        const installedPackages = await (0, config_1.listPackages)();
+        if (installedPackages.length === 0) {
+            console.log('No packages installed.');
+            success = true;
+            return;
+        }
+        // Determine which packages to upgrade
+        let packagesToUpgrade = installedPackages;
+        if (packageName) {
+            // Upgrade specific package
+            packagesToUpgrade = installedPackages.filter(p => p.id === packageName);
+            if (packagesToUpgrade.length === 0) {
+                throw new Error(`Package ${packageName} is not installed`);
+            }
+        }
+        console.log('🚀 Checking for upgrades...\n');
+        for (const pkg of packagesToUpgrade) {
+            try {
+                // Get package info from registry
+                const registryPkg = await client.getPackage(pkg.id);
+                if (!registryPkg.latest_version || !pkg.version) {
+                    continue;
+                }
+                const currentVersion = pkg.version;
+                const latestVersion = registryPkg.latest_version.version;
+                if (currentVersion === latestVersion) {
+                    console.log(`✅ ${pkg.id} is already at latest version (${currentVersion})`);
+                    continue;
+                }
+                const updateType = getUpdateType(currentVersion, latestVersion);
+                const emoji = updateType === 'major' ? '🔴' : updateType === 'minor' ? '🟡' : '🟢';
+                console.log(`\n${emoji} Upgrading ${pkg.id}: ${currentVersion} → ${latestVersion} (${updateType})`);
+                if (updateType === 'major' && !options.force) {
+                    console.log(`   ⚠️  This is a major version upgrade and may contain breaking changes`);
+                }
+                // Install new version
+                await (0, install_1.handleInstall)(`${pkg.id}@${latestVersion}`, {
+                    type: pkg.type,
+                });
+                upgradedCount++;
+            }
+            catch (err) {
+                console.error(`   ❌ Failed to upgrade ${pkg.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        if (upgradedCount === 0) {
+            console.log('\n✅ All packages are at the latest version!\n');
+        }
+        else {
+            console.log(`\n✅ Upgraded ${upgradedCount} package(s)\n`);
+        }
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Upgrade failed: ${error}`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'upgrade',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                packageName,
+                upgradedCount,
+            },
+        });
+    }
+}
+/**
+ * Determine update type based on semver
+ */
+function getUpdateType(current, latest) {
+    const currentParts = current.split('.').map(Number);
+    const latestParts = latest.split('.').map(Number);
+    const [currMajor = 0, currMinor = 0, currPatch = 0] = currentParts;
+    const [latestMajor = 0, latestMinor = 0, latestPatch = 0] = latestParts;
+    if (latestMajor > currMajor)
+        return 'major';
+    if (latestMinor > currMinor)
+        return 'minor';
+    return 'patch';
+}
+/**
+ * Create the upgrade command
+ */
+function createUpgradeCommand() {
+    return new commander_1.Command('upgrade')
+        .description('Upgrade packages to latest versions (including major updates)')
+        .argument('[package]', 'Specific package to upgrade (optional)')
+        .option('--all', 'Upgrade all packages')
+        .option('--force', 'Skip warning for major version upgrades')
+        .action(handleUpgrade);
+}

package/dist/commands/whoami.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Whoami command implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWhoami = handleWhoami;
+exports.createWhoamiCommand = createWhoamiCommand;
+const commander_1 = require("commander");
+const user_config_1 = require("../core/user-config");
+const telemetry_1 = require("../core/telemetry");
+/**
+ * Show current logged-in user
+ */
+async function handleWhoami() {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        const config = await (0, user_config_1.getConfig)();
+        if (!config.token || !config.username) {
+            console.log('Not logged in');
+            console.log('\n💡 Run "prpm login" to authenticate\n');
+            success = true;
+            return;
+        }
+        console.log(`${config.username}`);
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`❌ Error: ${error}`);
+        process.exit(1);
+    }
+    finally {
+        // Track telemetry
+        await telemetry_1.telemetry.track({
+            command: 'whoami',
+            success,
+            error,
+            duration: Date.now() - startTime,
+        });
+    }
+}
+/**
+ * Create the whoami command
+ */
+function createWhoamiCommand() {
+    return new commander_1.Command('whoami')
+        .description('Show current logged-in user')
+        .action(handleWhoami);
+}