@orchagent/cli 0.3.22 → 0.3.23

package/dist/commands/call.js

@@ -10,6 +10,7 @@ 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 spinner_1 = require("../lib/spinner");
 const llm_1 = require("../lib/llm");
 const analytics_1 = require("../lib/analytics");
 const DEFAULT_VERSION = 'latest';
@@ -311,11 +312,21 @@ argument or --file option instead.
             sourceLabel = multipart.sourceLabel;
         }
         const url = `${resolved.apiUrl.replace(/\/$/, '')}/${org}/${parsed.agent}/${parsed.version}/${endpoint}`;
-        const response = await (0, api_1.safeFetchWithRetryForCalls)(url, {
-            method: 'POST',
-            headers,
-            body,
-        });
+        // Make the API call with a spinner
+        const spinner = (0, spinner_1.createSpinner)(`Calling ${org}/${parsed.agent}@${parsed.version}...`);
+        spinner.start();
+        let response;
+        try {
+            response = await (0, api_1.safeFetchWithRetryForCalls)(url, {
+                method: 'POST',
+                headers,
+                body,
+            });
+        }
+        catch (err) {
+            spinner.fail(`Call failed: ${err instanceof Error ? err.message : 'Unknown error'}`);
+            throw err;
+        }
         if (!response.ok) {
             const text = await response.text();
             let payload;
@@ -330,6 +341,7 @@ argument or --file option instead.
                 ? payload.error?.code
                 : undefined;
             if (errorCode === 'LLM_KEY_REQUIRED') {
+                spinner.fail('LLM key required');
                 throw new errors_1.CliError('This public agent requires you to provide an LLM key.\n' +
                     'Use --key <key> --provider <provider> or set OPENAI_API_KEY/ANTHROPIC_API_KEY env var.');
             }
@@ -339,8 +351,10 @@ argument or --file option instead.
                     payload.message ||
                     response.statusText
                 : response.statusText;
+            spinner.fail(`Call failed: ${message}`);
             throw new errors_1.CliError(message);
         }
+        spinner.succeed(`Called ${org}/${parsed.agent}@${parsed.version}`);
         // Track successful call
         const inputType = filePaths.length > 0
             ? 'file'

package/dist/commands/index.js

@@ -27,6 +27,7 @@ const formats_1 = require("./formats");
 const update_1 = require("./update");
 const env_1 = require("./env");
 const list_1 = require("./list");
+const test_1 = require("./test");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -54,4 +55,5 @@ function registerCommands(program) {
     (0, update_1.registerUpdateCommand)(program);
     (0, env_1.registerEnvCommand)(program);
     (0, list_1.registerListCommand)(program);
+    (0, test_1.registerTestCommand)(program);
 }

package/dist/commands/run.js

@@ -45,6 +45,7 @@ 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 spinner_1 = require("../lib/spinner");
 const llm_1 = require("../lib/llm");
 const DEFAULT_VERSION = 'latest';
 const AGENTS_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent', 'agents');
@@ -210,17 +211,18 @@ async function downloadDependenciesRecursively(config, depStatuses, visited = ne
             continue;
         visited.add(depRef);
         const [org, agent] = status.dep.id.split('/');
-        process.stderr.write(`\nDownloading dependency: ${depRef}...\n`);
-        // Save the dependency metadata locally
-        await saveAgentLocally(org, agent, status.agentData);
-        // For bundle-based agents, also extract the bundle
-        if (status.agentData.has_bundle) {
-            await saveBundleLocally(config, org, agent, status.dep.version, status.agentData.id);
-        }
-        // Install if it's a pip/source code agent
-        if (status.agentData.type === 'code' && (status.agentData.source_url || status.agentData.pip_package)) {
-            await installCodeAgent(status.agentData);
-        }
+        await (0, spinner_1.withSpinner)(`Downloading dependency: ${depRef}...`, async () => {
+            // Save the dependency metadata locally
+            await saveAgentLocally(org, agent, status.agentData);
+            // For bundle-based agents, also extract the bundle
+            if (status.agentData.has_bundle) {
+                await saveBundleLocally(config, org, agent, status.dep.version, status.agentData.id);
+            }
+            // Install if it's a pip/source code agent
+            if (status.agentData.type === 'code' && (status.agentData.source_url || status.agentData.pip_package)) {
+                await installCodeAgent(status.agentData);
+            }
+        }, { successText: `Downloaded ${depRef}` });
         // Download default skills
         const defaultSkills = status.agentData.default_skills || [];
         for (const skillRef of defaultSkills) {
@@ -327,20 +329,18 @@ async function executePromptLocally(agentData, inputData, skillPrompts = [], con
         }));
         // Show which provider is being used (primary)
         const primary = providersWithModels[0];
