@orchagent/cli 0.2.26 → 0.3.0

package/dist/adapters/agents-md.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsMdAdapter = void 0;
+exports.agentsMdAdapter = {
+    id: 'agents-md',
+    name: 'AGENTS.md (Universal)',
+    version: '1.0.0',
+    formatVersion: '1.0',
+    supportsAgentTypes: ['prompt', 'skill'],
+    installPaths: [
+        {
+            scope: 'project',
+            path: './',
+            description: 'Project root (AGENTS.md)',
+        },
+    ],
+    canConvert(agent) {
+        const warnings = [];
+        const errors = [];
+        if (agent.type === 'code') {
+            errors.push('Code agents cannot be converted to AGENTS.md');
+            return { canConvert: false, warnings, errors };
+        }
+        if (!agent.prompt) {
+            errors.push('Agent has no prompt content');
+            return { canConvert: false, warnings, errors };
+        }
+        warnings.push('AGENTS.md content should be appended to existing file, not replaced');
+        return { canConvert: true, warnings, errors };
+    },
+    convert(agent) {
+        const agentRef = `${agent.org_slug}/${agent.name}`;
+        const description = agent.description || '';
+        // Use orchagent markers for managed section
+        const content = `<!-- orchagent:${agentRef} -->
+## ${agent.name}
+
+${description}
+
+${agent.prompt || ''}
+<!-- /orchagent:${agentRef} -->
+`;
+        return [
+            {
+                filename: 'AGENTS.md',
+                content,
+                installPath: './',
+            },
+        ];
+    },
+};

package/dist/adapters/claude-code.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeCodeAdapter = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+// Map Anthropic model names to Claude Code aliases
+function mapModelToAlias(model) {
+    if (!model)
+        return 'inherit';
+    const lower = model.toLowerCase();
+    if (lower.includes('opus'))
+        return 'opus';
+    if (lower.includes('haiku'))
+        return 'haiku';
+    // Default to sonnet for any Claude model
+    if (lower.includes('claude') || lower.includes('sonnet'))
+        return 'sonnet';
+    return 'inherit';
+}
+// Convert agent name to valid Claude Code name (lowercase + hyphens)
+function normalizeAgentName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+exports.claudeCodeAdapter = {
+    id: 'claude-code',
+    name: 'Claude Code Sub-Agent',
+    version: '1.0.0',
+    formatVersion: '2026-01',
+    supportsAgentTypes: ['prompt', 'skill'],
+    installPaths: [
+        {
+            scope: 'user',
+            path: '~/.claude/agents/',
+            description: 'User-level (available in all projects)',
+        },
+        {
+            scope: 'project',
+            path: '.claude/agents/',
+            description: 'Project-level (current directory)',
+        },
+    ],
+    canConvert(agent) {
+        const warnings = [];
+        const errors = [];
+        // Code agents cannot be converted
+        if (agent.type === 'code') {
+            errors.push('Code agents cannot be converted to Claude Code sub-agents (they require execution)');
+            return { canConvert: false, warnings, errors };
+        }
+        // Check for prompt
+        if (!agent.prompt) {
+            errors.push('Agent has no prompt content');
+            return { canConvert: false, warnings, errors };
+        }
+        // Warnings for fields that can't be fully mapped
+        if (agent.input_schema) {
+            warnings.push('input_schema will be described in the prompt body, not enforced');
+        }
+        if (agent.output_schema) {
+            warnings.push('output_schema will be described in the prompt body, not enforced');
+        }
+        return { canConvert: true, warnings, errors };
+    },
+    convert(agent) {
+        const normalizedName = normalizeAgentName(agent.name);
+        // Build frontmatter
+        const frontmatter = {
+            name: normalizedName,
+            description: agent.description || `Delegatable agent: ${agent.name}`,
+            tools: 'Read, Glob, Grep', // Safe defaults - read-only
+        };
+        // Map model if specified
+        if (agent.default_models?.anthropic) {
+            const modelAlias = mapModelToAlias(agent.default_models.anthropic);
+            if (modelAlias !== 'inherit') {
+                frontmatter.model = modelAlias;
+            }
+        }
+        // Build body
+        let body = agent.prompt || '';
+        // Add schema descriptions if present
+        if (agent.input_schema) {
+            body += `\n\n## Input Schema\n\nThis agent expects input matching:\n\`\`\`json\n${JSON.stringify(agent.input_schema, null, 2)}\n\`\`\``;
+        }
+        if (agent.output_schema) {
+            body += `\n\n## Output Schema\n\nThis agent should return output matching:\n\`\`\`json\n${JSON.stringify(agent.output_schema, null, 2)}\n\`\`\``;
+        }
+        // Combine frontmatter + body
+        const content = `---\n${yaml_1.default.stringify(frontmatter).trim()}\n---\n\n${body.trim()}\n`;
+        return [
+            {
+                filename: `${normalizedName}.md`,
+                content,
+                installPath: '.claude/agents/',
+            },
+        ];
+    },
+};

