prpm 0.1.5 → 0.1.6

package/dist/commands/buy-credits.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Buy Credits command - Purchase one-time playground credits
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBuyCredits = handleBuyCredits;
+exports.createBuyCreditsCommand = createBuyCreditsCommand;
+const commander_1 = require("commander");
+const user_config_1 = require("../core/user-config");
+const telemetry_1 = require("../core/telemetry");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Make authenticated API call
+ */
+async function apiCall(endpoint) {
+    const config = await (0, user_config_1.getConfig)();
+    const baseUrl = (config.registryUrl || 'https://registry.prpm.dev').replace(/\/$/, '');
+    if (!config.token) {
+        throw new Error('Authentication required. Please run `prpm login` first.');
+    }
+    const response = await fetch(`${baseUrl}${endpoint}`, {
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+        },
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || `API request failed: ${response.statusText}`);
+    }
+    return response;
+}
+/**
+ * Get current credits balance
+ */
+async function getBalance() {
+    const response = await apiCall('/api/v1/playground/credits');
+    return response.json();
+}
+/**
+ * Open URL in default browser
+ */
+async function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+    if (platform === 'darwin') {
+        command = `open "${url}"`;
+    }
+    else if (platform === 'win32') {
+        command = `start "" "${url}"`;
+    }
+    else {
+        // Linux and other Unix-like systems
+        command = `xdg-open "${url}"`;
+    }
+    try {
+        await execAsync(command);
+    }
+    catch (error) {
+        // If automatic opening fails, just show the URL
+        console.log(`\n🔗 Please open this URL in your browser:`);
+        console.log(`   ${url}`);
+    }
+}
+/**
+ * Poll for credits balance increase
+ */
+async function pollForPurchase(initialBalance, maxAttempts = 60, intervalMs = 2000) {
+    console.log('\n⏳ Waiting for purchase confirmation...');
+    console.log('   (This may take a minute. Press Ctrl+C to cancel)');
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        try {
+            const status = await getBalance();
+            if (status.balance > initialBalance) {
+                return status.balance - initialBalance;
+            }
+            // Show progress indicator
+            if (attempt % 5 === 0 && attempt > 0) {
+                process.stdout.write('.');
+            }
+        }
+        catch (error) {
+            // Continue polling even if there's an error
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Handle the buy-credits command
+ */
+async function handleBuyCredits(options) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        const config = await (0, user_config_1.getConfig)();
+        if (!config.token) {
+            console.error('❌ Authentication required');
+            console.log('\n💡 Please login first:');
+            console.log('   prpm login');
+            process.exit(1);
+        }
+        // Get current balance
+        console.log('🔍 Checking current credits balance...');
+        const initialStatus = await getBalance();
+        console.log(`   Current balance: ${initialStatus.balance} credits`);
+        console.log('\n💰 Available credit packages:');
+        console.log('   Small:   100 credits  - $5.00  ($0.05 per credit)');
+        console.log('   Medium:  250 credits  - $11.25 ($0.045 per credit) - 10% savings');
+        console.log('   Large:   600 credits  - $24.00 ($0.04 per credit) - 20% savings');
+        console.log('\n✨ These credits never expire!');
+        console.log('💡 Tip: Subscribe to PRPM+ for 100 monthly credits at just $6/month');
+        // Build URL with package parameter if specified
+        const baseUrl = (config.registryUrl || 'https://registry.prpm.dev').replace(/api\/?$/, '');
+        let purchaseUrl = `${baseUrl}/playground/credits/buy`;
+        if (options.package) {
+            const validPackages = ['small', 'medium', 'large'];
+            if (!validPackages.includes(options.package)) {
+                console.error(`\n❌ Invalid package: ${options.package}`);
+                console.log('   Valid options: small, medium, large');
+                process.exit(1);
+            }
+            purchaseUrl += `?package=${options.package}`;
+        }
+        // Open purchase page
+        console.log(`\n🌐 Opening purchase page in your browser...`);
+        await openBrowser(purchaseUrl);
+        // Poll for purchase confirmation
+        const creditsAdded = await pollForPurchase(initialStatus.balance);
+        if (creditsAdded !== null) {
+            const updatedStatus = await getBalance();
+            console.log('\n\n🎉 Successfully purchased credits!');
+            console.log('\n📊 Credits added:');
+            console.log(`   + ${creditsAdded} credits`);
+            console.log(`   💳 New balance: ${updatedStatus.balance} credits`);
+            console.log('\n✅ You can now:');
+            console.log('   - Test packages: prpm playground <package> "<input>"');
+            console.log('   - Check balance: prpm credits');
+            console.log('   - View history:  prpm credits --history');
+            success = true;
+        }
+        else {
+            console.log('\n\n⏱️  Purchase process timed out or was canceled.');
+            console.log('\n💡 If you completed the purchase, run this to verify:');
+            console.log('   prpm credits');
+            console.log('\n💡 Or check your transaction history:');
+            console.log('   prpm credits --history');
+        }
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Purchase failed: ${error}`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'buy-credits',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                package: options.package,
+            },
+        });
+        await telemetry_1.telemetry.shutdown();
+    }
+}
+/**
+ * Create the buy-credits command
+ */
+function createBuyCreditsCommand() {
+    const command = new commander_1.Command('buy-credits');
+    command
+        .description('Purchase one-time playground credits (never expire)')
+        .option('-p, --package <package>', 'Credit package to purchase (small, medium, large)')
+        .addHelpText('after', `
+Credit Packages:
+  Small:   100 credits  - $5.00  ($0.05 per credit)
+  Medium:  250 credits  - $11.25 ($0.045 per credit) - 10% savings
+  Large:   600 credits  - $24.00 ($0.04 per credit) - 20% savings
+
+Credits Usage:
+  - Testing packages in playground uses 1-5 credits per request
+  - Token-based pricing: 1 credit = 5,000 tokens
+  - Model multipliers apply (Opus 5x, GPT-4o 2x, etc.)
+  - Credits never expire
+
+How it works:
+  1. Opens purchase page in your browser
+  2. Select package and complete payment with Stripe
+  3. Credits are added to your account immediately
+  4. Start testing packages right away
+
+Examples:
+  # Browse all packages
+  $ prpm buy-credits
+
+  # Pre-select a specific package
+  $ prpm buy-credits --package small
+  $ prpm buy-credits --package medium
+  $ prpm buy-credits --package large
+
+  # After purchase, check balance
+  $ prpm credits
+
+  # Test packages in playground
+  $ prpm playground @user/prompt "test input"
+
+💡 Better Value:
+  Subscribe to PRPM+ for 100 monthly credits at just $6/month
+  Run: prpm subscribe
+
+Note: Purchased credits are one-time and never expire, unlike monthly credits.
+`)
+        .action(async (options) => {
+        await handleBuyCredits(options);
+        process.exit(0);
+    });
+    return command;
+}

package/dist/commands/credits.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Credits command - Check and manage playground credits
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCredits = handleCredits;
+exports.createCreditsCommand = createCreditsCommand;
+const commander_1 = require("commander");
+const user_config_1 = require("../core/user-config");
+const telemetry_1 = require("../core/telemetry");
+/**
+ * Make authenticated API call
+ */
+async function apiCall(endpoint) {
+    const config = await (0, user_config_1.getConfig)();
+    const baseUrl = (config.registryUrl || "https://registry.prpm.dev").replace(/\/$/, '');
+    if (!config.token) {
+        throw new Error('Authentication required. Please run `prpm login` first.');
+    }
+    const response = await fetch(`${baseUrl}${endpoint}`, {
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+        },
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || `API request failed: ${response.statusText}`);
+    }
+    return response;
+}
+/**
+ * Display credits balance
+ */
+async function showBalance() {
+    console.log('💳 Fetching playground credits balance...\n');
+    const response = await apiCall('/api/v1/playground/credits');
+    const balance = await response.json();
+    console.log('═'.repeat(5));
+    console.log('  PLAYGROUND CREDITS BALANCE');
+    console.log('═'.repeat(5));
+    // Total balance
+    console.log(`\n💰 Total Balance: ${balance.balance} credits`);
+    // Breakdown
+    console.log('\n📊 Breakdown:');
+    if (balance.monthly_credits > 0) {
+        const monthlyRemaining = balance.monthly_credits - balance.monthly_credits_used;
+        console.log(`   Monthly (PRPM+):    ${monthlyRemaining}/${balance.monthly_credits} credits`);
+        if (balance.monthly_reset_at) {
+            const resetDate = new Date(balance.monthly_reset_at).toLocaleDateString();
+            console.log(`                       (Resets: ${resetDate})`);
+        }
+    }
+    if (balance.rollover_credits > 0) {
+        console.log(`   Rollover:           ${balance.rollover_credits} credits`);
+        if (balance.rollover_expires_at) {
+            const expiresDate = new Date(balance.rollover_expires_at).toLocaleDateString();
+            console.log(`                       (Expires: ${expiresDate})`);
+        }
+    }
+    if (balance.purchased_credits > 0) {
+        console.log(`   Purchased:          ${balance.purchased_credits} credits`);
+        console.log(`                       (Never expire)`);
+    }
+    // PRPM+ Status
+    if (balance.prpm_plus_status === 'active') {
+        console.log('\n✨ PRPM+ Active - You get 100 monthly credits!');
+    }
+    else {
+        console.log('\n💡 Upgrade to PRPM+ for 100 monthly credits');
+        console.log('   Visit: https://prpm.dev/pricing');
+    }
+    console.log('\n═'.repeat(5));
+}
+/**
+ * Display recent credit transactions
+ */
+async function showHistory(limit = 10) {
+    console.log(`💳 Fetching recent credit transactions...\n`);
+    const response = await apiCall(`/api/v1/playground/credits/history?limit=${limit}`);
+    const data = await response.json();
+    if (data.transactions.length === 0) {
+        console.log('No transaction history yet.');
+        return;
+    }
+    console.log('═'.repeat(5));
+    console.log('  CREDIT TRANSACTION HISTORY');
+    console.log('═'.repeat(5));
+    console.log();
+    for (const tx of data.transactions) {
+        const date = new Date(tx.created_at).toLocaleString();
+        const amount = tx.amount >= 0 ? `+${tx.amount}` : `${tx.amount}`;
+        const emoji = tx.amount >= 0 ? '💰' : '💸';
+        console.log(`${emoji} ${date}`);
+        console.log(`   Type:     ${tx.transaction_type}`);
+        console.log(`   Amount:   ${amount} credits`);
+        console.log(`   Balance:  ${tx.balance_after} credits`);
+        console.log(`   Details:  ${tx.description}`);
+        console.log();
+    }
+    console.log('═'.repeat(5));
+}
+/**
+ * Handle the credits command
+ */
+async function handleCredits(options) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        const config = await (0, user_config_1.getConfig)();
+        if (!config.token) {
+            console.error('❌ Authentication required');
+            console.log('\n💡 Please login first:');
+            console.log('   prpm login');
+            process.exit(1);
+        }
+        if (options.history) {
+            await showHistory(options.limit || 10);
+        }
+        else {
+            await showBalance();
+        }
+        console.log('\n💡 Tips:');
+        console.log('   - Test packages:      prpm playground <package> "<input>"');
+        console.log('   - View history:       prpm credits --history');
+        console.log('   - Purchase credits:   prpm buy-credits');
+        console.log('   - Subscribe to PRPM+: prpm subscribe');
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Failed to fetch credits: ${error}`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'credits',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                showHistory: options.history || false,
+            },
+        });
+        await telemetry_1.telemetry.shutdown();
+    }
+}
+/**
+ * Create the credits command
+ */
+function createCreditsCommand() {
+    const command = new commander_1.Command('credits');
+    command
+        .description('Check playground credits balance and transaction history')
+        .option('-h, --history', 'Show transaction history instead of balance', false)
+        .option('-l, --limit <number>', 'Number of transactions to show in history', '10')
+        .addHelpText('after', `
+Examples:
+  # Check current balance
+  $ prpm credits
+
+  # View transaction history
+  $ prpm credits --history
+
+  # View last 20 transactions
+  $ prpm credits --history --limit 20
+
+Credits are used for:
+  - Testing packages in the playground
+  - Running prompts with AI models
+  - Comparing packages against baselines
+
+Get more credits:
+  - PRPM+ subscribers get 100 monthly credits
+  - Purchase additional credits at https://prpm.dev/playground/credits/buy
+  - Free tier gets 5 trial credits
+`)
+        .action(async (options) => {
+        await handleCredits({
+            history: options.history,
+            limit: options.limit ? parseInt(options.limit, 10) : undefined,
+        });
+        process.exit(0);
+    });
+    return command;
+}

