halfcopilot 0.0.1

package/dist/halfcop.js

@@ -0,0 +1,1103 @@
+#!/usr/bin/env node
+/**
+ * HalfCopilot CLI - Beautiful Chat Interface
+ */
+// Suppress noisy Node.js deprecation warnings (e.g. punycode from deps)
+try {
+    process.noDeprecation = true;
+}
+catch { }
+process.removeAllListeners("warning");
+process.on("warning", (w) => {
+    if (w.name === "DeprecationWarning" && String(w.message).includes("punycode"))
+        return;
+    // biome-ignore lint/suspicious/noConsole: intentional
+    console.error(w.stack ?? w.message);
+});
+import { Command } from "commander";
+import { loadConfig } from "@halfcopilot/config";
+import { ProviderRegistry } from "@halfcopilot/provider";
+import { ToolRegistry, createBuiltinTools, PermissionChecker, ToolExecutor, } from "@halfcopilot/tools";
+import { AgentLoop, HybridProvider } from "@halfcopilot/core";
+import { SkillRegistry, createBuiltinSkills } from "@halfcopilot/skills";
+import readline from "readline";
+const program = new Command();
+program
+    .name("halfcop")
+    .description("HalfCopilot — Multi-model Agent Framework CLI")
+    .version("1.0.29");
+// Beautiful color palette
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    italic: "\x1b[3m",
+    // Colors
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m",
+    // Background
+    bgCyan: "\x1b[46m",
+    bgGreen: "\x1b[42m",
+    bgYellow: "\x1b[43m",
+    bgBlue: "\x1b[44m",
+};
+// Box drawing characters
+const box = {
+    tl: "╭",
+    tr: "╮",
+    bl: "╰",
+    br: "╯",
+    h: "─",
+    v: "│",
+    ml: "├",
+    mr: "┤",
+};
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Braille dot spinning animation (Claude Code style)
+function createThinkingAnimation() {
+    let interval = null;
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const start = (message = "Thinking") => {
+        if (interval)
+            return;
+        interval = setInterval(() => {
+            process.stdout.write(`\r  ${c.cyan}${frames[i % frames.length]}${c.reset} ${c.dim}${message}${c.reset}   `);
+            i++;
+        }, 80);
+    };
+    const stop = () => {
+        if (interval) {
+            clearInterval(interval);
+            interval = null;
+        }
+        process.stdout.write("\r" + " ".repeat(50) + "\r");
+    };
+    return { start, stop };
+}
+// Animated loading indicator
+async function showLoading(message, duration = 1500) {
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    const startTime = Date.now();
+    let i = 0;
+    process.stdout.write(`\r${c.cyan}${frames[0]} ${message}${c.reset}`);
+    while (Date.now() - startTime < duration) {
+        await sleep(80);
+        i = (i + 1) % frames.length;
+        process.stdout.write(`\r${c.cyan}${frames[i]} ${message}${c.reset}`);
+    }
+    process.stdout.write("\r" + " ".repeat(message.length + 4) + "\r");
+}
+function printBox(content, color = c.cyan, width = 50) {
+    const lines = content.split("\n");
+    const maxLen = Math.max(...lines.map((l) => l.length), width - 4);
+    console.log(`${color}${box.tl}${box.h.repeat(maxLen + 2)}${box.tr}${c.reset}`);
+    for (const line of lines) {
+        const padding = " ".repeat(maxLen - line.length);
+        console.log(`${color}${box.v}${c.reset} ${line}${padding} ${color}${box.v}${c.reset}`);
+    }
+    console.log(`${color}${box.bl}${box.h.repeat(maxLen + 2)}${box.br}${c.reset}`);
+}
+// Simple banner - no ASCII art that breaks across terminals
+function printHeader() {
+    console.log("");
+    console.log(`  ${c.cyan}${c.bold}╭${"─".repeat(62)}╮${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}│${" ".repeat(62)}│${c.reset}`);
+    // Banner: H A L F C O P I L O T (19 chars), centered in 62-char box
+    const banner = "H A L F   C O P I L O T";
+    const bannerPad = Math.floor((62 - banner.length) / 2);
+    console.log(`  ${c.cyan}${c.bold}│${" ".repeat(bannerPad)}${c.white}${c.bold}${banner}${c.reset}${c.cyan}${" ".repeat(62 - bannerPad - banner.length)}│${c.reset}`);
+    // Subtitle: 32 chars, pad 15 each side
+    const subtitle = "Multi-model Agent Framework CLI";
+    const subPad = Math.floor((62 - subtitle.length) / 2);
+    console.log(`  ${c.cyan}${c.bold}│${" ".repeat(subPad)}${c.white}${subtitle}${c.reset}${c.cyan}${" ".repeat(62 - subPad - subtitle.length)}│${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}│${" ".repeat(62)}│${c.reset}`);
+    console.log(`  ${c.cyan}${c.bold}╰${"─".repeat(62)}╯${c.reset}`);
+    console.log("");
+}
+function printInfo(label, value) {
+    console.log(`  ${c.gray}${label}:${c.reset} ${c.white}${c.bold}${value}${c.reset}`);
+}
+function printUserMessage(message) {
+    const maxLen = Math.min(message.length, 60);
+    const display = message.substring(0, maxLen) + (message.length > maxLen ? "..." : "");
+    const lineLen = display.length + 4;
+    console.log(`\n  ${c.green}${box.tl}─── You ${box.h.repeat(Math.max(0, lineLen - 12))}${box.tr}${c.reset}`);
+    console.log(`  ${c.green}${box.v}${c.reset} ${c.green}${c.bold}${display}${c.reset}${" ".repeat(Math.max(0, 60 - display.length))} ${c.green}${box.v}${c.reset}`);
+    console.log(`  ${c.green}${box.bl}───${box.h.repeat(Math.max(0, lineLen - 1))}${box.br}${c.reset}\n`);
+}
+// Strip basic markdown syntax for clean terminal display
+function stripMarkdown(text) {
+    return text
+        .replace(/\*\*([^*]+)\*\*/g, "$1") // **bold** -> text
+        .replace(/\*([^*]+)\*/g, "$1") // *italic* -> text
+        .replace(/`([^`]+)`/g, "$1") // `code` -> text
+        .replace(/^#+\s+(.*)$/gm, "$1") // # headings -> plain
+        .replace(/^>\s+(.*)$/gm, "  ▸ $1") // > blockquote
+        .replace(/^-\s+/gm, "  • ") // - list items
+        .replace(/\*\*([^*]+)\*\*/g, "$1"); // already handled above, but double-check
+}
+// Print text with code block detection
+function printFormatted(text) {
+    const parts = text.split(/(```[\s\S]*?```)/);
+    for (const part of parts) {
+        if (part.startsWith("```")) {
+            const code = part.replace(/```\w*\n?/, "").replace(/```$/, "");
+            const lines = code.split("\n");
+            for (const line of lines) {
+                process.stdout.write(`  ${c.gray}│ ${line}${c.reset}\n`);
+            }
+        }
+        else {
+            process.stdout.write(part);
+        }
+    }
+}
+function printMarkdownBox(text) {
+    // Strip markdown first
+    const clean = stripMarkdown(text);
+    const displayLines = clean.split("\n").filter((l) => l.trim() !== "");
+    if (displayLines.length === 0)
+        return;
+    const maxLen = Math.min(Math.max(...displayLines.map((l) => l.length)), 64);
+    const top = `  ${c.blue}${box.tl}─── HalfCopilot ${box.h.repeat(Math.max(0, maxLen - 21))}${box.tr}${c.reset}`;
+    console.log("\n" + top);
+    for (const line of displayLines) {
+        const padding = " ".repeat(Math.max(0, maxLen - line.length));
+        console.log(`  ${c.blue}${box.v}${c.reset} ${c.white}${line}${c.reset}${padding} ${c.blue}${box.v}${c.reset}`);
+    }
+    const bot = `  ${c.blue}${box.bl}───${box.h.repeat(maxLen)}${box.br}${c.reset}`;
+    console.log(bot + "\n");
+}
+function displayThinkingBox(text) {
+    const lines = text.split("\n").filter(Boolean);
+    if (!lines.length)
+        return;
+    for (const line of lines) {
+        process.stdout.write(`  ${c.dim}${c.italic}💭 ${line}${c.reset}\n`);
+    }
+}
+function printAssistantStart() {
+    process.stdout.write(`\n  ${c.blue}${c.bold}🤖 ${c.reset}`);
+}
+function printAssistantEnd() {
+    console.log("\n");
+}
+function printAssistantText(text) {
+    printFormatted(text);
+}
+function printThinking() {
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    let interval = null;
+    const start = () => {
+        interval = setInterval(() => {
+            process.stdout.write(`\r  ${c.cyan}${frames[i % frames.length]} ${c.dim}Thinking...${c.reset}   `);
+            i++;
+        }, 80);
+    };
+    const stop = () => {
+        if (interval)
+            clearInterval(interval);
+        process.stdout.write("\r" + " ".repeat(30) + "\r");
+    };
+    return { start, stop };
+}
+// Status tracking variables
+let currentStatus = "idle";
+let currentProvider = "";
+let currentModel = "";
+let currentMode = "auto";
+let statusDescription = "Ready";
+let sessionStartTime = 0;
+let currentTurn = 0;
+let maxTurns = 20;
+let inputTokens = 0;
+let outputTokens = 0;
+let lastResponseTime = 0;
+let responseStartTime = 0;
+const statusColors = {
+    idle: c.gray,
+    thinking: c.yellow,
+    executing: c.blue,
+    completed: c.green,
+    error: c.red,
+};
+const statusEmoji = {
+    idle: "⚪",
+    thinking: "🟡",
+    executing: "🔵",
+    completed: "🟢",
+    error: "🔴",
+};
+const PERMISSION_INDICATORS = {
+    SAFE: "🟢",
+    WARN: "🟡",
+    UNSAFE: "🔴",
+};
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const m = Math.floor(ms / 60000);
+    const s = Math.floor((ms % 60000) / 1000);
+    return `${m}m${s}s`;
+}
+function getTerminalWidth() {
+    return process.stdout.columns || 80;
+}
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + "…";
+}
+// Enhanced status bar with rich session info
+function printStatusBar() {
+    const cols = getTerminalWidth();
+    const elapsed = sessionStartTime > 0 ? formatDuration(Date.now() - sessionStartTime) : "";
+    const tokens = inputTokens + outputTokens > 0 ? `${inputTokens}↓${outputTokens}↑` : "";
+    const turnInfo = currentTurn > 0 ? `${currentTurn}/${maxTurns}` : "";
+    const leftParts = [];
+    if (currentProvider)
+        leftParts.push(`${c.gray}${currentProvider}/${currentModel}${c.reset}`);
+    if (turnInfo)
+        leftParts.push(`${c.dim}${turnInfo}${c.reset}`);
+    const left = leftParts.join(" ");
+    const centerParts = [];
+    if (currentMode)
+        centerParts.push(`${c.cyan}[${currentMode.toUpperCase()}]${c.reset}`);
+    if (tokens)
+        centerParts.push(`${c.green}${tokens}${c.reset}`);
+    if (elapsed)
+        centerParts.push(`${c.dim}${elapsed}${c.reset}`);
+    const center = centerParts.join(" ");
+    const right = `${statusColors[currentStatus]}${statusEmoji[currentStatus]} ${truncate(statusDescription, 30)}${c.reset}`;
+    const paddedLeft = `  ${left}`;
+    const paddedRight = `${right}  `;
+    const remaining = Math.max(1, cols - paddedLeft.length - paddedRight.length);
+    const centerPadded = center.slice(0, remaining);
+    console.log(`${paddedLeft}${" ".repeat(Math.max(1, remaining - centerPadded.length))}${centerPadded}${paddedRight}`);
+}
+function updateStatus(status, desc) {
+    currentStatus = status;
+    if (desc)
+        statusDescription = desc;
+    if (currentStatus === "completed" && !desc) {
+        statusDescription = "Ready";
+    }
+}
+function checkConfig(config) {
+    const providers = config?.providers;
+    if (!providers || Object.keys(providers).length === 0) {
+        console.log("");
+        console.log(`  ${c.yellow}${c.bold}⚙️  首次使用需要先配置模型 API Key${c.reset}`);
+        console.log("");
+        console.log(`  ${c.white}运行以下命令进行交互式配置:${c.reset}`);
+        console.log("");
+        console.log(`    ${c.green}${c.bold}halfcop setup${c.reset}`);
+        console.log("");
+        console.log(`  ${c.dim}或手动创建 ~/.halfcopilot/settings.json${c.reset}`);
+        console.log("");
+        return false;
+    }
+    return true;
+}
+// Keypress-based tool approval (no readline question)
+async function askApproval(toolName, _input) {
+    return new Promise((resolve) => {
+        process.stdout.write(`  ${c.yellow}Allow ${toolName}? (y/n): ${c.reset}`);
+        const handler = (_str, key) => {
+            if (key.name === "y") {
+                process.stdin.removeListener("keypress", handler);
+                process.stdout.write("y\n");
+                resolve(true);
+            }
+            else if (key.name === "n") {
+                process.stdin.removeListener("keypress", handler);
+                process.stdout.write("n\n");
+                resolve(false);
+            }
+        };
+        process.stdin.on("keypress", handler);
+    });
+}
+function createAgent(options = {}) {
+    const config = loadConfig();
+    // Check if any providers configured
+    if (!checkConfig(config)) {
+        process.exit(0);
+    }
+    const providerRegistry = new ProviderRegistry();
+    providerRegistry.createFromConfig(config);
+    const providerName = options.provider ?? config.defaultProvider ?? "xiaomi";
+    let provider = providerRegistry.get(providerName);
+    if (options.hybrid) {
+        provider = new HybridProvider(provider);
+    }
+    const toolRegistry = new ToolRegistry();
+    const builtinTools = createBuiltinTools();
+    builtinTools.forEach((t) => toolRegistry.register(t));
+    const skillRegistry = new SkillRegistry();
+    const builtinSkills = createBuiltinSkills();
+    builtinSkills.forEach((s) => skillRegistry.register(s));
+    const permissions = new PermissionChecker({
+        autoApproveSafe: config.permissions.autoApproveSafe,
+        allow: config.permissions.allow,
+        deny: config.permissions.deny,
+    });
+    const executor = new ToolExecutor(toolRegistry, permissions, askApproval);
+    const modelName = options.model ?? config.defaultModel ?? "mimo-v2.5-pro";
+    const agent = new AgentLoop({
+        provider,
+        providerName,
+        model: modelName,
+        tools: toolRegistry,
+        executor,
+        permissions,
+        maxTurns: config.maxTurns,
+        mode: options.mode ?? "auto",
+    });
+    return {
+        agent,
+        providerName,
+        config,
+        skillRegistry,
+        modelName,
+        providerRegistry,
+    };
+}
+async function runInteractive(options = {}) {
+    const { agent, providerName, config, skillRegistry, modelName, providerRegistry, } = createAgent(options);
+    currentProvider = providerName;
+    currentModel = modelName;
+    currentMode = options.mode ?? "auto";
+    maxTurns = config.maxTurns ?? 20;
+    currentTurn = 0;
+    inputTokens = 0;
+    outputTokens = 0;
+    sessionStartTime = Date.now();
+    printHeader();
+    printInfo("Provider", providerName);
+    printInfo("Model", modelName);
+    printInfo("Mode", options.mode ?? "auto");
+    printInfo("Max Turns", String(maxTurns));
+    console.log("");
+    console.log(`  ${c.dim}Type to chat. /help for commands. "exit" to quit.${c.reset}`);
+    console.log("");
+    const agentRef = { current: agent };
+    let isProcessing = false;
+    // Setup readline for input (readline manages raw mode internally)
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const PROMPT = `  ${c.green}${c.bold}❯${c.reset} `;
+    const ask = () => {
+        rl.question(PROMPT, async (input) => {
+            if (isProcessing)
+                return;
+            const trimmed = input.trim();
+            if (!trimmed) {
+                ask();
+                return;
+            }
+            if (trimmed.toLowerCase() === "exit" ||
+                trimmed.toLowerCase() === "quit") {
+                console.log(`\n  ${c.yellow}Bye! 👋${c.reset}`);
+                rl.close();
+                return;
+            }
+            if (trimmed.startsWith("/")) {
+                const result = await handleCommand(trimmed, options, modelName, providerName, agentRef, providerRegistry, config);
+                if (result?.newModel)
+                    currentModel = result.newModel;
+                if (result?.newProvider)
+                    currentProvider = result.newProvider;
+                ask();
+                return;
+            }
+            await processInput(trimmed);
+            ask();
+        });
+    };
+    // ------- Agent processing -------
+    const processInput = async (input) => {
+        isProcessing = true;
+        const trimmed = input.trim();
+        if (!trimmed) {
+            isProcessing = false;
+            return;
+        }
+        let interrupted = false;
+        const onKeypress = (_str, key) => {
+            if (key.name === "escape")
+                interrupted = true;
+        };
+        process.stdin.on("keypress", onKeypress);
+        const thinking = createThinkingAnimation();
+        thinking.start();
+        let responseStarted = false;
+        let thinkingDisplayed = false;
+        let loopEnded = false;
+        let atLineStart = false;
+        let tBuffer = "";
+        try {
+            for await (const event of agentRef.current.run(trimmed)) {
+                if (interrupted) {
+                    loopEnded = true;
+                    thinking.stop();
+                    process.stdout.write(`\n    ${c.yellow}⏹ Interrupted${c.reset}\n`);
+                    atLineStart = true;
+                    updateStatus("idle", "Interrupted");
+                    break;
+                }
+                switch (event.type) {
+                    case "thinking":
+                        if (!responseStarted) {
+                            if (!thinkingDisplayed) {
+                                thinking.stop();
+                                thinkingDisplayed = true;
+                            }
+                            let content = event.content ?? "";
+                            content = content.replace(/<\/?think>/gi, "").trim();
+                            if (content)
+                                displayThinkingBox(content);
+                        }
+                        break;
+                    case "text": {
+                        const chunk = event.content ?? "";
+                        if (!responseStarted) {
+                            thinking.stop();
+                        }
+                        const combined = tBuffer + chunk;
+                        const openIdx = combined.indexOf("<think>");
+                        const closeIdx = combined.indexOf("</think>");
+                        const hasComplete = openIdx >= 0 && closeIdx >= 0 && closeIdx > openIdx + 6;
+                        if (!responseStarted && hasComplete) {
+                            const thinkText = combined.slice(openIdx + 7, closeIdx).trim();
+                            if (thinkText)
+                                displayThinkingBox(thinkText);
+                            const after = combined.slice(closeIdx + 8).trimStart();
+                            if (after) {
+                                process.stdout.write(`\n  ${c.green}${c.bold}●${c.reset} `);
+                                responseStarted = true;
+                                atLineStart = false;
+                                responseStartTime = Date.now();
+                                const clean = after.replace(/^\n+/, "");
+                                if (clean) {
+                                    const indented = clean.includes("\n")
+                                        ? clean.replace(/\n/g, "\n  ")
+                                        : clean;
+                                    process.stdout.write(indented);
+                                    atLineStart = clean.endsWith("\n");
+                                }
+                            }
+                            tBuffer = "";
+                            break;
+                        }
+                        if (!responseStarted && openIdx >= 0) {
+                            tBuffer = combined;
+                            break;
+                        }
+                        if (!responseStarted) {
+                            process.stdout.write(`\n  ${c.green}${c.bold}●${c.reset} `);
+                            responseStarted = true;
+                            atLineStart = false;
+                            responseStartTime = Date.now();
+                            const clean = combined.replace(/^\n+/, "");
+                            const indented = clean.includes("\n")
+                                ? clean.replace(/\n/g, "\n  ")
+                                : clean;
+                            process.stdout.write(indented);
+                            tBuffer = "";
+                            break;
+                        }
+                        if (tBuffer) {
+                            tBuffer = combined;
+                            if (closeIdx >= 0 && openIdx >= 0 && closeIdx > openIdx + 6) {
+                                const thinkText = tBuffer.slice(openIdx + 7, closeIdx).trim();
+                                if (thinkText)
+                                    displayThinkingBox(thinkText);
+                                process.stdout.write(`\n  ${c.green}${c.bold}●${c.reset} `);
+                                responseStarted = true;
+                                atLineStart = false;
+                                responseStartTime = Date.now();
+                                const after = tBuffer.slice(closeIdx + 8).trimStart();
+                                if (after) {
+                                    const clean = after.replace(/^\n+/, "");
+                                    if (clean) {
+                                        const indented = clean.includes("\n")
+                                            ? clean.replace(/\n/g, "\n  ")
+                                            : clean;
+                                        process.stdout.write(indented);
+                                        atLineStart = clean.endsWith("\n");
+                                    }
+                                }
+                                tBuffer = "";
+                                break;
+                            }
+                            break;
+                        }
+                        if (atLineStart) {
+                            process.stdout.write(`  `);
+                            atLineStart = false;
+                        }
+                        if (chunk.includes("\n")) {
+                            const indented = chunk.replace(/\n/g, "\n  ");
+                            process.stdout.write(indented);
+                            atLineStart = chunk.endsWith("\n");
+                        }
+                        else {
+                            process.stdout.write(chunk);
+                            atLineStart = false;
+                        }
+                        break;
+                    }
+                    case "tool_use":
+                        if (!responseStarted) {
+                            thinking.stop();
+                            responseStarted = true;
+                        }
+                        const toolInput = event.toolInput ?? {};
+                        const inputStr = JSON.stringify(toolInput);
+                        process.stdout.write(`\n    ${c.cyan}🔧 ${event.toolName}${c.reset} ${c.yellow}${PERMISSION_INDICATORS.WARN}${c.reset} `);
+                        if (inputStr.length < 60) {
+                            process.stdout.write(`${c.dim}${inputStr}${c.reset}`);
+                        }
+                        else {
+                            const formatted = JSON.stringify(toolInput, null, 2);
+                            process.stdout.write(`\n${formatted
+                                .split("\n")
+                                .map((l) => `      ${c.dim}${l}${c.reset}`)
+                                .join("\n")}`);
+                        }
+                        updateStatus("executing", event.toolName);
+                        break;
+                    case "tool_result":
+                        const output = event.toolOutput;
+                        const success = output !== undefined && output !== null;
+                        if (success) {
+                            process.stdout.write(` ${c.green}✓${c.reset}\n`);
+                        }
+                        else {
+                            const errSummary = (typeof output === "string" ? output : String(output ?? "")).slice(0, 100);
+                            process.stdout.write(` ${c.red}✗${c.reset} ${c.dim}${errSummary}${c.reset}\n`);
+                        }
+                        atLineStart = true;
+                        updateStatus("executing", "Tool completed");
+                        break;
+                    case "error":
+                        loopEnded = true;
+                        thinking.stop();
+                        process.stdout.write(`\n    ${c.red}✗ ${event.error?.message?.slice(0, 100) ?? "error"}${c.reset}\n`);
+                        atLineStart = true;
+                        updateStatus("error", event.error?.message?.slice(0, 50));
+                        break;
+                    case "done":
+                        loopEnded = true;
+                        if (responseStarted) {
+                            const respTime = responseStartTime > 0 ? Date.now() - responseStartTime : 0;
+                            lastResponseTime = respTime;
+                            process.stdout.write(`\n  ${c.dim}(${formatDuration(respTime)})${c.reset}\n\n`);
+                        }
+                        atLineStart = true;
+                        updateStatus("completed", "Ready");
+                        if (event.usage) {
+                            inputTokens += event.usage.inputTokens ?? 0;
+                            outputTokens += event.usage.outputTokens ?? 0;
+                        }
+                        break;
+                }
+            }
+            if (!loopEnded)
+                thinking.stop();
+        }
+        catch (err) {
+            thinking.stop();
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stdout.write(`\n    ${c.red}✗ ${msg.replace(/^400 /, "").replace(/^429 /, "Quota exhausted — ").slice(0, 120)}${c.reset}\n`);
+            updateStatus("error", msg.slice(0, 50));
+        }
+        finally {
+            process.stdin.removeListener("keypress", onKeypress);
+            isProcessing = false;
+            currentTurn++;
+        }
+    };
+    // Keep process alive, cleanup terminal on exit
+    await new Promise((resolve) => {
+        rl.on("close", () => {
+            try {
+                if (process.stdin.isTTY)
+                    process.stdin.setRawMode(false);
+            }
+            catch { }
+            process.stdin.pause();
+            resolve();
+        });
+        ask();
+    });
+}
+async function handleCommand(cmd, opts, currentModel, currentProvider, agentRef, providerRegistry, config) {
+    const parts = cmd.split(" ");
+    const command = parts[0].toLowerCase();
+    const arg = parts.slice(1).join(" ");
+    switch (command) {
+        case "/model":
+            if (arg) {
+                opts.model = arg;
+                updateStatus("thinking", `Switching to ${arg}...`);
+                try {
+                    // Re-create agent with new model
+                    const providerName = opts.provider ?? config.defaultProvider ?? "xiaomi";
+                    const provider = providerRegistry.get(providerName);
+                    const toolRegistry = new ToolRegistry();
+                    const builtinTools = createBuiltinTools();
+                    builtinTools.forEach((t) => toolRegistry.register(t));
+                    const permissions = new PermissionChecker({
+                        autoApproveSafe: config.permissions.autoApproveSafe,
+                        allow: config.permissions.allow,
+                        deny: config.permissions.deny,
+                    });
+                    const executor = new ToolExecutor(toolRegistry, permissions, askApproval);
+                    const newAgent = new AgentLoop({
+                        provider,
+                        providerName,
+                        model: arg,
+                        tools: toolRegistry,
+                        executor,
+                        permissions,
+                        maxTurns: config.maxTurns,
+                        mode: opts.mode ?? "auto",
+                    });
+                    agentRef.current = newAgent;
+                    console.log(`  ${c.green}✓ Model: ${arg}${c.reset}`);
+                    return { newModel: arg };
+                }
+                catch (err) {
+                    console.log(`  ${c.red}✗ Model not found: ${arg}${c.reset}`);
+                }
+            }
+            else {
+                console.log(`  ${c.yellow}Model: ${currentModel}${c.reset}`);
+            }
+            break;
+        case "/provider":
+            if (arg) {
+                opts.provider = arg;
+                updateStatus("thinking", `Switching to ${arg}...`);
+                try {
+                    const newProvider = providerRegistry.get(arg);
+                    const toolRegistry = new ToolRegistry();
+                    const builtinTools = createBuiltinTools();
+                    builtinTools.forEach((t) => toolRegistry.register(t));
+                    const permissions = new PermissionChecker({
+                        autoApproveSafe: config.permissions.autoApproveSafe,
+                        allow: config.permissions.allow,
+                        deny: config.permissions.deny,
+                    });
+                    const executor = new ToolExecutor(toolRegistry, permissions, askApproval);
+                    const newAgent = new AgentLoop({
+                        provider: newProvider,
+                        providerName: arg,
+                        model: opts.model ?? config.defaultModel ?? "mimo-v2.5-pro",
+                        tools: toolRegistry,
+                        executor,
+                        permissions,
+                        maxTurns: config.maxTurns,
+                        mode: opts.mode ?? "auto",
+                    });
+                    agentRef.current = newAgent;
+                    console.log(`  ${c.green}✓ Provider: ${arg}${c.reset}`);
+                    return { newProvider: arg };
+                }
+                catch (err) {
+                    console.log(`  ${c.red}✗ Provider not found: ${arg}${c.reset}`);
+                }
+            }
+            else {
+                console.log(`  ${c.yellow}Provider: ${currentProvider}${c.reset}`);
+            }
+            break;
+        case "/mode":
+            if (arg && ["plan", "act", "auto", "review"].includes(arg)) {
+                opts.mode = arg;
+                agentRef.current.setMode(arg);
+                console.log(`  ${c.green}✓ Mode: ${arg}${c.reset}`);
+                currentMode = arg;
+                updateStatus("idle", `Mode: ${arg}`);
+            }
+            else {
+                console.log(`  ${c.yellow}Mode: ${currentMode}${c.reset}`);
+                console.log(`  ${c.dim}Options: plan, act, auto, review${c.reset}`);
+            }
+            break;
+        case "/clear":
+            console.clear();
+            printHeader();
+            break;
+        case "/help":
+            console.log(`\n  ${c.cyan}Commands:${c.reset}`);
+            console.log(`  ${c.white}/model <name>${c.reset}   - Switch model`);
+            console.log(`  ${c.white}/provider <name>${c.reset} - Switch provider`);
+            console.log(`  ${c.white}/mode <name>${c.reset}    - Set mode (plan/act/auto/review)`);
+            console.log(`  ${c.white}/clear${c.reset}           - Clear screen`);
+            console.log(`  ${c.white}/help${c.reset}           - Show this help`);
+            console.log(`  ${c.white}/exit${c.reset}           - Quit\n`);
+            break;
+        default:
+            console.log(`  ${c.red}Unknown: ${command}${c.reset}`);
+    }
+}
+async function runSingle(prompt, options = {}) {
+    const { agent } = createAgent(options);
+    const thinking = printThinking();
+    let isFirstChunk = true;
+    let tBuffer = "";
+    let thinkRendered = false;
+    try {
+        for await (const event of agent.run(prompt)) {
+            switch (event.type) {
+                case "text": {
+                    const chunk = event.content ?? "";
+                    if (isFirstChunk) {
+                        thinking.stop();
+                        isFirstChunk = false;
+                    }
+                    const combined = tBuffer + chunk;
+                    const openIdx = combined.indexOf("<think>");
+                    const closeIdx = combined.indexOf("</think>");
+                    const hasComplete = openIdx >= 0 && closeIdx >= 0 && closeIdx > openIdx + 6;
+                    if (!thinkRendered && hasComplete) {
+                        const thinkText = combined.slice(openIdx + 7, closeIdx).trim();
+                        if (thinkText)
+                            displayThinkingBox(thinkText);
+                        const after = combined.slice(closeIdx + 8).trimStart();
+                        if (after) {
+                            process.stdout.write(`\n  ${c.green}${c.bold}●${c.reset} `);
+                            const clean3 = after.replace(/^\n+/, "");
+                            const indented3 = clean3.includes("\n")
+                                ? clean3.replace(/\n/g, "\n  ")
+                                : clean3;
+                            process.stdout.write(indented3);
+                            thinkRendered = true;
+                        }
+                        tBuffer = "";
+                        break;
+                    }
+                    if (!thinkRendered && openIdx >= 0) {
+                        tBuffer = combined;
+                        break;
+                    }
+                    if (!thinkRendered) {
+                        process.stdout.write(`\n  ${c.green}${c.bold}●${c.reset} `);
+                        thinkRendered = true;
+                    }
+                    const clean2 = combined.replace(/^\n+/, "");
+                    const indented2 = clean2.includes("\n")
+                        ? clean2.replace(/\n/g, "\n  ")
+                        : clean2;
+                    process.stdout.write(indented2);
+                    break;
+                }
+                case "thinking":
+                    if (isFirstChunk) {
+                        thinking.stop();
+                        isFirstChunk = false;
+                    }
+                    const tc = (event.content ?? "").replace(/<\/?think>/gi, "").trim();
+                    if (tc)
+                        displayThinkingBox(tc);
+                    break;
+                case "tool_use":
+                case "tool_result":
+                    break;
+            }
+        }
+        console.log("");
+    }
+    catch (err) {
+        thinking.stop();
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+    }
+}
+// Subcommands first
+program
+    .command("chat")
+    .description("Start interactive chat mode")
+    .option("-m, --model <model>", "Model to use")
+    .option("-p, --provider <provider>", "Provider to use")
+    .option("--mode <mode>", "Agent mode (plan/review/act/auto)", "auto")
+    .option("--hybrid", "Enable hybrid mode")
+    .action(async (options) => {
+    await runInteractive(options);
+});
+program
+    .command("run <prompt>")
+    .description("Run a single prompt and exit")
+    .option("-m, --model <model>", "Model to use")
+    .option("-p, --provider <provider>", "Provider to use")
+    .option("--mode <mode>", "Agent mode (plan/review/act/auto)", "act")
+    .option("--hybrid", "Enable hybrid mode")
+    .action(async (prompt, options) => {
+    await runSingle(prompt, options);
+    process.exit(0);
+});
+program
+    .command("models")
+    .description("List available models")
+    .action(() => {
+    console.log("");
+    console.log(`  ${c.cyan}${c.bold}Available Models:${c.reset}`);
+    console.log("");
+    const config = loadConfig();
+    for (const [provider, pConfig] of Object.entries(config.providers)) {
+        console.log(`  ${c.green}${c.bold}${provider}${c.reset}`);
+        for (const model of Object.keys(pConfig.models)) {
+            console.log(`    ${c.white}• ${model}${c.reset}`);
+        }
+        console.log("");
+    }
+});
+program
+    .command("doctor")
+    .description("Check configuration and environment")
+    .action(() => {
+    console.log("");
+    console.log(`  ${c.cyan}${c.bold}HalfCopilot Doctor${c.reset}`);
+    console.log("");
+    try {
+        const config = loadConfig();
+        console.log(`  ${c.green}✓${c.reset} Configuration loaded`);
+        console.log(`  ${c.green}✓${c.reset} Providers: ${Object.keys(config.providers).join(", ")}`);
+        console.log(`  ${c.green}✓${c.reset} Default: ${config.defaultProvider}/${config.defaultModel}`);
+        const toolRegistry = new ToolRegistry();
+        createBuiltinTools().forEach((t) => toolRegistry.register(t));
+        console.log(`  ${c.green}✓${c.reset} Tools: ${toolRegistry.list().length} available`);
+        const skillRegistry = new SkillRegistry();
+        createBuiltinSkills().forEach((s) => skillRegistry.register(s));
+        console.log(`  ${c.green}✓${c.reset} Skills: ${skillRegistry.list().length} available`);
+        console.log("");
+        console.log(`  ${c.green}${c.bold}All checks passed! ✓${c.reset}`);
+        console.log("");
+    }
+    catch (err) {
+        console.log(`  ${c.red}✗ Error: ${err instanceof Error ? err.message : err}${c.reset}`);
+    }
+});
+program
+    .command("skills")
+    .description("List available skills")
+    .action(() => {
+    const skillRegistry = new SkillRegistry();
+    createBuiltinSkills().forEach((s) => skillRegistry.register(s));
+    console.log("");
+    console.log(`  ${c.cyan}${c.bold}Available Skills:${c.reset}`);
+    console.log("");
+    for (const skill of skillRegistry.list()) {
+        console.log(`  ${c.green}• ${skill.name}${c.reset}`);
+        console.log(`    ${c.dim}${skill.description}${c.reset}`);
+    }
+    console.log("");
+});
+program
+    .command("setup")
+    .description("Interactive setup — configure API keys for model providers")
+    .action(async () => {
+    const fs = await import("fs");
+    const pathModule = await import("path");
+    const os = await import("os");
+    const configDir = pathModule.join(os.homedir(), ".halfcopilot");
+    const configFile = pathModule.join(configDir, "settings.json");
+    // Load existing or create default
+    let config = {};
+    if (fs.existsSync(configFile)) {
+        config = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+    }
+    if (!config.providers) {
+        config.providers = {};
+    }
+    const providersCfg = config.providers;
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    // Print header
+    console.log("");
+    console.log(`${c.cyan}${c.bold}  ╭─────────────────────────────────────────────────────╮${c.reset}`);
+    console.log(`${c.cyan}${c.bold}  │                                                     │${c.reset}`);
+    console.log(`${c.cyan}${c.bold}  │           ⚙️  HalfCopilot Setup                     │${c.reset}`);
+    console.log(`${c.cyan}${c.bold}  │                                                     │${c.reset}`);
+    console.log(`${c.cyan}${c.bold}  ╰─────────────────────────────────────────────────────╯${c.reset}`);
+    console.log("");
+    // Provider templates - updated with accurate endpoints
+    const providers = [
+        {
+            name: "minimax",
+            label: "MiniMax",
+            desc: "M2.7 / M2.5 — 海螺AI同款",
+            baseUrl: "https://api.minimaxi.com/v1",
+            models: ["MiniMax-M2.7", "MiniMax-M2.5"],
+        },
+        {
+            name: "xiaomi",
+            label: "小米 MiMo",
+            desc: "Token Plan API",
+            baseUrl: "https://token-plan-cn.xiaomimimo.com/v1",
+            models: ["mimo-v2.5-pro", "mimo-v2.5"],
+        },
+        {
+            name: "deepseek",
+            label: "DeepSeek",
+            desc: "高性价比，深度推理",
+            baseUrl: "https://api.deepseek.com/v1",
+            models: ["deepseek-chat", "deepseek-reasoner"],
+        },
+        {
+            name: "qwen",
+            label: "通义千问 Qwen",
+            desc: "阿里云出品",
+            baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+            models: ["qwen-turbo", "qwen-plus"],
+        },
+        {
+            name: "openai",
+            label: "OpenAI",
+            desc: "GPT-4o / GPT-4o-mini",
+            baseUrl: "https://api.openai.com/v1",
+            models: ["gpt-4o", "gpt-4o-mini"],
+        },
+        {
+            name: "anthropic",
+            label: "Anthropic Claude",
+            desc: "Claude Sonnet 4",
+            baseUrl: "",
+            models: ["claude-sonnet-4-20250514"],
+        },
+    ];
+    console.log(`  ${c.dim}选择你要配置的模型厂商，输入 API Key 即可。${c.reset}`);
+    console.log("");
+    console.log(`  ${c.cyan}${c.bold}📦 可用厂商:${c.reset}`);
+    console.log("");
+    for (let i = 0; i < providers.length; i++) {
+        const p = providers[i];
+        const configured = providersCfg[p.name]
+            ? ` ${c.green}(已配置)${c.reset}`
+            : "";
+        console.log(`  ${c.bold}${i + 1}${c.reset}. ${c.white}${p.label}${c.reset} — ${c.dim}${p.desc}${c.reset}${configured}`);
+    }
+    console.log(`  ${c.bold}0${c.reset}. ${c.dim}完成配置，退出${c.reset}`);
+    console.log("");
+    let selectedIdx = -1;
+    // Keyboard navigation (basic, using enter)
+    const choice = await ask(`  ${c.green}选择你要配置的厂商 (0-${providers.length}): ${c.reset}`);
+    selectedIdx = parseInt(choice.trim()) - 1;
+    if (isNaN(selectedIdx) ||
+        selectedIdx < -1 ||
+        selectedIdx >= providers.length) {
+        console.log(`  ${c.red}无效选择${c.reset}`);
+        rl.close();
+        return;
+    }
+    if (selectedIdx === -1) {
+        console.log(`  ${c.yellow}配置完成！${c.reset}`);
+        rl.close();
+        return;
+    }
+    const selected = providers[selectedIdx];
+    console.log("");
+    console.log(`  ${c.cyan}配置 ${selected.label}${c.reset}`);
+    let apiKey;
+    if (selected.name === "xiaomi") {
+        console.log("");
+        console.log(`  ${c.dim}小米 Token Plan API Key 示例格式:${c.reset}`);
+        console.log(`  ${c.dim}tp-xxxxxxxxxx...${c.reset}`);
+    }
+    if (selected.name === "minimax") {
+        console.log("");
+        console.log(`  ${c.dim}MiniMax API Key (来自 minimaxi.com):${c.reset}`);
+    }
+    if (selected.name === "deepseek") {
+        console.log("");
+        console.log(`  ${c.dim}DeepSeek API Key (来自 api.deepseek.com):${c.reset}`);
+    }
+    apiKey = await ask(`  ${c.green}API Key: ${c.reset}`);
+    if (!apiKey.trim()) {
+        console.log(`  ${c.yellow}已跳过${c.reset}`);
+        rl.close();
+        return;
+    }
+    // Build models object with proper context windows
+    const modelConfigs = {};
+    if (selected.name === "minimax") {
+        modelConfigs["MiniMax-M2.7"] = {
+            contextWindow: 128000,
+            maxOutput: 16384,
+        };
+        modelConfigs["MiniMax-M2.5"] = {
+            contextWindow: 128000,
+            maxOutput: 16384,
+        };
+    }
+    else if (selected.name === "deepseek") {
+        modelConfigs["deepseek-chat"] = { contextWindow: 64000, maxOutput: 8192 };
+        modelConfigs["deepseek-reasoner"] = {
+            contextWindow: 64000,
+            maxOutput: 8192,
+        };
+    }
+    else if (selected.name === "xiaomi") {
+        modelConfigs["mimo-v2.5-pro"] = {
+            contextWindow: 128000,
+            maxOutput: 16384,
+        };
+        modelConfigs["mimo-v2.5"] = { contextWindow: 128000, maxOutput: 16384 };
+    }
+    else {
+        for (const m of selected.models) {
+            modelConfigs[m] = { contextWindow: 128000, maxOutput: 8192 };
+        }
+    }
+    // Save provider config
+    providersCfg[selected.name] = {
+        type: selected.name === "anthropic" ? "anthropic" : "openai-compatible",
+        ...(selected.baseUrl ? { baseUrl: selected.baseUrl } : {}),
+        apiKey,
+        models: modelConfigs,
+    };
+    // Set as default if no default set
+    const configAny = config;
+    if (!configAny.defaultProvider) {
+        configAny.defaultProvider = selected.name;
+        configAny.defaultModel = selected.models[0];
+    }
+    // Write config
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+    console.log("");
+    console.log(`  ${c.green}${c.bold}✅ ${selected.label} 配置成功！${c.reset}`);
+    console.log(`  ${c.dim}配置文件: ${configFile}${c.reset}`);
+    console.log(`  ${c.dim}模型: ${Object.keys(modelConfigs).join(", ")}${c.reset}`);
+    if (configAny.defaultProvider === selected.name) {
+        console.log(`  ${c.green}已设为默认厂商${c.reset}`);
+    }
+    console.log("");
+    rl.close();
+});
+// Default action: when no command given, start interactive chat
+program.action(async () => {
+    await runInteractive({});
+});
+program.parse();
+//# sourceMappingURL=halfcop.js.map