openpets 1.0.11 → 1.0.12

package/dist/src/core/cli.js

@@ -1,82 +1,20 @@
 #!/usr/bin/env bun
 import { buildPet } from './build-pet.js';
 import { deployPet } from './deploy-pet.js';
+import { publishPet } from './publish-pet.js';
+import { generateOpenAPITools } from './openapi-generator.js';
 import { addFolderToHistory } from './config-manager.js';
 import { getRegistryClient } from './registry-client.js';
 import { loadPetConfig, validatePetConfig, generateOpenpetsYamlTemplate } from './pet-config.js';
 import { getPackageDiscovery, getRegistryAggregator } from './discovery.js';
 import { getPetDownloader } from './pet-downloader.js';
-import { getAllPets } from './search-pets.js';
+import { getAllPets, findSimilarPets } from './search-pets.js';
 import { syncEnvToConfig } from '../sdk/plugin-factory.js';
+import { fetchFromRegistry, readLocalCommands, getLiveTools, formatTools, listProjectTools, printProjectToolsSummary, getOpencodeCacheDir } from './tool-lister.js';
 import { spawn } from 'child_process';
 import { resolve, join } from 'path';
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
+import { readFileSync, existsSync, writeFileSync, mkdirSync, rmSync } from 'fs';
 import * as readline from 'readline';
