prpm 0.1.5 → 0.1.7

package/dist/commands/buy-credits.js

@@ -0,0 +1,224 @@
+"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 webapp_url_1 = require("../utils/webapp-url");
+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 webappUrl = (0, webapp_url_1.getWebappUrl)(config.registryUrl || 'https://registry.prpm.dev');
+        let purchaseUrl = `${webappUrl}/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/install.js

@@ -220,8 +220,20 @@ async function handleInstall(packageSpec, options) {
         console.log(`   ${pkg.name} ${pkg.official ? '🏅' : ''}`);
         console.log(`   ${pkg.description || 'No description'}`);
         console.log(`   ${typeIcon} Type: ${typeLabel}`);
-        // Determine format preference
-        let format = options.as || pkg.format;
+        // Determine format preference with auto-detection
+        let format = options.as;
+        // Auto-detect format if not explicitly specified
+        if (!format) {
+            const detectedFormat = await (0, filesystem_1.autoDetectFormat)();
+            if (detectedFormat) {
+                format = detectedFormat;
+                console.log(`   🔍 Auto-detected ${format} format (found .${format}/ directory)`);
+            }
+            else {
+                // No existing directories found, use package's native format
+                format = pkg.format;
+            }
+        }
         // Special handling for Claude packages: default to CLAUDE.md if it doesn't exist
         // BUT only for packages that are generic rules (not skills, agents, or commands)
         if (!options.as && pkg.format === 'claude' && pkg.subtype === 'rule') {

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/subscribe.js

@@ -0,0 +1,211 @@
+"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 webapp_url_1 = require("../utils/webapp-url");
+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 webappUrl = (0, webapp_url_1.getWebappUrl)(config.registryUrl || 'https://registry.prpm.dev');
+        const subscribeUrl = `${webappUrl}/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/core/filesystem.js

@@ -11,6 +11,8 @@ exports.ensureDirectoryExists = ensureDirectoryExists;
 exports.saveFile = saveFile;
 exports.deleteFile = deleteFile;
 exports.fileExists = fileExists;
+exports.directoryExists = directoryExists;
+exports.autoDetectFormat = autoDetectFormat;
 exports.generateId = generateId;
 exports.stripAuthorNamespace = stripAuthorNamespace;
 exports.getInstalledFilePath = getInstalledFilePath;
@@ -119,6 +121,39 @@ async function fileExists(filePath) {
         return false;
     }
 }
+/**
+ * Check if a directory exists
+ */
+async function directoryExists(dirPath) {
+    try {
+        const stats = await fs_1.promises.stat(dirPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Auto-detect the format based on existing directories in the current project
+ * Returns the format if a matching directory is found, or null if none found
+ */
+async function autoDetectFormat() {
+    const formatDirs = [
+        { format: 'cursor', dir: '.cursor' },
+        { format: 'claude', dir: '.claude' },
+        { format: 'continue', dir: '.continue' },
+        { format: 'windsurf', dir: '.windsurf' },
+        { format: 'copilot', dir: '.github/instructions' },
+        { format: 'kiro', dir: '.kiro' },
+        { format: 'agents.md', dir: '.agents' },
+    ];
+    for (const { format, dir } of formatDirs) {
+        if (await directoryExists(dir)) {
+            return format;
+        }
+    }
+    return null;
+}
 /**
  * Generate a unique ID from filename
  */

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/dist/utils/webapp-url.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Utility to convert registry URL to webapp URL
+ * Handles localhost, production, and custom registry URLs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebappUrl = getWebappUrl;
+/**
+ * Convert a registry URL to its corresponding webapp URL
+ *
+ * @param registryUrl - The registry URL (e.g., https://registry.prpm.dev)
+ * @returns The webapp URL (e.g., https://prpm.dev)
+ *
+ * @example
+ * // Production
+ * getWebappUrl('https://registry.prpm.dev') // => 'https://prpm.dev'
+ *
+ * // Local development
+ * getWebappUrl('http://localhost:3111') // => 'http://localhost:5173'
+ *
+ * // Custom registry
+ * getWebappUrl('https://registry.custom.com') // => 'https://custom.com'
+ */
+function getWebappUrl(registryUrl) {
+    const cleanUrl = registryUrl.replace(/\/$/, '').replace(/\/api\/?$/, '');
+    if (cleanUrl.includes('localhost') || cleanUrl.includes('127.0.0.1')) {
+        // Local development: registry on port 3111, webapp on port 5173
+        return cleanUrl.replace(':3111', ':5173');
+    }
+    if (cleanUrl.includes('registry.prpm.dev')) {
+        // Production: always use prpm.dev webapp
+        return 'https://prpm.dev';
+    }
+    // Custom registry: assume webapp is on same host without 'registry.' subdomain
+    try {
+        const url = new URL(cleanUrl);
+        const hostname = url.hostname.replace(/^registry\./, '');
+        return `${url.protocol}//${hostname}`;
+    }
+    catch {
+        // If URL parsing fails, return as-is
+        return cleanUrl;
+    }
+}

package/package.json

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