-        if (providersWithModels.length > 1) {
-            process.stderr.write(`Running with ${primary.provider} (${primary.model}), ` +
-                `${providersWithModels.length - 1} fallback(s) available...\n`);
-        }
-        else {
-            process.stderr.write(`Running with ${primary.provider} (${primary.model})...\n`);
-        }
+        const spinnerText = providersWithModels.length > 1
+            ? `Running with ${primary.provider} (${primary.model}), ${providersWithModels.length - 1} fallback(s) available...`
+            : `Running with ${primary.provider} (${primary.model})...`;
         // Use fallback if multiple providers, otherwise single call
-        if (providersWithModels.length > 1) {
-            return await (0, llm_1.callLlmWithFallback)(providersWithModels, prompt, agentData.output_schema);
-        }
-        else {
-            return await (0, llm_1.callLlm)(primary.provider, primary.apiKey, primary.model, prompt, agentData.output_schema);
-        }
+        return await (0, spinner_1.withSpinner)(spinnerText, async () => {
+            if (providersWithModels.length > 1) {
+                return await (0, llm_1.callLlmWithFallback)(providersWithModels, prompt, agentData.output_schema);
+            }
+            else {
+                return await (0, llm_1.callLlm)(primary.provider, primary.apiKey, primary.model, prompt, agentData.output_schema);
+            }
+        }, { successText: `Completed with ${primary.provider}` });
     }
     // Provider override: use single provider (existing behavior)
     const detected = await (0, llm_1.detectLlmKey)(providersToCheck, config);