package/dist/adapters/cursor.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorAdapter = void 0;
+// Convert agent name to valid filename (lowercase + hyphens)
+function normalizeAgentName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+exports.cursorAdapter = {
+    id: 'cursor',
+    name: 'Cursor Rules',
+    version: '1.0.0',
+    formatVersion: '2026-01',
+    supportsAgentTypes: ['prompt', 'skill'],
+    installPaths: [
+        {
+            scope: 'project',
+            path: '.cursor/rules/',
+            description: 'Project-level Cursor rules',
+        },
+    ],
+    canConvert(agent) {
+        const warnings = [];
+        const errors = [];
+        if (agent.type === 'code') {
+            errors.push('Code agents cannot be converted to Cursor rules');
+            return { canConvert: false, warnings, errors };
+        }
+        if (!agent.prompt) {
+            errors.push('Agent has no prompt content');
+            return { canConvert: false, warnings, errors };
+        }
+        // Cursor doesn't support input/output schemas
+        if (agent.input_schema) {
+            warnings.push('input_schema is not supported in Cursor rules');
+        }
+        if (agent.output_schema) {
+            warnings.push('output_schema is not supported in Cursor rules');
+        }
+        return { canConvert: true, warnings, errors };
+    },
+    convert(agent) {
+        const normalizedName = normalizeAgentName(agent.name);
+        const description = agent.description || `Rules from ${agent.name}`;
+        // Cursor .mdc format
+        const content = `---
+description: ${description}
+globs:
+alwaysApply: false
+---
+
+# ${agent.name}
+
+${agent.prompt || ''}
+`;
+        return [
+            {
+                filename: `${normalizedName}.mdc`,
+                content,
+                installPath: '.cursor/rules/',
+            },
+        ];
+    },
+};

package/dist/adapters/index.js

@@ -0,0 +1,38 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsMdAdapter = exports.cursorAdapter = exports.claudeCodeAdapter = exports.adapterRegistry = exports.AdapterRegistry = void 0;
+// Export types
+__exportStar(require("./types"), exports);
+// Export registry
+const registry_1 = require("./registry");
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "AdapterRegistry", { enumerable: true, get: function () { return registry_2.AdapterRegistry; } });
+Object.defineProperty(exports, "adapterRegistry", { enumerable: true, get: function () { return registry_2.adapterRegistry; } });
+// Import and register adapters
+const claude_code_1 = require("./claude-code");
+var claude_code_2 = require("./claude-code");
+Object.defineProperty(exports, "claudeCodeAdapter", { enumerable: true, get: function () { return claude_code_2.claudeCodeAdapter; } });
+const cursor_1 = require("./cursor");
+var cursor_2 = require("./cursor");
+Object.defineProperty(exports, "cursorAdapter", { enumerable: true, get: function () { return cursor_2.cursorAdapter; } });
+const agents_md_1 = require("./agents-md");
+var agents_md_2 = require("./agents-md");
+Object.defineProperty(exports, "agentsMdAdapter", { enumerable: true, get: function () { return agents_md_2.agentsMdAdapter; } });
+// Register built-in adapters
+registry_1.adapterRegistry.register(claude_code_1.claudeCodeAdapter);
+registry_1.adapterRegistry.register(cursor_1.cursorAdapter);
+registry_1.adapterRegistry.register(agents_md_1.agentsMdAdapter);

