prpm 0.1.12 → 0.1.14

package/dist/commands/playground.js

@@ -42,6 +42,8 @@ const commander_1 = require("commander");
 const user_config_1 = require("../core/user-config");
 const telemetry_1 = require("../core/telemetry");
 const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const errors_1 = require("../core/errors");
 /**
  * Create a readline interface for user input
@@ -94,21 +96,20 @@ async function resolvePackageId(packageName) {
     if (uuidRegex.test(packageName)) {
         return packageName;
     }
-    // Search for the package by name
+    // Look up package by name directly
     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`);
+    // URL encode the package name to handle scoped packages like @user/package
+    const encodedName = encodeURIComponent(packageName);
+    const response = await fetch(`${baseUrl}/api/v1/packages/${encodedName}`);
     if (!response.ok) {
-        throw new Error(`Failed to search for package: ${response.statusText}`);
+        if (response.status === 404) {
+            throw new Error(`Package not found: ${packageName}`);
+        }
+        throw new Error(`Failed to fetch 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}`);
+    return data.id;
 }
 /**
  * Execute a playground run
@@ -126,6 +127,28 @@ async function runPlayground(packageName, input, options, sessionId) {
     });
     return response.json();
 }
+/**
+ * Execute a custom prompt playground run
+ */
+async function runCustomPrompt(customPrompt, input, options, sessionId) {
+    const response = await apiCall('/api/v1/custom-prompt/run', 'POST', {
+        custom_prompt: customPrompt,
+        input,
+        model: options.model || 'sonnet',
+        session_id: sessionId,
+    });
+    return response.json();
+}
+/**
+ * Read custom prompt from file
+ */
+function readPromptFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`Prompt file not found: ${filePath}`);
+    }
+    return fs.readFileSync(absolutePath, 'utf-8');
+}
 /**
  * Format and display playground response
  */
@@ -200,6 +223,139 @@ async function runInteractive(packageName, options) {
         rl.close();
     }
 }
+/**
+ * Run interactive custom prompt session
+ */
+async function runCustomInteractive(customPrompt, options) {
+    console.log('\n🎮 Interactive Custom Prompt Mode');
+    console.log(`   Model: ${options.model || 'sonnet'}`);
+    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 runCustomPrompt(customPrompt, 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 baseline (no prompt) comparison
+ */
+async function runBaseline(input, options) {
+    // Use a minimal package but with use_no_prompt flag to get raw model baseline
+    // We need any valid package ID because the API requires it, but the prompt will be ignored
+    // Let's use a well-known minimal package (we'll search for any package)
+    const config = await (0, user_config_1.getConfig)();
+    const baseUrl = (config.registryUrl || "https://registry.prpm.dev").replace(/\/$/, '');
+    // Get any package to use for baseline comparison (the prompt will be ignored anyway)
+    const searchResponse = await fetch(`${baseUrl}/api/v1/search?q=coding&limit=1`);
+    if (!searchResponse.ok) {
+        throw new Error('Failed to find a package for baseline comparison');
+    }
+    const searchData = await searchResponse.json();
+    if (!searchData.packages || searchData.packages.length === 0) {
+        throw new Error('No packages found for baseline comparison');
+    }
+    const dummyPackageId = searchData.packages[0].id;
+    // Call playground with use_no_prompt flag (this ignores the package prompt)
+    const response = await apiCall('/api/v1/playground/run', 'POST', {
+        package_id: dummyPackageId,
+        input,
+        model: options.model || 'sonnet',
+        use_no_prompt: true, // This makes it a raw baseline with no system prompt
+    });
+    return response.json();
+}
+/**
+ * Run single custom prompt query
+ */
+async function runCustomSingle(customPrompt, input, options) {
+    console.log(`\n🎮 Testing custom prompt`);
+    console.log(`   Model: ${options.model || 'sonnet'}`);
+    console.log(`   Credits: 2x normal cost (custom prompts)`);
+    if (options.compare) {
+        console.log(`   Mode: Comparing custom prompt vs. no prompt (baseline)`);
+    }
+    try {
+        if (options.compare) {
+            // Comparison mode: run with custom prompt and without any prompt
+            console.log('\n⏳ Processing comparison (2 requests)...');
+            // Run with custom prompt
+            const resultWithPrompt = await runCustomPrompt(customPrompt, input, options);
+            // Run baseline (no prompt at all)
+            const resultBaseline = await runBaseline(input, options);
+            // Display both results
+            console.log('\n' + '═'.repeat(60));
+            console.log('✨ WITH CUSTOM PROMPT');
+            console.log('═'.repeat(60));
+            displayResponse(resultWithPrompt, false);
+            console.log('\n' + '═'.repeat(60));
+            console.log('🔵 WITHOUT PROMPT (BASELINE)');
+            console.log('═'.repeat(60));
+            displayResponse(resultBaseline, false);
+            // Combined stats
+            console.log(`\n📊 Combined Stats:`);
+            console.log(`   Total tokens: ${resultWithPrompt.tokens_used + resultBaseline.tokens_used}`);
+            console.log(`   Total credits: ${resultWithPrompt.credits_spent + resultBaseline.credits_spent}`);
+            console.log(`   Credits remaining: ${resultBaseline.credits_remaining}`);
+            console.log(`\n💡 Compare the responses to evaluate your custom prompt's effectiveness!`);
+        }
+        else {
+            // Single mode: run with custom prompt only
+            console.log('\n⏳ Processing...');
+            const result = await runCustomPrompt(customPrompt, input, options);
+            displayResponse(result, true);
+            console.log(`\n💡 Tips:`);
+            console.log(`   - Use --interactive for multi-turn conversation`);
+            console.log(`   - Use --compare to test against baseline (no prompt)`);
+            console.log(`   - Use --prompt-file to iterate on a prompt file`);
+            console.log(`   - Custom prompts cost 2x credits (no caching)`);
+        }
+    }
+    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');
+        }
+        throw new errors_1.CLIError(`\n❌ Error: ${error instanceof Error ? error.message : String(error)}`, 1);
+    }
+}
 /**
  * Run single playground query
  */
