@ai.ntellect/core 1.0.0 → 1.1.1

package/dist/modules/cli/index.js

@@ -0,0 +1,672 @@
+"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;
+    };
+})();
+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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCLI = runCLI;
+exports.startCLI = startCLI;
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const index_1 = require("../../index");
+const in_memory_checkpoint_1 = require("../../execution/adapters/in-memory-checkpoint");
+const memory_1 = require("../../modules/memory");
+const in_memory_1 = require("../memory/adapters/in-memory");
+const tools_1 = require("../../agent/tools");
+function loadEnv() {
+    const envPath = path.resolve(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+        fs.readFileSync(envPath, "utf-8")
+            .split("\n")
+            .forEach((line) => {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith("#")) {
+                const eqIdx = trimmed.indexOf("=");
+                if (eqIdx > 0) {
+                    const key = trimmed.substring(0, eqIdx).trim();
+                    const value = trimmed.substring(eqIdx + 1).trim();
+                    if (!process.env[key])
+                        process.env[key] = value;
+                }
+            }
+        });
+    }
+}
+loadEnv();
+const DEFAULT_ROLE = "Helpful Assistant";
+const DEFAULT_GOAL = "Assist the user with their requests";
+const DEFAULT_MODEL = {
+    openai: "gpt-4o-mini",
+    anthropic: "claude-3-haiku-20240307",
+    ollama: "llama3",
+    groq: "llama-3.1-8b-instant",
+    openrouter: "openai/gpt-4o-mini",
+    google: "gemini-2.0-flash",
+    custom: "custom",
+};
+function getLLMConfig(config) {
+    return {
+        provider: config.provider,
+        model: config.model || DEFAULT_MODEL[config.provider],
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+    };
+}
+function createAgent(config) {
+    const llmConfig = getLLMConfig(config);
+    const memory = new memory_1.Memory(new in_memory_1.InMemoryAdapter());
+    const tools = (0, tools_1.createAllAgentTools)();
+    return new index_1.Agent({
+        role: config.role || DEFAULT_ROLE,
+        goal: config.goal || DEFAULT_GOAL,
+        backstory: `You are a ${config.role || DEFAULT_ROLE}. Be concise and helpful.`,
+        tools,
+        llmConfig,
+        memory,
+        verbose: false,
+    });
+}
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+function getInput(rl, inputQueue, promptText) {
+    if (inputQueue.length > 0)
+        return Promise.resolve(inputQueue.shift().trim());
+    if (!rl)
+        return Promise.resolve("");
+    return new Promise((resolve) => {
+        try {
+            rl.question(promptText, (input) => resolve(input.trim()));
+        }
+        catch (_a) {
+            resolve("");
+        }
+    });
+}
+function formatSummary(ctx, totalMs) {
+    var _a;
+    const llmCalls = ctx.llmCalls || [];
+    const totalPrompt = llmCalls.reduce((s, c) => s + (c.promptTokens || 0), 0);
+    const totalCompletion = llmCalls.reduce((s, c) => s + (c.completionTokens || 0), 0);
+    const actionCount = ((_a = ctx.executedActions) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    const parts = [`${(totalMs / 1000).toFixed(1)}s`];
+    if (totalPrompt)
+        parts.push(`in ${totalPrompt}`);
+    if (totalCompletion)
+        parts.push(`out ${totalCompletion}`);
+    if (llmCalls.length)
+        parts.push(`${llmCalls.length} call${llmCalls.length > 1 ? 's' : ''}`);
+    if (actionCount)
+        parts.push(`${actionCount} action${actionCount > 1 ? 's' : ''}`);
+    return parts.join("  ");
+}
+function chatLoop(agent, provider, model) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        var _d;
+        // Pipe mode: buffer all stdin lines upfront
+        const inputQueue = [];
+        if (!process.stdin.isTTY) {
+            process.stdin.setEncoding("utf-8");
+            let data = "";
+            try {
+                for (var _e = true, _f = __asyncValues(process.stdin), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+                    _c = _g.value;
+                    _e = false;
+                    const chunk = _c;
+                    data += chunk;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            inputQueue.push(...data.split("\n"));
+        }
+        const rl = process.stdin.isTTY ? createInterface() : null;
+        const checkpointAdapter = new in_memory_checkpoint_1.InMemoryCheckpointAdapter();
+        let currentRunId = null;
+        let lastCheckpointId = null;
+        let pendingApprovalCp = null;
+        let exiting = false;
+        const workflow = agent.getWorkflow();
+        let activeStep = null;
+        let activeStepStart = 0;
+        let listening = false;
+        workflow.on("nodeStarted", (data) => {
+            var _a;
+            if (!listening)
+                return;
+            const name = (_a = data === null || data === void 0 ? void 0 : data.payload) === null || _a === void 0 ? void 0 : _a.name;
+            if (!name || name.startsWith("__"))
+                return;
+            activeStep = name;
+            activeStepStart = Date.now();
+        });
+        workflow.on("nodeCompleted", (data) => {
+            var _a;
+            if (!listening)
+                return;
+            const name = (_a = data === null || data === void 0 ? void 0 : data.payload) === null || _a === void 0 ? void 0 : _a.name;
+            if (!name || name.startsWith("__"))
+                return;
+            const elapsed = ((Date.now() - activeStepStart) / 1000).toFixed(1);
+            console.log(`    ${name.padEnd(14)} ${chalk_1.default.green(`${elapsed}s`)}`);
+            activeStep = null;
+        });
+        const execWithObs = (fn) => __awaiter(this, void 0, void 0, function* () {
+            console.log(`  ${chalk_1.default.dim("\u2500\u2500 Execution \u2500\u2500")}`);
+            listening = true;
+            try {
+                return yield fn();
+            }
+            finally {
+                listening = false;
+                if (activeStep) {
+                    const elapsed = ((Date.now() - activeStepStart) / 1000).toFixed(1);
+                    console.log(`    ${activeStep.padEnd(14)} ${chalk_1.default.dim(`${elapsed}s`)}`);
+                    activeStep = null;
+                }
+            }
+        });
+        const showBanner = () => {
+            console.log(chalk_1.default.cyan("\n=== @ai.ntellect/core CLI ==="));
+            console.log(chalk_1.default.gray(`Provider: ${provider} | Model: ${model}`));
+            console.log(chalk_1.default.gray("Type /help for commands, /exit to quit\n"));
+            console.log(chalk_1.default.green("Agent: ") + "Hello! How can I help you today?\n");
+        };
+        const printCheckpointStatus = (cpId, runId) => {
+            console.log(chalk_1.default.yellow(`  Checkpoint: ${cpId}`));
+            if (runId)
+                console.log(chalk_1.default.yellow(`  Run ID: ${runId}`));
+        };
+        const handleCommand = (cmd) => __awaiter(this, void 0, void 0, function* () {
+            const parts = cmd.split(" ");
+            const command = parts[0].toLowerCase();
+            switch (command) {
+                case "/help":
+                    showHelp();
+                    break;
+                case "/exit":
+                case "/quit":
+                    console.log(chalk_1.default.cyan("\nGoodbye!\n"));
+                    exiting = true;
+                    rl === null || rl === void 0 ? void 0 : rl.close();
+                    process.exit(0);
+                    break;
+                case "/clear":
+                    console.clear();
+                    showBanner();
+                    break;
+                case "/status":
+                    if (currentRunId)
+                        console.log(chalk_1.default.yellow("Current Run:"), currentRunId);
+                    if (pendingApprovalCp) {
+                        console.log(chalk_1.default.red("Pending Approval:"), pendingApprovalCp.nodeName);
+                        console.log(chalk_1.default.gray("  Context:", JSON.stringify(pendingApprovalCp.context, null, 2)));
+                    }
+                    if (lastCheckpointId)
+                        console.log(chalk_1.default.yellow("Last Checkpoint:"), lastCheckpointId);
+                    break;
+                case "/history":
+                case "/h": {
+                    const runId = parts[1] || currentRunId;
+                    if (!runId) {
+                        console.log(chalk_1.default.gray("No run ID. Use /history <runId>"));
+                        break;
+                    }
+                    const history = yield agent.getCheckpointHistory(runId, checkpointAdapter);
+                    if (history.length === 0) {
+                        console.log(chalk_1.default.gray("No checkpoints for this run."));
+                        break;
+                    }
+                    console.log(chalk_1.default.cyan(`\nCheckpoint History (run: ${runId.slice(0, 8)}...):`));
+                    history.forEach((cp, i) => {
+                        const marker = cp.metadata.awaitingApproval
+                            ? chalk_1.default.red(" [BREAKPOINT]")
+                            : cp.nodeName === "__completed__" ? chalk_1.default.green(" [COMPLETED]")
+                                : cp.nodeName === "__error__" ? chalk_1.default.red(" [ERROR]") : "";
+                        console.log(chalk_1.default.gray(`  ${i + 1}.`) + ` ${cp.nodeName}` + marker + chalk_1.default.dim(` (${cp.id})`));
+                    });
+                    console.log();
+                    break;
+                }
+                case "/list": {
+                    const allCps = yield agent.listCheckpoints(checkpointAdapter);
+                    if (allCps.length === 0) {
+                        console.log(chalk_1.default.gray("No checkpoints saved."));
+                        break;
+                    }
+                    console.log(chalk_1.default.cyan("\nAll Checkpoints:"));
+                    allCps.slice(0, 20).forEach((cp, i) => {
+                        const runLabel = cp.runId ? ` run:${cp.runId.slice(0, 8)}` : "";
+                        console.log(chalk_1.default.gray(`  ${i + 1}.`) + ` ${cp.nodeName}` + chalk_1.default.dim(`${runLabel} (${cp.id})`));
+                    });
+                    console.log();
+                    break;
+                }
+                case "/resume": {
+                    const cpId = parts[1] || lastCheckpointId;
+                    if (!cpId) {
+                        console.log(chalk_1.default.red("No checkpoint ID. Use /resume <id> or run first."));
+                        break;
+                    }
+                    const cp = yield checkpointAdapter.load(cpId);
+                    if (!cp) {
+                        console.log(chalk_1.default.red(`Checkpoint "${cpId}" not found.`));
+                        break;
+                    }
+                    console.log(chalk_1.default.yellow(`\nResuming from "${cp.nodeName}"...`));
+                    try {
+                        const result = yield execWithObs(() => agent.resumeFromCheckpoint(cpId, checkpointAdapter));
+                        currentRunId = cp.runId || `run-${Date.now()}`;
+                        if (result.response)
+                            console.log(chalk_1.default.green("\nAgent: ") + result.response + "\n");
+                        console.log(chalk_1.default.dim(`  [Completed]\n`));
+                    }
+                    catch (error) {
+                        if (error instanceof index_1.CheckpointAwaitApprovalError) {
+                            const cp = yield checkpointAdapter.load(error.checkpointId);
+                            if (cp) {
+                                pendingApprovalCp = cp;
+                                console.log(chalk_1.default.yellow(`\n\u23F8 Paused at "${pendingApprovalCp.nodeName}" for review.`));
+                                console.log(chalk_1.default.gray("Approve (press Enter), /reject, /modify <key>=<value>, or /exit\n"));
+                            }
+                            else
+                                console.log(chalk_1.default.red("Checkpoint not found."));
+                        }
+                        else
+                            console.log(chalk_1.default.red("\nError: ") + error.message + "\n");
+                    }
+                    break;
+                }
+                case "/reject":
+                    if (!pendingApprovalCp) {
+                        console.log(chalk_1.default.gray("No pending approval."));
+                        break;
+                    }
+                    console.log(chalk_1.default.red("Rejected. Skipping execution.\n"));
+                    pendingApprovalCp = null;
+                    break;
+                case "/modify": {
+                    if (!pendingApprovalCp) {
+                        console.log(chalk_1.default.gray("No pending approval to modify."));
+                        break;
+                    }
+                    const modifications = {};
+                    for (const part of parts.slice(1)) {
+                        const eqIdx = part.indexOf("=");
+                        if (eqIdx > 0)
+                            modifications[part.substring(0, eqIdx)] = isNaN(Number(part.substring(eqIdx + 1))) ? part.substring(eqIdx + 1) : Number(part.substring(eqIdx + 1));
+                    }
+                    if (Object.keys(modifications).length === 0) {
+                        console.log(chalk_1.default.red("Usage: /modify key=value [key2=value2]"));
+                        break;
+                    }
+                    try {
+                        const result = yield execWithObs(() => agent.resumeFromCheckpoint(pendingApprovalCp.id, checkpointAdapter, modifications));
+                        currentRunId = pendingApprovalCp.runId || `run-${Date.now()}`;
+                        pendingApprovalCp = null;
+                        if (result.response)
+                            console.log(chalk_1.default.green("\nAgent: ") + result.response + "\n");
+                    }
+                    catch (error) {
+                        console.log(chalk_1.default.red("\nError: ") + error.message + "\n");
+                    }
+                    break;
+                }
+                case "/approve":
+                    if (!pendingApprovalCp) {
+                        console.log(chalk_1.default.gray("No pending approval."));
+                        break;
+                    }
+                    {
+                        const cp = pendingApprovalCp;
+                        console.log(chalk_1.default.green("Approved. Continuing...\n"));
+                        try {
+                            const result = yield execWithObs(() => agent.resumeFromCheckpoint(cp.id, checkpointAdapter));
+                            currentRunId = cp.runId || `run-${Date.now()}`;
+                            pendingApprovalCp = null;
+                            if (result.response)
+                                console.log(chalk_1.default.green("\nAgent: ") + result.response + "\n");
+                        }
+                        catch (error) {
+                            console.log(chalk_1.default.red("\nError: ") + error.message + "\n");
+                            pendingApprovalCp = null;
+                        }
+                    }
+                    break;
+                case "/breakpoints":
+                    console.log(chalk_1.default.cyan("\nBreakpoint nodes (auto-pause before execution):"));
+                    console.log(chalk_1.default.gray("  - execute (before tool execution)"));
+                    console.log(chalk_1.default.gray("  - think   (before every LLM decision)\n"));
+                    break;
+                default:
+                    console.log(chalk_1.default.red(`Unknown command: ${command}. Type /help for commands.`));
+            }
+        });
+        const handleApproval = (message) => __awaiter(this, void 0, void 0, function* () {
+            if (message.toLowerCase() === "approve" || message === "") {
+                if (!pendingApprovalCp)
+                    return;
+                const cp = pendingApprovalCp;
+                console.log(chalk_1.default.green("Approved. Continuing...\n"));
+                try {
+                    const result = yield execWithObs(() => agent.resumeFromCheckpoint(cp.id, checkpointAdapter));
+                    currentRunId = cp.runId || `run-${Date.now()}`;
+                    pendingApprovalCp = null;
+                    if (result.response)
+                        console.log(chalk_1.default.green("\nAgent: ") + result.response + "\n");
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red("\nError: ") + error.message + "\n");
+                    pendingApprovalCp = null;
+                }
+            }
+            else if (message.toLowerCase().startsWith("/reject")) {
+                console.log(chalk_1.default.red("Rejected. Skipping execution.\n"));
+                pendingApprovalCp = null;
+            }
+            else if (message.toLowerCase().startsWith("/modify")) {
+                const parts = message.split(" ");
+                const modifications = {};
+                for (const part of parts.slice(1)) {
+                    const eqIdx = part.indexOf("=");
+                    if (eqIdx > 0)
+                        modifications[part.substring(0, eqIdx)] = isNaN(Number(part.substring(eqIdx + 1))) ? part.substring(eqIdx + 1) : Number(part.substring(eqIdx + 1));
+                }
+                if (Object.keys(modifications).length === 0) {
+                    console.log(chalk_1.default.red("Usage: /modify key=value"));
+                    return;
+                }
+                try {
+                    const result = yield execWithObs(() => agent.resumeFromCheckpoint(pendingApprovalCp.id, checkpointAdapter, modifications));
+                    currentRunId = pendingApprovalCp.runId || `run-${Date.now()}`;
+                    pendingApprovalCp = null;
+                    if (result.response)
+                        console.log(chalk_1.default.green("\nAgent: ") + result.response + "\n");
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red("\nError: ") + error.message + "\n");
+                    pendingApprovalCp = null;
+                }
+            }
+            else if (message.toLowerCase().startsWith("/exit")) {
+                console.log(chalk_1.default.cyan("\nGoodbye!\n"));
+                exiting = true;
+                rl === null || rl === void 0 ? void 0 : rl.close();
+                process.exit(0);
+            }
+            else if (message.toLowerCase().startsWith("/")) {
+                yield handleCommand(message);
+            }
+            else {
+                console.log(chalk_1.default.gray("Use /approve, /reject, /modify key=value, or press Enter to continue."));
+            }
+        });
+        // ─── Main loop ───
+        showBanner();
+        while (!exiting) {
+            if (inputQueue.length === 0 && !rl)
+                break;
+            const prefix = pendingApprovalCp
+                ? chalk_1.default.red("[AWAITING APPROVAL] ")
+                : currentRunId
+                    ? chalk_1.default.green("\u276F ")
+                    : "";
+            const input = yield getInput(rl, inputQueue, prefix + chalk_1.default.blue("You: "));
+            if (pendingApprovalCp) {
+                yield handleApproval(input);
+                continue;
+            }
+            if (!input)
+                continue;
+            if (input.startsWith("/")) {
+                yield handleCommand(input);
+                continue;
+            }
+            // ── Process a user message ──
+            try {
+                currentRunId = `run-${Date.now()}`;
+                const t0 = performance.now();
+                const result = yield execWithObs(() => agent.processWithCheckpoint(input, checkpointAdapter, {
+                    runId: currentRunId,
+                    saveOnComplete: true,
+                }));
+                lastCheckpointId = result.checkpointId;
+                const ctx = result.context;
+                // ── Agent response ──
+                if (ctx.response) {
+                    console.log(chalk_1.default.green("\nAgent: ") + ctx.response + "\n");
+                }
+                // ── Summary line ──
+                console.log(chalk_1.default.dim(`  ${formatSummary(ctx, performance.now() - t0)}`));
+                // ── Checkpoint save confirmation ──
+                const history = yield agent.getCheckpointHistory(currentRunId, checkpointAdapter);
+                const completed = history.find((c) => c.nodeName === "__completed__");
+                if (completed) {
+                    console.log(chalk_1.default.dim(`  [Saved: ${completed.id}]\n`));
+                    lastCheckpointId = completed.id;
+                }
+            }
+            catch (error) {
+                if (error instanceof index_1.CheckpointAwaitApprovalError) {
+                    const cp = yield checkpointAdapter.load(error.checkpointId);
+                    if (cp) {
+                        pendingApprovalCp = cp;
+                        const actions = ((_d = cp.context) === null || _d === void 0 ? void 0 : _d.actions) || [];
+                        console.log(chalk_1.default.yellow(`\n\u23F8 Paused at "${pendingApprovalCp.nodeName}" for review.`));
+                        if (actions.length > 0) {
+                            console.log(chalk_1.default.cyan("  Planned actions:"));
+                            actions.forEach((a) => {
+                                const params = Array.isArray(a.parameters)
+                                    ? a.parameters.map((p) => `${p.name}=${JSON.stringify(p.value)}`).join(", ")
+                                    : JSON.stringify(a.parameters);
+                                console.log(chalk_1.default.gray(`    \u2192 ${a.name}(${params})`));
+                            });
+                        }
+                        console.log(chalk_1.default.gray("Approve (press Enter), /reject, /modify <key>=<value>, /resume <cpId>, or /exit\n"));
+                        lastCheckpointId = error.checkpointId;
+                        printCheckpointStatus(error.checkpointId, currentRunId);
+                    }
+                    else {
+                        console.log(chalk_1.default.red("Checkpoint not found."));
+                    }
+                }
+                else if (error instanceof index_1.CheckpointInterruptError) {
+                    lastCheckpointId = error.checkpointId;
+                    console.log(chalk_1.default.yellow(`\n\u23F8 Interrupted. Checkpoint: ${error.checkpointId}`));
+                    console.log(chalk_1.default.gray("/resume to continue, /exit to quit\n"));
+                }
+                else {
+                    console.log(chalk_1.default.red("\nError: ") + error.message + "\n");
+                }
+            }
+        }
+        rl === null || rl === void 0 ? void 0 : rl.close();
+    });
+}
+function showHelp() {
+    console.log(`
+${chalk_1.default.cyan("Commands")}
+
+${chalk_1.default.bold("Chat:")}
+  (text)          Send a message to the agent
+
+${chalk_1.default.bold("Checkpoint:")}
+  /status          Show current run and checkpoint status
+  /history [runId] Show checkpoint history for current or specified run
+  /list            List all saved checkpoints
+  /resume [cpId]   Resume execution from a checkpoint
+
+${chalk_1.default.bold("Human-in-the-Loop:")}
+  /approve         Approve and continue from breakpoint
+  /reject          Reject and skip current execution
+  /modify k=v      Modify context and continue (e.g., /modify value=42)
+
+${chalk_1.default.bold("Other:")}
+  /clear           Clear screen
+  /help            Show this help
+  /exit            Quit the CLI
+
+${chalk_1.default.bold("Breakpoint Behavior:")}
+  Before the agent "thinks" (calls LLM), execution pauses.
+  You can review state, modify context, approve, or reject.
+`);
+}
+function runCLI(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const llmConfig = getLLMConfig(config);
+        if (!process.env.OPENAI_API_KEY &&
+            config.provider === "openai" &&
+            !config.apiKey) {
+            console.log(chalk_1.default.red("Error: OPENAI_API_KEY environment variable is not set."));
+            console.log(chalk_1.default.gray("Set it with: export OPENAI_API_KEY=your-key"));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.cyan(`Starting ${config.role || DEFAULT_ROLE}...`));
+        const agent = createAgent(config);
+        yield chatLoop(agent, config.provider, llmConfig.model);
+    });
+}
+function startCLI() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const args = process.argv.slice(2);
+        const config = {
+            provider: "ollama",
+            model: "",
+            baseUrl: "http://localhost:11434",
+        };
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            switch (arg) {
+                case "--provider":
+                case "-p":
+                    config.provider = args[++i];
+                    break;
+                case "--model":
+                case "-m":
+                    config.model = args[++i];
+                    break;
+                case "--api-key":
+                    config.apiKey = args[++i];
+                    break;
+                case "--base-url":
+                case "-b":
+                    config.baseUrl = args[++i];
+                    break;
+                case "--role":
+                case "-r":
+                    config.role = args[++i];
+                    break;
+                case "--goal":
+                case "-g":
+                    config.goal = args[++i];
+                    break;
+                case "--verbose":
+                case "-v":
+                    config.verbose = true;
+                    break;
+                case "--help":
+                case "-h":
+                    showHelp();
+                    return;
+                default:
+                    if (!arg.startsWith("-")) {
+                        config.role = arg;
+                    }
+            }
+        }
+        // Auto-resolve API keys from .env / environment
+        if (config.provider === "openai" && !config.apiKey) {
+            config.apiKey = process.env.OPENAI_API_KEY;
+        }
+        if (config.provider === "groq" && !config.apiKey) {
+            config.apiKey = process.env.GROQ_API_KEY;
+        }
+        if (config.provider === "openrouter" && !config.apiKey) {
+            config.apiKey = process.env.OPENROUTER_API_KEY;
+        }
+        if (config.provider === "openai" && !config.apiKey) {
+            console.log(chalk_1.default.red("Error: OpenAI requires an API key."));
+            console.log(chalk_1.default.gray("Use --api-key, set OPENAI_API_KEY, or add to .env"));
+            process.exit(1);
+        }
+        if (config.provider === "groq" && !config.apiKey) {
+            console.log(chalk_1.default.red("Error: Groq requires an API key."));
+            console.log(chalk_1.default.gray("Use --api-key, set GROQ_API_KEY, or add to .env"));
+            process.exit(1);
+        }
+        if (config.provider === "openrouter" && !config.apiKey) {
+            console.log(chalk_1.default.red("Error: OpenRouter requires an API key."));
+            console.log(chalk_1.default.gray("Use --api-key, set OPENROUTER_API_KEY, or add to .env"));
+            process.exit(1);
+        }
+        if (config.provider === "google" && !config.apiKey) {
+            console.log(chalk_1.default.red("Error: Google requires an API key."));
+            console.log(chalk_1.default.gray("Use --api-key, set GOOGLE_API_KEY, or add to .env"));
+            process.exit(1);
+        }
+        yield runCLI(config);
+    });
+}
+if (require.main === module) {
+    startCLI();
+}
+//# sourceMappingURL=index.js.map