@zhongqian97-code/ecode 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+const _ew=process.emitWarning.bind(process);process.emitWarning=function(w,...a){if((w?.message??w)?.includes?.('punycode'))return;_ew(w,...a);};
 
 // src/index.ts
 import { createRequire } from "module";
+import React4 from "react";
+import { render } from "ink";
 
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
@@ -10,7 +13,25 @@ import { join } from "path";
 var DEFAULTS = {
   baseUrl: "https://api.openai.com/v1",
   apiKey: "",
-  model: "gpt-4o"
+  model: "gpt-4o",
+  dangerousPatterns: [
+    "rm -rf",
+    "sudo",
+    "chmod",
+    "chown",
+    "mkfs",
+    "dd",
+    "fdisk",
+    "kill",
+    "pkill",
+    "killall",
+    "reboot",
+    "shutdown",
+    "halt",
+    "curl -X DELETE",
+    "wget --delete-after"
+  ],
+  logDir: void 0
 };
 function loadConfig() {
   const configPath = join(homedir(), ".ecode", "config.json");
@@ -25,58 +46,17 @@ function loadConfig() {
   return {
     baseUrl: process.env.ECODE_BASE_URL ?? fileConfig.baseUrl ?? DEFAULTS.baseUrl,
     apiKey: process.env.ECODE_API_KEY ?? fileConfig.apiKey ?? DEFAULTS.apiKey,
-    model: process.env.ECODE_MODEL ?? fileConfig.model ?? DEFAULTS.model
+    model: process.env.ECODE_MODEL ?? fileConfig.model ?? DEFAULTS.model,
+    // dangerousPatterns: 文件配置覆盖默认值，不支持环境变量（命令数组不适合通过环境变量传递）
+    dangerousPatterns: fileConfig.dangerousPatterns ?? DEFAULTS.dangerousPatterns,
+    // logDir: ECODE_LOG_DIR > 文件配置 > undefined
+    logDir: process.env.ECODE_LOG_DIR ?? fileConfig.logDir ?? DEFAULTS.logDir
   };
 }
 
-// src/repl.ts
-import * as readline from "readline/promises";
-
-// src/safety.ts
-var ALLOWLIST = [
-  "ls",
-  "cat",
-  "pwd",
-  "echo",
-  "head",
-  "tail",
-  "wc",
-  "date",
-  "whoami",
-  "which",
-  "env",
-  "printenv"
-];
-var DANGER_LIST = [
-  "rm -rf",
-  "sudo",
-  "chmod",
-  "chown",
-  "mkfs",
-  "dd",
-  "fdisk",
-  "kill",
-  "pkill",
-  "killall",
-  "reboot",
-  "shutdown",
-  "halt",
-  "curl -X DELETE",
-  "wget --delete-after"
-];
-function matchesEntry(cmd, entry) {
-  return cmd === entry || cmd.startsWith(entry + " ");
-}
-function classifyCommand(cmd) {
-  const trimmed = cmd.trim();
-  for (const entry of DANGER_LIST) {
-    if (matchesEntry(trimmed, entry)) return "danger";
-  }
-  for (const entry of ALLOWLIST) {
-    if (matchesEntry(trimmed, entry)) return "allow";
-  }
-  return "normal";
-}
+// src/ui/App.tsx
+import { useState as useState3, useCallback, useRef, useEffect as useEffect3 } from "react";
+import { Box as Box4, useInput as useInput2 } from "ink";
 
 // src/llm.ts
 import OpenAI from "openai";
@@ -92,12 +72,15 @@ function createLLMClient(config2) {
           const requestParams = {
             model: config2.model,
             messages,
-            stream: true
+            stream: true,
+            stream_options: { include_usage: true }
           };
           if (tools && tools.length > 0) {
             requestParams.tools = tools;
           }
-          const response = await openai.chat.completions.create(requestParams);
+          const response = await openai.chat.completions.create(
+            requestParams
+          );
           const tcAccumulator = /* @__PURE__ */ new Map();
           let reasoningAccumulator = "";
           for await (const chunk of response) {
@@ -124,12 +107,18 @@ function createLLMClient(config2) {
             }
             const isLast = choice.finish_reason !== null;
             if (isLast) {
+              const rawUsage = chunk.usage;
               yield {
                 text: delta.content ?? "",
                 done: true,
                 finishReason: choice.finish_reason,
                 toolCalls: tcAccumulator.size > 0 ? Array.from(tcAccumulator.values()) : void 0,
-                reasoning: reasoningAccumulator || void 0
+                reasoning: reasoningAccumulator || void 0,
+                usage: rawUsage ? {
+                  promptTokens: rawUsage.prompt_tokens,
+                  completionTokens: rawUsage.completion_tokens,
+                  totalTokens: rawUsage.total_tokens
+                } : void 0
               };
             } else {
               yield {
@@ -145,6 +134,56 @@ function createLLMClient(config2) {
   };
 }
 
+// src/repl.ts
+import * as readline from "readline/promises";
+
+// src/safety.ts
+var ALLOWLIST = [
+  "ls",
+  "cat",
+  "pwd",
+  "echo",
+  "head",
+  "tail",
+  "wc",
+  "date",
+  "whoami",
+  "which",
+  "env",
+  "printenv"
+];
+var DEFAULT_DANGER_LIST = [
+  "rm -rf",
+  "sudo",
+  "chmod",
+  "chown",
+  "mkfs",
+  "dd",
+  "fdisk",
+  "kill",
+  "pkill",
+  "killall",
+  "reboot",
+  "shutdown",
+  "halt",
+  "curl -X DELETE",
+  "wget --delete-after"
+];
+function matchesEntry(cmd, entry) {
+  return cmd === entry || cmd.startsWith(entry + " ");
+}
+function classifyCommand(cmd, dangerPatterns) {
+  const trimmed = cmd.trim();
+  const patterns = dangerPatterns ?? DEFAULT_DANGER_LIST;
+  for (const entry of patterns) {
+    if (matchesEntry(trimmed, entry)) return "danger";
+  }
+  for (const entry of ALLOWLIST) {
+    if (matchesEntry(trimmed, entry)) return "allow";
+  }
+  return "normal";
+}
+
 // src/tools/bash.ts
 import { exec } from "child_process";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -178,12 +217,14 @@ var BASH_TOOL = {
   }
 };
 async function handleBashTool(command, deps) {
-  const { confirm, print } = deps;
-  const cls = classifyCommand(command);
+  const { confirm, print, dangerousPatterns, autoApproveNormal } = deps;
+  const cls = classifyCommand(command, dangerousPatterns);
   if (cls === "normal") {
-    const ok = await confirm(`Execute command: ${command}
+    if (!autoApproveNormal) {
+      const ok = await confirm(`Execute command: ${command}
 Proceed? (y/n) `);
-    if (!ok) return SKIP_MESSAGE;
+      if (!ok) return SKIP_MESSAGE;
+    }
   } else if (cls === "danger") {
     print(`\u26A0\uFE0F  DANGEROUS COMMAND: ${command}`);
     const first = await confirm("Are you sure? (y/n) ");
@@ -201,107 +242,593 @@ Proceed? (y/n) `);
 [exit code: ${result.exitCode}]`;
   return output || "(no output)";
 }
-async function startRepl(config2) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const llm = createLLMClient(config2);
-  const messages = [];
-  const print = (text) => process.stdout.write(text);
-  const confirm = async (prompt) => {
-    const answer = await rl.question(prompt);
-    return answer.trim().toLowerCase() === "y";
+
+// src/logger.ts
+import * as fs from "fs";
+import * as path from "path";
+function createLogger(logDir, sessionStart) {
+  fs.mkdirSync(logDir, { recursive: true });
+  const filename = sessionStart.toISOString().replace(/:/g, "-").replace(/\..+/, "") + ".jsonl";
+  const filePath = path.join(logDir, filename);
+  return {
+    filePath,
+    append(entry) {
+      try {
+        fs.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+      } catch (err) {
+        process.stderr.write(`[logger] Failed to write log entry: ${err}
+`);
+      }
+    }
   };
-  const deps = { executeBash, confirm, print };
-  console.log('ecode \u2014 type "exit" to quit\n');
-  while (true) {
-    const input = await rl.question("you: ").catch(() => "exit");
-    const trimmed = input.trim();
-    if (trimmed === "exit" || trimmed === "quit") break;
-    if (!trimmed) continue;
-    messages.push({ role: "user", content: trimmed });
-    let continueLoop = true;
-    while (continueLoop) {
-      continueLoop = false;
-      process.stdout.write("assistant: ");
-      let assistantText = "";
-      let assistantReasoning;
-      const toolCalls = [];
-      for await (const chunk of llm.stream(messages, [BASH_TOOL])) {
-        if (chunk.text) {
-          process.stdout.write(chunk.text);
-          assistantText += chunk.text;
-        }
-        if (chunk.done) {
-          if (chunk.toolCalls) toolCalls.push(...chunk.toolCalls);
-          if (chunk.reasoning) assistantReasoning = chunk.reasoning;
+}
+
+// src/ui/StatusBar.tsx
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 80;
+function formatTokenCount(n) {
+  if (n < 1e3) return String(n);
+  return (n / 1e3).toFixed(1) + "k";
+}
+function buildStatusLabel(status, toolName, confirmPrompt) {
+  if (confirmPrompt) {
+    return `[y/n] ${confirmPrompt}`;
+  }
+  switch (status) {
+    case "thinking":
+      return "\u601D\u8003\u4E2D";
+    case "tool_calling":
+      return `\u8C03\u7528\u5DE5\u5177: ${toolName ?? ""}`;
+    case "awaiting_confirm":
+      return "\u7B49\u5F85\u786E\u8BA4";
+    case "idle":
+    default:
+      return "\u7B49\u5F85\u8F93\u5165";
+  }
+}
+function statusIcon(status, confirmPrompt) {
+  if (confirmPrompt) return "";
+  switch (status) {
+    case "thinking":
+      return "\u27F3";
+    case "tool_calling":
+      return "\u2699";
+    case "awaiting_confirm":
+    case "idle":
+    default:
+      return "\u25CE";
+  }
+}
+function StatusBar({
+  status,
+  toolName,
+  confirmPrompt,
+  version: version2,
+  tokenUsage
+}) {
+  const [spinnerIdx, setSpinnerIdx] = useState(0);
+  const isAnimating = !confirmPrompt && (status === "thinking" || status === "tool_calling");
+  useEffect(() => {
+    if (!isAnimating) return;
+    const timer = setInterval(() => {
+      setSpinnerIdx((prev) => (prev + 1) % SPINNER_FRAMES.length);
+    }, SPINNER_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, [isAnimating]);
+  const label = buildStatusLabel(status, toolName, confirmPrompt);
+  const icon = statusIcon(status, confirmPrompt);
+  const spinner = isAnimating ? SPINNER_FRAMES[spinnerIdx] : " ";
+  const usedStr = formatTokenCount(tokenUsage.used);
+  const limitStr = formatTokenCount(tokenUsage.limit);
+  const ctxStr = `ctx: ${tokenUsage.estimated ? "~" : ""}${usedStr}/${limitStr}`;
+  const versionStr = `v${version2}`;
+  return (
+    // justifyContent="space-between" 让 Ink 自动撑开左右，
+    // 避免用 string.length 手动计算填充（CJK 双宽字符会导致计算偏差）
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          spinner,
+          " "
+        ] }),
+        confirmPrompt ? (
+          // 确认模式：整体用黄色显示
+          /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+            icon,
+            label
+          ] })
+        ) : status === "thinking" || status === "tool_calling" ? (
+          // 进行中状态：icon 用绿色，文字用白色
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+              icon,
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: "white", children: label })
+          ] })
+        ) : (
+          // 空闲 / 等待确认：淡灰
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              icon,
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: label })
+          ] })
+        )
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          versionStr,
+          "  "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: tokenUsage.estimated ? "yellow" : "cyan", children: ctxStr })
+      ] })
+    ] })
+  );
+}
+
+// src/ui/ConversationHistory.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var TOOL_RESULT_MAX_LINES = 3;
+function truncateLines(text, maxLines) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return text;
+  return lines.slice(0, maxLines).join("\n") + "\n\u2026";
+}
+function UserMessage({
+  content
+}) {
+  return (
+    // 用户消息使用 ">" 前缀，白色，与助手消息对比
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "row", marginBottom: 0, children: /* @__PURE__ */ jsxs2(Text2, { color: "white", children: [
+      "> ",
+      content
+    ] }) })
+  );
+}
+function AssistantMessage({
+  content,
+  tool_calls,
+  reasoning_content,
+  expandTools
+}) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 0, children: [
+    reasoning_content && reasoning_content.length > 0 && (expandTools ? /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "<thinking>" }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: reasoning_content })
+    ] }) : /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "[+ thinking]" })),
+    content && content.trim().length > 0 && /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: content }),
+    tool_calls && tool_calls.length > 0 && (expandTools ? tool_calls.map((tc, idx) => {
+      let argsDisplay = tc.function.arguments;
+      try {
+        const parsed = JSON.parse(tc.function.arguments);
+        if (typeof parsed === "object" && parsed !== null) {
+          argsDisplay = Object.values(parsed).map(String).join(", ");
         }
+      } catch {
+      }
+      return /* @__PURE__ */ jsxs2(Text2, { color: "yellow", children: [
+        "\u2699 \u8C03\u7528\u5DE5\u5177: ",
+        tc.function.name,
+        "(",
+        argsDisplay,
+        ")"
+      ] }, idx);
+    }) : /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+      "[+ ",
+      tool_calls.length,
+      " \u4E2A\u5DE5\u5177\u8C03\u7528]"
+    ] }))
+  ] });
+}
+function ToolMessage({
+  content,
+  expandTools
+}) {
+  if (!expandTools) {
+    return /* @__PURE__ */ jsx2(Box2, { flexDirection: "row", marginBottom: 0, children: /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "[+ \u5DE5\u5177\u7ED3\u679C]" }) });
+  }
+  const truncated = truncateLines(content, TOOL_RESULT_MAX_LINES);
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "row", marginBottom: 0, children: /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+    "[\u5DE5\u5177\u7ED3\u679C] ",
+    truncated
+  ] }) });
+}
+function ConversationHistory({
+  messages,
+  maxHeight = 20,
+  expandTools = false
+}) {
+  const visible = messages.filter(
+    (m) => m.role !== "system"
+  );
+  function estimateLines(msg) {
+    if (msg.role === "user") {
+      return Math.max(1, msg.content.split("\n").length);
+    }
+    if (msg.role === "assistant") {
+      const contentLines = msg.content ? msg.content.split("\n").length : 0;
+      const toolLines = msg.tool_calls?.length ?? 0;
+      return Math.max(1, contentLines + toolLines);
+    }
+    if (msg.role === "tool") {
+      return Math.min(TOOL_RESULT_MAX_LINES, msg.content.split("\n").length) + 1;
+    }
+    return 1;
+  }
+  let totalLines = 0;
+  let startIdx = visible.length;
+  for (let i = visible.length - 1; i >= 0; i--) {
+    const lines = estimateLines(visible[i]);
+    if (totalLines + lines > maxHeight) break;
+    totalLines += lines;
+    startIdx = i;
+  }
+  const displayMessages = visible.slice(startIdx);
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: displayMessages.map((msg, idx) => {
+    if (msg.role === "user") {
+      return /* @__PURE__ */ jsx2(UserMessage, { content: msg.content }, idx);
+    }
+    if (msg.role === "assistant") {
+      const assistantMsg = msg;
+      return /* @__PURE__ */ jsx2(
+        AssistantMessage,
+        {
+          content: assistantMsg.content,
+          tool_calls: assistantMsg.tool_calls,
+          reasoning_content: assistantMsg.reasoning_content,
+          expandTools
+        },
+        idx
+      );
+    }
+    if (msg.role === "tool") {
+      return /* @__PURE__ */ jsx2(ToolMessage, { content: msg.content, expandTools }, idx);
+    }
+    return null;
+  }) });
+}
+
+// src/ui/Input.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var CURSOR_CHAR = "\u258C";
+var BLINK_INTERVAL_MS = 530;
+function Input({ isActive, onSubmit, placeholder }) {
+  const [lines, setLines] = useState2([""]);
+  const [cursorVisible, setCursorVisible] = useState2(true);
+  useEffect2(() => {
+    if (!isActive) {
+      setCursorVisible(true);
+      return;
+    }
+    const timer = setInterval(() => {
+      setCursorVisible((prev) => !prev);
+    }, BLINK_INTERVAL_MS);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [isActive]);
+  useInput(
+    (input, key) => {
+      if (key.return && key.shift) {
+        setLines((prev) => [...prev, ""]);
+        return;
       }
-      if (toolCalls.length > 0) {
-        messages.push({
-          role: "assistant",
-          content: assistantText || null,
-          tool_calls: toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: { name: tc.name, arguments: tc.arguments }
-          })),
-          ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+      if (key.return) {
+        const text = lines.join("\n");
+        onSubmit(text);
+        setLines([""]);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setLines((prev) => {
+          const next = [...prev];
+          const lastIdx = next.length - 1;
+          const lastLine = next[lastIdx];
+          if (lastLine.length > 0) {
+            next[lastIdx] = lastLine.slice(0, -1);
+            return next;
+          }
+          if (next.length > 1) {
+            return next.slice(0, -1);
+          }
+          return next;
         });
-        for (const tc of toolCalls) {
-          if (tc.name === "bash") {
-            let args;
-            try {
-              args = JSON.parse(tc.arguments);
-            } catch {
-              args = { command: "" };
-            }
-            print(`
-[bash] ${args.command}
-`);
-            const toolResult = await handleBashTool(args.command, deps);
-            print(toolResult + "\n");
-            messages.push({
-              role: "tool",
-              tool_call_id: tc.id,
-              content: toolResult
+        return;
+      }
+      if (key.ctrl || key.escape || key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.tab || key.pageUp || key.pageDown) {
+        return;
+      }
+      if (input.length > 0) {
+        setLines((prev) => {
+          const next = [...prev];
+          next[next.length - 1] = next[next.length - 1] + input;
+          return next;
+        });
+      }
+    },
+    { isActive }
+  );
+  const isEmpty = lines.every((line) => line === "");
+  const renderLines = () => {
+    if (isEmpty && placeholder) {
+      return /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "> " }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: placeholder }),
+        isActive && cursorVisible && /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: CURSOR_CHAR })
+      ] });
+    }
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: lines.map((line, idx) => {
+      const isLastLine = idx === lines.length - 1;
+      const prefix = idx === 0 ? "> " : "  ";
+      return /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: prefix }),
+        /* @__PURE__ */ jsx3(Text3, { children: line }),
+        isActive && isLastLine && cursorVisible && /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: CURSOR_CHAR })
+      ] }, idx);
+    }) });
+  };
+  return /* @__PURE__ */ jsx3(Box3, { children: isActive ? renderLines() : /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "> " }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: isEmpty ? placeholder ?? "" : lines.join(" ") })
+  ] }) });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function App({ config: config2, version: version2, autoMode: autoMode2 = false }) {
+  const [messages, setMessages] = useState3([]);
+  const [status, setStatus] = useState3("idle");
+  const [tokenUsage, setTokenUsage] = useState3({
+    used: 0,
+    estimated: true,
+    limit: 128e3
+  });
+  const [toolName, setToolName] = useState3(void 0);
+  const [confirmPrompt, setConfirmPrompt] = useState3(void 0);
+  const [expandTools, setExpandTools] = useState3(false);
+  const pendingConfirmRef = useRef(null);
+  const llmRef = useRef(createLLMClient(config2));
+  const loggerRef = useRef(null);
+  const loggedCountRef = useRef(0);
+  useEffect3(() => {
+    if (config2.logDir) {
+      loggerRef.current = createLogger(config2.logDir, /* @__PURE__ */ new Date());
+    }
+  }, []);
+  useEffect3(() => {
+    if (!loggerRef.current) return;
+    for (let i = loggedCountRef.current; i < messages.length; i++) {
+      const msg = messages[i];
+      loggerRef.current.append({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        role: msg.role,
+        content: typeof msg.content === "string" ? msg.content : null,
+        tool_call_id: "tool_call_id" in msg ? msg.tool_call_id : void 0,
+        tool_calls: "tool_calls" in msg ? msg.tool_calls : void 0
+      });
+    }
+    loggedCountRef.current = messages.length;
+  }, [messages]);
+  useInput2((_input, key) => {
+    if (key.tab) {
+      setExpandTools((prev) => !prev);
+    }
+  });
+  const confirm = useCallback((prompt) => {
+    return new Promise((resolve) => {
+      setStatus("awaiting_confirm");
+      setConfirmPrompt(prompt);
+      pendingConfirmRef.current = { resolve };
+    });
+  }, []);
+  const runLlmLoop = useCallback(
+    async (history) => {
+      const print = (_text) => {
+      };
+      const deps = {
+        executeBash,
+        confirm,
+        print,
+        dangerousPatterns: config2.dangerousPatterns,
+        autoApproveNormal: autoMode2
+      };
+      let currentMessages = history;
+      let continueLoop = true;
+      while (continueLoop) {
+        continueLoop = false;
+        setStatus("thinking");
+        let assistantText = "";
+        let assistantReasoning;
+        const toolCalls = [];
+        for await (const chunk of llmRef.current.stream(currentMessages, [BASH_TOOL])) {
+          if (chunk.text) {
+            assistantText += chunk.text;
+            setMessages((prev) => {
+              const last = prev[prev.length - 1];
+              if (last?.role === "assistant" && !last.tool_calls) {
+                return [...prev.slice(0, -1), { ...last, content: assistantText }];
+              }
+              return [...prev, { role: "assistant", content: assistantText }];
             });
           }
+          if (chunk.done) {
+            if (chunk.toolCalls) toolCalls.push(...chunk.toolCalls);
+            if (chunk.reasoning) assistantReasoning = chunk.reasoning;
+            if (chunk.usage) {
+              setTokenUsage({
+                used: chunk.usage.totalTokens,
+                estimated: false,
+                limit: 128e3
+              });
+            }
+          } else {
+            const estimatedUsed = Math.floor(
+              currentMessages.reduce(
+                (acc, m) => acc + (typeof m.content === "string" ? m.content.length : 0),
+                0
+              ) * 0.25 + assistantText.length * 0.25
+            );
+            setTokenUsage((prev) => ({ ...prev, used: estimatedUsed, estimated: true }));
+          }
         }
-        continueLoop = true;
-      } else {
-        process.stdout.write("\n");
-        if (assistantText) {
-          messages.push({
+        if (toolCalls.length > 0) {
+          const assistantMsg = {
             role: "assistant",
-            content: assistantText,
+            content: assistantText || null,
+            tool_calls: toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: { name: tc.name, arguments: tc.arguments }
+            })),
             ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+          };
+          setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            const withoutStreaming = last?.role === "assistant" && !last.tool_calls ? prev.slice(0, -1) : prev;
+            return [...withoutStreaming, assistantMsg];
           });
+          currentMessages = [...currentMessages, assistantMsg];
+          setStatus("tool_calling");
+          for (const tc of toolCalls) {
+            if (tc.name === "bash") {
+              let args;
+              try {
+                args = JSON.parse(tc.arguments);
+              } catch {
+                args = { command: "" };
+              }
+              setToolName(tc.name);
+              const toolResult = await handleBashTool(args.command, deps);
+              const toolMsg = {
+                role: "tool",
+                tool_call_id: tc.id,
+                content: toolResult
+              };
+              setMessages((prev) => [...prev, toolMsg]);
+              currentMessages = [...currentMessages, toolMsg];
+            }
+          }
+          continueLoop = true;
+        } else {
+          setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            if (last?.role === "assistant" && !last.tool_calls) {
+              const updated = {
+                role: "assistant",
+                content: assistantText,
+                ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+              };
+              return [...prev.slice(0, -1), updated];
+            }
+            return prev;
+          });
+          if (assistantText) {
+            currentMessages = [
+              ...currentMessages,
+              {
+                role: "assistant",
+                content: assistantText,
+                ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+              }
+            ];
+          }
         }
       }
-    }
-  }
-  rl.close();
-  console.log("\nBye!");
+      setStatus("idle");
+      setToolName(void 0);
+    },
+    [confirm, config2.dangerousPatterns, autoMode2]
+  );
+  const handleSubmit = useCallback(
+    (text) => {
+      const trimmed = text.trim();
+      if (status === "awaiting_confirm") {
+        const pending = pendingConfirmRef.current;
+        if (pending) {
+          pendingConfirmRef.current = null;
+          setConfirmPrompt(void 0);
+          setStatus("tool_calling");
+          pending.resolve(trimmed.toLowerCase() === "y");
+        }
+        return;
+      }
+      if (!trimmed) return;
+      const userMsg = { role: "user", content: trimmed };
+      const nextMessages = [...messages, userMsg];
+      setMessages(nextMessages);
+      runLlmLoop(nextMessages).catch((err) => {
+        setStatus("idle");
+        setToolName(void 0);
+        setMessages((prev) => [
+          ...prev,
+          { role: "assistant", content: `[error] ${String(err)}` }
+        ]);
+      });
+    },
+    [status, messages, runLlmLoop]
+  );
+  const isInputActive = status === "idle" || status === "awaiting_confirm";
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx4(ConversationHistory, { messages, expandTools }),
+    /* @__PURE__ */ jsx4(
+      StatusBar,
+      {
+        status,
+        toolName,
+        confirmPrompt,
+        version: version2,
+        tokenUsage
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      Input,
+      {
+        isActive: isInputActive,
+        onSubmit: handleSubmit,
+        placeholder: status === "awaiting_confirm" ? "y / n" : void 0
+      }
+    )
+  ] });
 }
 
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var arg = process.argv[2];
-if (arg === "-v" || arg === "--version") {
-  console.log(version);
-  process.exit(0);
+var VERSION = version;
+var rawArgs = process.argv.slice(2);
+var autoMode = false;
+var cliLogDir;
+for (let i = 0; i < rawArgs.length; i++) {
+  const arg = rawArgs[i];
+  if (arg === "-v" || arg === "--version") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (arg === "--auto") {
+    autoMode = true;
+  }
+  if (arg === "--log-dir") {
+    const next = rawArgs[i + 1];
+    if (next && !next.startsWith("-")) {
+      cliLogDir = next;
+      i++;
+    }
+  }
 }
 var config = loadConfig();
-if (!config.apiKey) {
+var finalConfig = cliLogDir ? { ...config, logDir: cliLogDir } : config;
+if (!finalConfig.apiKey) {
   console.error(
     "Error: no API key configured.\nSet ECODE_API_KEY or add apiKey to ~/.ecode/config.json"
   );
   process.exit(1);
 }
-startRepl(config).catch((err) => {
-  console.error("Fatal error:", err);
-  process.exit(1);
-});
+render(React4.createElement(App, { config: finalConfig, version: VERSION, autoMode }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhongqian97-code/ecode",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "A minimal Claude Code clone with REPL interface and bash tool calling",
   "type": "module",
   "author": "zhongqian97-code",
@@ -39,7 +39,10 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "openai": "^4.0.0"
+    "@types/react": "^19.2.14",
+    "ink": "^7.0.2",
+    "openai": "^4.0.0",
+    "react": "^19.2.5"
   },
   "devDependencies": {
     "@types/node": "^18.0.0",