codymaster 4.8.0 → 7.0.0

package/dist/cli/commands/install.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInstallCommands = registerInstallCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const engine_1 = require("../../install/engine");
+const profiles_1 = require("../../install/profiles");
+const repoRoot = path_1.default.join(__dirname, '..', '..', '..');
+function registerInstallCommands(program) {
+    program
+        .command('install [platform]')
+        .description('Install CodyMaster skills to an AI coding platform')
+        .option('-p, --profile <name>', 'Skill profile: core | growth | design | knowledge | full', 'full')
+        .option('-s, --scope <scope>', 'Install scope for platforms that support it: user | project', 'user')
+        .option('--all', 'Install to every detected platform')
+        .option('--list', 'List supported platforms and exit')
+        .option('--sync', 'Sync skills to all platforms after install')
+        .option('--dry-run', 'Show what would change without writing any files')
+        .action((platform, opts) => __awaiter(this, void 0, void 0, function* () {
+        if (opts.list)
+            return printPlatforms();
+        const profile = String(opts.profile);
+        if (!(0, profiles_1.isValidProfile)(profile)) {
+            console.error(chalk_1.default.red(`Invalid profile: ${profile}`));
+            console.error(chalk_1.default.dim('Valid: core, growth, design, knowledge, full'));
+            process.exit(1);
+        }
+        if (opts.scope !== 'user' && opts.scope !== 'project') {
+            console.error(chalk_1.default.red(`Invalid scope: ${opts.scope} (expected user|project)`));
+            process.exit(1);
+        }
+        const installOpts = {
+            profile: profile,
+            scope: opts.scope,
+            dryRun: !!opts.dryRun,
+        };
+        let targets;
+        if (opts.all) {
+            targets = (0, engine_1.detectPlatforms)()
+                .filter((p) => p.installed)
+                .map((p) => p.platform.id);
+            if (targets.length === 0) {
+                console.error(chalk_1.default.red('No installed AI platforms detected.'));
+                console.error(chalk_1.default.dim("Pass a platform id explicitly: cm install claude-code"));
+                process.exit(1);
+            }
+        }
+        else if (platform) {
+            targets = [platform];
+        }
+        else {
+            printPlatforms();
+            console.log(chalk_1.default.dim('\nUsage: cm install <platform> [--profile core] [--scope user|project]'));
+            return;
+        }
+        console.log(chalk_1.default.bold(`\nInstalling profile=${profile} scope=${opts.scope}${opts.dryRun ? ' (dry-run)' : ''}`));
+        const results = yield (0, engine_1.installToMany)(targets, installOpts);
+        for (const r of results) {
+            console.log('');
+            console.log(chalk_1.default.bold.magenta(`  ${r.platform}`));
+            console.log(chalk_1.default.dim(`  → ${r.targetPath}`));
+            console.log(chalk_1.default.green(`  ✓ ${r.installed.length} skills installed`) + chalk_1.default.dim(` (${r.skipped.length} skipped)`));
+            for (const h of r.postInstallHints)
+                console.log(chalk_1.default.cyan(`  ℹ  ${h}`));
+        }
+        // Auto-sync if --sync flag or --all flag
+        if ((opts.sync || opts.all) && !opts.dryRun) {
+            console.log(chalk_1.default.bold('\n  Syncing skills to all platforms...'));
+            try {
+                (0, child_process_1.execSync)('node scripts/build-skills.mjs --all-platforms', {
+                    stdio: 'inherit',
+                    cwd: repoRoot,
+                    timeout: 60000,
+                });
+                console.log(chalk_1.default.green('  ✅ Skills synced to all platforms'));
+            }
+            catch (error) {
+                console.log(chalk_1.default.yellow('  ⚠️  Sync failed (run `cm update --sync` manually)'));
+            }
+        }
+        console.log('');
+    }));
+    // ─── Doctor Command ─────────────────────────────────────────
+    program
+        .command('doctor')
+        .description('Check which AI platforms are installed and which have CodyMaster skills')
+        .option('--sync-check', 'Check skill sync status across platforms')
+        .action((opts) => {
+        console.log(chalk_1.default.bold('\nDetected platforms:\n'));
+        for (const d of (0, engine_1.detectPlatforms)()) {
+            const mark = d.installed ? chalk_1.default.green('●') : chalk_1.default.dim('○');
+            const detail = d.detail ? chalk_1.default.dim(`  (${d.detail})`) : '';
+            console.log(`  ${mark} ${d.platform.emoji}  ${d.platform.name}${detail}`);
+        }
+        // Sync check
+        if (opts.syncCheck) {
+            console.log(chalk_1.default.bold('\n  Sync Status:\n'));
+            checkSyncStatus();
+        }
+        console.log('');
+    });
+}
+function checkSyncStatus() {
+    const platforms = [
+        { name: 'claude-code', dir: '.claude/skills' },
+        { name: 'claude-desktop', dir: '.claude-desktop/skills' },
+        { name: 'cursor', dir: '.cursor-plugin/skills' },
+        { name: 'windsurf', dir: '.windsurf/skills' },
+        { name: 'antigravity', dir: '.gemini/skills' },
+        { name: 'codex', dir: '.codex/skills' },
+        { name: 'opencode', dir: '.opencode/skills' },
+        { name: 'cline', dir: '.cline/skills' },
+        { name: 'kiro', dir: '.kiro/skills' },
+        { name: 'copilot', dir: '.copilot/skills' },
+        { name: 'aider', dir: '.aider/skills' },
+        { name: 'continue', dir: '.continue/skills' },
+        { name: 'amazon-q', dir: '.amazonq/skills' },
+        { name: 'amp', dir: '.amp/skills' },
+    ];
+    let synced = 0;
+    let missing = 0;
+    for (const p of platforms) {
+        const fullPath = path_1.default.join(repoRoot, p.dir);
+        const hasShared = fs_1.default.existsSync(path_1.default.join(fullPath, '_shared', 'helpers.md'));
+        if (hasShared) {
+            synced++;
+        }
+        else {
+            missing++;
+            console.log(chalk_1.default.yellow(`    ⚠ ${p.name}: _shared/helpers.md missing`));
+        }
+    }
+    if (missing === 0) {
+        console.log(chalk_1.default.green(`    ✅ All ${synced} platforms synced`));
+    }
+    else {
+        console.log(chalk_1.default.dim(`    ${synced} synced, ${missing} missing`));
+        console.log(chalk_1.default.dim('    Run `cm update --sync` to fix.'));
+    }
+}
+function printPlatforms() {
+    console.log(chalk_1.default.bold('\nSupported platforms:\n'));
+    for (const p of (0, engine_1.listPlatforms)()) {
+        console.log(`  ${p.emoji}  ${chalk_1.default.cyan(p.id.padEnd(16))} ${chalk_1.default.dim(p.name)}`);
+    }
+}