package/dist/commands/hooks.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Hooks command - Manage git hooks for running agents
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHooksCommand = createHooksCommand;
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Check if we're in a git repository
+ */
+function isGitRepo() {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the git hooks directory
+ */
+function getGitHooksDir() {
+    try {
+        const gitDir = (0, child_process_1.execSync)('git rev-parse --git-dir', { encoding: 'utf-8' }).trim();
+        return (0, path_1.join)(gitDir, 'hooks');
+    }
+    catch (error) {
+        throw new Error('Not in a git repository');
+    }
+}
+/**
+ * Create hooks configuration file template
+ */
+function createHooksConfig() {
+    const configDir = '.prpm';
+    const configPath = (0, path_1.join)(configDir, 'hooks.json');
+    if ((0, fs_1.existsSync)(configPath)) {
+        console.log(chalk_1.default.yellow(`⚠️  Hooks configuration already exists at ${configPath}`));
+        return;
+    }
+    // Create .prpm directory if it doesn't exist
+    if (!(0, fs_1.existsSync)(configDir)) {
+        (0, fs_1.mkdirSync)(configDir, { recursive: true });
+    }
+    const template = {
+        hooks: {
+            'pre-commit': {
+                enabled: true,
+                agents: [
+                    {
+                        name: '@pre-commit/security-scanner',
+                        files: '**/*.{js,ts,py}',
+                        severity: 'error',
+                        autoFix: false,
+                    },
+                ],
+            },
+        },
+        settings: {
+            enabled: true,
+            timeout: 30000,
+            cache: {
+                enabled: true,
+                ttl: 3600,
+            },
+        },
+    };
+    (0, fs_1.writeFileSync)(configPath, JSON.stringify(template, null, 2));
+    console.log(chalk_1.default.green(`✓ Created hooks configuration at ${configPath}`));
+    console.log(chalk_1.default.dim('\nEdit this file to configure which agents run on git hooks.'));
+    console.log(chalk_1.default.dim('Install agents with: prpm install @pre-commit/security-scanner\n'));
+}
+/**
+ * Install git hooks
+ */
+async function handleInstall() {
+    if (!isGitRepo()) {
+        console.error(chalk_1.default.red('✗ Not in a git repository'));
+        console.log(chalk_1.default.dim('Run this command from the root of your git repository.\n'));
+        process.exit(1);
+    }
+    const hooksDir = getGitHooksDir();
+    const configPath = (0, path_1.join)('.prpm', 'hooks.json');
+    // Create hooks config if it doesn't exist
+    if (!(0, fs_1.existsSync)(configPath)) {
+        createHooksConfig();
+    }
+    // Create hooks directory if it doesn't exist
+    if (!(0, fs_1.existsSync)(hooksDir)) {
+        (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+    }
+    // Create pre-commit hook
+    const preCommitHook = (0, path_1.join)(hooksDir, 'pre-commit');
+    const hookScript = `#!/bin/sh
+# PRPM pre-commit hook
+# Generated by prpm hooks install
+
+# Run PRPM hooks command
+prpm hooks run pre-commit
+
+# Exit with the same code as the hooks command
+exit $?
+`;
+    (0, fs_1.writeFileSync)(preCommitHook, hookScript);
+    (0, fs_1.chmodSync)(preCommitHook, 0o755);
+    console.log(chalk_1.default.green('✓ Git hooks installed successfully'));
+    console.log(chalk_1.default.dim(`\nInstalled hooks:`));
+    console.log(chalk_1.default.dim(`  - pre-commit → ${preCommitHook}`));
+    console.log(chalk_1.default.dim(`\nConfiguration: ${configPath}`));
+    console.log(chalk_1.default.dim('\nRun ') + chalk_1.default.cyan('prpm hooks uninstall') + chalk_1.default.dim(' to remove hooks.\n'));
+}
+/**
+ * Uninstall git hooks
+ */
+async function handleUninstall() {
+    if (!isGitRepo()) {
+        console.error(chalk_1.default.red('✗ Not in a git repository'));
+        process.exit(1);
+    }
+    const hooksDir = getGitHooksDir();
+    const preCommitHook = (0, path_1.join)(hooksDir, 'pre-commit');
+    if ((0, fs_1.existsSync)(preCommitHook)) {
+        // Check if it's a PRPM hook
+        const content = (0, fs_1.readFileSync)(preCommitHook, 'utf-8');
+        if (content.includes('PRPM pre-commit hook')) {
+            (0, fs_1.unlinkSync)(preCommitHook);
+            console.log(chalk_1.default.green('✓ PRPM git hooks uninstalled successfully'));
+            console.log(chalk_1.default.dim(`\nRemoved: ${preCommitHook}\n`));
+        }
+        else {
+            console.log(chalk_1.default.yellow('⚠️  Pre-commit hook exists but was not installed by PRPM'));
+            console.log(chalk_1.default.dim('Will not remove it. Please remove manually if needed.\n'));
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('⚠️  No PRPM hooks found'));
+        console.log(chalk_1.default.dim('Hooks may have already been removed.\n'));
+    }
+}
+/**
+ * Run hooks for a specific event (pre-commit, pre-push, etc.)
+ */
+async function handleRun(hookType) {
+    const configPath = (0, path_1.join)('.prpm', 'hooks.json');
+    if (!(0, fs_1.existsSync)(configPath)) {
+        console.error(chalk_1.default.red('✗ Hooks configuration not found'));
+        console.log(chalk_1.default.dim(`Run ${chalk_1.default.cyan('prpm hooks install')} to set up hooks.\n`));
+        process.exit(1);
+    }
+    // Read configuration
+    const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+    // Check if hooks are globally enabled
+    if (config.settings?.enabled === false) {
+        console.log(chalk_1.default.dim('ℹ️  Hooks are disabled in configuration'));
+        process.exit(0);
+    }
+    // Get hook configuration
+    const hookConfig = config.hooks?.[hookType];
+    if (!hookConfig || !hookConfig.enabled) {
+        console.log(chalk_1.default.dim(`ℹ️  ${hookType} hook is not enabled`));
+        process.exit(0);
+    }
+    // Check if any agents are configured
+    if (!hookConfig.agents || hookConfig.agents.length === 0) {
+        console.log(chalk_1.default.dim(`ℹ️  No agents configured for ${hookType}`));
+        process.exit(0);
+    }
+    console.log(chalk_1.default.blue(`\n🔍 Running ${hookType} checks...\n`));
+    // TODO: Implement agent execution
+    // For now, just show what would be executed
+    let hasErrors = false;
+    for (const agent of hookConfig.agents) {
+        if (!agent.enabled) {
+            continue;
+        }
+        console.log(chalk_1.default.dim(`  Checking with ${agent.name}...`));
+        // TODO: Execute agent here
+        // This is a placeholder - actual implementation will:
+        // 1. Get staged files (for pre-commit) using git diff --cached --name-only
+        // 2. Filter files by glob pattern (agent.files)
+        // 3. Load agent package
+        // 4. Execute agent via Anthropic SDK
+        // 5. Process results and show output
+        console.log(chalk_1.default.yellow(`    ⚠️  Not implemented yet - would check files matching: ${agent.files}`));
+        if (agent.severity === 'error') {
+            // hasErrors = true; // Uncomment when implemented
+        }
+    }
+    if (hasErrors) {
+        console.log(chalk_1.default.red('\n✗ Checks failed. Please fix the issues above.\n'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green('\n✓ All checks passed\n'));
+    process.exit(0);
+}
+/**
+ * Show status of installed hooks
+ */
+async function handleStatus() {
+    if (!isGitRepo()) {
+        console.error(chalk_1.default.red('✗ Not in a git repository'));
+        process.exit(1);
+    }
+    const hooksDir = getGitHooksDir();
+    const configPath = (0, path_1.join)('.prpm', 'hooks.json');
+    const preCommitHook = (0, path_1.join)(hooksDir, 'pre-commit');
+    console.log(chalk_1.default.blue('\n📋 PRPM Hooks Status\n'));
+    // Check if hooks are installed
+    let hooksInstalled = false;
+    if ((0, fs_1.existsSync)(preCommitHook)) {
+        const content = (0, fs_1.readFileSync)(preCommitHook, 'utf-8');
+        if (content.includes('PRPM pre-commit hook')) {
+            hooksInstalled = true;
+            console.log(chalk_1.default.green('✓ Git hooks: Installed'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('⚠️  Git hooks: Other hook exists'));
+        }
+    }
+    else {
+        console.log(chalk_1.default.red('✗ Git hooks: Not installed'));
+    }
+    // Check if config exists
+    if ((0, fs_1.existsSync)(configPath)) {
+        console.log(chalk_1.default.green(`✓ Configuration: ${configPath}`));
+        const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        const enabled = config.settings?.enabled !== false;
+        console.log(chalk_1.default.dim(`  Enabled: ${enabled ? 'yes' : 'no'}`));
+        // Show configured hooks
+        if (config.hooks) {
+            const hookTypes = Object.keys(config.hooks);
+            if (hookTypes.length > 0) {
+                console.log(chalk_1.default.dim(`\n  Configured hooks:`));
+                for (const hookType of hookTypes) {
+                    const hookConfig = config.hooks[hookType];
+                    const agentCount = hookConfig.agents?.length || 0;
+                    const hookEnabled = hookConfig.enabled !== false;
+                    const status = hookEnabled ? chalk_1.default.green('enabled') : chalk_1.default.dim('disabled');
+                    console.log(chalk_1.default.dim(`    - ${hookType}: ${status}, ${agentCount} agent(s)`));
+                }
+            }
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('⚠️  Configuration: Not found'));
+    }
+    console.log();
+}
+/**
+ * Create the hooks command
+ */
+function createHooksCommand() {
+    const hooksCommand = new commander_1.Command('hooks')
+        .description('Manage git hooks for running agents on code changes');
+    hooksCommand
+        .command('install')
+        .description('Install PRPM git hooks')
+        .action(handleInstall);
+    hooksCommand
+        .command('uninstall')
+        .description('Uninstall PRPM git hooks')
+        .action(handleUninstall);
+    hooksCommand
+        .command('run <hook-type>')
+        .description('Run agents for a specific hook (used internally by git)')
+        .action(handleRun);
+    hooksCommand
+        .command('status')
+        .description('Show status of installed hooks and configuration')
+        .action(handleStatus);
+    return hooksCommand;
+}

package/dist/commands/playground.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Playground command - Test packages with AI models
+ */
+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.handlePlayground = handlePlayground;
+exports.createPlaygroundCommand = createPlaygroundCommand;
+const commander_1 = require("commander");
+const user_config_1 = require("../core/user-config");
+const telemetry_1 = require("../core/telemetry");
+const readline = __importStar(require("readline"));
+/**
+ * Create a readline interface for user input
+ */
+function createReadline() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+/**
+ * Prompt user for input
+ */
+function prompt(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+/**
+ * Make authenticated API call to registry
+ */
+async function apiCall(endpoint, method = 'GET', body) {
+    const config = await (0, user_config_1.getConfig)();
+    const baseUrl = (config.registryUrl || "https://registry.prpm.dev").replace(/\/$/, '');
+    if (!config.token) {
+        throw new Error('Authentication required. Please run `prpm login` first.');
+    }
+    const response = await fetch(`${baseUrl}${endpoint}`, {
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${config.token}`,
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || `API request failed: ${response.statusText}`);
+    }
+    return response;
+}
+/**
+ * Resolve package name to UUID
+ */
+async function resolvePackageId(packageName) {
+    // If it's already a UUID, return it
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidRegex.test(packageName)) {
+        return packageName;
+    }
+    // Search for the package by name
+    const config = await (0, user_config_1.getConfig)();
+    const baseUrl = (config.registryUrl || "https://registry.prpm.dev").replace(/\/$/, '');
+    const response = await fetch(`${baseUrl}/api/v1/search?q=${encodeURIComponent(packageName)}&limit=10`);
+    if (!response.ok) {
+        throw new Error(`Failed to search for package: ${response.statusText}`);
+    }
+    const data = await response.json();
+    // Find exact match
+    const exactMatch = data.packages.find(pkg => pkg.name === packageName);
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    // If no exact match, throw error
+    throw new Error(`Package not found: ${packageName}`);
+}
+/**
+ * Execute a playground run
+ */
+async function runPlayground(packageName, input, options, sessionId) {
+    // Resolve package name to UUID
+    const packageId = await resolvePackageId(packageName);
+    const response = await apiCall('/api/v1/playground/run', 'POST', {
+        package_id: packageId,
+        package_version: options.version,
+        input,
+        model: options.model || 'sonnet',
+        use_no_prompt: options.compare || false,
+        session_id: sessionId,
+    });
+    return response.json();
+}
+/**
+ * Format and display playground response
+ */
+function displayResponse(result, showStats = true) {
+    // Get the latest assistant response
+    const lastMessage = result.conversation[result.conversation.length - 1];
+    if (lastMessage?.role === 'assistant') {
+        console.log('\n' + '─'.repeat(60));
+        console.log('🤖 Assistant:');
+        console.log('─'.repeat(60));
+        console.log(lastMessage.content);
+        console.log('─'.repeat(60));
+    }
+    if (showStats) {
+        console.log(`\n📊 Stats:`);
+        console.log(`   Model: ${result.model}`);
+        console.log(`   Tokens: ${result.tokens_used.toLocaleString()}`);
+        console.log(`   Credits spent: ${result.credits_spent}`);
+        console.log(`   Credits remaining: ${result.credits_remaining}`);
+        console.log(`   Duration: ${result.duration_ms}ms`);
+    }
+}
+/**
+ * Run interactive playground session
+ */
+async function runInteractive(packageName, options) {
+    console.log('\n🎮 Interactive Playground Mode');
+    console.log(`   Package: ${packageName}`);
+    console.log(`   Model: ${options.model || 'sonnet'}`);
+    if (options.compare) {
+        console.log(`   Mode: Comparing against no prompt (raw model baseline)`);
+    }
+    console.log(`   Type 'exit' or 'quit' to end session\n`);
+    const rl = createReadline();
+    let sessionId;
+    let turnCount = 0;
+    try {
+        while (true) {
+            const input = await prompt(rl, `\n💬 You: `);
+            if (input.trim().toLowerCase() === 'exit' || input.trim().toLowerCase() === 'quit') {
+                console.log('\n👋 Ending playground session. Goodbye!');
+                break;
+            }
+            if (!input.trim()) {
+                console.log('❌ Please enter a message');
+                continue;
+            }
+            try {
+                console.log('\n⏳ Processing...');
+                const result = await runPlayground(packageName, input, options, sessionId);
+                // Store session ID for conversation continuity
+                sessionId = result.session_id;
+                turnCount++;
+                displayResponse(result, true);
+            }
+            catch (error) {
+                console.error(`\n❌ Error: ${error instanceof Error ? error.message : String(error)}`);
+                if (error instanceof Error && error.message.includes('Insufficient credits')) {
+                    console.log('\n💡 Get more credits:');
+                    console.log('   - Purchase credits:   prpm buy-credits');
+                    console.log('   - Subscribe to PRPM+: prpm subscribe');
+                    console.log('   - Check balance:      prpm credits');
+                    break;
+                }
+            }
+        }
+        if (turnCount > 0) {
+            console.log(`\n📝 Session summary: ${turnCount} turn(s)`);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Run single playground query
+ */
+async function runSingle(packageName, input, options) {
+    console.log(`\n🎮 Testing package: ${packageName}`);
+    console.log(`   Model: ${options.model || 'sonnet'}`);
+    if (options.compare) {
+        console.log(`   Mode: Comparing with package vs. without (baseline)`);
+    }
+    try {
+        if (options.compare) {
+            // Comparison mode: run both with package and without
+            console.log('\n⏳ Processing comparison (2 requests)...');
+            // Run with package (without use_no_prompt flag)
+            const withPackageOptions = { ...options, compare: false };
+            const resultWithPackage = await runPlayground(packageName, input, withPackageOptions);
+            // Run without package (with use_no_prompt flag)
+            const withoutPackageOptions = { ...options, compare: true };
+            const resultWithoutPackage = await runPlayground(packageName, input, withoutPackageOptions);
+            // Display both results
+            console.log('\n' + '═'.repeat(60));
+            console.log('📦 WITH PACKAGE PROMPT');
+            console.log('═'.repeat(60));
+            displayResponse(resultWithPackage, false);
+            console.log('\n' + '═'.repeat(60));
+            console.log('🔵 WITHOUT PACKAGE (BASELINE)');
+            console.log('═'.repeat(60));
+            displayResponse(resultWithoutPackage, false);
+            // Combined stats
+            console.log(`\n📊 Combined Stats:`);
+            console.log(`   Total tokens: ${resultWithPackage.tokens_used + resultWithoutPackage.tokens_used}`);
+            console.log(`   Total credits: ${resultWithPackage.credits_spent + resultWithoutPackage.credits_spent}`);
+            console.log(`   Credits remaining: ${resultWithoutPackage.credits_remaining}`);
+        }
+        else {
+            // Single mode: run with package only
+            console.log('\n⏳ Processing...');
+            const result = await runPlayground(packageName, input, options);
+            displayResponse(result, true);
+        }
+        console.log(`\n💡 Tips:`);
+        console.log(`   - Use --interactive for multi-turn conversation`);
+        console.log(`   - Use --compare to test with and without the package prompt`);
+        console.log(`   - Use --model to choose different models (sonnet, opus, gpt-4o, etc.)`);
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error instanceof Error ? error.message : String(error)}`);
+        if (error instanceof Error && error.message.includes('Insufficient credits')) {
+            console.log('\n💡 Get more credits:');
+            console.log('   - Purchase credits:   prpm buy-credits');
+            console.log('   - Subscribe to PRPM+: prpm subscribe');
+            console.log('   - Check balance:      prpm credits');
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Handle the playground command
+ */
+async function handlePlayground(packageName, input, options) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        // Validate authentication
+        const config = await (0, user_config_1.getConfig)();
+        if (!config.token) {
+            console.error('❌ Authentication required');
+            console.log('\n💡 Please login first:');
+            console.log('   prpm login');
+            process.exit(1);
+        }
+        // Interactive mode or single query
+        if (options.interactive || !input) {
+            // Interactive mode
+            await runInteractive(packageName, options);
+        }
+        else {
+            // Single query mode
+            await runSingle(packageName, input, options);
+        }
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Playground execution failed: ${error}`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'playground',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                packageName,
+                model: options.model || 'sonnet',
+                compare: options.compare || false,
+                interactive: options.interactive || false,
+            },
+        });
+        await telemetry_1.telemetry.shutdown();
+    }
+}
+/**
+ * Create the playground command
+ */
+function createPlaygroundCommand() {
+    const command = new commander_1.Command('playground');
+    command
+        .description('Test a package with AI models in the playground')
+        .argument('<package>', 'Package name to test')
+        .argument('[input]', 'Input text to send to the model (omit for interactive mode)')
+        .option('-m, --model <model>', 'AI model to use (sonnet, opus, gpt-4o, gpt-4o-mini, gpt-4-turbo)', 'sonnet')
+        .option('-c, --compare', 'Compare against no prompt (test raw model baseline)', false)
+        .option('-i, --interactive', 'Start interactive multi-turn conversation mode', false)
+        .option('-v, --version <version>', 'Specific package version to test')
+        .addHelpText('after', `
+Examples:
+  # Single query with default model (Sonnet)
+  $ prpm playground @anthropic/code-reviewer "Review this code: console.log('hello')"
+
+  # Interactive mode for multi-turn conversation
+  $ prpm playground @anthropic/brainstorm-assistant --interactive
+
+  # Compare with and without the package prompt
+  $ prpm playground @user/custom-prompt "Test input" --compare
+
+  # Use a different model
+  $ prpm playground @user/prompt --model opus "Complex task requiring Opus"
+  $ prpm playground @user/prompt --model gpt-4o "Test with GPT-4o"
+
+  # Test specific version
+  $ prpm playground @user/prompt@1.2.0 "Test input"
+
+Available Models:
+  sonnet       - Claude 3.5 Sonnet (default, balanced performance)
+  opus         - Claude 3 Opus (most capable, higher cost)
+  gpt-4o       - GPT-4o (OpenAI's latest)
+  gpt-4o-mini  - GPT-4o Mini (faster, cheaper)
+  gpt-4-turbo  - GPT-4 Turbo
+
+Note: Playground usage requires credits. Run 'prpm credits' to check balance.
+`)
+        .action(async (packageName, input, options) => {
+        await handlePlayground(packageName, input, options);
+        process.exit(0);
+    });
+    return command;
+}

package/dist/commands/remove.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Remove command implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRemove = handleRemove;
+exports.createRemoveCommand = createRemoveCommand;
+const commander_1 = require("commander");
+const lockfile_1 = require("../core/lockfile");
+const filesystem_1 = require("../core/filesystem");
+const fs_1 = require("fs");
+/**
+ * Handle the remove command
+ */
+async function handleRemove(name) {
+    try {
+        console.log(`🗑️  Removing package: ${name}`);
+        // Remove from lockfile and get package info
+        const pkg = await (0, lockfile_1.removePackage)(name);
+        if (!pkg) {
+            console.error(`❌ Package "${name}" not found`);
+            process.exit(1);
+        }
+        // Determine file path based on package type and format
+        const effectiveType = (pkg.format === 'claude' ? 'claude-skill' :
+            pkg.format === 'cursor' ? 'cursor' :
+                pkg.format === 'continue' ? 'continue' :
+                    pkg.format === 'windsurf' ? 'windsurf' :
+                        pkg.type);
+        const destDir = (0, filesystem_1.getDestinationDir)(effectiveType);
+        const fileExtension = pkg.format === 'cursor' ? 'mdc' : 'md';
+        // Strip author namespace to get just the package name
+        const packageName = (0, filesystem_1.stripAuthorNamespace)(name);
+        // Try single file first
+        const singleFilePath = `${destDir}/${packageName}.${fileExtension}`;
+        if (await (0, filesystem_1.fileExists)(singleFilePath)) {
+            // Single file package
+            await (0, filesystem_1.deleteFile)(singleFilePath);
+            console.log(`   🗑️  Deleted file: ${singleFilePath}`);
+        }
+        else {
+            // Try multi-file package directory
+            const packageDir = `${destDir}/${packageName}`;
+            try {
+                const stats = await fs_1.promises.stat(packageDir);
+                if (stats.isDirectory()) {
+                    await fs_1.promises.rm(packageDir, { recursive: true, force: true });
+                    console.log(`   🗑️  Deleted directory: ${packageDir}`);
+                }
+            }
+            catch (error) {
+                const err = error;
+                if (err.code !== 'ENOENT') {
+                    console.warn(`   ⚠️  Could not delete package files: ${err.message}`);
+                }
+            }
+        }
+        console.log(`✅ Successfully removed ${name}`);
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(`❌ Failed to remove package: ${error}`);
+        process.exit(1);
+    }
+}
+/**
+ * Create the remove command
+ */
+function createRemoveCommand() {
+    const command = new commander_1.Command('remove');
+    command
+        .description('Remove a prompt package')
+        .argument('<id>', 'Package ID to remove')
+        .action(handleRemove);
+    return command;
+}

package/dist/commands/subscribe.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Subscribe command - Subscribe to PRPM+ for monthly credits
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSubscribe = handleSubscribe;
+exports.createSubscribeCommand = createSubscribeCommand;
+const commander_1 = require("commander");
+const user_config_1 = require("../core/user-config");
+const telemetry_1 = require("../core/telemetry");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Make authenticated API call
+ */
+async function apiCall(endpoint) {
+    const config = await (0, user_config_1.getConfig)();
+    const baseUrl = (config.registryUrl || "https://registry.prpm.dev").replace(/\/$/, '');
+    if (!config.token) {
+        throw new Error('Authentication required. Please run `prpm login` first.');
+    }
+    const response = await fetch(`${baseUrl}${endpoint}`, {
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+        },
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || `API request failed: ${response.statusText}`);
+    }
+    return response;
+}
+/**
+ * Get current subscription status
+ */
+async function getSubscriptionStatus() {
+    const response = await apiCall('/api/v1/playground/credits');
+    return response.json();
+}
+/**
+ * Open URL in default browser
+ */
+async function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+    if (platform === 'darwin') {
+        command = `open "${url}"`;
+    }
+    else if (platform === 'win32') {
+        command = `start "" "${url}"`;
+    }
+    else {
+        // Linux and other Unix-like systems
+        command = `xdg-open "${url}"`;
+    }
+    try {
+        await execAsync(command);
+    }
+    catch (error) {
+        // If automatic opening fails, just show the URL
+        console.log(`\n🔗 Please open this URL in your browser:`);
+        console.log(`   ${url}`);
+    }
+}
+/**
+ * Poll for subscription status change
+ */
+async function pollForSubscription(initialStatus, maxAttempts = 60, intervalMs = 2000) {
+    console.log('\n⏳ Waiting for subscription confirmation...');
+    console.log('   (This may take a minute. Press Ctrl+C to cancel)');
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        try {
+            const status = await getSubscriptionStatus();
+            if (status.prpm_plus_status === 'active' && initialStatus !== 'active') {
+                return true;
+            }
+            // Show progress indicator
+            if (attempt % 5 === 0 && attempt > 0) {
+                process.stdout.write('.');
+            }
+        }
+        catch (error) {
+            // Continue polling even if there's an error
+            continue;
+        }
+    }
+    return false;
+}
+/**
+ * Handle the subscribe command
+ */
+async function handleSubscribe() {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        const config = await (0, user_config_1.getConfig)();
+        if (!config.token) {
+            console.error('❌ Authentication required');
+            console.log('\n💡 Please login first:');
+            console.log('   prpm login');
+            process.exit(1);
+        }
+        // Get current status
+        console.log('🔍 Checking current subscription status...');
+        const initialStatus = await getSubscriptionStatus();
+        if (initialStatus.prpm_plus_status === 'active') {
+            console.log('\n✅ You are already subscribed to PRPM+!');
+            console.log(`\n📊 Current benefits:`);
+            console.log(`   💰 Monthly credits: ${initialStatus.monthly_credits}`);
+            console.log(`   📦 Priority support`);
+            console.log(`   🚀 Early access to new features`);
+            console.log('\n💡 Manage your subscription at:');
+            console.log('   https://prpm.dev/settings/billing');
+            process.exit(0);
+        }
+        console.log('\n✨ Subscribe to PRPM+ and get:');
+        console.log('   💰 100 monthly playground credits');
+        console.log('   ♻️  Rollover unused credits (up to 200)');
+        console.log('   📦 Priority support');
+        console.log('   🚀 Early access to new features');
+        console.log('\n💵 Pricing:');
+        console.log('   $6/month for individuals');
+        console.log('   $3/month for verified organization members (50% off)');
+        // Open subscription page
+        const subscribeUrl = `${(config.registryUrl || "https://registry.prpm.dev").replace(/api\/?$/, '')}/playground/credits/subscribe`;
+        console.log(`\n🌐 Opening subscription page in your browser...`);
+        await openBrowser(subscribeUrl);
+        // Poll for subscription confirmation
+        const subscribed = await pollForSubscription(initialStatus.prpm_plus_status);
+        if (subscribed) {
+            const updatedStatus = await getSubscriptionStatus();
+            console.log('\n\n🎉 Successfully subscribed to PRPM+!');
+            console.log('\n📊 Your benefits:');
+            console.log(`   💰 Monthly credits: ${updatedStatus.monthly_credits}`);
+            console.log(`   💳 Current balance: ${updatedStatus.balance} credits`);
+            console.log('\n✅ You can now:');
+            console.log('   - Test packages in playground: prpm playground <package> "<input>"');
+            console.log('   - Check credits anytime: prpm credits');
+            success = true;
+        }
+        else {
+            console.log('\n\n⏱️  Subscription process timed out or was canceled.');
+            console.log('\n💡 If you completed the subscription, run this to verify:');
+            console.log('   prpm credits');
+            console.log('\n💡 Or visit your account settings:');
+            console.log('   https://prpm.dev/settings/billing');
+        }
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Subscription failed: ${error}`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'subscribe',
+            success,
+            error,
+            duration: Date.now() - startTime,
+        });
+        await telemetry_1.telemetry.shutdown();
+    }
+}
+/**
+ * Create the subscribe command
+ */
+function createSubscribeCommand() {
+    const command = new commander_1.Command('subscribe');
+    command
+        .description('Subscribe to PRPM+ for monthly playground credits and benefits')
+        .addHelpText('after', `
+PRPM+ Benefits:
+  ✨ 100 monthly playground credits (worth $6+ in API costs)
+  ♻️  Rollover unused credits up to 200 (1-month expiry)
+  📦 Priority support and bug fixes
+  🚀 Early access to new features
+  💬 Access to PRPM+ community
+
+Pricing:
+  Individual:     $6/month
+  Organization:   $3/month (50% discount for verified org members)
+
+How it works:
+  1. Opens subscription page in your browser
+  2. Complete payment with Stripe
+  3. Credits are added automatically
+  4. Start testing packages immediately
+
+Examples:
+  # Subscribe to PRPM+
+  $ prpm subscribe
+
+  # After subscribing, check your credits
+  $ prpm credits
+
+  # Test packages in playground
+  $ prpm playground @anthropic/assistant "Help me brainstorm ideas"
+
+Note: You can cancel anytime from https://prpm.dev/settings/billing
+`)
+        .action(async () => {
+        await handleSubscribe();
+        process.exit(0);
+    });
+    return command;
+}

package/dist/index.js

@@ -27,6 +27,10 @@ const schema_1 = require("./commands/schema");
 const init_1 = require("./commands/init");
 const config_1 = require("./commands/config");
 const catalog_1 = require("./commands/catalog");
+const playground_1 = require("./commands/playground");
+const credits_1 = require("./commands/credits");
+const subscribe_1 = require("./commands/subscribe");
+const buy_credits_1 = require("./commands/buy-credits");
 const telemetry_2 = require("./core/telemetry");
 // Read version from package.json
 function getVersion() {
@@ -65,6 +69,11 @@ program.addCommand((0, list_1.createListCommand)());
 program.addCommand((0, uninstall_1.createUninstallCommand)());
 program.addCommand((0, index_1.createIndexCommand)());
 program.addCommand((0, telemetry_1.createTelemetryCommand)());
+// Playground commands
+program.addCommand((0, playground_1.createPlaygroundCommand)());
+program.addCommand((0, credits_1.createCreditsCommand)());
+program.addCommand((0, subscribe_1.createSubscribeCommand)());
+program.addCommand((0, buy_credits_1.createBuyCreditsCommand)());
 // Utility commands
 program.addCommand((0, schema_1.createSchemaCommand)());
 program.addCommand((0, config_1.createConfigCommand)());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prpm",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Prompt Package Manager CLI - Install and manage prompt-based files",
   "main": "dist/index.js",
   "bin": {
@@ -46,7 +46,7 @@
   "dependencies": {
     "@octokit/rest": "^22.0.0",
     "@pr-pm/registry-client": "^1.3.4",
-    "@pr-pm/types": "^0.2.4",
+    "@pr-pm/types": "^0.2.6",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^11.1.0",