@toyako/hive 1.0.0

package/dist/commands/cli.js

@@ -0,0 +1,848 @@
+#!/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 Broker_1 = require("../broker/Broker");
+const registry_1 = require("../adapters/registry");
+const GraphValidator_1 = require("../graph/GraphValidator");
+const TopologyTemplates_1 = require("../graph/TopologyTemplates");
+const TaskIntentClassifier_1 = require("../product/TaskIntentClassifier");
+const AutoTopologySelector_1 = require("../product/AutoTopologySelector");
+const ProviderRegistry_1 = require("../product/ProviderRegistry");
+const MemoryManager_1 = require("../memory/MemoryManager");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pkg = require('../../package.json');
+const ARGS = process.argv.slice(2);
+const CMD = ARGS[0];
+// Known commands (not task descriptions)
+const KNOWN_CMDS = ["config", "mcp", "roles", "role", "workflows", "tools", "channels", "resume", "cost", "status", "--version", "--help", "-v", "-h", "memory", "project", "setup", "init", "detect", "agents", "link", "graph", "graph-template", "graph-validate", "graph-migrate", "task", "run", "dashboard", "doctor", "version", "health", "history", "help"];
+async function main() {
+    const broker = new Broker_1.Broker();
+    // No args → interactive mode
+    if (!CMD) {
+        return cmdInteractive(broker);
+    }
+    // First arg looks like a task (not a known command) → treat as shortcut
+    if (!KNOWN_CMDS.includes(CMD)) {
+        const task = ARGS.join(" ");
+        return cmdRunWithTask(broker, task);
+    }
+    switch (CMD) {
+        case "setup": return cmdSetup();
+        case "init": return cmdInit();
+        case "detect": return cmdDetect(broker, ARGS);
+        case "agents": return cmdAgents(broker);
+        case "link": return cmdLink(broker, ARGS[1], ARGS[2]);
+        case "graph": return cmdGraph(broker);
+        case "graph-template": return cmdGraphTemplate(broker, ARGS);
+        case "graph-validate": return cmdGraphValidate(broker);
+        case "graph-migrate": return cmdGraphMigrate(broker);
+        case "task": return cmdTask(broker, ARGS);
+        case "run": return cmdRun(broker, ARGS);
+        case "dashboard": return cmdDashboard();
+        case "doctor": return cmdDoctor(broker);
+        case "version":
+        case "--version":
+        case "-v": return cmdVersion();
+        case "help":
+        case "--help":
+        case "-h": return printUsage();
+        case "health": return cmdHealth(broker);
+        case "history": return cmdHistory(broker, ARGS);
+        case "memory": return cmdMemory(ARGS);
+        case "project": return cmdProject(ARGS);
+        case "resume": return cmdResume(broker);
+        case "cost": return cmdCost();
+        case "status": return cmdStatus();
+        case "config": return cmdConfig();
+        case "mcp": return cmdMCP(ARGS);
+        case "roles": return cmdRoles(ARGS);
+        case "role": return cmdRoleInfo(ARGS);
+        case "workflows": return cmdWorkflows();
+        case "tools": return cmdTools();
+        case "channels": return cmdChannels(ARGS);
+        case "help":
+        case "--help":
+        case "-h": return printUsage();
+    }
+}
+async function cmdInteractive(broker) {
+    const readline = require("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    console.log("\n  🐝 Agent Hive\n");
+    const task = await ask("  What do you want to build?\n\n  > ");
+    rl.close();
+    if (!task.trim()) {
+        console.log("  Bye! 🐝\n");
+        return;
+    }
+    await cmdRunWithTask(broker, task);
+}
+async function cmdRunWithTask(broker, task) {
+    cleanTasks();
+    console.log(`\n  🐝 Working on: "${task.slice(0, 80)}${task.length > 80 ? "..." : ""}"\n`);
+    await cmdDetect(broker, []);
+    // Auto-classify and select
+    const classifier = new TaskIntentClassifier_1.TaskIntentClassifier();
+    const adapters = broker.registry.all().map(e => broker.registry.getAdapter(e.name)).filter(Boolean);
+    const selector = new AutoTopologySelector_1.AutoTopologySelector(adapters);
+    const classification = classifier.classify(task);
+    const selection = selector.select(classification.intent);
+    console.log(`  [classify] ${classification.intent} (${classification.confidence})`);
+    console.log(`  [select]   ${selection.executor} → ${selection.reviewer} (${selection.topology})\n`);
+    broker.addAgentProfile({ id: selection.executor, runtimeId: selection.executor, role: "executor", maxConcurrency: 1, status: "idle" });
+    broker.addAgentProfile({ id: selection.reviewer, runtimeId: selection.reviewer, role: "reviewer", maxConcurrency: 1, status: "idle" });
+    broker.addGraphEdge(selection.executor, selection.reviewer, "reviews", 10);
+    broker.addGraphEdge(selection.reviewer, selection.executor, "escalates", 5);
+    broker.enableGraphMode();
+    broker.submit({ instruction: task, executor: selection.executor, reviewer: selection.reviewer, workingDirectory: process.cwd(), maxRevision: 3 });
+    await broker.run();
+    const tasks = broker.listTasks();
+    if (tasks.length > 0) {
+        const t = tasks[0];
+        const history = broker.history.get(t.id);
+        const lastReview = history[history.length - 1];
+        const icon = t.status === "COMPLETED" ? "✓" : "✗";
+        console.log(`  ${icon} ${t.status} — score: ${lastReview?.score || "N/A"}, revisions: ${t.revisionCount}\n`);
+    }
+}
+function cmdInit() {
+    const base = path.resolve(process.cwd(), ".agent-hive");
+    const dirs = ["tasks", "messages", "logs", "memory", "history", "conversations", "traces", "metrics", "benchmark", "reports"];
+    for (const d of dirs)
+        fs.mkdirSync(path.join(base, d), { recursive: true });
+    console.log(`  ✓ Agent Hive initialized (v${pkg.version})`);
+    console.log(`    ${base}/`);
+    dirs.forEach((d) => console.log(`    ├── ${d}/`));
+}
+async function cmdDetect(broker, args) {
+    const dryRun = args.includes("--dry-run");
+    const healthCheck = args.includes("--health");
+    console.log("\n  Scanning for agent runtimes...\n");
+    const adapters = dryRun ? (0, registry_1.getMockAdapters)() : (0, registry_1.getAllAdapters)();
+    for (const adapter of adapters) {
+        await broker.registerAdapter(adapter);
+    }
+    if (healthCheck && !dryRun) {
+        console.log("\n  Running health checks...\n");
+        for (const name of (0, registry_1.getAdapterNames)()) {
+            const ok = await broker.healthCheck(name);
+            console.log(`    ${name}: ${ok ? "✓ responsive" : "✗ not responding"}`);
+        }
+        console.log("\n  Note: Agent Hive does not manage Provider config.");
+    }
+    broker.migrateFromRegistry();
+    console.log("\n  Scan complete.");
+}
+function cmdAgents(broker) {
+    const entries = broker.registry.all();
+    if (entries.length === 0) {
+        console.log("\n  No agents registered. Run: hive detect\n");
+        return;
+    }
+    console.log("\n  Registered Agents:\n");
+    for (const e of entries) {
+        const status = e.healthy ? "✓" : "✗";
+        const reports = e.reportsTo ? ` → ${e.reportsTo}` : "";
+        console.log(`    ${status} ${e.name} [${e.role}]${reports}`);
+        console.log(`      capabilities: ${e.capabilities.join(", ")}`);
+    }
+}
+function cmdLink(broker, from, to) {
+    if (!from || !to) {
+        console.log("  Usage: hive link <from> <to>");
+        return;
+    }
+    broker.registry.link(from, to);
+    console.log(`  ✓ Linked: ${from} → ${to}`);
+}
+function cmdGraph(broker) {
+    const graph = broker.getGraph();
+    const agents = graph.allAgents();
+    const edges = graph.allEdges();
+    if (agents.length === 0) {
+        console.log("\n  No agents in graph.\n");
+        return;
+    }
+    console.log("\n  Graph:\n");
+    console.log(`  Agents: ${agents.map(a => a.id).join(", ")}`);
+    console.log(`  Edges: ${edges.length}`);
+}
+function cmdGraphTemplate(broker, args) {
+    const template = args[1];
+    const runtimes = args.slice(2);
+    if (!template) {
+        console.log("  Usage: hive graph-template <name> [runtimes...]");
+        return;
+    }
+    let result;
+    switch (template) {
+        case "simpleChain":
+            result = TopologyTemplates_1.TopologyTemplates.simpleChain(runtimes[0] || "executor", runtimes[1] || "reviewer");
+            break;
+        case "planExecuteReview":
+            result = TopologyTemplates_1.TopologyTemplates.planExecuteReview(runtimes[0] || "planner", runtimes[1] || "executor", runtimes[2] || "reviewer");
+            break;
+        case "pipeline":
+            result = TopologyTemplates_1.TopologyTemplates.pipeline(runtimes.length >= 2 ? runtimes : ["stage-1", "stage-2", "stage-3"]);
+            break;
+        case "peerReview":
+            result = TopologyTemplates_1.TopologyTemplates.peerReview(runtimes[0] || "agent-a", runtimes[1] || "agent-b");
+            break;
+        case "fanOutReview":
+            result = TopologyTemplates_1.TopologyTemplates.fanOutReview(runtimes[0] || "executor", runtimes.slice(1).length ? runtimes.slice(1) : ["r1", "r2", "r3"]);
+            break;
+        default:
+            console.log(`  Unknown template: ${template}`);
+            return;
+    }
+    TopologyTemplates_1.TopologyTemplates.apply(broker.getGraph(), result);
+    broker.enableGraphMode();
+    console.log(`  ✓ Applied template: ${result.description}`);
+}
+function cmdGraphValidate(broker) {
+    const validator = new GraphValidator_1.GraphValidator();
+    const report = validator.validate(broker.getGraph());
+    console.log("\n  Graph Validation:\n");
+    console.log(`  Cycles: ${report.cycles.length}`);
+    console.log(`  Review loops: ${report.reviewLoops.length}`);
+    console.log(`  Isolated agents: ${report.isolatedAgents.length}`);
+    if (report.isValid)
+        console.log("  ✓ Graph is valid");
+    else
+        console.log("  ✗ Graph has issues");
+}
+function cmdGraphMigrate(broker) {
+    broker.migrateFromRegistry();
+}
+function cmdTask(broker, args) {
+    const executor = getArg(args, "--executor") || (0, registry_1.getAdapterNames)()[0];
+    const reviewer = getArg(args, "--reviewer") || (0, registry_1.getAdapterNames)()[0];
+    const instruction = getArg(args, "--instruction") || args.slice(1).join(" ");
+    const workDir = getArg(args, "--dir") || process.cwd();
+    const maxRevision = parseInt(getArg(args, "--max-revision") || "3", 10);
+    if (!instruction) {
+        console.log('  Usage: hive task --instruction "do something" [--dir /path]');
+        return;
+    }
+    broker.submit({ instruction, executor, reviewer, workingDirectory: workDir, maxRevision });
+}
+async function cmdRun(broker, args) {
+    const task = getArg(args, "--task");
+    const dryRun = args.includes("--dry-run");
+    const workDir = getArg(args, "--dir") || process.cwd();
+    const maxRevision = parseInt(getArg(args, "--max-revision") || "3", 10);
+    // Clean stale tasks
+    cleanTasks();
+    // Register adapters
+    if (dryRun) {
+        console.log("  [mode] DRY-RUN (using mock adapters)\n");
+        broker.setDryRun(true);
+        await cmdDetect(broker, ["--dry-run"]);
+    }
+    else {
+        console.log("  [mode] LIVE (using real agent runtimes)\n");
+        await cmdDetect(broker, []);
+    }
+    if (task) {
+        // Unified entry: auto-classify and select topology
+        const classifier = new TaskIntentClassifier_1.TaskIntentClassifier();
+        const adapters = broker.registry.all().map(e => {
+            const adapter = broker.registry.getAdapter(e.name);
+            return adapter;
+        }).filter(Boolean);
+        const selector = new AutoTopologySelector_1.AutoTopologySelector(adapters);
+        const classification = classifier.classify(task);
+        const selection = selector.select(classification.intent);
+        console.log(`\n  [classify] Intent: ${classification.intent} (confidence: ${classification.confidence})`);
+        console.log(`  [classify] Keywords: ${classification.keywords.join(", ")}`);
+        console.log(`  [select]   ${selection.reason}`);
+        console.log(`  [select]   Topology: ${selection.topology}\n`);
+        // Build graph
+        broker.addAgentProfile({ id: selection.executor, runtimeId: selection.executor, role: "executor", maxConcurrency: 1, status: "idle" });
+        broker.addAgentProfile({ id: selection.reviewer, runtimeId: selection.reviewer, role: "reviewer", maxConcurrency: 1, status: "idle" });
+        broker.addGraphEdge(selection.executor, selection.reviewer, "reviews", 10);
+        broker.addGraphEdge(selection.reviewer, selection.executor, "escalates", 5);
+        broker.enableGraphMode();
+        broker.submit({
+            instruction: task,
+            executor: selection.executor,
+            reviewer: selection.reviewer,
+            workingDirectory: workDir,
+            maxRevision,
+        });
+    }
+    await broker.run();
+    // Print results
+    const tasks = broker.listTasks();
+    if (tasks.length > 0) {
+        const t = tasks[0];
+        const history = broker.history.get(t.id);
+        const lastReview = history[history.length - 1];
+        console.log(`\n  ┌─────────────────────────────────────┐`);
+        console.log(`  │ Result                               │`);
+        console.log(`  ├─────────────────────────────────────┤`);
+        console.log(`  │ Status:    ${t.status.padEnd(24)}│`);
+        console.log(`  │ Revisions: ${String(t.revisionCount).padEnd(24)}│`);
+        console.log(`  │ Score:     ${String(lastReview?.score || "N/A").padEnd(24)}│`);
+        console.log(`  │ Decision:  ${String(lastReview?.decision || "N/A").padEnd(24)}│`);
+        console.log(`  └─────────────────────────────────────┘`);
+    }
+}
+function cleanTasks() {
+    const tasksDir = path.resolve(process.cwd(), ".agent-hive/tasks");
+    if (fs.existsSync(tasksDir)) {
+        for (const f of fs.readdirSync(tasksDir).filter(f => f.endsWith(".json"))) {
+            fs.unlinkSync(path.join(tasksDir, f));
+        }
+    }
+}
+function cmdHistory(broker, args) {
+    const taskId = args[1];
+    if (taskId) {
+        const records = broker.history.get(taskId);
+        if (records.length === 0) {
+            console.log(`  No history for ${taskId}`);
+            return;
+        }
+        console.log(`\n  Revision History for ${taskId}:\n`);
+        for (const r of records) {
+            console.log(`    #${r.attempt} ${r.decision} (score=${r.score}) ${r.timestamp}`);
+            if (r.issues.length)
+                console.log(`      issues: ${r.issues.join(", ")}`);
+        }
+    }
+    else {
+        const all = broker.history.all();
+        if (all.length === 0) {
+            console.log("  No revision history.");
+            return;
+        }
+        console.log(`\n  Revision History (${all.length} records):\n`);
+        for (const r of all)
+            console.log(`    ${r.taskId} #${r.attempt} ${r.decision} (score=${r.score})`);
+    }
+}
+async function cmdResume(broker) {
+    const mm = new MemoryManager_1.MemoryManager();
+    const projects = mm.listProjects();
+    const tasks = mm.listTaskMemories();
+    console.log("\n  🐝 Session Resume\n");
+    if (projects.length > 0) {
+        console.log("  Projects:");
+        projects.forEach(p => console.log(`    ${p.project}: ${p.techStack.join(", ") || "no stack"}`));
+    }
+    if (tasks.length > 0) {
+        console.log("\n  Recent tasks:");
+        tasks.slice(-5).forEach(t => console.log(`    ${t.taskId}: ${t.goal.slice(0, 60)}`));
+    }
+    if (projects.length === 0 && tasks.length === 0) {
+        console.log("  No previous session found.");
+        console.log("  Start with: hive project init <name>\n");
+    }
+    else {
+        console.log("\n  Continue with: hive \"<your next task>\"\n");
+    }
+}
+function cmdCost() {
+    const mm = new MemoryManager_1.MemoryManager();
+    const tasks = mm.listTaskMemories();
+    console.log("\n  🐝 Cost Tracking\n");
+    // Estimate costs from task memories
+    let totalTokens = 0;
+    const runtimeUsage = {};
+    for (const task of tasks) {
+        // Rough estimate: summary length * 4 (chars to tokens)
+        const est = Math.ceil((task.summary?.length || 0) / 4);
+        totalTokens += est;
+        // We don't track per-runtime tokens yet, so estimate evenly
+        for (const runtime of ["codex", "claude", "hermes"]) {
+            if (!runtimeUsage[runtime])
+                runtimeUsage[runtime] = { tasks: 0, tokens: 0 };
+            runtimeUsage[runtime].tasks++;
+            runtimeUsage[runtime].tokens += Math.ceil(est / 3);
+        }
+    }
+    for (const [name, usage] of Object.entries(runtimeUsage)) {
+        console.log(`  ${name}: ${usage.tasks} tasks, ~${usage.tokens} tokens`);
+    }
+    console.log(`\n  Total: ${tasks.length} tasks, ~${totalTokens} tokens`);
+    console.log(`  (Estimates based on memory summaries. Actual API usage may differ.)\n`);
+}
+function cmdStatus() {
+    const mm = new MemoryManager_1.MemoryManager();
+    const projects = mm.listProjects();
+    const tasks = mm.listTaskMemories();
+    console.log("\n  🐝 Status\n");
+    console.log(`  Projects: ${projects.length}`);
+    console.log(`  Tasks: ${tasks.length}`);
+    // Check context
+    const configPath = path.resolve(process.cwd(), ".agent-hive/config.json");
+    if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        console.log(`  Provider: ${config.provider || "unknown"}`);
+        console.log(`  Model: ${config.model || "unknown"}`);
+    }
+    // Check memory files
+    const memDir = path.resolve(process.cwd(), ".agent-hive/memory");
+    if (fs.existsSync(memDir)) {
+        const taskFiles = fs.readdirSync(path.join(memDir, "tasks")).filter(f => f.endsWith(".json")).length;
+        const projFiles = fs.readdirSync(path.join(memDir, "projects")).filter(f => f.endsWith(".json")).length;
+        console.log(`  Memory: ${taskFiles} task entries, ${projFiles} project entries`);
+    }
+    console.log("");
+}
+function cmdConfig() {
+    console.log("\n  🐝 Config Center\n");
+    console.log("  1. Providers    — API providers configuration");
+    console.log("  2. Models       — Default model settings");
+    console.log("  3. Roles        — Agent role assignments");
+    console.log("  4. Tools        — Available tools");
+    console.log("  5. MCP          — MCP server registry");
+    console.log("  6. Projects     — Project management");
+    console.log("  7. Memory       — Memory settings");
+    console.log("  8. Status       — Current configuration\n");
+    const configPath = path.resolve(process.cwd(), ".agent-hive/config.json");
+    if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        console.log("  Current config:");
+        console.log(`    Provider: ${config.provider || "not set"}`);
+        console.log(`    Model: ${config.model || "not set"}`);
+        console.log(`    Base URL: ${config.baseUrl || "not set"}`);
+    }
+    else {
+        console.log("  No config found. Run: hive setup");
+    }
+    console.log("");
+}
+function cmdMCP(args) {
+    const sub = args[1];
+    const mcpServers = [
+        { name: "filesystem", status: "available", description: "File system access" },
+        { name: "github", status: "available", description: "GitHub API integration" },
+        { name: "browser", status: "experimental", description: "Browser automation" },
+        { name: "database", status: "coming-soon", description: "Database access" },
+    ];
+    if (sub === "list" || !sub) {
+        console.log("\n  🐝 MCP Servers\n");
+        for (const s of mcpServers) {
+            const icon = s.status === "available" ? "✓" : s.status === "experimental" ? "⚡" : "○";
+            console.log(`    ${icon} ${s.name.padEnd(15)} ${s.description.padEnd(25)} [${s.status}]`);
+        }
+    }
+    else if (sub === "status") {
+        console.log("\n  🐝 MCP Status\n");
+        for (const s of mcpServers) {
+            console.log(`    ${s.name}: ${s.status}`);
+        }
+    }
+    else {
+        console.log("\n  Usage: hive mcp [list|status]\n");
+    }
+    console.log("");
+}
+function cmdRoles(args) {
+    const roles = [
+        { name: "Planner", runtime: "hermes", caps: "planning, research" },
+        { name: "Coder", runtime: "codex", caps: "coding, refactor" },
+        { name: "Reviewer", runtime: "claude", caps: "review, architecture" },
+        { name: "Architect", runtime: "claude", caps: "architecture, planning" },
+        { name: "Researcher", runtime: "hermes", caps: "research, planning" },
+    ];
+    if (args[1] === "info" && args[2]) {
+        return cmdRoleInfo(args);
+    }
+    console.log("\n  🐝 Roles\n");
+    for (const r of roles) {
+        console.log(`    ${r.name.padEnd(15)} → ${r.runtime.padEnd(10)} (${r.caps})`);
+    }
+    console.log("\n  Details: hive role info <name>\n");
+}
+function cmdRoleInfo(args) {
+    const roleName = (args[1] === "info" ? args[2] : args[1]) || "";
+    const roles = {
+        planner: { runtime: "hermes", caps: "planning, research", description: "Breaks tasks into steps, creates execution plans" },
+        coder: { runtime: "codex", caps: "coding, refactor", description: "Writes and refactors code" },
+        reviewer: { runtime: "claude", caps: "review, architecture", description: "Reviews code quality, finds issues" },
+        architect: { runtime: "claude", caps: "architecture, planning", description: "Designs system architecture" },
+        researcher: { runtime: "hermes", caps: "research, planning", description: "Researches topics, analyzes codebases" },
+    };
+    const role = roles[roleName.toLowerCase()];
+    if (role) {
+        console.log(`\n  🐝 Role: ${roleName}\n`);
+        console.log(`  Runtime: ${role.runtime}`);
+        console.log(`  Capabilities: ${role.caps}`);
+        console.log(`  Description: ${role.description}\n`);
+    }
+    else {
+        console.log(`\n  Role "${roleName}" not found. Available: planner, coder, reviewer, architect, researcher\n`);
+    }
+}
+function cmdWorkflows() {
+    const workflows = [
+        { name: "Single Agent", description: "One runtime does everything", topology: "simpleChain" },
+        { name: "Code Review", description: "Execute + Review loop", topology: "simpleChain" },
+        { name: "Research + Planning", description: "Plan → Execute → Review", topology: "planExecuteReview" },
+        { name: "Architecture Design", description: "Architect → Implement → Review", topology: "planExecuteReview" },
+        { name: "Full Team", description: "Planner → Coder → Reviewer → Architect", topology: "planExecuteReview" },
+    ];
+    console.log("\n  🐝 Workflows\n");
+    for (const w of workflows) {
+        console.log(`    ${w.name.padEnd(25)} ${w.description}`);
+    }
+    console.log("\n  Agent Hive automatically selects the best workflow for your task.\n");
+}
+function cmdTools() {
+    console.log("\n  🐝 Tools\n");
+    console.log("  Available:");
+    console.log("    ✓ Files         — Read, write, edit files");
+    console.log("    ✓ Terminal      — Run shell commands");
+    console.log("    ✓ Memory        — Project memory system");
+    console.log("    ✓ Planning      — Task decomposition");
+    console.log("\n  Experimental:");
+    console.log("    ⚡ Browser       — Web page interaction");
+    console.log("    ⚡ Web Search    — Internet search");
+    console.log("\n  Coming Soon:");
+    console.log("    ○ Video         — Video generation");
+    console.log("    ○ Discord       — Discord integration");
+    console.log("    ○ Telegram      — Telegram bot\n");
+}
+function cmdChannels(args) {
+    const sub = args[1];
+    const channels = [
+        { name: "CLI", status: "active", description: "Terminal interface" },
+        { name: "Discord", status: "coming-soon", description: "Discord bot" },
+        { name: "Telegram", status: "coming-soon", description: "Telegram bot" },
+        { name: "Feishu", status: "coming-soon", description: "Feishu/Lark bot" },
+        { name: "WeChat", status: "coming-soon", description: "WeChat integration" },
+    ];
+    if (sub === "list" || !sub) {
+        console.log("\n  🐝 Channels\n");
+        for (const c of channels) {
+            const icon = c.status === "active" ? "✓" : "○";
+            console.log(`    ${icon} ${c.name.padEnd(15)} ${c.description.padEnd(25)} [${c.status}]`);
+        }
+    }
+    else if (sub === "status") {
+        console.log("\n  🐝 Channel Status\n");
+        for (const c of channels) {
+            console.log(`    ${c.name}: ${c.status}`);
+        }
+    }
+    else {
+        console.log("\n  Usage: hive channels [list|status]\n");
+    }
+    console.log("");
+}
+function cmdMemory(args) {
+    const mm = new MemoryManager_1.MemoryManager();
+    const sub = args[1];
+    if (sub === "list") {
+        const tasks = mm.listTaskMemories();
+        const projects = mm.listProjects();
+        console.log(`\n  🐝 Memory\n`);
+        console.log(`  Tasks: ${tasks.length}`);
+        console.log(`  Projects: ${projects.length}`);
+        tasks.forEach(t => console.log(`    ${t.taskId}: ${t.goal.slice(0, 60)}`));
+        projects.forEach(p => console.log(`    ${p.project}: ${p.techStack.join(", ")}`));
+    }
+    else if (sub === "show" && args[2]) {
+        const proj = mm.getProjectMemory(args[2]);
+        if (proj) {
+            console.log(`\n  Project: ${proj.project}`);
+            console.log(`  Stack: ${proj.techStack.join(", ")}`);
+            console.log(`  Issues: ${proj.knownIssues.join(", ") || "none"}`);
+            console.log(`  Patterns: ${proj.patterns.join(", ") || "none"}`);
+        }
+        else {
+            console.log(`  Project "${args[2]}" not found`);
+        }
+    }
+    else if (sub === "search" && args[2]) {
+        const results = mm.searchMemories(args.slice(2).join(" "));
+        console.log(`\n  🐝 Search: "${args.slice(2).join(" ")}"\n`);
+        results.forEach(r => console.log(`  ${r.type}/${r.name}: ${r.matches.join(", ")}`));
+        if (results.length === 0)
+            console.log("  No results");
+    }
+    else {
+        console.log("\n  Usage: hive memory [list|show <name>|search <query>]\n");
+    }
+}
+function cmdProject(args) {
+    const mm = new MemoryManager_1.MemoryManager();
+    const sub = args[1];
+    if (sub === "init" && args[2]) {
+        const name = args[2];
+        mm.saveProjectMemory({
+            project: name,
+            techStack: args.slice(3),
+            architecture: [],
+            knownIssues: [],
+            patterns: [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        });
+        console.log(`\n  ✓ Project "${name}" initialized\n`);
+    }
+    else if (sub === "list") {
+        const projects = mm.listProjects();
+        console.log(`\n  🐝 Projects\n`);
+        projects.forEach(p => console.log(`    ${p.project}: ${p.techStack.join(", ") || "no stack"}`));
+        if (projects.length === 0)
+            console.log("    No projects. Run: hive project init <name>");
+    }
+    else if (sub === "info" && args[2]) {
+        const proj = mm.getProjectMemory(args[2]);
+        if (proj) {
+            console.log(`\n  Project: ${proj.project}`);
+            console.log(`  Stack: ${proj.techStack.join(", ")}`);
+            console.log(`  Created: ${proj.createdAt}`);
+        }
+        else {
+            console.log(`  Project "${args[2]}" not found`);
+        }
+    }
+    else {
+        console.log("\n  Usage: hive project [init <name> [stack...]|list|info <name>]\n");
+    }
+}
+async function cmdSetup() {
+    const readline = require("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    console.log("\n  🐝 Welcome to Agent Hive\n");
+    // Step 1: Choose provider
+    console.log("  Choose Provider:\n");
+    ProviderRegistry_1.PROVIDERS.forEach((p, i) => console.log(`    ${i + 1}. ${p.name}`));
+    const choice = await ask("\n  > ");
+    const providerIdx = parseInt(choice) - 1;
+    const provider = ProviderRegistry_1.PROVIDERS[providerIdx] || ProviderRegistry_1.PROVIDERS[0];
+    // Step 2: Base URL
+    const baseUrl = provider.baseUrl || await ask(`  Base URL: `);
+    // Step 3: API Key
+    const apiKey = await ask("  API Key: ");
+    // Step 4: Auto-discover models
+    console.log("\n  Connecting...");
+    let models = [];
+    try {
+        const res = await fetch(`${baseUrl}/models`, { headers: { "Authorization": `Bearer ${apiKey}` } });
+        if (res.ok) {
+            const data = await res.json();
+            models = (data.data || []).map((m) => m.id).slice(0, 10);
+            console.log(`  ✓ Connected — ${models.length} models found`);
+        }
+    }
+    catch {
+        console.log("  ✗ Could not discover models");
+    }
+    // Step 5: Choose model
+    let model = provider.defaultModel;
+    if (models.length > 0) {
+        console.log("\n  Choose Default Model:\n");
+        models.forEach((m, i) => console.log(`    ${i + 1}. ${m}`));
+        const modelChoice = await ask("\n  > ");
+        const modelIdx = parseInt(modelChoice) - 1;
+        if (modelIdx >= 0 && modelIdx < models.length)
+            model = models[modelIdx];
+        else if (modelChoice)
+            model = modelChoice;
+    }
+    rl.close();
+    // Save config
+    const configDir = path.resolve(process.cwd(), ".agent-hive");
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ provider: provider.name.toLowerCase(), baseUrl, apiKey, model }, null, 2));
+    // Also write runtime.json for adapter compatibility
+    const runtimeConfig = {};
+    for (const name of ["codex", "claude", "hermes"]) {
+        runtimeConfig[name] = { binary: "openai-sdk", model, env: { OPENAI_API_KEY: apiKey, OPENAI_BASE_URL: baseUrl } };
+    }
+    fs.writeFileSync("runtime.json", JSON.stringify(runtimeConfig, null, 2));
+    console.log(`\n  ✓ Setup complete!`);
+    console.log(`  ✓ Provider: ${provider.name}`);
+    console.log(`  ✓ Model: ${model}`);
+    console.log(`\n  Try it: hive "Build a hello world function"\n`);
+}
+function cmdVersion() {
+    console.log(`
+  Agent Hive v${pkg.version}
+  TypeScript: 5.8.3
+  Node.js: ${process.version}
+  Platform: ${process.platform} ${process.arch}
+  `);
+}
+async function cmdDoctor(broker) {
+    console.log("\n  🐝 Agent Hive Doctor\n");
+    let allOk = true;
+    // 1. Config
+    const configPath = path.resolve(process.cwd(), ".agent-hive/config.json");
+    if (fs.existsSync(configPath)) {
+        console.log("  ✓ Config Found");
+    }
+    else {
+        console.log("  ❌ Config Missing — run: hive setup");
+        allOk = false;
+    }
+    // 2. Runtime.json
+    const runtimePath = path.resolve(process.cwd(), "runtime.json");
+    if (fs.existsSync(runtimePath)) {
+        const runtime = JSON.parse(fs.readFileSync(runtimePath, "utf-8"));
+        for (const [name, cfg] of Object.entries(runtime)) {
+            const r = cfg;
+            const hasKey = r.env?.OPENAI_API_KEY || r.env?.ANTHROPIC_API_KEY;
+            if (!hasKey) {
+                console.log(`  ❌ ${name}: API Key Missing`);
+                allOk = false;
+            }
+        }
+    }
+    else {
+        console.log("  ❌ runtime.json Missing — run: hive setup");
+        allOk = false;
+    }
+    // 3. API Reachable
+    if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        try {
+            const res = await fetch(`${config.baseUrl}/models`, { headers: { "Authorization": `Bearer ${config.apiKey}` }, signal: AbortSignal.timeout(5000) });
+            if (res.ok)
+                console.log("  ✓ API Reachable");
+            else {
+                console.log(`  ❌ API Unreachable (${res.status})`);
+                allOk = false;
+            }
+        }
+        catch {
+            console.log("  ❌ API Unreachable");
+            allOk = false;
+        }
+    }
+    // 4. Directory structure
+    const base = path.resolve(process.cwd(), ".agent-hive");
+    const requiredDirs = ["tasks", "traces", "metrics", "reports"];
+    let dirOk = true;
+    for (const d of requiredDirs) {
+        if (!fs.existsSync(path.join(base, d))) {
+            dirOk = false;
+        }
+    }
+    if (dirOk)
+        console.log("  ✓ Directory Structure OK");
+    else {
+        console.log("  ❌ Directory Missing — run: hive init");
+        allOk = false;
+    }
+    // 5. Runtime Detection
+    await cmdDetect(broker, []);
+    const installed = broker.registry.all().filter(e => e.installed);
+    if (installed.length > 0)
+        console.log(`  ✓ ${installed.length} Runtime(s) Healthy`);
+    else {
+        console.log("  ❌ No Runtimes Detected");
+        allOk = false;
+    }
+    // Summary
+    console.log(`\n  ${allOk ? "✓ All checks passed!" : "❌ Some checks failed — see above"}\n`);
+}
+async function cmdHealth(broker) {
+    console.log("\n  Health Check\n");
+    await cmdDetect(broker, []);
+    console.log("\n  Running health checks...\n");
+    for (const entry of broker.registry.all()) {
+        const ok = await broker.healthCheck(entry.name);
+        const status = ok ? "✓ healthy" : "✗ unhealthy";
+        console.log(`    ${entry.name}: ${status}`);
+    }
+    console.log("");
+}
+function cmdDashboard() {
+    const { execSync } = require("child_process");
+    // generate-dashboard.js is a plain JS file in src/ (not compiled)
+    const script = path.resolve(__dirname, "../../src/commands/generate-dashboard.js");
+    try {
+        execSync(`node ${script}`, { stdio: "inherit" });
+    }
+    catch {
+        console.log("  ✗ Failed to generate dashboard");
+    }
+}
+function getArg(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+function printUsage() {
+    console.log(`
+  Agent Hive v${pkg.version}
+
+  Quick Start:
+    hive setup                        First-time setup
+    hive run --task "Build a landing page"     Auto-select everything
+
+  Commands:
+    setup                             First-time setup wizard
+    init                              Initialize .agent-hive directory
+    detect [--dry-run] [--health]     Scan for agent runtimes
+    agents                            List registered agents
+    link <from> <to>                  Link two agents
+    graph                             Show agent graph
+    graph-template <name> [runtimes]  Apply topology template
+    graph-validate                    Validate graph structure
+    graph-migrate                     Migrate v1.1 registry to graph
+    task --instruction "..."          Submit a task (manual)
+      --executor <name>                 Executor agent
+      --reviewer <name>                 Reviewer agent
+      --dir /path/to/project            Working directory
+      --max-revision 3                  Max revision attempts
+    run --task "..."                  Unified entry (auto everything)
+      --dir /path/to/project            Working directory
+      --max-revision 3                  Max revision attempts
+      --dry-run                         Use mock adapters
+    dashboard                         Generate visual dashboard
+    doctor                            Check system health
+    version                           Show version info
+    health                            Check runtime health
+    history [task-id]                 View revision history
+  `);
+}
+main().then(() => { process.exit(0); }).catch((err) => { console.error("Fatal:", err); process.exit(1); });
+// Force exit — OpenAI SDK HTTP agent keeps event loop alive
+// Use a long timeout so real API calls can complete
+setTimeout(() => process.exit(0), 600_000);
+//# sourceMappingURL=cli.js.map