prpm 0.1.4 → 0.1.6

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

@@ -90,6 +90,7 @@ async function findAndLoadManifests() {
                     homepage: pkg.homepage ?? multiManifest.homepage,
                     documentation: pkg.documentation ?? multiManifest.documentation,
                     organization: pkg.organization ?? multiManifest.organization,
+                    private: pkg.private ?? multiManifest.private,
                     tags: pkg.tags ?? multiManifest.tags,
                     keywords: pkg.keywords ?? multiManifest.keywords,
                     subtype: pkg.subtype,

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

@@ -134,6 +134,10 @@ function buildWebappUrl(query, options, page = 1) {
         params.append('subtype', options.subtype);
     if (options.author)
         params.append('author', options.author);
+    if (options.language)
+        params.append('language', options.language);
+    if (options.framework)
+        params.append('framework', options.framework);
     if (page > 1)
         params.append('page', page.toString());
     return `${baseUrl}/search?${params.toString()}`;
@@ -312,6 +316,12 @@ async function handleSearch(query, options) {
         if (options.author) {
             searchOptions.author = options.author;
         }
+        if (options.language) {
+            searchOptions.language = options.language;
+        }
+        if (options.framework) {
+            searchOptions.framework = options.framework;
+        }
         result = await client.search(query || '', searchOptions);
         if (!result || result.packages.length === 0) {
             console.log('\n❌ No packages found');
@@ -377,6 +387,8 @@ async function handleSearch(query, options) {
                 query: query.substring(0, 100),
                 format: options.format,
                 subtype: options.subtype,
+                language: options.language,
+                framework: options.framework,
                 resultCount: success && result ? result.packages.length : 0,
                 page: options.page,
                 interactive: options.interactive,
@@ -394,6 +406,8 @@ function createSearchCommand() {
         .option('--format <format>', 'Filter by package format (cursor, claude, continue, windsurf, copilot, kiro, agents.md, generic, mcp)')
         .option('--subtype <subtype>', 'Filter by package subtype (rule, agent, skill, slash-command, prompt, workflow, tool, template, collection)')
         .option('--author <username>', 'Filter by author username')
+        .option('--language <language>', 'Filter by programming language (javascript, typescript, python, etc.)')
+        .option('--framework <framework>', 'Filter by framework (react, nextjs, django, etc.)')
         .option('--limit <number>', 'Number of results per page', '20')
         .option('--page <number>', 'Page number (default: 1)', '1')
         .option('--interactive', 'Enable interactive pagination (default: true for multiple pages)', true)
@@ -423,7 +437,7 @@ function createSearchCommand() {
             console.log(`   prpm search --author prpm  # List packages by @prpm`);
             process.exit(1);
         }
-        await handleSearch(query || '', { format, subtype, author, limit, page, interactive: options.interactive });
+        await handleSearch(query || '', { format, subtype, author, language: options.language, framework: options.framework, limit, page, interactive: options.interactive });
         process.exit(0);
     });
     return command;