@@ -259,10 +415,11 @@ async function runSingle(packageName, input, options) {
 /**
  * Handle the playground command
  */
-async function handlePlayground(packageName, input, options) {
+async function handlePlayground(options) {
     const startTime = Date.now();
     let success = false;
     let error;
+    let customPromptMode = false;
     try {
         // Validate authentication
         const config = await (0, user_config_1.getConfig)();
@@ -272,14 +429,50 @@ async function handlePlayground(packageName, input, options) {
             console.log('   prpm login');
             throw new errors_1.CLIError('❌ Authentication required', 1);
         }
-        // Interactive mode or single query
-        if (options.interactive || !input) {
-            // Interactive mode
-            await runInteractive(packageName, options);
+        // Check for custom prompt mode
+        if (options.custom || options.promptFile) {
+            customPromptMode = true;
+            // Get custom prompt from option or file
+            let customPrompt;
+            if (options.promptFile) {
+                console.log(`📄 Loading prompt from: ${options.promptFile}`);
+                customPrompt = readPromptFile(options.promptFile);
+                console.log(`✅ Loaded ${customPrompt.length} characters\n`);
+            }
+            else {
+                customPrompt = options.custom;
+            }
+            // Validate custom prompt length
+            if (customPrompt.length < 10) {
+                throw new Error('Custom prompt too short (minimum 10 characters)');
+            }
+            if (customPrompt.length > 50000) {
+                throw new Error('Custom prompt too long (maximum 50000 characters)');
+            }
+            // Interactive mode or single query
+            if (options.interactive || !options.input) {
+                // Interactive mode with custom prompt
+                await runCustomInteractive(customPrompt, options);
+            }
+            else {
+                // Single query mode with custom prompt
+                await runCustomSingle(customPrompt, options.input, options);
+            }
         }
         else {
-            // Single query mode
-            await runSingle(packageName, input, options);
+            // Regular package-based playground
+            if (!options.package) {
+                throw new Error('Either --package or --custom/--prompt-file is required');
+            }
+            // Interactive mode or single query
+            if (options.interactive || !options.input) {
+                // Interactive mode
+                await runInteractive(options.package, options);
+            }
+            else {
+                // Single query mode
+                await runSingle(options.package, options.input, options);
+            }
         }
         success = true;
     }
@@ -295,10 +488,11 @@ async function handlePlayground(packageName, input, options) {
             error,
             duration: Date.now() - startTime,
             data: {
-                packageName,
+                packageName: customPromptMode ? 'custom-prompt' : (options.package || 'unknown'),
                 model: options.model || 'sonnet',
                 compare: options.compare || false,
                 interactive: options.interactive || false,
+                customPrompt: customPromptMode,
             },
         });
         await telemetry_1.telemetry.shutdown();
@@ -310,30 +504,49 @@ async function handlePlayground(packageName, input, options) {
 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)')
+        .description('Test a package or custom prompt with AI models in the playground')
+        .option('-p, --package <name>', 'Package name to test')
+        .option('--input <text>', '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')
+        .option('--custom <prompt>', 'Use a custom prompt string (verified authors only)')
+        .option('--prompt-file <file>', 'Load custom prompt from a file (verified authors only)')
         .addHelpText('after', `
 Examples:
-  # Single query with default model (Sonnet)
-  $ prpm playground @anthropic/code-reviewer "Review this code: console.log('hello')"
+  # Test a package (single query)
+  $ prpm playground --package @anthropic/code-reviewer --input "Review this code: console.log('hello')"
 
   # Interactive mode for multi-turn conversation
-  $ prpm playground @anthropic/brainstorm-assistant --interactive
+  $ prpm playground --package @anthropic/brainstorm-assistant --interactive
 
   # Compare with and without the package prompt
-  $ prpm playground @user/custom-prompt "Test input" --compare
+  $ prpm playground --package @user/custom-prompt --input "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"
+  $ prpm playground --package @user/prompt --model opus --input "Complex task requiring Opus"
+  $ prpm playground --package @user/prompt --model gpt-4o --input "Test with GPT-4o"
 
   # Test specific version
-  $ prpm playground @user/prompt@1.2.0 "Test input"
+  $ prpm playground --package @user/prompt --version 1.2.0 --input "Test input"
+
+  # Use a custom prompt string (verified authors only)
+  $ prpm playground --custom "You are a helpful coding assistant" --input "Explain async/await"
+
+  # Load custom prompt from a file (verified authors only)
+  $ prpm playground --prompt-file ./my-prompt.txt --input "Test input"
+
+  # Compare custom prompt against baseline (no prompt)
+  $ prpm playground --custom "You are concise" --input "Explain recursion" --compare
+  $ prpm playground --prompt-file ./my-prompt.txt --input "Test" --compare
+
+  # Interactive mode with custom prompt from file
+  $ prpm playground --prompt-file ./my-prompt.txt --interactive
+
+  # Short flags for common usage
+  $ prpm playground -p @user/prompt --input "Test this"
+  $ prpm playground -p @user/prompt -i
 
 Available Models:
   sonnet       - Claude 3.5 Sonnet (default, balanced performance)
@@ -342,10 +555,16 @@ Available Models:
   gpt-4o-mini  - GPT-4o Mini (faster, cheaper)
   gpt-4-turbo  - GPT-4 Turbo
 
+Custom Prompts:
+  - Available to verified authors (link your GitHub account)
+  - Cost 2x normal credits (no prompt caching)
+  - Min 10 characters, max 50,000 characters
+  - Perfect for iterating on prompt files locally
+
 Note: Playground usage requires credits. Run 'prpm credits' to check balance.
 `)
-        .action(async (packageName, input, options) => {
-        await handlePlayground(packageName, input, options);
+        .action(async (options) => {
+        await handlePlayground(options);
     });
     return command;
 }

package/dist/commands/uninstall.js

@@ -21,57 +21,41 @@ async function handleUninstall(name) {
         if (!pkg) {
             throw new errors_1.CLIError(`❌ Package "${name}" not found`, 1);
         }
-        // Get destination directory using format and subtype
-        const format = pkg.format || 'generic';
-        const subtype = pkg.subtype || 'rule';
+        // Get the installation path from lock file if available, otherwise calculate it
         const packageName = (0, filesystem_1.stripAuthorNamespace)(name);
-        const destDir = (0, filesystem_1.getDestinationDir)(format, subtype, packageName);
-        const fileExtension = pkg.format === 'cursor' ? 'mdc' : 'md';
-        // For Claude skills, delete the entire directory (may contain multiple files)
-        if (format === 'claude' && subtype === 'skill') {
-            // Claude skills are in .claude/skills/${packageName}/ directory
-            // Delete the entire directory (includes SKILL.md, EXAMPLES.md, docs/, etc.)
-            try {
-                const stats = await fs_1.promises.stat(destDir);
-                if (stats.isDirectory()) {
-                    await fs_1.promises.rm(destDir, { recursive: true, force: true });
-                    console.log(`   🗑️  Deleted directory: ${destDir}`);
-                }
+        let targetPath;
+        if (pkg.installedPath) {
+            // Use the exact path where it was installed (from lock file)
+            targetPath = pkg.installedPath;
+            console.log(`   📍 Using installation path from lock file: ${targetPath}`);
+        }
+        else {
+            // Fallback: warn user that installedPath is missing (shouldn't happen with recent installations)
+            console.warn(`   ⚠️  No installation path in lock file for ${name}`);
+            console.warn(`   ⚠️  This may indicate an old or corrupted lock file`);
+            throw new errors_1.CLIError(`Cannot uninstall ${name}: installation path unknown`, 1);
+        }
+        // Check if the target path is a directory or file and delete accordingly
+        try {
+            const stats = await fs_1.promises.stat(targetPath);
+            if (stats.isDirectory()) {
+                // Delete entire directory
+                await fs_1.promises.rm(targetPath, { recursive: true, force: true });
+                console.log(`   🗑️  Deleted directory: ${targetPath}`);
             }
-            catch (error) {
-                const err = error;
-                if (err.code === 'ENOENT') {
-                    console.warn(`   ⚠️  Skill directory not found: ${destDir}`);
-                }
-                else {
-                    console.warn(`   ⚠️  Could not delete skill directory: ${err.message}`);
-                }
+            else if (stats.isFile()) {
+                // Delete single file
+                await fs_1.promises.unlink(targetPath);
+                console.log(`   🗑️  Deleted file: ${targetPath}`);
             }
         }
-        else {
-            // For other formats, 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}`);
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                console.warn(`   ⚠️  File/directory not found: ${targetPath}`);
             }
             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}`);
-                    }
-                }
+                throw err;
             }
         }
         console.log(`✅ Successfully uninstalled ${name}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prpm",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "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.10",
-    "@pr-pm/types": "^0.2.11",
+    "@pr-pm/registry-client": "^1.3.12",
+    "@pr-pm/types": "^0.2.13",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^11.1.0",