package/dist/adapters/registry.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterRegistry = exports.AdapterRegistry = void 0;
+class AdapterRegistry {
+    adapters = new Map();
+    /**
+     * Register an adapter
+     */
+    register(adapter) {
+        if (this.adapters.has(adapter.id)) {
+            throw new Error(`Adapter '${adapter.id}' is already registered`);
+        }
+        this.adapters.set(adapter.id, adapter);
+    }
+    /**
+     * Get adapter by ID
+     */
+    get(id) {
+        return this.adapters.get(id);
+    }
+    /**
+     * List all registered adapters
+     */
+    list() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * Find adapters compatible with an agent
+     */
+    findCompatible(agent) {
+        return this.list().filter(adapter => {
+            const result = adapter.canConvert(agent);
+            return result.canConvert;
+        });
+    }
+    /**
+     * Check if an adapter ID is valid
+     */
+    has(id) {
+        return this.adapters.has(id);
+    }
+    /**
+     * Get all adapter IDs
+     */
+    getIds() {
+        return Array.from(this.adapters.keys());
+    }
+}
+exports.AdapterRegistry = AdapterRegistry;
+// Global registry instance
+exports.adapterRegistry = new AdapterRegistry();

package/dist/adapters/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/config.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigCommand = registerConfigCommand;
+const config_1 = require("../lib/config");
+const errors_1 = require("../lib/errors");
+const SUPPORTED_KEYS = ['default-format'];
+function isValidKey(key) {
+    return SUPPORTED_KEYS.includes(key);
+}
+async function setConfigValue(key, value) {
+    if (!isValidKey(key)) {
+        throw new errors_1.CliError(`Unknown config key: ${key}. Supported keys: ${SUPPORTED_KEYS.join(', ')}`);
+    }
+    if (key === 'default-format') {
+        const formats = value.split(',').map((f) => f.trim()).filter(Boolean);
+        // Validate all format IDs
+        const invalidFormats = formats.filter((f) => !config_1.VALID_FORMAT_IDS.includes(f));
+        if (invalidFormats.length > 0) {
+            throw new errors_1.CliError(`Invalid format ID(s): ${invalidFormats.join(', ')}. Valid formats: ${config_1.VALID_FORMAT_IDS.join(', ')}`);
+        }
+        await (0, config_1.setDefaultFormats)(formats);
+        process.stdout.write(`Set default-format to: ${formats.join(',')}\n`);
+    }
+}
+async function getConfigValue(key) {
+    if (!isValidKey(key)) {
+        throw new errors_1.CliError(`Unknown config key: ${key}. Supported keys: ${SUPPORTED_KEYS.join(', ')}`);
+    }
+    if (key === 'default-format') {
+        const formats = await (0, config_1.getDefaultFormats)();
+        if (formats.length === 0) {
+            process.stdout.write('(not set)\n');
+        }
+        else {
+            process.stdout.write(`${formats.join(',')}\n`);
+        }
+    }
+}
+async function listConfigValues() {
+    const config = await (0, config_1.loadConfig)();
+    process.stdout.write('CLI Configuration:\n\n');
+    // default-format
+    const formats = config.default_formats ?? [];
+    if (formats.length > 0) {
+        process.stdout.write(`  default-format: ${formats.join(',')}\n`);
+    }
+    else {
+        process.stdout.write('  default-format: (not set)\n');
+    }
+    process.stdout.write('\n');
+}
+function registerConfigCommand(program) {
+    const config = program
+        .command('config')
+        .description('Manage CLI configuration');
+    config
+        .command('set <key> <value>')
+        .description('Set a configuration value')
+        .action(async (key, value) => {
+        await setConfigValue(key, value);
+    });
+    config
+        .command('get <key>')
+        .description('Get a configuration value')
+        .action(async (key) => {
+        await getConfigValue(key);
+    });
+    config
+        .command('list')
+        .description('List all configuration values')
+        .action(async () => {
+        await listConfigValues();
+    });
+}

package/dist/commands/formats.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFormatsCommand = registerFormatsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const adapters_1 = require("../adapters");
+function registerFormatsCommand(program) {
+    program
+        .command('formats')
+        .description('List available export formats for agents')
+        .option('--json', 'Output raw JSON')
+        .action(async (options) => {
+        const adapters = adapters_1.adapterRegistry.list();
+        if (options.json) {
+            const data = adapters.map(a => ({
+                id: a.id,
+                name: a.name,
+                version: a.version,
+                formatVersion: a.formatVersion,
+                supportsAgentTypes: a.supportsAgentTypes,
+                installPaths: a.installPaths,
+            }));
+            process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+            return;
+        }
+        process.stdout.write('\nAvailable export formats:\n\n');
+        for (const adapter of adapters) {
+            process.stdout.write(`  ${chalk_1.default.cyan(adapter.id)}    ${adapter.name}\n`);
+            process.stdout.write(`               Supports: ${adapter.supportsAgentTypes.join(', ')} agents\n`);
+            process.stdout.write(`               Format version: ${adapter.formatVersion}\n`);
+            for (const installPath of adapter.installPaths) {
+                const pathDisplay = installPath.scope === 'user'
+                    ? installPath.path
+                    : installPath.path;
+                process.stdout.write(`               ${installPath.scope}: ${pathDisplay}\n`);
+            }
+            process.stdout.write('\n');
+        }
+        process.stdout.write('Use with: orch install <agent> --format <id>\n');
+        process.stdout.write('Set default: orch config set default-format <ids>\n\n');
+    });
+}

package/dist/commands/index.js

@@ -21,6 +21,10 @@ const status_1 = require("./status");
 const workspace_1 = require("./workspace");
 const tree_1 = require("./tree");
 const docs_1 = require("./docs");
+const config_1 = require("./config");
+const install_1 = require("./install");
+const formats_1 = require("./formats");
+const update_1 = require("./update");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -42,4 +46,8 @@ function registerCommands(program) {
     (0, workspace_1.registerWorkspaceCommand)(program);
     (0, tree_1.registerTreeCommand)(program);
     (0, docs_1.registerDocsCommand)(program);
+    (0, config_1.registerConfigCommand)(program);
+    (0, install_1.registerInstallCommand)(program);
+    (0, formats_1.registerFormatsCommand)(program);
+    (0, update_1.registerUpdateCommand)(program);
 }

package/dist/commands/install.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInstallCommand = registerInstallCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+const adapters_1 = require("../adapters");
+const installed_1 = require("../lib/installed");
+const DEFAULT_VERSION = 'v1';
+function parseAgentRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || DEFAULT_VERSION;
+    const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { name: segments[0], version };
+    }
+    if (segments.length === 2) {
+        return { org: segments[0], name: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid agent reference. Use org/agent or agent format.');
+}
+async function downloadAgentWithFallback(config, org, name, version) {
+    // Try public endpoint first
+    try {
+        const agent = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${name}/${version}`);
+        return { ...agent, org_slug: org };
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Fallback to authenticated endpoint for private agents
+    if (!config.apiKey) {
+        throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+    }
+    const userOrg = await (0, api_1.getOrg)(config);
+    if (userOrg.slug !== org) {
+        throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+    }
+    const agents = await (0, api_1.listMyAgents)(config);
+    const matching = agents.filter(a => a.name === name);
+    if (matching.length === 0) {
+        throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+    }
+    let targetAgent;
+    if (version === 'latest') {
+        targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    else {
+        const found = matching.find(a => a.version === version);
+        if (!found) {
+            throw new api_1.ApiError(`Agent '${org}/${name}@${version}' not found`, 404);
+        }
+        targetAgent = found;
+    }
+    return { ...targetAgent, org_slug: org };
+}
+function registerInstallCommand(program) {
+    program
+        .command('install <agent>')
+        .description('Install agent as sub-agent (Claude Code, Cursor, etc.)')
+        .option('--format <formats>', 'Comma-separated format IDs (e.g., claude-code,cursor)')
+        .option('--scope <scope>', 'Install scope: user (home dir) or project (current dir)', 'user')
+        .option('--dry-run', 'Show what would be installed without making changes')
+        .action(async (agentArg, options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        const parsed = parseAgentRef(agentArg);
+        const org = parsed.org ?? resolved.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
+        }
+        // Determine target formats
+        let targetFormats = [];
+        if (options.format) {
+            targetFormats = options.format.split(',').map(f => f.trim());
+            const invalid = targetFormats.filter(f => !adapters_1.adapterRegistry.has(f));
+            if (invalid.length > 0) {
+                throw new errors_1.CliError(`Unknown format(s): ${invalid.join(', ')}. Available: ${adapters_1.adapterRegistry.getIds().join(', ')}`);
+            }
+        }
+        else {
+            const defaults = await (0, config_1.getDefaultFormats)();
+            if (defaults.length > 0) {
+                targetFormats = defaults;
+            }
+            else {
+                // No default configured - use claude-code as sensible default
+                targetFormats = ['claude-code'];
+            }
+        }
+        // Validate scope
+        const scope = options.scope;
+        if (scope !== 'user' && scope !== 'project') {
+            throw new errors_1.CliError('Scope must be "user" or "project"');
+        }
+        // Download agent
+        process.stdout.write(`Fetching ${org}/${parsed.name}@${parsed.version}...\n`);
+        const agent = await downloadAgentWithFallback(resolved, org, parsed.name, parsed.version);
+        // Install for each format
+        for (const formatId of targetFormats) {
+            const adapter = adapters_1.adapterRegistry.get(formatId);
+            if (!adapter) {
+                process.stderr.write(`Warning: Unknown format '${formatId}', skipping\n`);
+                continue;
+            }
+            // Check if can convert
+            const checkResult = adapter.canConvert(agent);
+            if (!checkResult.canConvert) {
+                process.stderr.write(`Cannot convert to ${adapter.name}:\n`);
+                for (const err of checkResult.errors) {
+                    process.stderr.write(`  - ${err}\n`);
+                }
+                continue;
+            }
+            // Show warnings
+            for (const warn of checkResult.warnings) {
+                process.stdout.write(`Warning (${formatId}): ${warn}\n`);
+            }
+            // Convert
+            const files = adapter.convert(agent);
+            // Determine base directory
+            const baseDir = scope === 'user' ? os_1.default.homedir() : process.cwd();
+            // Install each file
+            for (const file of files) {
+                const fullDir = path_1.default.join(baseDir, file.installPath);
+                const fullPath = path_1.default.join(fullDir, file.filename);
+                if (options.dryRun) {
+                    process.stdout.write(`Would install: ${fullPath}\n`);
+                    process.stdout.write(`Content preview:\n${file.content.slice(0, 500)}...\n\n`);
+                    continue;
+                }
+                // Create directory and write file
+                await promises_1.default.mkdir(fullDir, { recursive: true });
+                await promises_1.default.writeFile(fullPath, file.content);
+                // Track installation
+                const installedAgent = {
+                    agent: `${org}/${parsed.name}`,
+                    version: parsed.version,
+                    format: formatId,
+                    scope,
+                    path: fullPath,
+                    installedAt: new Date().toISOString(),
+                    adapterVersion: adapter.version,
+                    contentHash: (0, installed_1.computeHash)(file.content),
+                };
+                await (0, installed_1.trackInstall)(installedAgent);
+                process.stdout.write(`Installed: ${fullPath}\n`);
+            }
+        }
+        if (!options.dryRun) {
+            await (0, analytics_1.track)('cli_agent_install', {
+                agent: `${org}/${parsed.name}`,
+                formats: targetFormats,
+                scope,
+            });
+            process.stdout.write(`\nAgent installed successfully!\n`);
+            if (scope === 'user') {
+                process.stdout.write(`Available in all your projects.\n`);
+            }
+            else {
+                process.stdout.write(`Available in this project only.\n`);
+            }
+        }
+    });
+}

package/dist/commands/skill.js

@@ -162,8 +162,29 @@ Instructions and guidance for AI agents...
         .description('Install skill to local AI tool directories (Claude Code, Cursor, etc.)')
         .option('--global', 'Install to home directory (default: current directory)')
         .option('--dry-run', 'Show what would be installed without making changes')
+        .option('--format <formats>', 'Comma-separated format IDs (e.g., claude-code,cursor)')
         .action(async (skillRef, options) => {
         const resolved = await (0, config_1.getResolvedConfig)();
+        // Determine target formats
+        let targetFormats = [];
+        if (options.format) {
+            targetFormats = options.format.split(',').map((f) => f.trim());
+            // Validate format IDs
+            const invalid = targetFormats.filter(f => !config_1.VALID_FORMAT_IDS.includes(f));
+            if (invalid.length > 0) {
+                throw new errors_1.CliError(`Invalid format ID(s): ${invalid.join(', ')}. Valid: ${config_1.VALID_FORMAT_IDS.join(', ')}`);
+            }
+        }
+        else {
+            const defaults = await (0, config_1.getDefaultFormats)();
+            if (defaults.length > 0) {
+                targetFormats = defaults;
+            }
+        }
+        // Determine target directories
+        const toolDirs = targetFormats.length > 0
+            ? targetFormats.map(f => config_1.FORMAT_SKILL_DIRS[f])
+            : AI_TOOL_SKILL_DIRS; // fallback to all
         const parsed = parseSkillRef(skillRef);
         const org = parsed.org ?? resolved.defaultOrg;
         if (!org) {
@@ -191,7 +212,7 @@ ${skillData.prompt}
         if (options.dryRun) {
             process.stdout.write(`Would install ${org}/${parsed.skill}@${parsed.version}\n\n`);
             process.stdout.write(`Target directories:\n`);
-            for (const tool of AI_TOOL_SKILL_DIRS) {
+            for (const tool of toolDirs) {
                 const skillDir = path_1.default.join(baseDir, tool.path);
                 const skillFile = path_1.default.join(skillDir, `${parsed.skill}.md`);
                 process.stdout.write(`  - ${tool.name}: ${skillFile}\n`);
@@ -199,9 +220,9 @@ ${skillData.prompt}
             process.stdout.write(`\nNo changes made (dry run)\n`);
             return;
         }
-        // Install to all AI tool directories
+        // Install to target AI tool directories
         const installed = [];
-        for (const tool of AI_TOOL_SKILL_DIRS) {
+        for (const tool of toolDirs) {
             const skillDir = path_1.default.join(baseDir, tool.path);
             const skillFile = path_1.default.join(skillDir, `${parsed.skill}.md`);
             try {

package/dist/commands/update.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUpdateCommand = registerUpdateCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const analytics_1 = require("../lib/analytics");
+const adapters_1 = require("../adapters");
+const installed_1 = require("../lib/installed");
+async function fetchLatestAgent(config, agentRef) {
+    const [org, name] = agentRef.split('/');
+    if (!org || !name)
+        return null;
+    try {
+        // Try to get latest version
+        const agent = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${name}/latest`);
+        return {
+            agent: { ...agent, org_slug: org },
+            latestVersion: agent.version
+        };
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError && err.status === 404) {
+            return null;
+        }
+        throw err;
+    }
+}
+function registerUpdateCommand(program) {
+    program
+        .command('update [agent]')
+        .description('Update installed agents to latest versions')
+        .option('--check', 'Check for updates without installing')
+        .option('--force', 'Force update even if file was modified locally')
+        .action(async (agentRef, options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        const installed = await (0, installed_1.getInstalled)();
+        if (installed.length === 0) {
+            process.stdout.write('No agents installed. Use "orch install <agent>" to install agents.\n');
+            return;
+        }
+        // Filter to specific agent if provided
+        const toCheck = agentRef
+            ? installed.filter(i => i.agent === agentRef)
+            : installed;
+        if (toCheck.length === 0) {
+            process.stdout.write(`Agent "${agentRef}" is not installed.\n`);
+            return;
+        }
+        process.stdout.write(`Checking ${toCheck.length} installed agent(s) for updates...\n\n`);
+        let updatesAvailable = 0;
+        let updatesApplied = 0;
+        let skippedModified = 0;
+        for (const item of toCheck) {
+            // Check if file was modified locally
+            const wasModified = await (0, installed_1.checkModified)(item);
+            // Fetch latest version
+            const latest = await fetchLatestAgent(resolved, item.agent);
+            if (!latest) {
+                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${item.agent} - could not fetch latest\n`);
+                continue;
+            }
+            const hasUpdate = latest.latestVersion !== item.version;
+            if (!hasUpdate && !wasModified) {
+                process.stdout.write(`  ${chalk_1.default.green('✓')} ${item.agent}@${item.version} - up to date\n`);
+                continue;
+            }
+            if (wasModified && !options.force) {
+                process.stdout.write(`  ${chalk_1.default.yellow('!')} ${item.agent} - local modifications (use --force to overwrite)\n`);
+                skippedModified++;
+                continue;
+            }
+            if (hasUpdate) {
+                updatesAvailable++;
+                process.stdout.write(`  ${chalk_1.default.blue('↑')} ${item.agent}@${item.version} → ${latest.latestVersion}`);
+                if (wasModified) {
+                    process.stdout.write(` ${chalk_1.default.yellow('(modified)')}`);
+                }
+                process.stdout.write('\n');
+                if (options.check) {
+                    continue;
+                }
+                // Apply update
+                const adapter = adapters_1.adapterRegistry.get(item.format);
+                if (!adapter) {
+                    process.stderr.write(`    Skipped: Unknown format "${item.format}"\n`);
+                    continue;
+                }
+                const checkResult = adapter.canConvert(latest.agent);
+                if (!checkResult.canConvert) {
+                    process.stderr.write(`    Skipped: ${checkResult.errors.join(', ')}\n`);
+                    continue;
+                }
+                const files = adapter.convert(latest.agent);
+                for (const file of files) {
+                    // Use the original path from tracking
+                    const fullPath = item.path;
+                    try {
+                        const dir = path_1.default.dirname(fullPath);
+                        await promises_1.default.mkdir(dir, { recursive: true });
+                        await promises_1.default.writeFile(fullPath, file.content);
+                        // Update tracking
+                        const updatedItem = {
+                            ...item,
+                            version: latest.latestVersion,
+                            installedAt: new Date().toISOString(),
+                            adapterVersion: adapter.version,
+                            contentHash: (0, installed_1.computeHash)(file.content),
+                        };
+                        await (0, installed_1.trackInstall)(updatedItem);
+                        process.stdout.write(`    Updated: ${fullPath}\n`);
+                        updatesApplied++;
+                    }
+                    catch (err) {
+                        process.stderr.write(`    Error: ${err.message}\n`);
+                    }
+                }
+            }
+        }
+        process.stdout.write('\n');
+        if (options.check) {
+            process.stdout.write(`Found ${updatesAvailable} update(s) available.\n`);
+            if (skippedModified > 0) {
+                process.stdout.write(`${skippedModified} agent(s) have local modifications.\n`);
+            }
+            process.stdout.write('Run "orch update" without --check to apply updates.\n');
+        }
+        else {
+            process.stdout.write(`Applied ${updatesApplied} update(s).\n`);
+            if (skippedModified > 0) {
+                process.stdout.write(`Skipped ${skippedModified} modified agent(s). Use --force to overwrite.\n`);
+            }
+        }
+        await (0, analytics_1.track)('cli_agent_update', {
+            checked: toCheck.length,
+            updatesAvailable,
+            updatesApplied,
+            skippedModified,
+        });
+    });
+}

package/dist/lib/config.js

@@ -3,16 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT_SKILL_DIRS = exports.VALID_FORMAT_IDS = void 0;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
 exports.getResolvedConfig = getResolvedConfig;
 exports.getConfigPath = getConfigPath;
+exports.getDefaultFormats = getDefaultFormats;
+exports.setDefaultFormats = setDefaultFormats;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
 const CONFIG_PATH = path_1.default.join(CONFIG_DIR, 'config.json');
 const DEFAULT_API_URL = 'https://api.orchagent.io';
+// Valid format IDs for multi-format agent export
+exports.VALID_FORMAT_IDS = ['claude-code', 'cursor', 'codex', 'amp', 'opencode', 'antigravity'];
+// Map format IDs to skill directories (used by skill install and agent install)
+exports.FORMAT_SKILL_DIRS = {
+    'claude-code': { name: 'Claude Code', path: '.claude/skills' },
+    'cursor': { name: 'Cursor', path: '.cursor/skills' },
+    'codex': { name: 'Codex', path: '.codex/skills' },
+    'amp': { name: 'Amp', path: '.agents/skills' },
+    'opencode': { name: 'OpenCode', path: '.opencode/skill' },
+    'antigravity': { name: 'Antigravity', path: '.agent/skills' },
+};
 async function loadConfig() {
     try {
         const raw = await promises_1.default.readFile(CONFIG_PATH, 'utf-8');
@@ -56,3 +70,12 @@ async function getResolvedConfig(overrides = {}, profile) {
 function getConfigPath() {
     return CONFIG_PATH;
 }
+async function getDefaultFormats() {
+    const config = await loadConfig();
+    return config.default_formats ?? [];
+}
+async function setDefaultFormats(formats) {
+    const config = await loadConfig();
+    config.default_formats = formats;
+    await saveConfig(config);
+}

package/dist/lib/installed.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHash = computeHash;
+exports.loadInstalled = loadInstalled;
+exports.saveInstalled = saveInstalled;
+exports.trackInstall = trackInstall;
+exports.getInstalled = getInstalled;
+exports.getInstalledByFormat = getInstalledByFormat;
+exports.checkModified = checkModified;
+exports.untrackInstall = untrackInstall;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+const ORCHAGENT_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
+const INSTALLED_PATH = path_1.default.join(ORCHAGENT_DIR, 'installed.json');
+/**
+ * Compute SHA-256 hash of content
+ */
+function computeHash(content) {
+    return crypto_1.default.createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Load installed agents from tracking file
+ */
+async function loadInstalled() {
+    try {
+        const raw = await promises_1.default.readFile(INSTALLED_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return { version: 1, installed: [] };
+        }
+        throw err;
+    }
+}
+/**
+ * Save installed agents to tracking file
+ */
+async function saveInstalled(data) {
+    await promises_1.default.mkdir(ORCHAGENT_DIR, { recursive: true });
+    await promises_1.default.writeFile(INSTALLED_PATH, JSON.stringify(data, null, 2) + '\n');
+}
+/**
+ * Track a newly installed agent
+ */
+async function trackInstall(agent) {
+    const data = await loadInstalled();
+    // Remove any existing entry for same agent/format/scope/path
+    data.installed = data.installed.filter(i => !(i.agent === agent.agent && i.format === agent.format && i.path === agent.path));
+    // Add new entry
+    data.installed.push(agent);
+    await saveInstalled(data);
+}
+/**
+ * Get all installed agents
+ */
+async function getInstalled() {
+    const data = await loadInstalled();
+    return data.installed;
+}
+/**
+ * Get installed agents filtered by format
+ */
+async function getInstalledByFormat(format) {
+    const data = await loadInstalled();
+    return data.installed.filter(i => i.format === format);
+}
+/**
+ * Check if a file has been modified since installation
+ */
+async function checkModified(installed) {
+    try {
+        const content = await promises_1.default.readFile(installed.path, 'utf-8');
+        const currentHash = computeHash(content);
+        return currentHash !== installed.contentHash;
+    }
+    catch {
+        // File doesn't exist or can't be read
+        return true;
+    }
+}
+/**
+ * Remove an installed agent from tracking
+ */
+async function untrackInstall(agentRef, format, filePath) {
+    const data = await loadInstalled();
+    data.installed = data.installed.filter(i => !(i.agent === agentRef && i.format === format && i.path === filePath));
+    await saveInstalled(data);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.2.26",
+  "version": "0.3.0",
   "description": "Command-line interface for the orchagent AI agent marketplace",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",