@@ -352,11 +352,10 @@ async function executePromptLocally(agentData, inputData, skillPrompts = [], con
     const { provider, key, model: serverModel } = detected;
     // Priority: CLI override > server config model > agent default model > hardcoded default
     const model = modelOverride || serverModel || agentData.default_models?.[provider] || (0, llm_1.getDefaultModel)(provider);
-    // Show which provider is being used (helpful for debugging rate limits)
-    process.stderr.write(`Running with ${provider} (${model})...\n`);
-    // Call the LLM directly
-    const response = await (0, llm_1.callLlm)(provider, key, model, prompt, agentData.output_schema);
-    return response;
+    // Call the LLM with spinner
+    return await (0, spinner_1.withSpinner)(`Running with ${provider} (${model})...`, async () => {
+        return await (0, llm_1.callLlm)(provider, key, model, prompt, agentData.output_schema);
+    }, { successText: `Completed with ${provider}` });
 }
 function parseSkillRef(value) {
     const [ref, versionPart] = value.split('@');
@@ -436,21 +435,22 @@ async function installCodeAgent(agentData) {
     if (agentData.pip_package) {
         const installed = await checkPackageInstalled(agentData.pip_package);
         if (installed) {
-            process.stderr.write(`Package ${agentData.pip_package} already installed.\n`);
+            const spinner = (0, spinner_1.createSpinner)(`Package ${agentData.pip_package}`);
+            spinner.succeed(`Package ${agentData.pip_package} already installed`);
             return;
         }
     }
-    process.stderr.write(`Installing ${installSource}...\n`);
-    const { code } = await runCommand('python3', ['-m', 'pip', 'install', '--quiet', '--disable-pip-version-check', installSource]);
-    if (code !== 0) {
-        throw new errors_1.CliError(`Failed to install agent (exit code ${code}).\n\n` +
-            'Troubleshooting:\n' +
-            '  - Check Python is installed: python3 --version\n' +
-            '  - Check pip is available: pip --version\n' +
-            '  - Check network connectivity\n' +
-            '  - Try installing manually: pip install <package>');
-    }
-    process.stderr.write(`Installation complete.\n`);
+    await (0, spinner_1.withSpinner)(`Installing ${installSource}...`, async () => {
+        const { code } = await runCommand('python3', ['-m', 'pip', 'install', '--quiet', '--disable-pip-version-check', installSource]);
+        if (code !== 0) {
+            throw new errors_1.CliError(`Failed to install agent (exit code ${code}).\n\n` +
+                'Troubleshooting:\n' +
+                '  - Check Python is installed: python3 --version\n' +
+                '  - Check pip is available: pip --version\n' +
+                '  - Check network connectivity\n' +
+                '  - Try installing manually: pip install <package>');
+        }
+    }, { successText: 'Installation complete' });
 }
 async function executeCodeAgent(agentData, args) {
     if (!agentData.run_command) {
@@ -502,24 +502,27 @@ async function executeBundleAgent(config, org, agentName, version, agentData, ar
     const bundleZip = path_1.default.join(tempDir, 'bundle.zip');
     const extractDir = path_1.default.join(tempDir, 'agent');
     try {
-        // Download the bundle
-        process.stderr.write(`Downloading bundle...\n`);
-        const bundleBuffer = await downloadBundleWithFallback(config, org, agentName, version, agentData.id);
-        await promises_1.default.writeFile(bundleZip, bundleBuffer);
-        process.stderr.write(`Bundle downloaded (${bundleBuffer.length} bytes)\n`);
-        // Extract the bundle
+        // Download the bundle with spinner
+        const bundleBuffer = await (0, spinner_1.withSpinner)(`Downloading ${org}/${agentName}@${version} bundle...`, async () => {
+            const buffer = await downloadBundleWithFallback(config, org, agentName, version, agentData.id);
+            await promises_1.default.writeFile(bundleZip, buffer);
+            return buffer;
+        }, { successText: (buf) => `Downloaded bundle (${buf.length} bytes)` });
+        // Extract the bundle with spinner
         await promises_1.default.mkdir(extractDir, { recursive: true });
-        process.stderr.write(`Extracting bundle...\n`);
-        await unzipBundle(bundleZip, extractDir);
+        await (0, spinner_1.withSpinner)('Extracting bundle...', async () => {
+            await unzipBundle(bundleZip, extractDir);
+        }, { successText: 'Bundle extracted' });
         // Check if requirements.txt exists and install dependencies
         const requirementsPath = path_1.default.join(extractDir, 'requirements.txt');
         try {
             await promises_1.default.access(requirementsPath);
-            process.stderr.write(`Installing dependencies from requirements.txt...\n`);
-            const { code } = await runCommand('python3', ['-m', 'pip', 'install', '-q', '--disable-pip-version-check', '-r', requirementsPath]);
-            if (code !== 0) {
-                throw new errors_1.CliError('Failed to install dependencies from requirements.txt');
-            }
+            await (0, spinner_1.withSpinner)('Installing dependencies...', async () => {
+                const { code } = await runCommand('python3', ['-m', 'pip', 'install', '-q', '--disable-pip-version-check', '-r', requirementsPath]);
+                if (code !== 0) {
+                    throw new errors_1.CliError('Failed to install dependencies from requirements.txt');
+                }
+            }, { successText: 'Dependencies installed' });
         }
         catch (err) {
             if (err.code !== 'ENOENT') {
@@ -739,8 +742,7 @@ async function saveBundleLocally(config, org, agent, version, agentId) {
         // Metadata doesn't exist, need to download
     }
     // Download and extract bundle
-    process.stderr.write(`Downloading bundle for ${org}/${agent}@${version}...\n`);
-    const bundleBuffer = await downloadBundleWithFallback(config, org, agent, version, agentId);
+    const bundleBuffer = await (0, spinner_1.withSpinner)(`Downloading bundle for ${org}/${agent}@${version}...`, async () => downloadBundleWithFallback(config, org, agent, version, agentId), { successText: `Downloaded bundle for ${org}/${agent}@${version}` });
     const tempZip = path_1.default.join(os_1.default.tmpdir(), `bundle-${Date.now()}.zip`);
     await promises_1.default.writeFile(tempZip, bundleBuffer);
     // Clean and recreate bundle directory
@@ -818,23 +820,23 @@ Note: Use 'run' for local execution, 'call' for server-side execution.
         if (!org) {
             throw new errors_1.CliError('Missing org. Use org/agent format.');
         }
-        // Download agent definition
-        process.stderr.write(`Downloading ${org}/${parsed.agent}@${parsed.version}...\n`);
-        let agentData;
-        try {
-            agentData = await downloadAgent(resolved, org, parsed.agent, parsed.version);
-        }
-        catch (err) {
-            // Fall back to getting public agent info if download endpoint not available
-            const agentMeta = await (0, api_1.getPublicAgent)(resolved, org, parsed.agent, parsed.version);
-            agentData = {
-                type: agentMeta.type || 'code',
-                name: agentMeta.name,
-                version: agentMeta.version,
-                description: agentMeta.description || undefined,
-                supported_providers: agentMeta.supported_providers || ['any'],
-            };
-        }
+        // Download agent definition with spinner
+        const agentData = await (0, spinner_1.withSpinner)(`Downloading ${org}/${parsed.agent}@${parsed.version}...`, async () => {
+            try {
+                return await downloadAgent(resolved, org, parsed.agent, parsed.version);
+            }
+            catch (err) {
+                // Fall back to getting public agent info if download endpoint not available
+                const agentMeta = await (0, api_1.getPublicAgent)(resolved, org, parsed.agent, parsed.version);
+                return {
+                    type: agentMeta.type || 'code',
+                    name: agentMeta.name,
+                    version: agentMeta.version,
+                    description: agentMeta.description || undefined,
+                    supported_providers: agentMeta.supported_providers || ['any'],
+                };
+            }
+        }, { successText: `Downloaded ${org}/${parsed.agent}@${parsed.version}` });
         // Skills cannot be run directly - they're instructions to inject into agents
         if (agentData.type === 'skill') {
             throw new errors_1.CliError('Skills cannot be run directly.\n\n' +
@@ -845,8 +847,7 @@ Note: Use 'run' for local execution, 'call' for server-side execution.
         }
         // Check for dependencies (orchestrator agents)
         if (agentData.dependencies && agentData.dependencies.length > 0) {
-            process.stderr.write(`\nChecking dependencies...\n`);
-            const depStatuses = await checkDependencies(resolved, agentData.dependencies);
+            const depStatuses = await (0, spinner_1.withSpinner)('Checking dependencies...', async () => checkDependencies(resolved, agentData.dependencies), { successText: `Found ${agentData.dependencies.length} dependencies` });
             let choice;
             if (options.withDeps) {
                 // Auto-download deps without prompting
@@ -865,9 +866,7 @@ Note: Use 'run' for local execution, 'call' for server-side execution.
                 process.exit(0);
             }
             // choice === 'local' - download dependencies
-            process.stderr.write(`\nDownloading dependencies...\n`);
             await downloadDependenciesRecursively(resolved, depStatuses);
-            process.stderr.write(`\nAll dependencies downloaded.\n`);
         }
         // Check if user is overriding locked skills
         const agentSkillsLocked = agentData.skills_locked;
@@ -954,12 +953,10 @@ Note: Use 'run' for local execution, 'call' for server-side execution.
                 }
             }
             if (skillRefs.length > 0) {
-                process.stderr.write(`Loading ${skillRefs.length} skill(s)...\n`);
-                skillPrompts = await loadSkillPrompts(resolved, skillRefs, org);
+                skillPrompts = await (0, spinner_1.withSpinner)(`Loading ${skillRefs.length} skill(s)...`, async () => loadSkillPrompts(resolved, skillRefs, org), { successText: `Loaded ${skillRefs.length} skill(s)` });
             }
         }
-        // Execute locally
-        process.stderr.write(`Executing locally...\n\n`);
+        // Execute locally (the spinner is inside executePromptLocally)
         const result = await executePromptLocally(agentData, inputData, skillPrompts, resolved, options.provider, options.model);
         if (options.json) {
             (0, output_1.printJson)(result);

package/dist/commands/test.js

@@ -0,0 +1,536 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTestCommand = registerTestCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const yaml_1 = __importDefault(require("yaml"));
+const errors_1 = require("../lib/errors");
+const config_1 = require("../lib/config");
+const llm_1 = require("../lib/llm");
+/**
+ * Parse SKILL.md frontmatter
+ */
+async function parseSkillMd(filePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (!match)
+            return null;
+        const frontmatter = yaml_1.default.parse(match[1]);
+        const body = match[2].trim();
+        if (!frontmatter.name || !frontmatter.description)
+            return null;
+        return { frontmatter, body };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Run a command and return the result
+ */
+function runCommand(command, args, cwd, verbose) {
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: ['inherit', 'pipe', 'pipe'],
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            const text = data.toString();
+            stdout += text;
+            if (verbose) {
+                process.stdout.write(text);
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderr += text;
+            // Always show stderr for test output
+            process.stderr.write(text);
+        });
+        proc.on('close', (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        proc.on('error', (err) => {
+            resolve({ code: 1, stdout, stderr: err.message });
+        });
+    });
+}
+/**
+ * Check if a command exists
+ */
+async function commandExists(command) {
+    try {
+        const proc = (0, child_process_1.spawn)('which', [command], { shell: true });
+        return new Promise((resolve) => {
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a file exists
+ */
+async function fileExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect the agent type from the directory structure
+ */
+async function detectAgentType(agentDir) {
+    // Check for SKILL.md first
+    if (await fileExists(path_1.default.join(agentDir, 'SKILL.md'))) {
+        return 'skill';
+    }
+    // Check for prompt.md (prompt agent)
+    if (await fileExists(path_1.default.join(agentDir, 'prompt.md'))) {
+        return 'prompt';
+    }
+    // Check for orchagent.json
+    const manifestPath = path_1.default.join(agentDir, 'orchagent.json');
+    if (await fileExists(manifestPath)) {
+        try {
+            const raw = await promises_1.default.readFile(manifestPath, 'utf-8');
+            const manifest = JSON.parse(raw);
+            if (manifest.type === 'prompt')
+                return 'prompt';
+            if (manifest.type === 'skill')
+                return 'skill';
+            if (manifest.type === 'code') {
+                // Detect language
+                if (await fileExists(path_1.default.join(agentDir, 'requirements.txt')))
+                    return 'code-python';
+                if (await fileExists(path_1.default.join(agentDir, 'pyproject.toml')))
+                    return 'code-python';
+                if (await fileExists(path_1.default.join(agentDir, 'package.json')))
+                    return 'code-js';
+                // Default to Python for code agents
+                return 'code-python';
+            }
+        }
+        catch {
+            // Invalid manifest, continue detection
+        }
+    }
+    // Fallback: detect by file presence
+    if (await fileExists(path_1.default.join(agentDir, 'requirements.txt')))
+        return 'code-python';
+    if (await fileExists(path_1.default.join(agentDir, 'pyproject.toml')))
+        return 'code-python';
+    if (await fileExists(path_1.default.join(agentDir, 'package.json')))
+        return 'code-js';
+    return 'unknown';
+}
+/**
+ * Recursively walk a directory and return all files
+ */
+async function walkDir(dir, files = []) {
+    try {
+        const entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            // Skip common non-source directories
+            if (entry.isDirectory()) {
+                if (['node_modules', '__pycache__', '.git', 'dist', 'build', '.venv', 'venv'].includes(entry.name)) {
+                    continue;
+                }
+                await walkDir(fullPath, files);
+            }
+            else if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or not readable
+    }
+    return files;
+}
+/**
+ * Discover test files in the agent directory
+ */
+async function discoverTests(agentDir) {
+    const result = {
+        python: [],
+        javascript: [],
+        fixtures: [],
+    };
+    // Get all files recursively
+    const allFiles = await walkDir(agentDir);
+    for (const file of allFiles) {
+        const basename = path_1.default.basename(file);
+        const relPath = path_1.default.relative(agentDir, file);
+        // Python test patterns: test_*.py, *_test.py
+        if (basename.endsWith('.py')) {
+            if (basename.startsWith('test_') || basename.endsWith('_test.py')) {
+                result.python.push(file);
+            }
+        }
+        // JS/TS test patterns: *.test.ts, *.test.js, *.spec.ts, *.spec.js
+        if (basename.endsWith('.test.ts') || basename.endsWith('.test.js') ||
+            basename.endsWith('.spec.ts') || basename.endsWith('.spec.js')) {
+            result.javascript.push(file);
+        }
+        // Fixture patterns: tests/fixture*.json or fixture*.json in tests/ subdirs
+        if (basename.endsWith('.json') && basename.startsWith('fixture')) {
+            if (relPath.includes('tests' + path_1.default.sep) || relPath.startsWith('tests' + path_1.default.sep)) {
+                result.fixtures.push(file);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Run Python tests using pytest
+ */
+async function runPythonTests(agentDir, verbose) {
+    process.stderr.write(chalk_1.default.blue('\nRunning Python tests...\n\n'));
+    // Check if pytest is available
+    const hasPytest = await commandExists('pytest');
+    let command;
+    let args;
+    if (hasPytest) {
+        command = 'pytest';
+        args = verbose ? ['-v'] : [];
+    }
+    else {
+        command = 'python3';
+        args = ['-m', 'pytest'];
+        if (verbose)
+            args.push('-v');
+    }
+    const { code } = await runCommand(command, args, agentDir, verbose);
+    return code;
+}
+/**
+ * Run JavaScript/TypeScript tests
+ */
+async function runJsTests(agentDir, verbose) {
+    process.stderr.write(chalk_1.default.blue('\nRunning JavaScript/TypeScript tests...\n\n'));
+    // Check for vitest first
+    const hasVitest = await fileExists(path_1.default.join(agentDir, 'node_modules', '.bin', 'vitest'));
+    if (hasVitest) {
+        const args = ['run'];
+        if (verbose)
+            args.push('--reporter=verbose');
+        const { code } = await runCommand('npx', ['vitest', ...args], agentDir, verbose);
+        return code;
+    }
+    // Fall back to npm test
+    const packageJsonPath = path_1.default.join(agentDir, 'package.json');
+    if (await fileExists(packageJsonPath)) {
+        try {
+            const raw = await promises_1.default.readFile(packageJsonPath, 'utf-8');
+            const pkg = JSON.parse(raw);
+            if (pkg.scripts?.test) {
+                const { code } = await runCommand('npm', ['test'], agentDir, verbose);
+                return code;
+            }
+        }
+        catch {
+            // Invalid package.json
+        }
+    }
+    process.stderr.write(chalk_1.default.yellow('No JavaScript test runner found. Install vitest or add a test script to package.json.\n'));
+    return 1;
+}
+/**
+ * Run fixture-based tests for prompt agents
+ */
+async function runFixtureTests(agentDir, fixtures, verbose, config) {
+    process.stderr.write(chalk_1.default.blue('\nRunning fixture tests...\n\n'));
+    // Read prompt
+    let prompt;
+    const promptPath = path_1.default.join(agentDir, 'prompt.md');
+    const skillPath = path_1.default.join(agentDir, 'SKILL.md');
+    // Check if this is a skill
+    const skillData = await parseSkillMd(skillPath);
+    if (skillData) {
+        prompt = skillData.body;
+    }
+    else {
+        try {
+            prompt = await promises_1.default.readFile(promptPath, 'utf-8');
+        }
+        catch {
+            throw new errors_1.CliError('No prompt.md or SKILL.md found for fixture tests');
+        }
+    }
+    // Read output schema if available
+    let outputSchema;
+    const schemaPath = path_1.default.join(agentDir, 'schema.json');
+    try {
+        const raw = await promises_1.default.readFile(schemaPath, 'utf-8');
+        const schemas = JSON.parse(raw);
+        outputSchema = schemas.output;
+    }
+    catch {
+        // Schema is optional
+    }
+    // Detect LLM key
+    const detected = await (0, llm_1.detectLlmKey)(['any'], config);
+    if (!detected) {
+        throw new errors_1.CliError('No LLM key found for fixture tests.\n' +
+            'Set an environment variable (e.g., OPENAI_API_KEY) or run `orchagent keys add <provider>`');
+    }
+    const { provider, key } = detected;
+    const model = (0, llm_1.getDefaultModel)(provider);
+    let passed = 0;
+    let failed = 0;
+    for (const fixturePath of fixtures) {
+        const fixtureName = path_1.default.basename(fixturePath);
+        process.stderr.write(`  ${fixtureName}: `);
+        try {
+            const raw = await promises_1.default.readFile(fixturePath, 'utf-8');
+            const fixture = JSON.parse(raw);
+            // Build and call LLM
+            const fullPrompt = (0, llm_1.buildPrompt)(prompt, fixture.input);
+            const result = await (0, llm_1.callLlm)(provider, key, model, fullPrompt, outputSchema);
+            // Validate result
+            let testPassed = true;
+            const failures = [];
+            if (fixture.expected_output) {
+                // Exact match comparison
+                const resultStr = JSON.stringify(result, Object.keys(result).sort());
+                const expectedStr = JSON.stringify(fixture.expected_output, Object.keys(fixture.expected_output).sort());
+                if (resultStr !== expectedStr) {
+                    testPassed = false;
+                    failures.push(`Expected: ${expectedStr}\nGot: ${resultStr}`);
+                }
+            }
+            if (fixture.expected_contains) {
+                // Check if output contains expected strings
+                const resultStr = JSON.stringify(result);
+                for (const expected of fixture.expected_contains) {
+                    if (!resultStr.includes(expected)) {
+                        testPassed = false;
+                        failures.push(`Expected output to contain: "${expected}"`);
+                    }
+                }
+            }
+            if (testPassed) {
+                process.stderr.write(chalk_1.default.green('PASS\n'));
+                passed++;
+                if (verbose) {
+                    process.stderr.write(chalk_1.default.gray(`    Input: ${JSON.stringify(fixture.input)}\n`));
+                    process.stderr.write(chalk_1.default.gray(`    Output: ${JSON.stringify(result)}\n`));
+                }
+            }
+            else {
+                process.stderr.write(chalk_1.default.red('FAIL\n'));
+                failed++;
+                for (const failure of failures) {
+                    process.stderr.write(chalk_1.default.red(`    ${failure}\n`));
+                }
+            }
+        }
+        catch (err) {
+            process.stderr.write(chalk_1.default.red('ERROR\n'));
+            failed++;
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(chalk_1.default.red(`    ${message}\n`));
+        }
+    }
+    process.stderr.write('\n');
+    process.stderr.write(`Fixtures: ${passed} passed, ${failed} failed\n`);
+    return failed > 0 ? 1 : 0;
+}
+/**
+ * Watch mode: re-run tests on file changes
+ */
+async function watchTests(agentDir, agentType, testFiles, verbose, config) {
+    process.stderr.write(chalk_1.default.cyan('\nWatching for file changes... (press Ctrl+C to exit)\n\n'));
+    // Collect all files to watch
+    const watchPaths = [agentDir];
+    const runTests = async () => {
+        process.stderr.write(chalk_1.default.dim(`\n[${new Date().toLocaleTimeString()}] Running tests...\n`));
+        await executeTests(agentDir, agentType, testFiles, verbose, config);
+    };
+    // Initial run
+    await runTests();
+    // Set up file watcher using fs.watch (basic implementation)
+    const watchers = [];
+    let debounceTimer = null;
+    const onChange = () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(runTests, 500);
+    };
+    for (const watchPath of watchPaths) {
+        try {
+            // Use recursive watch on the directory
+            const ac = new AbortController();
+            (async () => {
+                try {
+                    const watcher = promises_1.default.watch(watchPath, { recursive: true, signal: ac.signal });
+                    for await (const _event of watcher) {
+                        onChange();
+                    }
+                }
+                catch (err) {
+                    if (err.name !== 'AbortError') {
+                        // Watcher error, ignore
+                    }
+                }
+            })();
+        }
+        catch {
+            // Watch not supported, fall back to polling
+        }
+    }
+    // Keep process alive
+    await new Promise(() => { });
+}
+/**
+ * Execute tests based on agent type and discovered test files
+ */
+async function executeTests(agentDir, agentType, testFiles, verbose, config) {
+    let exitCode = 0;
+    // Run tests based on what's available
+    const hasTests = testFiles.python.length > 0 ||
+        testFiles.javascript.length > 0 ||
+        testFiles.fixtures.length > 0;
+    if (!hasTests) {
+        // For prompt agents/skills, suggest creating fixtures
+        if (agentType === 'prompt' || agentType === 'skill') {
+            process.stderr.write(chalk_1.default.yellow('No test files found.\n\n'));
+            process.stderr.write('For prompt agents, create fixture files in tests/:\n');
+            process.stderr.write(chalk_1.default.gray('  tests/fixture-1.json:\n'));
+            process.stderr.write(chalk_1.default.gray('  {\n'));
+            process.stderr.write(chalk_1.default.gray('    "input": {"text": "Hello world"},\n'));
+            process.stderr.write(chalk_1.default.gray('    "expected_contains": ["response"]\n'));
+            process.stderr.write(chalk_1.default.gray('  }\n\n'));
+        }
+        else {
+            process.stderr.write(chalk_1.default.yellow('No test files found.\n\n'));
+            process.stderr.write('Supported test file patterns:\n');
+            process.stderr.write(chalk_1.default.gray('  Python: test_*.py, *_test.py, tests/test_*.py\n'));
+            process.stderr.write(chalk_1.default.gray('  JS/TS:  *.test.ts, *.spec.ts, tests/*.test.ts\n'));
+            process.stderr.write(chalk_1.default.gray('  Fixtures: tests/fixture-*.json\n\n'));
+        }
+        return 1;
+    }
+    // Run Python tests if found
+    if (testFiles.python.length > 0) {
+        if (verbose) {
+            process.stderr.write(chalk_1.default.gray(`Found ${testFiles.python.length} Python test file(s)\n`));
+        }
+        const code = await runPythonTests(agentDir, verbose);
+        if (code !== 0)
+            exitCode = 1;
+    }
+    // Run JS/TS tests if found
+    if (testFiles.javascript.length > 0) {
+        if (verbose) {
+            process.stderr.write(chalk_1.default.gray(`Found ${testFiles.javascript.length} JavaScript/TypeScript test file(s)\n`));
+        }
+        const code = await runJsTests(agentDir, verbose);
+        if (code !== 0)
+            exitCode = 1;
+    }
+    // Run fixture tests if found (for prompt agents)
+    if (testFiles.fixtures.length > 0) {
+        if (verbose) {
+            process.stderr.write(chalk_1.default.gray(`Found ${testFiles.fixtures.length} fixture file(s)\n`));
+        }
+        const code = await runFixtureTests(agentDir, testFiles.fixtures, verbose, config);
+        if (code !== 0)
+            exitCode = 1;
+    }
+    return exitCode;
+}
+function registerTestCommand(program) {
+    program
+        .command('test [path]')
+        .description('Run agent test suite locally')
+        .option('-v, --verbose', 'Show detailed test output')
+        .option('-w, --watch', 'Watch for file changes and re-run tests')
+        .addHelpText('after', `
+Examples:
+  orch test                    Run tests in current directory
+  orch test ./my-agent         Run tests in specified directory
+  orch test --verbose          Show detailed test output
+  orch test --watch            Watch mode - re-run on file changes
+
+Test Discovery:
+  Python:   test_*.py, *_test.py, tests/test_*.py, tests/*_test.py
+  JS/TS:    *.test.ts, *.test.js, *.spec.ts, *.spec.js, tests/*.test.*
+  Fixtures: tests/fixture-*.json (for prompt agents)
+
+Fixture Format (tests/fixture-1.json):
+  {
+    "input": {"key": "value"},
+    "expected_output": {"result": "expected"},
+    "expected_contains": ["substring"],
+    "description": "Test description"
+  }
+`)
+        .action(async (agentPath, options) => {
+        const agentDir = agentPath
+            ? path_1.default.resolve(process.cwd(), agentPath)
+            : process.cwd();
+        // Verify directory exists
+        try {
+            const stat = await promises_1.default.stat(agentDir);
+            if (!stat.isDirectory()) {
+                throw new errors_1.CliError(`Not a directory: ${agentDir}`);
+            }
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                throw new errors_1.CliError(`Directory not found: ${agentDir}`);
+            }
+            throw err;
+        }
+        // Detect agent type
+        const agentType = await detectAgentType(agentDir);
+        if (options.verbose) {
+            process.stderr.write(chalk_1.default.gray(`Detected agent type: ${agentType}\n`));
+        }
+        // Discover test files
+        const testFiles = await discoverTests(agentDir);
+        if (options.verbose) {
+            const totalTests = testFiles.python.length + testFiles.javascript.length + testFiles.fixtures.length;
+            process.stderr.write(chalk_1.default.gray(`Discovered ${totalTests} test file(s)\n`));
+        }
+        // Get config for LLM access (needed for fixture tests)
+        let config;
+        try {
+            config = await (0, config_1.getResolvedConfig)();
+        }
+        catch {
+            // Config not available, fixture tests will use env vars only
+        }
+        // Watch mode
+        if (options.watch) {
+            await watchTests(agentDir, agentType, testFiles, !!options.verbose, config);
+            return;
+        }
+        // Run tests
+        const exitCode = await executeTests(agentDir, agentType, testFiles, !!options.verbose, config);
+        if (exitCode === 0) {
+            process.stderr.write(chalk_1.default.green('\nAll tests passed.\n'));
+        }
+        else {
+            process.stderr.write(chalk_1.default.red('\nSome tests failed.\n'));
+        }
+        process.exit(exitCode);
+    });
+}

package/dist/index.js

@@ -45,6 +45,8 @@ const commander_1 = require("commander");
 const commands_1 = require("./commands");
 const errors_1 = require("./lib/errors");
 const analytics_1 = require("./lib/analytics");
+const config_1 = require("./lib/config");
+const spinner_1 = require("./lib/spinner");
 const package_json_1 = __importDefault(require("../package.json"));
 (0, analytics_1.initPostHog)();
 const program = new commander_1.Command();
@@ -52,6 +54,7 @@ program
     .name('orchagent')
     .description('orchagent CLI')
     .version(package_json_1.default.version)
+    .option('--no-progress', 'Disable progress spinners (useful for CI/scripts)')
     .addHelpText('after', `
 Quick Reference:
   run   Download and run an agent locally (your machine)
@@ -64,7 +67,22 @@ Documentation: https://docs.orchagent.io
   orchagent docs agents  Building agents guide
 `);
 (0, commands_1.registerCommands)(program);
-program
-    .parseAsync(process.argv)
+// Initialize progress setting before parsing
+async function main() {
+    // Check config for no_progress setting
+    const config = await (0, config_1.loadConfig)();
+    if (config.no_progress) {
+        (0, spinner_1.setProgressEnabled)(false);
+    }
+    // Parse args - hook will set noProgress if --no-progress flag is passed
+    program.hook('preAction', () => {
+        const opts = program.opts();
+        if (opts.progress === false) {
+            (0, spinner_1.setProgressEnabled)(false);
+        }
+    });
+    await program.parseAsync(process.argv);
+}
+main()
     .catch(errors_1.exitWithError)
     .finally(() => (0, analytics_1.shutdownPostHog)());

package/dist/lib/spinner.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setProgressEnabled = setProgressEnabled;
+exports.isProgressEnabled = isProgressEnabled;
+exports.createSpinner = createSpinner;
+exports.withSpinner = withSpinner;
+exports.createProgressSpinner = createProgressSpinner;
+const ora_1 = __importDefault(require("ora"));
+// Global flag to control spinner visibility (set via --no-progress)
+let progressEnabled = true;
+/**
+ * Set whether progress spinners are enabled.
+ * Disable for CI/scripts with --no-progress flag.
+ */
+function setProgressEnabled(enabled) {
+    progressEnabled = enabled;
+}
+/**
+ * Check if progress spinners are enabled.
+ */
+function isProgressEnabled() {
+    return progressEnabled;
+}
+/**
+ * Create a spinner with the given text.
+ * Returns a spinner that auto-disables in non-TTY environments.
+ * If progress is disabled (--no-progress), returns a no-op spinner.
+ */
+function createSpinner(text) {
+    if (!progressEnabled) {
+        // Return a no-op spinner that writes to stderr instead
+        const noopSpinner = {
+            text,
+            isSpinning: false,
+            start() {
+                process.stderr.write(`${text}\n`);
+                return noopSpinner;
+            },
+            stop() {
+                return noopSpinner;
+            },
+            succeed(msg) {
+                if (msg)
+                    process.stderr.write(`${msg}\n`);
+                return noopSpinner;
+            },
+            fail(msg) {
+                if (msg)
+                    process.stderr.write(`${msg}\n`);
+                return noopSpinner;
+            },
+            warn(msg) {
+                if (msg)
+                    process.stderr.write(`${msg}\n`);
+                return noopSpinner;
+            },
+            info(msg) {
+                if (msg)
+                    process.stderr.write(`${msg}\n`);
+                return noopSpinner;
+            },
+        };
+        return noopSpinner;
+    }
+    // ora automatically handles non-TTY by falling back to text output
+    return (0, ora_1.default)({
+        text,
+        stream: process.stderr, // Use stderr so it doesn't interfere with JSON output
+    });
+}
+/**
+ * Execute an async function with a spinner.
+ * Automatically handles success/failure states.
+ *
+ * @param text - Text to show while operation is running
+ * @param fn - Async function to execute
+ * @param options - Optional success/fail message overrides
+ * @returns Result of the async function
+ */
+async function withSpinner(text, fn, options) {
+    const spinner = createSpinner(text);
+    spinner.start();
+    try {
+        const result = await fn();
+        const successMsg = typeof options?.successText === 'function'
+            ? options.successText(result)
+            : options?.successText;
+        spinner.succeed(successMsg);
+        return result;
+    }
+    catch (err) {
+        const failMsg = typeof options?.failText === 'function'
+            ? options.failText(err)
+            : options?.failText || (err instanceof Error ? err.message : 'Failed');
+        spinner.fail(failMsg);
+        throw err;
+    }
+}
+/**
+ * Create a spinner that can be updated with progress info.
+ * Useful for operations like downloads where you want to show progress.
+ */
+function createProgressSpinner(initialText) {
+    const spinner = createSpinner(initialText);
+    const updateProgress = (current, total, unit = 'bytes') => {
+        if (progressEnabled && spinner.isSpinning) {
+            const percent = total > 0 ? Math.round((current / total) * 100) : 0;
+            spinner.text = `${initialText} (${percent}% - ${current}/${total} ${unit})`;
+        }
+    };
+    return { spinner, updateProgress };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.3.22",
+  "version": "0.3.23",
   "description": "Command-line interface for the orchagent AI agent marketplace",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",
@@ -49,6 +49,7 @@
     "cli-table3": "^0.6.3",
     "commander": "^11.1.0",
     "open": "^8.4.2",
+    "ora": "^9.1.0",
     "posthog-node": "^4.0.0",
     "yaml": "^2.8.2"
   },