-async function publishPet(petName, options = {}) {
-    const { preview = false, channel = 'latest' } = options;
-    // Find the script path - try multiple locations
-    const possiblePaths = [
-        resolve(__dirname, '../../scripts/publish-pet.ts'),
-        resolve(__dirname, '../../../scripts/publish-pet.ts'),
-        resolve(process.cwd(), 'scripts/publish-pet.ts'),
-        resolve(process.cwd(), '../../scripts/publish-pet.ts')
-    ];
-    let scriptPath = possiblePaths.find(p => existsSync(p));
-    if (!scriptPath) {
-        console.error(`❌ Publish script not found`);
-        console.error(`   Tried:`);
-        possiblePaths.forEach(p => console.error(`     - ${p}`));
-        process.exit(1);
-    }
-    // If no petName provided, try to infer from current directory
-    let finalPetName = petName;
-    if (!finalPetName) {
-        const cwd = process.cwd();
-        const pkgPath = resolve(cwd, 'package.json');
-        if (existsSync(pkgPath)) {
-            try {
-                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-                // Extract pet name from @openpets/maps -> maps
-                if (pkg.name && pkg.name.startsWith('@openpets/')) {
-                    finalPetName = pkg.name.replace('@openpets/', '');
-                    console.log(`📦 Detected pet: ${finalPetName}`);
-                }
-            }
-            catch (e) {
-                // Ignore parse errors
-            }
-        }
-        if (!finalPetName) {
-            console.error('❌ Could not determine pet name. Run from pet directory or specify pet name.');
-            process.exit(1);
-        }
-    }
-    const bunArgs = [scriptPath, finalPetName];
-    if (preview)
-        bunArgs.push('--preview');
-    if (channel && channel !== 'latest')
-        bunArgs.push('--channel', channel);
-    return new Promise((resolve, reject) => {
-        const child = spawn('bun', bunArgs, {
-            stdio: 'inherit',
-            shell: true,
-            env: {
-                ...process.env,
-                OPENPETS_PREVIEW: preview ? 'true' : 'false',
-                OPENPETS_CHANNEL: channel
-            }
-        });
-        child.on('error', reject);
-        child.on('exit', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Publish exited with code ${code}`));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
 const args = process.argv.slice(2);
 const command = args[0];
 const DEBUG = process.env.PETS_DEBUG === 'true';
@@ -220,8 +158,17 @@ else if (command === 'publish') {
     const preview = args.includes('--preview');
     const channelIndex = args.indexOf('--channel');
     const channel = channelIndex >= 0 ? args[channelIndex + 1] : 'latest';
-    log('Publishing pet:', petName || '(auto-detect)', { preview, channel });
-    publishPet(petName, { preview, channel }).catch(error => {
+    const scopeIndex = args.indexOf('--scope');
+    const scope = scopeIndex >= 0 ? args[scopeIndex + 1] : '@openpets';
+    const otpIndex = args.indexOf('--otp');
+    const otp = otpIndex >= 0 ? args[otpIndex + 1] : undefined;
+    log('Publishing pet:', petName || '(auto-detect)', { preview, channel, scope, otp: otp ? '***' : undefined });
+    publishPet(petName, { preview, channel, scope, otp }).then(result => {
+        if (!result.success) {
+            console.error('Error publishing pet:', result.message);
+            process.exit(1);
+        }
+    }).catch(error => {
         console.error('Error publishing pet:', error);
         log('Publish error details:', error);
         process.exit(1);
@@ -266,9 +213,21 @@ else if (command === 'registry') {
 else if (command === 'prune') {
     handlePrune(args.slice(1));
 }
+else if (command === 'clear') {
+    handleClear(args.slice(1));
+}
+else if (command === 'config') {
+    handleConfig(args.slice(1));
+}
 else if (command === 'reload') {
     handleReload(args.slice(1));
 }
+else if (command === 'tools') {
+    handleTools(args.slice(1));
+}
+else if (command === 'generate-openapi') {
+    handleGenerateOpenAPI(args.slice(1));
+}
 else if (command === 'help' || command === '--help' || command === '-h') {
     showHelp();
 }
@@ -842,26 +801,55 @@ async function handleAdd(args) {
     const packageName = args.find(a => !a.startsWith('--'));
     if (!packageName) {
         console.error('❌ Package name required');
-        console.error('Usage: pets add <package-name> [--skip-config] [--version <version>]');
+        console.error('Usage: pets add <package-name> [--version <version>]');
         process.exit(1);
     }
-    const skipConfig = args.includes('--skip-config');
     const versionIndex = args.indexOf('--version');
     const version = versionIndex >= 0 ? args[versionIndex + 1] : undefined;
-    const configIndex = args.indexOf('--config');
-    const configStr = configIndex >= 0 ? args[configIndex + 1] : undefined;
-    const presetEnv = configStr ? JSON.parse(configStr) : undefined;
     ensureOpencodeJson();
     console.log(`\n📦 Adding ${packageName}...`);
     const downloader = getPetDownloader();
     const result = await downloader.add(packageName, {
         targetDir: process.cwd(),
-        version,
-        skipConfig,
-        envValues: presetEnv
+        version
     });
     if (!result.success) {
         console.error(`\n❌ ${result.message}`);
+        // If package not found, suggest similar pets
+        if (result.message.includes('Package not found')) {
+            const shortName = packageName
+                .replace(/^@openpets\//, '')
+                .replace(/^openpets\//, '');
+            try {
+                const similar = await findSimilarPets(shortName, 5);
+                if (similar.length > 0) {
+                    console.log('\n💡 Did you mean one of these?\n');
+                    for (const pet of similar) {
+                        // Strip all prefixes to get clean pet ID
+                        const petId = pet.id
+                            .replace(/^@openpets\//, '')
+                            .replace(/^openpets\//, '')
+                            .replace(/^@/, '');
+                        console.log(`   📦 ${petId}`);
+                        if (pet.description) {
+                            console.log(`      ${pet.description}`);
+                        }
+                        console.log(`      Run: pets add ${petId}`);
+                        console.log('');
+                    }
+                }
+                else {
+                    console.log('\n💡 Try searching for available pets:');
+                    console.log(`   pets search ${shortName}`);
+                }
+            }
+            catch (e) {
+                // Silently fail if we can't fetch suggestions
+                log('Failed to fetch similar pets:', e);
+                console.log('\n💡 Try searching for available pets:');
+                console.log(`   pets search ${shortName}`);
+            }
+        }
         process.exit(1);
     }
     console.log(`\n✅ ${result.message}`);
@@ -874,23 +862,100 @@ async function handleAdd(args) {
             console.log(`   ${result.config.description}`);
         }
     }
-    if (result.envVariables && result.envVariables.length > 0 && !skipConfig) {
-        console.log('\n🔧 Configuration required:\n');
-        await promptForConfiguration(result.envVariables, result.packagePath);
+    // Display prompts/agents copied info
+    if (result.promptsCopied && result.promptsCopied.copied > 0) {
+        console.log(`   🤖 Installed ${result.promptsCopied.copied} agent(s) to .opencode/agent/${packageName.replace('@openpets/', '')}/`);
+        for (const file of result.promptsCopied.files) {
+            console.log(`      • ${file.replace('.md', '')}`);
+        }
     }
-    else if (result.envVariables && result.envVariables.length > 0) {
-        console.log('\n⚠️  Environment variables needed (skipped with --skip-config):');
-        for (const env of result.envVariables) {
-            const status = env.currentValue ? '✅' : (env.required ? '❌' : '⚪');
-            console.log(`   ${status} ${env.name}: ${env.description}`);
+    // Show required env vars if any are missing
+    if (result.envVariables && result.envVariables.length > 0) {
+        const missing = result.envVariables.filter(e => e.required && !e.currentValue);
+        const optional = result.envVariables.filter(e => !e.required && !e.currentValue);
+        if (missing.length > 0) {
+            console.log('\n⚠️  Required environment variables:');
+            for (const env of missing) {
+                console.log(`   ❌ ${env.name}: ${env.description}`);
+            }
+            console.log(`\n   Run "pets config ${packageName.replace('@openpets/', '')}" to configure`);
+        }
+        if (optional.length > 0 && missing.length === 0) {
+            console.log('\n💡 Optional environment variables available:');
+            console.log(`   Run "pets config ${packageName.replace('@openpets/', '')}" to configure`);
         }
     }
-    console.log('\n💡 Plugin added to opencode.json');
+    console.log('\n✅ Plugin added to opencode.json');
     console.log('   To apply changes:');
     console.log('   • New session: restart opencode');
     console.log('   • Keep session: run "opencode --continue" or "pets reload"\n');
 }
-async function promptForConfiguration(envVariables, packagePath) {
+async function handleConfig(args) {
+    const petName = args.find(a => !a.startsWith('--'));
+    if (!petName) {
+        console.error('❌ Pet name required');
+        console.error('Usage: pets config <pet-name>');
+        console.error('\nExamples:');
+        console.error('  pets config maps');
+        console.error('  pets config github');
+        process.exit(1);
+    }
+    const shortName = petName
+        .replace(/^@openpets\//, '')
+        .replace(/^openpets\//, '');
+    console.log(`\n🔧 Configuring ${shortName}...\n`);
+    // Try to load pet config to get env variable definitions
+    const downloader = getPetDownloader();
+    const petPath = downloader.getInstalledPetPath(shortName);
+    if (!petPath) {
+        console.error(`❌ Pet "${shortName}" is not installed`);
+        console.error(`   Run "pets add ${shortName}" first`);
+        process.exit(1);
+    }
+    const { loadPetConfig } = await import('./pet-config.js');
+    const petConfig = loadPetConfig(petPath);
+    if (!petConfig) {
+        console.error(`❌ Could not load configuration for ${shortName}`);
+        process.exit(1);
+    }
+    // Extract env variables from pet config
+    const envVariables = [];
+    if (petConfig.envVariables) {
+        const required = petConfig.envVariables.required || [];
+        const optional = petConfig.envVariables.optional || [];
+        for (const v of required) {
+            const varName = v.name || '';
+            const isSecret = v.secret || varName.includes('TOKEN') || varName.includes('KEY') || varName.includes('SECRET');
+            envVariables.push({
+                name: varName,
+                description: v.description || '',
+                required: true,
+                secret: isSecret,
+                currentValue: process.env[varName]
+            });
+        }
+        for (const v of optional) {
+            const varName = v.name || '';
+            const isSecret = v.secret || varName.includes('TOKEN') || varName.includes('KEY') || varName.includes('SECRET');
+            envVariables.push({
+                name: varName,
+                description: v.description || '',
+                required: false,
+                secret: isSecret,
+                currentValue: process.env[varName]
+            });
+        }
+    }
+    if (envVariables.length === 0) {
+        console.log(`✅ ${shortName} has no configurable environment variables`);
+        return;
+    }
+    await promptForConfiguration(envVariables, petPath, shortName);
+    console.log('\n💡 To apply changes:');
+    console.log('   • New session: restart opencode');
+    console.log('   • Keep session: run "opencode --continue" or "pets reload"\n');
+}
+async function promptForConfiguration(envVariables, packagePath, petId) {
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout
@@ -938,8 +1003,8 @@ async function promptForConfiguration(envVariables, packagePath) {
     }
     rl.close();
     if (Object.keys(envValues).length > 0) {
-        // Extract petId from the package path (e.g., /path/to/@openpets/maps -> maps)
-        const petId = packagePath.split('/').pop() || 'unknown';
+        // Use provided petId or extract from package path
+        const resolvedPetId = petId || packagePath.split('/').pop() || 'unknown';
         // Save to .pets/config.json (proper location for pet environment variables)
         const petsConfigDir = resolve(process.cwd(), '.pets');
         const petsConfigPath = resolve(petsConfigDir, 'config.json');
@@ -973,11 +1038,11 @@ async function promptForConfiguration(envVariables, packagePath) {
                 petsConfig.envConfig = {};
             }
             // Create or update pet-specific env config
-            if (!petsConfig.envConfig[petId]) {
-                petsConfig.envConfig[petId] = {};
+            if (!petsConfig.envConfig[resolvedPetId]) {
+                petsConfig.envConfig[resolvedPetId] = {};
             }
             // Set the environment variables
-            Object.assign(petsConfig.envConfig[petId], envValues);
+            Object.assign(petsConfig.envConfig[resolvedPetId], envValues);
             // Update timestamp
             petsConfig.last_updated = new Date().toISOString();
             // Write config
@@ -993,36 +1058,6 @@ async function promptForConfiguration(envVariables, packagePath) {
         }
     }
 }
-async function launchConfigModal(packageName, envVariables) {
-    const uiDir = resolve(__dirname, '../../apps/desktop');
-    if (!existsSync(uiDir)) {
-        console.log('Desktop UI not available, using CLI configuration...');
-        await promptForConfiguration(envVariables, '');
-        return;
-    }
-    console.log('🖥️  Launching configuration modal...');
-    const configData = {
-        packageName,
-        envVariables,
-        projectDir: process.cwd()
-    };
-    const child = spawn('bun', ['run', 'tauri:dev'], {
-        cwd: uiDir,
-        stdio: 'inherit',
-        shell: true,
-        env: {
-            ...process.env,
-            OPENPETS_CONFIG_MODE: 'true',
-            OPENPETS_CONFIG_DATA: JSON.stringify(configData),
-            OPENPETS_PROJECT_DIR: process.cwd()
-        }
-    });
-    child.on('error', (error) => {
-        console.error('Failed to launch configuration modal:', error);
-        console.log('Falling back to CLI configuration...');
-        promptForConfiguration(envVariables, '');
-    });
-}
 async function handlePrune(args) {
     const keepPets = args.filter(a => !a.startsWith('--'));
     const dryRun = args.includes('--dry-run');
@@ -1167,11 +1202,240 @@ async function handlePrune(args) {
     }
     writeFileSync(petsConfigPath, JSON.stringify(petsConfig, null, 2));
     console.log('✅ Updated .pets/config.json');
+    // Remove agent folders for disabled plugins
+    const agentRemovals = [];
+    for (const plugin of toDisable) {
+        const normalized = normalizeId(plugin);
+        const agentDir = resolve(process.cwd(), '.opencode', 'agent', normalized);
+        if (existsSync(agentDir)) {
+            try {
+                rmSync(agentDir, { recursive: true, force: true });
+                agentRemovals.push(normalized);
+                log(`Removed agent folder: ${agentDir}`);
+            }
+            catch (e) {
+                log(`Failed to remove agent folder ${agentDir}:`, e);
+            }
+        }
+    }
+    if (agentRemovals.length > 0) {
+        console.log(`🗑️  Removed ${agentRemovals.length} agent folder(s) from .opencode/agent/`);
+        for (const agent of agentRemovals) {
+            console.log(`   • ${agent}`);
+        }
+    }
     console.log(`\n🎉 Pruned ${toDisable.length} plugin(s), kept ${toKeep.length} plugin(s)`);
     console.log('💡 To apply changes:');
     console.log('   • New session: restart opencode');
     console.log('   • Keep session: run "opencode --continue" or "pets reload"');
 }
+async function handleTools(args) {
+    const petName = args.find(a => !a.startsWith('--'));
+    const showSchema = !args.includes('--no-schema'); // Default: show schema
+    const jsonOutput = args.includes('--json');
+    const liveMode = !args.includes('--static'); // Default: live mode
+    const expanded = args.includes('--expanded'); // Show detailed expanded view
+    const options = { showSchema, jsonOutput, liveMode, expanded };
+    let commandsData = null;
+    // Determine the plugin directory
+    let pluginDir = null;
+    if (petName) {
+        // Check local pets/ directory first
+        const localPetDir = resolve(process.cwd(), 'pets', petName);
+        if (existsSync(localPetDir)) {
+            pluginDir = localPetDir;
+        }
+        else {
+            // Check opencode cache
+            const cachePath = join(getOpencodeCacheDir(), '@openpets', petName);
+            if (existsSync(cachePath)) {
+                pluginDir = cachePath;
+            }
+        }
+    }
+    else {
+        // Current directory - only if it's a pet directory
+        if (existsSync(resolve(process.cwd(), 'index.ts'))) {
+            pluginDir = process.cwd();
+        }
+    }
+    // If we have a plugin directory, try to get tools
+    if (pluginDir) {
+        if (liveMode) {
+            commandsData = await getLiveTools(pluginDir, options);
+            if (!commandsData) {
+                console.log('⚠️  Could not load live tools, falling back to static commands.json...');
+            }
+        }
+        if (!commandsData) {
+            commandsData = readLocalCommands(pluginDir);
+        }
+        if (commandsData) {
+            if (jsonOutput) {
+                console.log(JSON.stringify(commandsData, null, 2));
+            }
+            else {
+                formatTools(commandsData, showSchema, expanded);
+            }
+            return;
+        }
+    }
+    // If pet name specified but not found locally, fetch from registry
+    if (petName && !commandsData) {
+        console.log(`🔍 Fetching tools for ${petName} from registry...`);
+        commandsData = await fetchFromRegistry(petName);
+        if (commandsData) {
+            if (jsonOutput) {
+                console.log(JSON.stringify(commandsData, null, 2));
+            }
+            else {
+                formatTools(commandsData, showSchema, expanded);
+            }
+            return;
+        }
+        console.error(`❌ Could not find tools for '${petName}'`);
+        console.error('   Make sure the pet exists and has been built with "pets build"');
+        console.error('   Or check if it\'s published to npm under @openpets/ scope');
+        process.exit(1);
+    }
+    // No pet name - check if this is a project directory with installed plugins
+    const opencodeJsonPath = resolve(process.cwd(), 'opencode.json');
+    if (existsSync(opencodeJsonPath)) {
+        const { plugins, totalTools } = await listProjectTools(process.cwd(), options);
+        if (plugins.length > 0) {
+            if (jsonOutput) {
+                console.log(JSON.stringify({ plugins, totalTools }, null, 2));
+            }
+            else {
+                printProjectToolsSummary(plugins, totalTools, showSchema, expanded);
+            }
+            return;
+        }
+    }
+    // Nothing found
+    console.error('❌ No tools found');
+    console.error('   - In a pet directory: run "pets build" to generate commands.json');
+    console.error('   - In a project: ensure opencode.json has plugins configured');
+    console.error('   - Or specify a pet name: pets tools <pet-name>');
+    process.exit(1);
+}
+async function handleClear(args) {
+    const dryRun = args.includes('--dry-run');
+    const keepAgents = args.includes('--keep-agents');
+    const opencodeJsonPath = resolve(process.cwd(), 'opencode.json');
+    const opencodeJsoncPath = resolve(process.cwd(), 'opencode.jsonc');
+    const petsConfigDir = resolve(process.cwd(), '.pets');
+    const petsConfigPath = resolve(petsConfigDir, 'config.json');
+    const agentBaseDir = resolve(process.cwd(), '.opencode', 'agent');
+    const configPath = existsSync(opencodeJsonPath) ? opencodeJsonPath :
+        existsSync(opencodeJsoncPath) ? opencodeJsoncPath : null;
+    if (!configPath) {
+        console.error('❌ No opencode.json found in current directory');
+        process.exit(1);
+    }
+    console.log('\n🧹 Clearing all pets plugins...');
+    if (dryRun) {
+        console.log('   (dry-run mode - no changes will be made)\n');
+    }
+    else {
+        console.log('');
+    }
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    const currentPlugins = Array.isArray(config.plugin)
+        ? config.plugin
+        : (config.plugin ? [config.plugin] : []);
+    const normalizeId = (id) => {
+        return id
+            .replace(/^@openpets\//, '')
+            .replace(/^openpets\//, '')
+            .replace(/^pets\//, '')
+            .replace(/^\.\/pets\//, '')
+            .replace(/\/index\.ts$/, '')
+            .replace(/\/index\.js$/, '');
+    };
+    if (currentPlugins.length === 0) {
+        console.log('📦 No plugins currently installed');
+        return;
+    }
+    console.log('📦 Plugins to REMOVE:');
+    for (const plugin of currentPlugins) {
+        console.log(`   ❌ ${plugin}`);
+    }
+    // Find agent folders to remove
+    const agentFoldersToRemove = [];
+    if (!keepAgents && existsSync(agentBaseDir)) {
+        for (const plugin of currentPlugins) {
+            const normalized = normalizeId(plugin);
+            const agentDir = resolve(agentBaseDir, normalized);
+            if (existsSync(agentDir)) {
+                agentFoldersToRemove.push(normalized);
+            }
+        }
+        if (agentFoldersToRemove.length > 0) {
+            console.log('\n🤖 Agent folders to REMOVE:');
+            for (const agent of agentFoldersToRemove) {
+                console.log(`   ❌ .opencode/agent/${agent}/`);
+            }
+        }
+    }
+    if (dryRun) {
+        console.log('\n💡 Run without --dry-run to apply these changes');
+        return;
+    }
+    // Clear plugins from opencode.json
+    config.plugin = [];
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('\n✅ Cleared all plugins from opencode.json');
+    // Update .pets/config.json
+    let petsConfig = {
+        enabled: [],
+        disabled: [],
+    };
+    if (existsSync(petsConfigPath)) {
+        try {
+            petsConfig = JSON.parse(readFileSync(petsConfigPath, 'utf-8'));
+        }
+        catch (e) {
+            log('Could not parse existing .pets/config.json, creating new one');
+        }
+    }
+    if (!Array.isArray(petsConfig.enabled))
+        petsConfig.enabled = [];
+    if (!Array.isArray(petsConfig.disabled))
+        petsConfig.disabled = [];
+    // Move all enabled to disabled
+    for (const plugin of currentPlugins) {
+        const normalized = normalizeId(plugin);
+        petsConfig.enabled = petsConfig.enabled.filter(p => normalizeId(p) !== normalized);
+        if (!petsConfig.disabled.some(p => normalizeId(p) === normalized)) {
+            petsConfig.disabled.push(normalized);
+        }
+    }
+    petsConfig.last_updated = new Date().toISOString();
+    if (!existsSync(petsConfigDir)) {
+        mkdirSync(petsConfigDir, { recursive: true });
+    }
+    writeFileSync(petsConfigPath, JSON.stringify(petsConfig, null, 2));
+    console.log('✅ Updated .pets/config.json');
+    // Remove agent folders
+    if (!keepAgents && agentFoldersToRemove.length > 0) {
+        for (const agent of agentFoldersToRemove) {
+            const agentDir = resolve(agentBaseDir, agent);
+            try {
+                rmSync(agentDir, { recursive: true, force: true });
+                log(`Removed agent folder: ${agentDir}`);
+            }
+            catch (e) {
+                log(`Failed to remove agent folder ${agentDir}:`, e);
+            }
+        }
+        console.log(`🗑️  Removed ${agentFoldersToRemove.length} agent folder(s)`);
+    }
+    console.log(`\n🎉 Cleared ${currentPlugins.length} plugin(s)`);
+    console.log('💡 To apply changes:');
+    console.log('   • New session: restart opencode');
+    console.log('   • Keep session: run "opencode --continue" or "pets reload"');
+}
 async function handleReload(args) {
     const sessionIndex = args.indexOf('--session');
     const sessionId = sessionIndex >= 0 ? args[sessionIndex + 1] : undefined;
@@ -1238,10 +1502,37 @@ async function handleReload(args) {
         });
     }
 }
+async function handleGenerateOpenAPI(args) {
+    const urlIndex = args.indexOf('--url');
+    const fileIndex = args.indexOf('--file');
+    const baseUrlIndex = args.indexOf('--base-url');
+    const outputIndex = args.indexOf('--output');
+    const options = {
+        url: urlIndex >= 0 ? args[urlIndex + 1] : undefined,
+        file: fileIndex >= 0 ? args[fileIndex + 1] : undefined,
+        baseUrl: baseUrlIndex >= 0 ? args[baseUrlIndex + 1] : undefined,
+        outputFile: outputIndex >= 0 ? args[outputIndex + 1] : undefined,
+        dryRun: args.includes('--dry-run') || args.includes('-n'),
+        verbose: args.includes('--verbose') || args.includes('-v'),
+        dumpSpec: args.includes('--dump-spec'),
+    };
+    console.log('🔧 Generating OpenAPI tools...');
+    const result = await generateOpenAPITools(options);
+    if (result.success) {
+        console.log(`✅ ${result.message}`);
+        if (result.outputPath && !options.dryRun) {
+            console.log(`📁 Output: ${result.outputPath}`);
+        }
+    }
+    else {
+        console.error(`❌ ${result.message}`);
+        process.exit(1);
+    }
+}
 function showUnknownCommandError(command) {
     const validCommands = [
-        'add', 'install', 'uninstall', 'remove', 'delete', 'inspect', 'search', 'list', 'run', 'prune', 'reload',
-        'init', 'build', 'deploy', 'validate', 'publish', 'playground',
+        'add', 'install', 'uninstall', 'remove', 'delete', 'inspect', 'search', 'list', 'run', 'prune', 'clear', 'config', 'reload',
+        'init', 'build', 'deploy', 'validate', 'publish', 'playground', 'generate-openapi',
         'discover', 'registry', 'help'
     ];
     const similar = validCommands.find(cmd => cmd.startsWith(command.slice(0, 2)) ||
@@ -1261,13 +1552,14 @@ USAGE:
 
 REGISTRY COMMANDS:
   add <name>              Download pet and add to local opencode.json
+                          Also copies prompts/ to .opencode/agent/<name>/
     --version <version>   Install specific version
-    --skip-config         Skip environment variable configuration
-    --config '{"k":"v"}'  Pre-set environment variables
+
+  config <name>           Configure environment variables for a pet
+                          Interactive prompt for required and optional vars
 
   install <name>          Install a pet from the registry (npm install)
     --client <client>     Target client (claude, opencode, cursor, vscode)
-    --config '{"k":"v"}'  Pre-configure environment variables
     --global, -g          Install globally
     --version <version>   Install specific version
 
@@ -1290,7 +1582,13 @@ REGISTRY COMMANDS:
     --transport <type>    Transport type (stdio, http)
 
   prune <pet> [pets...]   Keep only specified pets, disable all others
+                          Also removes agent folders for disabled pets
+    --dry-run             Preview changes without applying
+
+  clear                   Remove ALL pets plugins from opencode.json
+                          Also removes all pet agent folders
     --dry-run             Preview changes without applying
+    --keep-agents         Keep agent folders (only clear opencode.json)
 
   reload [message]        Reload OpenCode with updated plugins (continues session)
     --session <id>        Continue a specific session instead of the last one
@@ -1304,10 +1602,25 @@ DEVELOPMENT COMMANDS:
   build <pet-name>        Build and validate a pet package
   deploy <pet-name>       Build and deploy with metadata
   validate [dir]          Validate pet configuration
+  generate-openapi        Generate tools from OpenAPI/Swagger spec
+    --url <url>           URL to fetch OpenAPI spec from
+    --file <path>         Local file path to OpenAPI spec
+    --base-url <url>      Base URL for API calls (overrides spec servers)
+    --output <file>       Output file name (default: openapi-client.ts)
+    -n, --dry-run         Preview without writing files
+    -v, --verbose         Show detailed output
+    --dump-spec           Dump raw spec to JSON for debugging
+  tools [pet-name]        List tools provided by a pet (single line by default)
+    --expanded            Show detailed view with parameters
+    --static              Use static commands.json instead of running plugin
+    --no-schema           Hide parameter details (in expanded mode)
+    --json                Output as JSON
 
   publish [pet-name]      Publish a pet to npm
     --preview             Dry-run mode
     --channel <name>      npm tag (default: latest)
+    --scope <scope>       npm scope (default: @openpets, use "" for unscoped)
+    --otp <code>          One-time password for 2FA-enabled accounts
 
   playground              Open the web playground
 
@@ -1327,9 +1640,9 @@ OTHER:
   help, --help, -h        Show this help message
 
 EXAMPLES:
-  pets add maps                                  # Download @openpets/maps and configure
-  pets add @openpets/maps --skip-config          # Download without configuration prompts
-  pets add postgres --config '{"DATABASE_URL":"postgres://..."}'
+  pets add maps                                  # Download @openpets/maps
+  pets add maps --version 1.0.0                  # Install specific version
+  pets config maps                               # Configure environment variables
   pets install maps --client claude              # Install via npm for specific client
   pets search github
   pets inspect linear
@@ -1338,6 +1651,10 @@ EXAMPLES:
   pets run hackernews
   pets init my-awesome-pet
   pets validate ./pets/my-pet
+  pets tools                                      # List tools in current dir (single line)
+  pets tools coder                                # List tools for coder pet
+  pets tools coder --expanded                     # List tools with detailed parameters
+  pets tools asana --static                       # List tools from static commands.json
   pets publish --preview
   pets discover --github
   pets registry update
@@ -1350,6 +1667,15 @@ ENVIRONMENT:
   PETS_DEBUG=true         Enable detailed debug logging
   GITHUB_TOKEN=<token>    GitHub token for repository discovery
 
+AGENT PROMPTS:
+  Pets can include agent prompts in their prompts/ directory.
+  When you run "pets add <name>", these are automatically copied to:
+    .opencode/agent/<pet-name>/
+
+  OpenCode discovers agents from .opencode/agent/ directories and makes
+  them available for @mentions in your conversations. Agent files are
+  markdown with YAML frontmatter defining behavior (model, tools, etc.)
+
 HOW DISCOVERY WORKS:
   The discovery system finds OpenPets-compatible packages via: