@orchagent/cli 0.1.0

package/dist/commands/run.test.js

@@ -0,0 +1,330 @@
+"use strict";
+/**
+ * Tests for the run command and LLM utilities.
+ *
+ * These tests cover downloading and running agents locally:
+ * - parseAgentRef() parsing org/agent@version formats
+ * - downloadAgent() fetching from API
+ * - LLM key detection from environment
+ * - Building prompts with variable substitution
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const commander_1 = require("commander");
+// Mock modules before importing
+vitest_1.vi.mock('fs/promises');
+vitest_1.vi.mock('../lib/config');
+vitest_1.vi.mock('../lib/api');
+const promises_1 = __importDefault(require("fs/promises"));
+const run_1 = require("./run");
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const llm_1 = require("../lib/llm");
+const mockFs = vitest_1.vi.mocked(promises_1.default);
+const mockGetResolvedConfig = vitest_1.vi.mocked(config_1.getResolvedConfig);
+const mockPublicRequest = vitest_1.vi.mocked(api_1.publicRequest);
+const mockGetPublicAgent = vitest_1.vi.mocked(api_1.getPublicAgent);
+(0, vitest_1.describe)('run command - agent ref parsing', () => {
+    let program;
+    let stdoutSpy;
+    let stderrSpy;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        program = new commander_1.Command();
+        program.exitOverride();
+        (0, run_1.registerRunCommand)(program);
+        stdoutSpy = vitest_1.vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        stderrSpy = vitest_1.vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        mockGetResolvedConfig.mockResolvedValue({
+            apiKey: 'sk_test_123',
+            apiUrl: 'https://api.test.com',
+            defaultOrg: 'default-org',
+        });
+        // Mock mkdir for agent saving
+        mockFs.mkdir.mockResolvedValue(undefined);
+        mockFs.writeFile.mockResolvedValue(undefined);
+    });
+    (0, vitest_1.afterEach)(() => {
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('parses org/agent@version format', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'code',
+            name: 'my-agent',
+            version: 'v2',
+            supported_providers: ['any'],
+        });
+        await program.parseAsync(['node', 'test', 'run', 'myorg/my-agent@v2']);
+        (0, vitest_1.expect)(mockPublicRequest).toHaveBeenCalledWith(vitest_1.expect.any(Object), '/public/agents/myorg/my-agent/v2/download');
+    });
+    (0, vitest_1.it)('parses org/agent format with default version', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'code',
+            name: 'my-agent',
+            version: 'latest',
+            supported_providers: ['any'],
+        });
+        await program.parseAsync(['node', 'test', 'run', 'myorg/my-agent']);
+        (0, vitest_1.expect)(mockPublicRequest).toHaveBeenCalledWith(vitest_1.expect.any(Object), '/public/agents/myorg/my-agent/latest/download');
+    });
+    (0, vitest_1.it)('uses defaultOrg when no org specified', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'code',
+            name: 'my-agent',
+            version: 'latest',
+            supported_providers: ['any'],
+        });
+        await program.parseAsync(['node', 'test', 'run', 'my-agent']);
+        (0, vitest_1.expect)(mockPublicRequest).toHaveBeenCalledWith(vitest_1.expect.any(Object), '/public/agents/default-org/my-agent/latest/download');
+    });
+    (0, vitest_1.it)('parses agent@version format', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'code',
+            name: 'my-agent',
+            version: 'v3',
+            supported_providers: ['any'],
+        });
+        await program.parseAsync(['node', 'test', 'run', 'my-agent@v3']);
+        (0, vitest_1.expect)(mockPublicRequest).toHaveBeenCalledWith(vitest_1.expect.any(Object), '/public/agents/default-org/my-agent/v3/download');
+    });
+    (0, vitest_1.it)('throws error for invalid agent ref format', async () => {
+        mockGetResolvedConfig.mockResolvedValue({
+            apiUrl: 'https://api.test.com',
+            // No defaultOrg
+        });
+        await (0, vitest_1.expect)(program.parseAsync(['node', 'test', 'run', 'just-agent'])).rejects.toThrow('Missing org');
+    });
+    (0, vitest_1.it)('throws error for too many segments', async () => {
+        await (0, vitest_1.expect)(program.parseAsync(['node', 'test', 'run', 'a/b/c/d'])).rejects.toThrow('Invalid agent reference');
+    });
+});
+(0, vitest_1.describe)('run command - download agent', () => {
+    let program;
+    let stdoutSpy;
+    let stderrSpy;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        program = new commander_1.Command();
+        program.exitOverride();
+        (0, run_1.registerRunCommand)(program);
+        stdoutSpy = vitest_1.vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        stderrSpy = vitest_1.vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        mockGetResolvedConfig.mockResolvedValue({
+            apiKey: 'sk_test_123',
+            apiUrl: 'https://api.test.com',
+            defaultOrg: 'test-org',
+        });
+        mockFs.mkdir.mockResolvedValue(undefined);
+        mockFs.writeFile.mockResolvedValue(undefined);
+    });
+    (0, vitest_1.afterEach)(() => {
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('downloads agent via public API', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'prompt',
+            name: 'test-agent',
+            version: 'v1',
+            description: 'A test agent',
+            prompt: 'You are a test assistant.',
+            supported_providers: ['openai'],
+        });
+        await program.parseAsync(['node', 'test', 'run', 'test-org/test-agent@v1']);
+        (0, vitest_1.expect)(mockPublicRequest).toHaveBeenCalledWith({ apiKey: 'sk_test_123', apiUrl: 'https://api.test.com', defaultOrg: 'test-org' }, '/public/agents/test-org/test-agent/v1/download');
+    });
+    (0, vitest_1.it)('falls back to getPublicAgent if download fails', async () => {
+        mockPublicRequest.mockRejectedValue(new Error('Not found'));
+        mockGetPublicAgent.mockResolvedValue({
+            id: 'agent-123',
+            org_id: 'org-123',
+            name: 'fallback-agent',
+            version: 'v1',
+            type: 'code',
+            supported_providers: ['any'],
+            is_public: true,
+        });
+        await program.parseAsync(['node', 'test', 'run', 'test-org/fallback-agent@v1']);
+        (0, vitest_1.expect)(mockGetPublicAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), 'test-org', 'fallback-agent', 'v1');
+    });
+    (0, vitest_1.it)('saves agent metadata locally', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'prompt',
+            name: 'saved-agent',
+            version: 'v1',
+            prompt: 'Test prompt',
+            supported_providers: ['any'],
+        });
+        await program.parseAsync(['node', 'test', 'run', 'test-org/saved-agent@v1']);
+        (0, vitest_1.expect)(mockFs.mkdir).toHaveBeenCalled();
+        (0, vitest_1.expect)(mockFs.writeFile).toHaveBeenCalledWith(vitest_1.expect.stringContaining('agent.json'), vitest_1.expect.stringContaining('"name": "saved-agent"'));
+    });
+    (0, vitest_1.it)('saves prompt.md for prompt agents', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'prompt',
+            name: 'prompt-agent',
+            version: 'v1',
+            prompt: 'You are a helpful assistant.',
+            supported_providers: ['any'],
+        });
+        await program.parseAsync(['node', 'test', 'run', 'test-org/prompt-agent@v1']);
+        (0, vitest_1.expect)(mockFs.writeFile).toHaveBeenCalledWith(vitest_1.expect.stringContaining('prompt.md'), 'You are a helpful assistant.');
+    });
+    (0, vitest_1.it)('handles --download-only flag', async () => {
+        mockPublicRequest.mockResolvedValue({
+            type: 'prompt',
+            name: 'download-only-agent',
+            version: 'v1',
+            prompt: 'Test',
+            supported_providers: ['any'],
+        });
+        await program.parseAsync([
+            'node',
+            'test',
+            'run',
+            'test-org/download-only-agent@v1',
+            '--download-only',
+        ]);
+        (0, vitest_1.expect)(stdoutSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Agent downloaded'));
+    });
+});
+(0, vitest_1.describe)('LLM utilities - detectLlmKeyFromEnv', () => {
+    const originalEnv = process.env;
+    (0, vitest_1.beforeEach)(() => {
+        process.env = { ...originalEnv };
+        delete process.env.OPENAI_API_KEY;
+        delete process.env.ANTHROPIC_API_KEY;
+        delete process.env.GEMINI_API_KEY;
+    });
+    (0, vitest_1.afterEach)(() => {
+        process.env = originalEnv;
+    });
+    (0, vitest_1.it)('returns null when no keys found', () => {
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['openai']);
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)('detects OpenAI key', () => {
+        process.env.OPENAI_API_KEY = 'sk-openai-test';
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['openai']);
+        (0, vitest_1.expect)(result).toEqual({ provider: 'openai', key: 'sk-openai-test' });
+    });
+    (0, vitest_1.it)('detects Anthropic key', () => {
+        process.env.ANTHROPIC_API_KEY = 'sk-ant-test';
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['anthropic']);
+        (0, vitest_1.expect)(result).toEqual({ provider: 'anthropic', key: 'sk-ant-test' });
+    });
+    (0, vitest_1.it)('detects Gemini key', () => {
+        process.env.GEMINI_API_KEY = 'AIza-gemini-test';
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['gemini']);
+        (0, vitest_1.expect)(result).toEqual({ provider: 'gemini', key: 'AIza-gemini-test' });
+    });
+    (0, vitest_1.it)('returns first matching provider in order', () => {
+        process.env.ANTHROPIC_API_KEY = 'sk-ant-test';
+        process.env.OPENAI_API_KEY = 'sk-openai-test';
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['openai', 'anthropic']);
+        (0, vitest_1.expect)(result).toEqual({ provider: 'openai', key: 'sk-openai-test' });
+    });
+    (0, vitest_1.it)('handles "any" provider - checks all in order', () => {
+        process.env.GEMINI_API_KEY = 'AIza-gemini-test';
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['any']);
+        // 'any' should find the first available key
+        (0, vitest_1.expect)(result?.key).toBe('AIza-gemini-test');
+    });
+    (0, vitest_1.it)('handles "any" provider - returns first found', () => {
+        process.env.OPENAI_API_KEY = 'sk-openai-test';
+        process.env.ANTHROPIC_API_KEY = 'sk-ant-test';
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['any']);
+        // OpenAI is checked first in the provider order
+        (0, vitest_1.expect)(result).toEqual({ provider: 'openai', key: 'sk-openai-test' });
+    });
+    (0, vitest_1.it)('skips unavailable providers', () => {
+        process.env.ANTHROPIC_API_KEY = 'sk-ant-test';
+        // No OpenAI key
+        const result = (0, llm_1.detectLlmKeyFromEnv)(['openai', 'anthropic']);
+        (0, vitest_1.expect)(result).toEqual({ provider: 'anthropic', key: 'sk-ant-test' });
+    });
+});
+(0, vitest_1.describe)('LLM utilities - getDefaultModel', () => {
+    (0, vitest_1.it)('returns default model for OpenAI', () => {
+        (0, vitest_1.expect)((0, llm_1.getDefaultModel)('openai')).toBe('gpt-4o');
+    });
+    (0, vitest_1.it)('returns default model for Anthropic', () => {
+        (0, vitest_1.expect)((0, llm_1.getDefaultModel)('anthropic')).toBe('claude-sonnet-4-20250514');
+    });
+    (0, vitest_1.it)('returns default model for Gemini', () => {
+        (0, vitest_1.expect)((0, llm_1.getDefaultModel)('gemini')).toBe('gemini-1.5-pro');
+    });
+    (0, vitest_1.it)('returns gpt-4o for unknown provider', () => {
+        (0, vitest_1.expect)((0, llm_1.getDefaultModel)('unknown')).toBe('gpt-4o');
+    });
+});
+(0, vitest_1.describe)('LLM utilities - buildPrompt', () => {
+    (0, vitest_1.it)('substitutes single variable', () => {
+        const template = 'Analyze this: {{input}}';
+        const result = (0, llm_1.buildPrompt)(template, { input: 'Hello world' });
+        (0, vitest_1.expect)(result).toContain('Analyze this: Hello world');
+    });
+    (0, vitest_1.it)('substitutes multiple variables', () => {
+        const template = 'Name: {{name}}, Age: {{age}}';
+        const result = (0, llm_1.buildPrompt)(template, { name: 'Alice', age: 30 });
+        (0, vitest_1.expect)(result).toContain('Name: Alice, Age: 30');
+    });
+    (0, vitest_1.it)('appends JSON input block', () => {
+        const template = 'Process this';
+        const result = (0, llm_1.buildPrompt)(template, { key: 'value' });
+        (0, vitest_1.expect)(result).toContain('Input:');
+        (0, vitest_1.expect)(result).toContain('```json');
+        (0, vitest_1.expect)(result).toContain('"key": "value"');
+    });
+    (0, vitest_1.it)('handles empty input data', () => {
+        const template = 'No inputs needed';
+        const result = (0, llm_1.buildPrompt)(template, {});
+        (0, vitest_1.expect)(result).toBe('No inputs needed');
+    });
+    (0, vitest_1.it)('handles multiple occurrences of same variable', () => {
+        const template = '{{name}} said hello. {{name}} waved goodbye.';
+        const result = (0, llm_1.buildPrompt)(template, { name: 'Bob' });
+        (0, vitest_1.expect)(result).toContain('Bob said hello. Bob waved goodbye.');
+    });
+    (0, vitest_1.it)('preserves unused placeholders', () => {
+        const template = 'Value: {{exists}}, Missing: {{missing}}';
+        const result = (0, llm_1.buildPrompt)(template, { exists: 'here' });
+        (0, vitest_1.expect)(result).toContain('Value: here');
+        (0, vitest_1.expect)(result).toContain('{{missing}}');
+    });
+    (0, vitest_1.it)('handles complex nested objects in JSON', () => {
+        const template = 'Process data';
+        const inputData = {
+            nested: { deep: { value: 42 } },
+            array: [1, 2, 3],
+        };
+        const result = (0, llm_1.buildPrompt)(template, inputData);
+        (0, vitest_1.expect)(result).toContain('"nested"');
+        (0, vitest_1.expect)(result).toContain('"deep"');
+        (0, vitest_1.expect)(result).toContain('"array"');
+    });
+    (0, vitest_1.it)('converts non-string values to strings', () => {
+        const template = 'Count: {{count}}, Active: {{active}}';
+        const result = (0, llm_1.buildPrompt)(template, { count: 42, active: true });
+        (0, vitest_1.expect)(result).toContain('Count: 42');
+        (0, vitest_1.expect)(result).toContain('Active: true');
+    });
+});
+(0, vitest_1.describe)('LLM utilities - constants', () => {
+    (0, vitest_1.it)('has correct provider env vars', () => {
+        (0, vitest_1.expect)(llm_1.PROVIDER_ENV_VARS.openai).toBe('OPENAI_API_KEY');
+        (0, vitest_1.expect)(llm_1.PROVIDER_ENV_VARS.anthropic).toBe('ANTHROPIC_API_KEY');
+        (0, vitest_1.expect)(llm_1.PROVIDER_ENV_VARS.gemini).toBe('GEMINI_API_KEY');
+    });
+    (0, vitest_1.it)('has correct default models', () => {
+        (0, vitest_1.expect)(llm_1.DEFAULT_MODELS.openai).toBe('gpt-4o');
+        (0, vitest_1.expect)(llm_1.DEFAULT_MODELS.anthropic).toBe('claude-sonnet-4-20250514');
+        (0, vitest_1.expect)(llm_1.DEFAULT_MODELS.gemini).toBe('gemini-1.5-pro');
+    });
+});

package/dist/commands/search.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSearchCommand = registerSearchCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const output_1 = require("../lib/output");
+const analytics_1 = require("../lib/analytics");
+function registerSearchCommand(program) {
+    program
+        .command('search')
+        .description('Search for public agents')
+        .argument('[query]', 'Search query')
+        .option('--sort <field>', 'Sort by: stars, recent, name (default: stars)', 'stars')
+        .option('--json', 'Output raw JSON')
+        .action(async (query, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        let agents;
+        if (query) {
+            agents = await (0, api_1.searchAgents)(config, query);
+            await (0, analytics_1.track)('cli_search', { query });
+        }
+        else {
+            agents = await (0, api_1.listPublicAgents)(config);
+            await (0, analytics_1.track)('cli_search');
+        }
+        // Sort results
+        if (options.sort === 'stars') {
+            agents.sort((a, b) => (b.stars_count ?? 0) - (a.stars_count ?? 0));
+        }
+        else if (options.sort === 'recent') {
+            agents.sort((a, b) => (b.created_at ?? '').localeCompare(a.created_at ?? ''));
+        }
+        else {
+            agents.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        if (options.json) {
+            (0, output_1.printJson)(agents);
+            return;
+        }
+        if (agents.length === 0) {
+            process.stdout.write(query ? 'No agents found matching your search.\n' : 'No public agents found.\n');
+            return;
+        }
+        (0, output_1.printAgentsTable)(agents);
+    });
+}

package/dist/commands/skill.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSkillCommand = registerSkillCommand;
+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 output_1 = require("../lib/output");
+const analytics_1 = require("../lib/analytics");
+const DEFAULT_VERSION = 'v1';
+/**
+ * AI tool skill directories.
+ *
+ * Each AI coding tool has its own directory for skills. When installing a skill,
+ * we write to all known directories so the skill works with any tool.
+ *
+ * TODO: Research and add more AI tool directories as the ecosystem evolves.
+ * Known tools to research: Gemini CLI, Aider, OpenCode, Amp, Windsurf, Cline,
+ * GitHub Copilot CLI, Codex CLI, Qwen Code, Kimi Code, etc.
+ *
+ * References:
+ * - https://github.com/gotalab/skillport
+ * - https://github.com/numman-ali/openskills
+ * - https://github.com/skillcreatorai/Ai-Agent-Skills
+ */
+const AI_TOOL_SKILL_DIRS = [
+    { name: 'Claude Code', path: '.claude/skills' },
+    { name: 'Cursor', path: '.cursor/skills' },
+    { name: 'Codex', path: '.codex/skills' },
+    { name: 'Amp', path: '.agents/skills' },
+    { name: 'OpenCode', path: '.opencode/skill' },
+    { name: 'Antigravity', path: '.agent/skills' },
+    // TODO: Add more as we research them:
+    // { name: 'Windsurf', path: '.windsurf/skills' },
+];
+function parseSkillRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || DEFAULT_VERSION;
+    const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { skill: segments[0], version };
+    }
+    if (segments.length === 2) {
+        return { org: segments[0], skill: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid skill reference. Use org/skill or skill format.');
+}
+function registerSkillCommand(program) {
+    const skill = program.command('skill').description('Manage and install skills');
+    // orch skill list
+    skill
+        .command('list')
+        .description('List available skills')
+        .option('--json', 'Output raw JSON')
+        .action(async (options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        const skills = await (0, api_1.publicRequest)(resolved, '/public/agents?type=skills');
+        await (0, analytics_1.track)('cli_skill_list');
+        if (options.json) {
+            (0, output_1.printJson)(skills);
+            return;
+        }
+        if (!skills.length) {
+            process.stdout.write('No skills found.\n');
+            return;
+        }
+        for (const skill of skills) {
+            const stars = skill.stars_count ? ` ⭐${skill.stars_count}` : '';
+            process.stdout.write(`${skill.org_slug}/${skill.name}@${skill.version}${stars}\n` +
+                `  ${skill.description || 'No description'}\n\n`);
+        }
+    });
+    // orch skill install <skill>
+    skill
+        .command('install <skill>')
+        .description('Install skill to local AI tool directories (Claude Code, Cursor, etc.)')
+        .option('--global', 'Install to home directory (default: current directory)')
+        .action(async (skillRef, options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        const parsed = parseSkillRef(skillRef);
+        const org = parsed.org ?? resolved.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/skill or set default org.');
+        }
+        // Fetch skill metadata to verify it's a skill
+        const skillMeta = await (0, api_1.publicRequest)(resolved, `/public/agents/${org}/${parsed.skill}/${parsed.version}`);
+        const skillType = skillMeta.type;
+        if (skillType !== 'skill') {
+            throw new errors_1.CliError(`${org}/${parsed.skill} is not a skill (type: ${skillType || 'prompt'})`);
+        }
+        // Download skill content
+        const skillData = await (0, api_1.publicRequest)(resolved, `/public/agents/${org}/${parsed.skill}/${parsed.version}/download`);
+        if (!skillData.prompt) {
+            throw new errors_1.CliError('Skill has no content');
+        }
+        // Determine base directory (home or current)
+        const baseDir = options.global ? os_1.default.homedir() : process.cwd();
+        // Build skill content with header
+        const skillContent = `# ${skillData.name}
+
+${skillData.description || ''}
+
+---
+
+${skillData.prompt}
+`;
+        // Install to all AI tool directories
+        const installed = [];
+        for (const tool of AI_TOOL_SKILL_DIRS) {
+            const skillDir = path_1.default.join(baseDir, tool.path);
+            const skillFile = path_1.default.join(skillDir, `${parsed.skill}.md`);
+            try {
+                await promises_1.default.mkdir(skillDir, { recursive: true });
+                await promises_1.default.writeFile(skillFile, skillContent);
+                installed.push(tool.name);
+            }
+            catch (err) {
+                // Skip if we can't write (e.g., permission issues)
+                process.stderr.write(`Warning: Could not install to ${tool.path}: ${err.message}\n`);
+            }
+        }
+        if (installed.length === 0) {
+            throw new errors_1.CliError('Failed to install skill to any directory');
+        }
+        await (0, analytics_1.track)('cli_skill_install', {
+            skill: `${org}/${parsed.skill}`,
+            global: Boolean(options.global),
+        });
+        process.stdout.write(`Installed ${org}/${parsed.skill}@${parsed.version}\n`);
+        process.stdout.write(`\nAvailable for:\n`);
+        for (const tool of installed) {
+            process.stdout.write(`  - ${tool}\n`);
+        }
+        process.stdout.write(`\nLocation: ${options.global ? '~/' : './'}\n`);
+    });
+}

package/dist/commands/star.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStarCommand = registerStarCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+function parseAgentRef(ref) {
+    // Format: org/agent/version or org/agent (defaults to v1)
+    const parts = ref.split('/');
+    if (parts.length < 2 || parts.length > 3) {
+        throw new errors_1.CliError('Invalid agent reference. Use: org/agent or org/agent/version');
+    }
+    return {
+        org: parts[0],
+        name: parts[1],
+        version: parts[2] || 'v1',
+    };
+}
+function registerStarCommand(program) {
+    program
+        .command('star')
+        .description('Star an agent')
+        .argument('<agent>', 'Agent reference (org/name or org/name/version)')
+        .option('--remove', 'Remove star instead of adding')
+        .action(async (agent, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const { org, name, version } = parseAgentRef(agent);
+        // Get the agent to get its ID
+        const agentInfo = await (0, api_1.getPublicAgent)(config, org, name, version);
+        if (options.remove) {
+            await (0, api_1.unstarAgent)(config, agentInfo.id);
+            process.stdout.write(`Removed star from ${org}/${name}/${version}\n`);
+        }
+        else {
+            await (0, api_1.starAgent)(config, agentInfo.id);
+            await (0, analytics_1.track)('cli_star', { agent: `${org}/${name}/${version}` });
+            process.stdout.write(`Starred ${org}/${name}/${version}\n`);
+        }
+    });
+}

package/dist/commands/whoami.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWhoamiCommand = registerWhoamiCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+function registerWhoamiCommand(program) {
+    program
+        .command('whoami')
+        .description('Show current user/org info')
+        .action(async () => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const org = await (0, api_1.getOrg)(config);
+        process.stdout.write(`Logged in as: ${org.name}\n`);
+        process.stdout.write(`Org slug: ${org.slug}\n`);
+        process.stdout.write(`API URL: ${config.apiUrl}\n`);
+    });
+}

package/dist/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const Sentry = __importStar(require("@sentry/node"));
+if (process.env.SENTRY_DSN) {
+    Sentry.init({ dsn: process.env.SENTRY_DSN });
+}
+const commander_1 = require("commander");
+const commands_1 = require("./commands");
+const errors_1 = require("./lib/errors");
+const analytics_1 = require("./lib/analytics");
+(0, analytics_1.initPostHog)();
+const program = new commander_1.Command();
+program
+    .name('orchagent')
+    .description('OrchAgent CLI')
+    .version('0.1.0');
+(0, commands_1.registerCommands)(program);
+program
+    .parseAsync(process.argv)
+    .catch(errors_1.exitWithError)
+    .finally(() => (0, analytics_1.shutdownPostHog)());

package/dist/lib/analytics.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initPostHog = initPostHog;
+exports.shutdownPostHog = shutdownPostHog;
+exports.track = track;
+const posthog_node_1 = require("posthog-node");
+const config_1 = require("./config");
+let client = null;
+function initPostHog() {
+    if (process.env.POSTHOG_API_KEY) {
+        client = new posthog_node_1.PostHog(process.env.POSTHOG_API_KEY, {
+            host: 'https://us.i.posthog.com',
+        });
+    }
+}
+async function shutdownPostHog() {
+    if (client) {
+        await client.shutdown();
+    }
+}
+async function track(event, properties) {
+    if (!client)
+        return;
+    const config = await (0, config_1.getResolvedConfig)();
+    const distinctId = config.defaultOrg || 'anonymous';
+    client.capture({ distinctId, event, properties });
+}