package/dist/cli/commands/learn.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncLearnings = syncLearnings;
+exports.registerLearnCommands = registerLearnCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const learnings_1 = require("../../learnings");
+const VALID_TYPES = ['pitfall', 'preference', 'pattern', 'fact'];
+function resolveProject(opts) {
+    var _a;
+    return path_1.default.resolve((_a = opts.project) !== null && _a !== void 0 ? _a : process.cwd());
+}
+function git(cwd, args) {
+    return (0, child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}
+function syncLearnings(projectPath, opts) {
+    var _a;
+    const syncDir = (_a = opts.syncDir) !== null && _a !== void 0 ? _a : path_1.default.join(os_1.default.homedir(), '.cm', 'learnings-sync');
+    const remoteFile = path_1.default.join(syncDir, 'learnings.jsonl');
+    if (!fs_1.default.existsSync(path_1.default.join(syncDir, '.git'))) {
+        fs_1.default.mkdirSync(path_1.default.dirname(syncDir), { recursive: true });
+        if (fs_1.default.existsSync(syncDir)) {
+            // Existing non-git dir — abort rather than wipe.
+            throw new Error(`${syncDir} exists but is not a git checkout`);
+        }
+        git(path_1.default.dirname(syncDir), ['clone', opts.remote, path_1.default.basename(syncDir)]);
+        // Ensure a local identity exists so commits succeed even when the host
+        // has no global git config (CI runners, fresh containers).
+        try {
+            git(syncDir, ['config', 'user.email', 'cm-learn-sync@codymaster.local']);
+        }
+        catch (_b) { }
+        try {
+            git(syncDir, ['config', 'user.name', 'cm-learn-sync']);
+        }
+        catch (_c) { }
+    }
+    else {
+        // Make sure we point at the requested remote, then refresh.
+        try {
+            git(syncDir, ['remote', 'set-url', 'origin', opts.remote]);
+        }
+        catch (_d) {
+            git(syncDir, ['remote', 'add', 'origin', opts.remote]);
+        }
+        try {
+            git(syncDir, ['pull', '--ff-only', 'origin', 'HEAD']);
+        }
+        catch (_e) {
+            // Empty repo / unborn HEAD — ignore; nothing to pull.
+        }
+    }
+    const localFile = (0, learnings_1.learningsPath)(projectPath);
+    const localBefore = (0, learnings_1.readLearningsFile)(localFile);
+    const remoteBefore = (0, learnings_1.readLearningsFile)(remoteFile);
+    const merged = (0, learnings_1.mergeLearnings)(localBefore, remoteBefore);
+    // Local: write merged set verbatim (keeps full fidelity for the user).
+    (0, learnings_1.writeLearningsFile)(localFile, merged);
+    const pulled = merged.length - localBefore.length;
+    if (opts.pullOnly) {
+        return { pulled, pushed: 0, localTotal: merged.length };
+    }
+    // Remote: write anonymized merge.
+    const anonMerged = (0, learnings_1.mergeLearnings)(remoteBefore, localBefore.map(learnings_1.anonymize));
+    (0, learnings_1.writeLearningsFile)(remoteFile, anonMerged);
+    const pushed = anonMerged.length - remoteBefore.length;
+    if (pushed > 0) {
+        git(syncDir, ['add', 'learnings.jsonl']);
+        try {
+            git(syncDir, ['commit', '-m', `learn: +${pushed} from ${path_1.default.basename(projectPath)}`]);
+            git(syncDir, ['push', 'origin', 'HEAD']);
+        }
+        catch (e) {
+            // Bubble up so the caller can decide; non-zero pushes left in local mirror are fine.
+            throw new Error(`git push failed: ${e.message}`);
+        }
+    }
+    return { pulled, pushed, localTotal: merged.length };
+}
+function registerLearnCommands(program) {
+    program
+        .command('learn <cmd> [args...]')
+        .description('Per-project learnings log (.cm/learnings.jsonl) — gstack-style notes')
+        .option('-p, --project <path>', 'Project path (default: cwd)')
+        .option('-t, --type <type>', 'pitfall | preference | pattern | fact', 'fact')
+        .option('-s, --scope <scope>', 'Scope tag (deploy, ui, test, ...)', 'general')
+        .option('--source <source>', 'Origin label (e.g. cm-retro-cli)', 'manual')
+        .option('--days <n>', 'For prune: max age in days', '180')
+        .option('--limit <n>', 'For list: max rows', '20')
+        .option('--filter-type <type>', 'For list: filter by type')
+        .option('--filter-scope <scope>', 'For list: filter by scope')
+        .option('--remote <url>', 'For sync: git remote URL of the shared learnings repo')
+        .option('--pull-only', 'For sync: pull + merge only, do not push back')
+        .option('--sync-dir <path>', 'For sync: working dir (default: ~/.cm/learnings-sync)')
+        .action((cmd, args, opts) => {
+        const project = resolveProject(opts);
+        switch (cmd) {
+            case 'add': {
+                const note = args.join(' ').trim();
+                if (!note) {
+                    console.error(chalk_1.default.red('Usage: cm learn add "<note>"  [--type ... --scope ...]'));
+                    process.exitCode = 1;
+                    return;
+                }
+                if (!VALID_TYPES.includes(opts.type)) {
+                    console.error(chalk_1.default.red(`Invalid --type. Use one of: ${VALID_TYPES.join(', ')}`));
+                    process.exitCode = 1;
+                    return;
+                }
+                try {
+                    const l = (0, learnings_1.addLearning)(project, {
+                        type: opts.type,
+                        scope: opts.scope,
+                        note,
+                        source: opts.source,
+                    });
+                    console.log(chalk_1.default.green(`✓ Learned [${l.type}/${l.scope}]: ${l.note}`));
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(`✗ ${e.message}`));
+                    process.exitCode = 1;
+                }
+                return;
+            }
+            case 'list':
+            case 'ls': {
+                const items = (0, learnings_1.listLearnings)(project, {
+                    limit: parseInt(opts.limit, 10),
+                    type: opts.filterType,
+                    scope: opts.filterScope,
+                });
+                if (items.length === 0) {
+                    console.log(chalk_1.default.dim('(no learnings yet)'));
+                    return;
+                }
+                for (const l of items) {
+                    const date = l.ts.slice(0, 10);
+                    console.log(`${chalk_1.default.gray(date)} ${chalk_1.default.cyan(l.type.padEnd(10))} ${chalk_1.default.yellow(l.scope.padEnd(12))} ${l.note}`);
+                }
+                console.log(chalk_1.default.dim(`\n${items.length} learning(s)`));
+                return;
+            }
+            case 'prune': {
+                const days = parseInt(opts.days, 10);
+                const n = (0, learnings_1.pruneLearnings)(project, days);
+                console.log(chalk_1.default.green(`✓ Pruned ${n} learning(s) older than ${days} days`));
+                return;
+            }
+            case 'sync': {
+                if (!opts.remote) {
+                    console.error(chalk_1.default.red('Usage: cm learn sync --remote <git-url> [--pull-only]'));
+                    process.exitCode = 1;
+                    return;
+                }
+                try {
+                    const result = syncLearnings(project, {
+                        remote: opts.remote,
+                        pullOnly: !!opts.pullOnly,
+                        syncDir: opts.syncDir,
+                    });
+                    console.log(chalk_1.default.green(`✓ sync ok — pulled=${result.pulled} pushed=${result.pushed} local=${result.localTotal}`));
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(`✗ sync failed: ${e.message}`));
+                    process.exitCode = 1;
+                }
+                return;
+            }
+            default:
+                console.error(chalk_1.default.red(`Unknown subcommand: ${cmd}`));
+                console.log(chalk_1.default.dim('Available: add, list, prune, sync'));
+                process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/mcp-serve.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.registerMcpServeCommands = registerMcpServeCommands;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+function registerMcpServeCommands(program) {
+    program
+        .command('mcp-serve')
+        .description('Start CodyMaster MCP context server (stdio transport for Goose, Claude Desktop, etc.)')
+        .option('--project <path>', 'Project root directory (default: current working directory)')
+        .option('--print-config', 'Print Goose/Claude Desktop JSON config snippet and exit')
+        .option('--install-claude', 'Auto-install MCP servers into Claude Desktop / Cowork config')
+        .action((opts) => {
+        var _a;
+        const projectPath = path_1.default.resolve((_a = opts.project) !== null && _a !== void 0 ? _a : process.cwd());
+        if (opts.installClaude) {
+            let configPath = '';
+            if (process.platform === 'win32') {
+                configPath = path_1.default.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+            }
+            else if (process.platform === 'darwin') {
+                configPath = path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+            }
+            else {
+                console.error(chalk_1.default.red('Auto-install is currently only supported on Windows and macOS.'));
+                process.exit(1);
+            }
+            let config = {};
+            if (fs_1.default.existsSync(configPath)) {
+                try {
+                    config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(`Failed to parse ${configPath}: ${e.message}`));
+                    process.exit(1);
+                }
+            }
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            const serverPath = path_1.default.join(__dirname, '..', '..', '..', 'dist', 'mcp-context-server.js');
+            const dashboardPath = path_1.default.join(__dirname, '..', '..', '..', 'scripts', 'mcp-bridge.js');
+            config.mcpServers['cm-context'] = {
+                command: process.execPath,
+                args: [serverPath, '--project', projectPath],
+                env: { 'CM_PROJECT_PATH': projectPath }
+            };
+            config.mcpServers['cm-dashboard'] = {
+                command: process.execPath,
+                args: [dashboardPath]
+            };
+            const configDir = path_1.default.dirname(configPath);
+            if (!fs_1.default.existsSync(configDir))
+                fs_1.default.mkdirSync(configDir, { recursive: true });
+            fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+            console.log(chalk_1.default.green(`🎉 Installed successfully into Claude Desktop: ${configPath}`));
+            process.exit(0);
+        }
+        if (opts.printConfig) {
+            const gooseConfig = {
+                id: 'codymaster',
+                name: 'CodyMaster Intelligence Layer',
+                type: 'stdio',
+                cmd: 'npx',
+                args: ['codymaster', 'mcp-serve', '--project', projectPath],
+            };
+            const claudeConfig = {
+                mcpServers: {
+                    'cm-context': {
+                        command: process.execPath,
+                        args: [
+                            path_1.default.join(__dirname, '..', '..', '..', 'dist', 'mcp-context-server.js'),
+                            '--project',
+                            projectPath,
+                        ],
+                    },
+                },
+            };
+            console.log(chalk_1.default.bold('\nGoose config (add to ~/.config/goose/config.yaml extensions):'));
+            console.log(JSON.stringify(gooseConfig, null, 2));
+            console.log(chalk_1.default.bold('\nClaude Desktop config (add to mcpServers in claude_desktop_config.json):'));
+            console.log(JSON.stringify(claudeConfig.mcpServers, null, 2));
+            process.exit(0);
+        }
+        const serverPath = path_1.default.join(__dirname, '..', '..', '..', 'dist', 'mcp-context-server.js');
+        if (!fs_1.default.existsSync(serverPath)) {
+            console.error(chalk_1.default.red(`Error: MCP server not found at ${serverPath}`));
+            console.error(chalk_1.default.yellow('Run `npm run build` first to compile the server.'));
+            process.exit(1);
+        }
+        console.error(chalk_1.default.dim(`[CodyMaster] Starting MCP server for project: ${projectPath}`));
+        const child = (0, child_process_1.spawn)(process.execPath, [serverPath, '--project', projectPath], {
+            stdio: 'inherit',
+        });
+        child.on('exit', (code) => process.exit(code !== null && code !== void 0 ? code : 0));
+        process.on('SIGINT', () => child.kill('SIGINT'));
+        process.on('SIGTERM', () => child.kill('SIGTERM'));
+    });
+}

package/dist/cli/commands/parallel.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * cm parallel — Execute tasks in parallel using Gemini CLI
+ *
+ * TRIZ Principle #1 (Segmentation):
+ *   Split task into independent subtasks, run in parallel.
+ *
+ * TRIZ Principle #15 (Dynamicity):
+ *   Adapt batch size based on task complexity.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerParallelCommands = registerParallelCommands;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const box_1 = require("../../ui/box");
+function registerParallelCommands(program) {
+    program
+        .command('parallel <task>')
+        .description('Execute task in parallel using Gemini CLI')
+        .option('-n, --count <n>', 'Number of parallel instances', '3')
+        .option('-c, --context <files>', 'Context files to include (comma-separated)')
+        .option('-m, --model <model>', 'Gemini model to use', 'gemini-2.0-flash')
+        .option('--timeout <ms>', 'Timeout per instance in milliseconds', '120000')
+        .action((task, opts) => __awaiter(this, void 0, void 0, function* () {
+        const count = parseInt(opts.count, 10);
+        const timeout = parseInt(opts.timeout, 10);
+        console.log((0, box_1.renderCommandHeader)('Parallel Execution', '⚡'));
+        console.log(chalk_1.default.dim(`  Task: ${task}`));
+        console.log(chalk_1.default.dim(`  Instances: ${count}`));
+        console.log(chalk_1.default.dim(`  Model: ${opts.model}`));
+        console.log('');
+        // Check if gemini CLI is available
+        const geminiAvailable = yield checkGeminiCli();
+        if (!geminiAvailable) {
+            console.log(chalk_1.default.yellow('⚠ Gemini CLI not found. Falling back to single-agent execution.'));
+            console.log(chalk_1.default.dim('Install: npm install -g @anthropic-ai/gemini-cli'));
+            console.log('');
+            yield executeSingleAgent(task, opts);
+            return;
+        }
+        // Execute in parallel
+        const results = yield executeParallel(task, count, opts);
+        // Display results
+        console.log(chalk_1.default.bold('\n📊 Results:\n'));
+        for (const result of results) {
+            const status = result.exitCode === 0 ? chalk_1.default.green('✅') : chalk_1.default.red('❌');
+            console.log(`  ${status} Instance ${result.instance}: exit=${result.exitCode}`);
+            if (result.output) {
+                console.log(chalk_1.default.dim(`     ${result.output.slice(0, 100)}...`));
+            }
+        }
+        // Summary
+        const passed = results.filter(r => r.exitCode === 0).length;
+        const failed = results.filter(r => r.exitCode !== 0).length;
+        console.log('');
+        console.log(chalk_1.default.bold(`  Summary: ${chalk_1.default.green(`${passed} passed`)} / ${chalk_1.default.red(`${failed} failed`)}`));
+    }));
+}
+function checkGeminiCli() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('which', ['gemini'], { stdio: 'pipe' });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+        });
+    });
+}
+function executeParallel(task, count, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = [];
+        const promises = [];
+        for (let i = 1; i <= count; i++) {
+            promises.push(executeInstance(task, i, opts));
+        }
+        return Promise.all(promises);
+    });
+}
+function executeInstance(task, instance, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const args = [
+                '-p', `Instance ${instance}: ${task}`,
+                '--model', opts.model,
+            ];
+            if (opts.context) {
+                args.push('--context', opts.context);
+            }
+            const proc = (0, child_process_1.spawn)('gemini', args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: parseInt(opts.timeout, 10),
+            });
+            let output = '';
+            let error = '';
+            proc.stdout.on('data', (data) => {
+                output += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                error += data.toString();
+            });
+            proc.on('close', (code) => {
+                resolve({
+                    instance,
+                    exitCode: code,
+                    output: output.trim(),
+                    error: error.trim(),
+                });
+            });
+            proc.on('error', (err) => {
+                resolve({
+                    instance,
+                    exitCode: 1,
+                    output: '',
+                    error: err.message,
+                });
+            });
+        });
+    });
+}
+function executeSingleAgent(task, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(chalk_1.default.dim('  Executing with single agent...'));
+        // Fallback: just print the task for the AI agent to handle
+        console.log(chalk_1.default.bold(`  Task: ${task}`));
+        console.log(chalk_1.default.dim('  (Single-agent mode — use Gemini CLI for parallel execution)'));
+    });
+}