deeper-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1599 @@
+// src/ui/themes/default.ts
+var defaultTheme = {
+  primary: "#00BFA5",
+  secondary: "#7C4DFF",
+  success: "#00E676",
+  warning: "#FFAB40",
+  error: "#FF5252",
+  text: "#E0E0E0",
+  dimText: "#757575",
+  border: "#424242",
+  background: "#121212",
+  cardBackground: "#1E1E1E"
+};
+
+// src/ui/themes/dark.ts
+var darkTheme = { ...defaultTheme };
+
+// src/ui/themes/light.ts
+var lightTheme = {
+  primary: "#00897B",
+  secondary: "#6200EA",
+  success: "#00C853",
+  warning: "#FF6D00",
+  error: "#D50000",
+  text: "#212121",
+  dimText: "#9E9E9E",
+  border: "#E0E0E0",
+  background: "#FAFAFA",
+  cardBackground: "#FFFFFF"
+};
+
+// src/ui/Spinner.tsx
+import { useState, useEffect } from "react";
+import { Text, Box } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner({ label, type = "braille" }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % spinnerFrames.length);
+    }, 80);
+    return () => clearInterval(timer);
+  }, []);
+  const dotsFrames = ["   ", ".  ", ".. ", "..."];
+  const frameChar = type === "dots" ? dotsFrames[frame % dotsFrames.length] : type === "line" ? ["|", "/", "-", "\\"][frame % 4] : spinnerFrames[frame];
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { color: defaultTheme.primary, children: frameChar }),
+    label ? /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      label
+    ] }) : null
+  ] });
+}
+
+// src/ui/MessageBubble.tsx
+import { Text as Text2, Box as Box2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function MessageBubble({ role, content }) {
+  const display = content ?? "";
+  const lines = display.split("\n");
+  const color = role === "user" ? defaultTheme.secondary : defaultTheme.text;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsx2(Text2, { color: role === "user" ? defaultTheme.secondary : defaultTheme.primary, bold: true, children: role === "user" ? "> " : role === "system" ? "\u2699 " : "\u25CF " }) }),
+    lines.map((line, i) => /* @__PURE__ */ jsx2(Box2, { paddingLeft: 1, children: /* @__PURE__ */ jsx2(Text2, { color, children: line || " " }) }, i))
+  ] });
+}
+
+// src/ui/ToolCallCard.tsx
+import { Text as Text3, Box as Box3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var statusConfig = {
+  pending: { icon: "\u23F3", color: defaultTheme.dimText, label: "\u7B49\u5F85\u4E2D" },
+  running: { icon: "\u{1F504}", color: defaultTheme.primary, label: "\u6267\u884C\u4E2D" },
+  completed: { icon: "\u2705", color: defaultTheme.success, label: "\u5DF2\u5B8C\u6210" },
+  failed: { icon: "\u274C", color: defaultTheme.error, label: "\u5931\u8D25" }
+};
+function summarizeArgs(args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "\u65E0\u53C2\u6570";
+  const maxLen = 60;
+  const summary = entries.map(([k, v]) => {
+    const strVal = typeof v === "string" ? v : JSON.stringify(v);
+    return `${k}: ${strVal.length > 40 ? strVal.slice(0, 40) + "..." : strVal}`;
+  }).join(", ");
+  return summary.length > maxLen ? summary.slice(0, maxLen) + "..." : summary;
+}
+function ToolCallCard({ toolName, args, result, status }) {
+  const cfg = statusConfig[status];
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: cfg.color,
+      paddingX: 1,
+      marginY: 0,
+      children: [
+        /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsx3(Text3, { color: cfg.color, children: cfg.icon }),
+          /* @__PURE__ */ jsxs3(Text3, { bold: true, color: cfg.color, children: [
+            " ",
+            toolName
+          ] }),
+          /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+            " - ",
+            cfg.label
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs3(Box3, { marginTop: 0, children: [
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u53C2\u6570: " }),
+          /* @__PURE__ */ jsx3(Text3, { children: summarizeArgs(args) })
+        ] }),
+        result && status === "completed" ? /* @__PURE__ */ jsxs3(Box3, { marginTop: 0, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u7ED3\u679C: " }),
+          /* @__PURE__ */ jsx3(Box3, { borderStyle: "single", borderColor: defaultTheme.border, paddingX: 1, children: /* @__PURE__ */ jsx3(Text3, { children: result.length > 200 ? result.slice(0, 200) + "..." : result }) })
+        ] }) : null,
+        result && status === "failed" ? /* @__PURE__ */ jsx3(Box3, { marginTop: 0, children: /* @__PURE__ */ jsxs3(Text3, { color: defaultTheme.error, children: [
+          "\u9519\u8BEF: ",
+          result
+        ] }) }) : null
+      ]
+    }
+  );
+}
+
+// src/ui/DiffView.tsx
+import { useMemo } from "react";
+import { Text as Text4, Box as Box4 } from "ink";
+import { diffLines } from "diff";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function DiffView({ filePath, oldContent, newContent }) {
+  const changes = useMemo(() => {
+    return diffLines(oldContent || "", newContent || "", {
+      ignoreWhitespace: false
+    });
+  }, [oldContent, newContent]);
+  const addedCount = changes.filter((c) => c.added).length;
+  const removedCount = changes.filter((c) => c.removed).length;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: defaultTheme.border, paddingX: 1, children: [
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, children: "\u{1F4C4} " }),
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: defaultTheme.primary, children: filePath }),
+      /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        " ",
+        /* @__PURE__ */ jsxs4(Text4, { color: defaultTheme.success, children: [
+          "+",
+          addedCount
+        ] }),
+        " / ",
+        /* @__PURE__ */ jsxs4(Text4, { color: defaultTheme.error, children: [
+          "-",
+          removedCount
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginTop: 0, children: changes.slice(0, 50).map((change, i) => {
+      if (change.added) {
+        return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: defaultTheme.success, children: [
+          "+ ",
+          change.value.trimEnd()
+        ] }) }, i);
+      }
+      if (change.removed) {
+        return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color: defaultTheme.error, children: [
+          "- ",
+          change.value.trimEnd()
+        ] }) }, i);
+      }
+      return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "  ",
+        change.value.trimEnd()
+      ] }) }, i);
+    }) }),
+    changes.length > 50 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "... \u8FD8\u6709 ",
+      changes.length - 50,
+      " \u5904\u53D8\u66F4\u672A\u663E\u793A"
+    ] }) : null
+  ] });
+}
+
+// src/ui/FilePreview.tsx
+import { Text as Text5, Box as Box5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function detectLang(path) {
+  const ext = path.split(".").pop()?.toLowerCase();
+  const map = {
+    ts: "TypeScript",
+    tsx: "TSX",
+    js: "JavaScript",
+    jsx: "JSX",
+    py: "Python",
+    rs: "Rust",
+    go: "Go",
+    java: "Java",
+    json: "JSON",
+    yaml: "YAML",
+    yml: "YAML",
+    toml: "TOML",
+    md: "Markdown",
+    html: "HTML",
+    css: "CSS",
+    scss: "SCSS",
+    sql: "SQL",
+    sh: "Shell",
+    bat: "Batch",
+    ps1: "PowerShell"
+  };
+  return map[ext || ""] || ext?.toUpperCase() || "text";
+}
+function FilePreview({ filePath, content, language, lineCount, size }) {
+  const lang = language || detectLang(filePath);
+  const lines = content ? content.split("\n").slice(0, 10) : [];
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: defaultTheme.border, paddingX: 1, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "\u{1F4C4} " }),
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: defaultTheme.primary, children: filePath }),
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        " (",
+        lang,
+        ")"
+      ] }),
+      size !== void 0 ? /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        " - ",
+        formatSize(size)
+      ] }) : null,
+      lineCount !== void 0 ? /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        " - ",
+        lineCount,
+        " \u884C"
+      ] }) : null
+    ] }),
+    content ? /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "single", borderColor: defaultTheme.border, paddingX: 1, marginTop: 0, children: [
+      lines.map((line, i) => /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+          (i + 1).toString().padStart(3, " "),
+          " \u2502 "
+        ] }),
+        /* @__PURE__ */ jsx5(Text5, { children: line.length > 100 ? line.slice(0, 100) + "..." : line })
+      ] }, i)),
+      content.split("\n").length > 10 ? /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "... \u8FD8\u6709 ",
+        content.split("\n").length - 10,
+        " \u884C"
+      ] }) : null
+    ] }) : null
+  ] });
+}
+
+// src/ui/AgentTree.tsx
+import { Text as Text6, Box as Box6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var statusIcon = {
+  idle: "\u23F8",
+  running: "\u{1F504}",
+  completed: "\u2705",
+  failed: "\u274C"
+};
+var statusColor = {
+  idle: defaultTheme.dimText,
+  running: defaultTheme.primary,
+  completed: defaultTheme.success,
+  failed: defaultTheme.error
+};
+function AgentNodeRow({
+  node,
+  depth,
+  isLast
+}) {
+  const prefix = depth === 0 ? "" : "  ".repeat(depth - 1) + (isLast ? "\u2514\u2500" : "\u251C\u2500");
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: prefix }),
+      /* @__PURE__ */ jsx6(Text6, { color: statusColor[node.status], children: statusIcon[node.status] }),
+      /* @__PURE__ */ jsxs6(Text6, { bold: true, color: statusColor[node.status], children: [
+        " ",
+        node.name
+      ] })
+    ] }),
+    node.children?.map((child, i) => /* @__PURE__ */ jsx6(
+      AgentNodeRow,
+      {
+        node: child,
+        depth: depth + 1,
+        isLast: i === (node.children?.length || 0) - 1
+      },
+      child.id
+    ))
+  ] });
+}
+function AgentTree({ agents }) {
+  const total = agents.length;
+  const running = agents.filter((a) => a.status === "running").length;
+  const completed = agents.filter((a) => a.status === "completed").length;
+  const failed = agents.filter((a) => a.status === "failed").length;
+  const countChildren = (ns) => ns.reduce((sum, n) => sum + 1 + countChildren(n.children || []), 0);
+  const totalWithChildren = countChildren(agents);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", borderStyle: "round", borderColor: defaultTheme.border, paddingX: 1, children: [
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "\u{1F916} Agent \u6811" }),
+      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        " ",
+        "[",
+        totalWithChildren,
+        " \u8282\u70B9:",
+        " ",
+        /* @__PURE__ */ jsxs6(Text6, { color: defaultTheme.success, children: [
+          completed,
+          " \u5B8C\u6210"
+        ] }),
+        running > 0 ? /* @__PURE__ */ jsxs6(Text6, { color: defaultTheme.primary, children: [
+          " ",
+          running,
+          " \u8FD0\u884C"
+        ] }) : null,
+        failed > 0 ? /* @__PURE__ */ jsxs6(Text6, { color: defaultTheme.error, children: [
+          " ",
+          failed,
+          " \u5931\u8D25"
+        ] }) : null,
+        "]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", marginTop: 0, children: agents.map((agent, i) => /* @__PURE__ */ jsx6(
+      AgentNodeRow,
+      {
+        node: agent,
+        depth: 0,
+        isLast: i === total - 1
+      },
+      agent.id
+    )) })
+  ] });
+}
+
+// src/ui/ConfirmDialog.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Text as Text7, Box as Box7, useInput } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function ConfirmDialog({ message, detail, onConfirm, onReject }) {
+  const [selected, setSelected] = useState2("reject");
+  useInput((input, key) => {
+    if (key.leftArrow || key.rightArrow) {
+      setSelected((prev) => prev === "confirm" ? "reject" : "confirm");
+    }
+    if (key.return) {
+      if (selected === "confirm") {
+        onConfirm();
+      } else {
+        onReject();
+      }
+    }
+    if (input === "y" || input === "Y") {
+      onConfirm();
+    }
+    if (input === "n" || input === "N") {
+      onReject();
+    }
+  });
+  useEffect2(() => {
+    setSelected("reject");
+  }, [message]);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "double", borderColor: defaultTheme.warning, paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsxs7(Text7, { bold: true, color: defaultTheme.warning, children: [
+      "\u26A0 ",
+      message
+    ] }) }),
+    detail ? /* @__PURE__ */ jsx7(Box7, { marginTop: 0, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: detail }) }) : null,
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx7(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(
+        Text7,
+        {
+          color: selected === "confirm" ? defaultTheme.success : defaultTheme.dimText,
+          bold: selected === "confirm",
+          children: [
+            selected === "confirm" ? "\u25B6 " : "  ",
+            "[Y] \u786E\u8BA4"
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsxs7(
+        Text7,
+        {
+          color: selected === "reject" ? defaultTheme.error : defaultTheme.dimText,
+          bold: selected === "reject",
+          children: [
+            selected === "reject" ? "\u25B6 " : "  ",
+            "[N] \u53D6\u6D88"
+          ]
+        }
+      ) })
+    ] })
+  ] });
+}
+
+// src/ui/StatusBar.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { Text as Text8, Box as Box8 } from "ink";
+
+// src/core/eventbus.ts
+import { EventEmitter } from "events";
+var Events = {
+  CONTEXT_UPDATED: "context:updated",
+  MESSAGE_SEND: "message:send",
+  MESSAGE_RECEIVED: "message:received",
+  MESSAGE_STREAMING: "message:streaming",
+  TOOL_CALL_START: "tool:call:start",
+  TOOL_CALL_END: "tool:call:end",
+  FILE_DIFF: "file:diff",
+  AGENT_TREE_UPDATED: "agent:tree:updated",
+  APP_QUIT: "app:quit",
+  APP_CLEAR: "app:clear",
+  STATUS_UPDATE: "status:update",
+  CONFIG_CHANGED: "config:changed",
+  AGENT_STATUS_CHANGE: "agent:status:change",
+  AGENT_CREATED: "agent:created",
+  AGENT_THINKING: "agent:thinking",
+  AGENT_EXECUTING: "agent:executing",
+  AGENT_WAITING: "agent:waiting",
+  AGENT_COMPLETED: "agent:completed",
+  AGENT_FAILED: "agent:failed",
+  AGENT_CANCELLED: "agent:cancelled",
+  AGENT_LOOP_ITERATION: "agent:loop:iteration",
+  AGENT_LOOP_DETECTED: "agent:loop:detected",
+  AGENT_LOOP_LIMIT: "agent:loop:limit",
+  TOOL_CALL_ERROR: "tool:call:error",
+  ORCHESTRATOR_DECOMPOSE: "orchestrator:decompose",
+  ORCHESTRATOR_DISPATCH: "orchestrator:dispatch",
+  ORCHESTRATOR_AGGREGATE: "orchestrator:aggregate",
+  SUBAGENT_START: "subagent:start",
+  SUBAGENT_TIMEOUT: "subagent:timeout",
+  SUBAGENT_COMPLETE: "subagent:complete",
+  SUBAGENT_ERROR: "subagent:error",
+  POOL_ACQUIRE: "pool:acquire",
+  POOL_RELEASE: "pool:release",
+  POOL_QUEUE: "pool:queue",
+  CONTEXT_SUMMARIZED: "context:summarized",
+  CONTEXT_TOKEN_WARNING: "context:token:warning",
+  MCP_CONNECTED: "mcp:connected",
+  MCP_ERROR: "mcp:error",
+  MCP_DISCONNECTED: "mcp:disconnected",
+  MCP_TOOLS_DISCOVERED: "mcp:tools:discovered",
+  SKILL_LOADED: "skill:loaded",
+  SKILL_EXECUTED: "skill:executed",
+  SKILL_CREATED: "skill:created",
+  SKILL_TRIGGERED: "skill:triggered"
+};
+var EventBusEvents = Events;
+var EventBus = class _EventBus extends EventEmitter {
+  static instance;
+  static getInstance() {
+    if (!_EventBus.instance) {
+      _EventBus.instance = new _EventBus();
+    }
+    return _EventBus.instance;
+  }
+  onContextUpdated(handler) {
+    this.on(EventBusEvents.CONTEXT_UPDATED, handler);
+  }
+  emitContextUpdated(payload) {
+    this.emit(EventBusEvents.CONTEXT_UPDATED, payload);
+  }
+  onMessageSend(handler) {
+    this.on(EventBusEvents.MESSAGE_SEND, handler);
+  }
+  emitMessageSend(payload) {
+    this.emit(EventBusEvents.MESSAGE_SEND, payload);
+  }
+  onMessageReceived(handler) {
+    this.on(EventBusEvents.MESSAGE_RECEIVED, handler);
+  }
+  emitMessageReceived(payload) {
+    this.emit(EventBusEvents.MESSAGE_RECEIVED, payload);
+  }
+  onMessageStreaming(handler) {
+    this.on(EventBusEvents.MESSAGE_STREAMING, handler);
+  }
+  emitMessageStreaming(payload) {
+    this.emit(EventBusEvents.MESSAGE_STREAMING, payload);
+  }
+  onToolCallStart(handler) {
+    this.on(EventBusEvents.TOOL_CALL_START, handler);
+  }
+  emitToolCallStart(payload) {
+    this.emit(EventBusEvents.TOOL_CALL_START, payload);
+  }
+  onToolCallEnd(handler) {
+    this.on(EventBusEvents.TOOL_CALL_END, handler);
+  }
+  emitToolCallEnd(payload) {
+    this.emit(EventBusEvents.TOOL_CALL_END, payload);
+  }
+  onFileDiff(handler) {
+    this.on(EventBusEvents.FILE_DIFF, handler);
+  }
+  emitFileDiff(payload) {
+    this.emit(EventBusEvents.FILE_DIFF, payload);
+  }
+  onAgentTreeUpdated(handler) {
+    this.on(EventBusEvents.AGENT_TREE_UPDATED, handler);
+  }
+  emitAgentTreeUpdated(payload) {
+    this.emit(EventBusEvents.AGENT_TREE_UPDATED, payload);
+  }
+  onAppQuit(handler) {
+    this.on(EventBusEvents.APP_QUIT, handler);
+  }
+  emitAppQuit() {
+    this.emit(EventBusEvents.APP_QUIT);
+  }
+  onAppClear(handler) {
+    this.on(EventBusEvents.APP_CLEAR, handler);
+  }
+  emitAppClear() {
+    this.emit(EventBusEvents.APP_CLEAR);
+  }
+  onStatusUpdate(handler) {
+    this.on(EventBusEvents.STATUS_UPDATE, handler);
+  }
+  emitStatusUpdate(payload) {
+    this.emit(EventBusEvents.STATUS_UPDATE, payload);
+  }
+  onConfigChanged(handler) {
+    this.on(EventBusEvents.CONFIG_CHANGED, handler);
+  }
+  emitConfigChanged(payload) {
+    this.emit(EventBusEvents.CONFIG_CHANGED, payload);
+  }
+  reset() {
+    this.removeAllListeners();
+  }
+};
+var eventbus = EventBus.getInstance();
+
+// src/ui/StatusBar.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function fmtTokens(n) {
+  return n > 1e3 ? `${(n / 1e3).toFixed(1)}K` : `${n}`;
+}
+function fmtUptime(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  return `${m}m ${s % 60}s`;
+}
+function StatusBar() {
+  const [st, setSt] = useState3({
+    modelName: "deepseek-v4-pro",
+    tokenCount: 0,
+    memoryUsage: 0,
+    uptime: 0
+  });
+  useEffect3(() => {
+    const h = (p) => setSt((prev) => ({ ...prev, ...p }));
+    eventbus.onStatusUpdate(h);
+    eventbus.onContextUpdated(h);
+    return () => {
+      eventbus.removeAllListeners();
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: st.modelName }),
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      " | Tok: ",
+      fmtTokens(st.tokenCount)
+    ] }),
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      " | Mem: ",
+      st.memoryUsage,
+      "MB"
+    ] }),
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      " | ",
+      fmtUptime(st.uptime)
+    ] }),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " | Ctrl+C \u9000\u51FA" })
+  ] });
+}
+
+// src/ui/InputBox.tsx
+import { useState as useState4, useCallback, useRef } from "react";
+import { Text as Text9, Box as Box9, useInput as useInput2 } from "ink";
+
+// src/model/types.ts
+var SLASH_COMMANDS = [
+  { command: "/help", description: "\u663E\u793A\u5E2E\u52A9\u4FE1\u606F" },
+  { command: "/clear", description: "\u6E05\u7A7A\u5BF9\u8BDD" },
+  { command: "/quit", description: "\u9000\u51FA DeeperCode" },
+  { command: "/model", description: "\u67E5\u770B/\u5207\u6362\u6A21\u578B" },
+  { command: "/config", description: "\u67E5\u770B/\u4FEE\u6539\u914D\u7F6E" },
+  { command: "/tools", description: "\u5217\u51FA\u53EF\u7528\u5DE5\u5177" },
+  { command: "/skills", description: "\u5217\u51FA\u5DF2\u52A0\u8F7D\u6280\u80FD" },
+  { command: "/mcp", description: "\u7BA1\u7406 MCP \u8FDE\u63A5" },
+  { command: "/save", description: "\u4FDD\u5B58\u5F53\u524D\u4F1A\u8BDD" },
+  { command: "/load", description: "\u52A0\u8F7D\u5386\u53F2\u4F1A\u8BDD" }
+];
+
+// src/ui/InputBox.tsx
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var MAX_HISTORY = 100;
+var history = [];
+function addHistory(content) {
+  if (content.trim() && history[history.length - 1] !== content) {
+    history.push(content);
+    if (history.length > MAX_HISTORY) {
+      history.shift();
+    }
+  }
+}
+function InputBox({ onSubmit, placeholder = "\u8F93\u5165\u6D88\u606F..." }) {
+  const [value, setValue] = useState4("");
+  const [cursorPos, setCursorPos] = useState4(0);
+  const [historyIndex, setHistoryIndex] = useState4(-1);
+  const [showConfirmExit, setShowConfirmExit] = useState4(false);
+  const [tabSuggestions, setTabSuggestions] = useState4([]);
+  const [showSuggestions, setShowSuggestions] = useState4(false);
+  const valueRef = useRef(value);
+  valueRef.current = value;
+  const handleSubmit = useCallback(() => {
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    if (trimmed.startsWith("/")) {
+      const cmd = SLASH_COMMANDS.find((c) => trimmed.startsWith(c.command));
+      if (cmd) {
+        eventbus.emitMessageSend({ content: trimmed });
+        addHistory(trimmed);
+        setValue("");
+        setCursorPos(0);
+        setHistoryIndex(-1);
+        return;
+      }
+    }
+    onSubmit(trimmed);
+    eventbus.emitMessageSend({ content: trimmed });
+    addHistory(trimmed);
+    setValue("");
+    setCursorPos(0);
+    setHistoryIndex(-1);
+  }, [value, onSubmit]);
+  const handleTabComplete = useCallback(() => {
+    if (value.startsWith("/")) {
+      const matching = SLASH_COMMANDS.filter((c) => c.command.startsWith(value)).map((c) => c.command);
+      if (matching.length === 1) {
+        setValue(matching[0] + " ");
+        setCursorPos(matching[0].length + 1);
+        setShowSuggestions(false);
+      } else if (matching.length > 1) {
+        setTabSuggestions(matching);
+        setShowSuggestions(true);
+      }
+    }
+  }, [value]);
+  useInput2((input, key) => {
+    if (showConfirmExit) {
+      if (input === "y" || input === "Y") {
+        eventbus.emitAppQuit();
+        return;
+      }
+      if (input === "n" || input === "N" || key.escape) {
+        setShowConfirmExit(false);
+        return;
+      }
+      return;
+    }
+    if (input === "") {
+      setShowConfirmExit(true);
+      return;
+    }
+    if (key.return) {
+      if (key.ctrl) {
+        handleSubmit();
+        return;
+      }
+      if (showSuggestions) {
+        setShowSuggestions(false);
+        return;
+      }
+      handleSubmit();
+      return;
+    }
+    if (key.tab) {
+      handleTabComplete();
+      return;
+    }
+    if (key.upArrow) {
+      if (showSuggestions) {
+        setShowSuggestions(false);
+        return;
+      }
+      if (history.length === 0) return;
+      const newIndex = historyIndex === -1 ? history.length - 1 : Math.max(0, historyIndex - 1);
+      setHistoryIndex(newIndex);
+      setValue(history[newIndex]);
+      setCursorPos(history[newIndex].length);
+      return;
+    }
+    if (key.downArrow) {
+      if (showSuggestions) {
+        setShowSuggestions(false);
+        return;
+      }
+      if (historyIndex === -1) return;
+      const newIndex = historyIndex + 1;
+      if (newIndex >= history.length) {
+        setHistoryIndex(-1);
+        setValue("");
+        setCursorPos(0);
+      } else {
+        setHistoryIndex(newIndex);
+        setValue(history[newIndex]);
+        setCursorPos(history[newIndex].length);
+      }
+      return;
+    }
+    if (key.escape) {
+      setShowSuggestions(false);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setShowSuggestions(false);
+      if (key.backspace) {
+        if (cursorPos > 0) {
+          const newVal = value.slice(0, cursorPos - 1) + value.slice(cursorPos);
+          setValue(newVal);
+          setCursorPos(Math.max(0, cursorPos - 1));
+        }
+      }
+      if (key.delete) {
+        if (cursorPos < value.length) {
+          const newVal = value.slice(0, cursorPos) + value.slice(cursorPos + 1);
+          setValue(newVal);
+        }
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      setCursorPos(Math.max(0, cursorPos - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursorPos(Math.min(value.length, cursorPos + 1));
+      return;
+    }
+    if (key.home) {
+      setCursorPos(0);
+      return;
+    }
+    if (key.end) {
+      setCursorPos(value.length);
+      return;
+    }
+    if (input && input.length === 1 && !key.ctrl && !key.meta) {
+      const newVal = value.slice(0, cursorPos) + input + value.slice(cursorPos);
+      setValue(newVal);
+      setCursorPos(cursorPos + 1);
+      if (newVal.startsWith("/") && newVal.length > 1) {
+        const matching = SLASH_COMMANDS.filter((c) => c.command.startsWith(newVal)).map((c) => c.command);
+        if (matching.length > 0) {
+          setTabSuggestions(matching);
+          setShowSuggestions(true);
+        } else {
+          setShowSuggestions(false);
+        }
+      } else {
+        setShowSuggestions(false);
+      }
+      return;
+    }
+  });
+  if (showConfirmExit) {
+    return /* @__PURE__ */ jsxs9(
+      Box9,
+      {
+        flexDirection: "column",
+        borderStyle: "double",
+        borderColor: defaultTheme.error,
+        paddingX: 2,
+        paddingY: 0,
+        children: [
+          /* @__PURE__ */ jsx9(Box9, { children: /* @__PURE__ */ jsx9(Text9, { bold: true, color: defaultTheme.error, children: "\u26A0 \u786E\u8BA4\u9000\u51FA DeeperCode?" }) }),
+          /* @__PURE__ */ jsx9(Box9, { marginTop: 0, children: /* @__PURE__ */ jsx9(Text9, { children: "\u6309 [Y] \u9000\u51FA  [N/ESC] \u53D6\u6D88" }) })
+        ]
+      }
+    );
+  }
+  const cursorChar = "\u2588";
+  const beforeCursor = value.slice(0, cursorPos);
+  const atCursor = value[cursorPos] || " ";
+  const afterCursor = value.slice(cursorPos + 1);
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    showSuggestions && tabSuggestions.length > 0 ? /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", borderStyle: "single", borderColor: defaultTheme.border, paddingX: 1, children: tabSuggestions.map((s) => /* @__PURE__ */ jsx9(Text9, { color: defaultTheme.primary, children: s }, s)) }) : null,
+    /* @__PURE__ */ jsxs9(
+      Box9,
+      {
+        flexDirection: "row",
+        borderStyle: "round",
+        borderColor: defaultTheme.primary,
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsx9(Text9, { color: defaultTheme.primary, bold: true, children: "\u276F " }),
+          /* @__PURE__ */ jsxs9(Box9, { children: [
+            /* @__PURE__ */ jsx9(Text9, { children: beforeCursor }),
+            /* @__PURE__ */ jsx9(Text9, { backgroundColor: defaultTheme.primary, color: defaultTheme.background, children: atCursor }),
+            /* @__PURE__ */ jsx9(Text9, { children: afterCursor }),
+            value.length === 0 ? /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: placeholder }) : null
+          ] }),
+          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: " Ctrl+Enter \u53D1\u9001" })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/ui/ChatView.tsx
+import { useEffect as useEffect4, useState as useState5, useRef as useRef2 } from "react";
+import { Text as Text10, Box as Box10, useStdin } from "ink";
+import readline from "readline";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+var HISTORY_MAX = 100;
+var history2 = [];
+var SLASH_RESULTS = {
+  "/help": "\u547D\u4EE4: /help /clear /quit /config /model /tools /export /theme",
+  "/clear": "__CLEAR__",
+  "/quit": "__QUIT__",
+  "/config": "\u6253\u5F00\u914D\u7F6E: deeper config list | deeper config set <key> <value>",
+  "/model": "\u6A21\u578B: deepseek-v4-pro / v4-flash",
+  "/tools": "105 \u4E2A\u5185\u7F6E\u5DE5\u5177\u5DF2\u5C31\u7EEA",
+  "/export": "\u5BF9\u8BDD\u5BFC\u51FA\u529F\u80FD\u5F00\u53D1\u4E2D",
+  "/theme": "\u4E3B\u9898: dark | \u5207\u6362: deeper config set theme light"
+};
+function ChatView({ initialMessages = [], apiKey, model }) {
+  const [messages, setMessages] = useState5(initialMessages);
+  const [thinking, setThinking] = useState5(false);
+  const keyRef = useRef2(apiKey);
+  const modelRef = useRef2(model || "deepseek-v4-pro");
+  keyRef.current = apiKey;
+  useEffect4(() => {
+    const onMsg = (p) => {
+      setMessages((prev) => [...prev, { ...p }]);
+    };
+    const onClear = () => {
+      setMessages([]);
+      setThinking(false);
+    };
+    eventbus.onMessageReceived(onMsg);
+    eventbus.onAppClear(onClear);
+    return () => {
+      eventbus.removeAllListeners();
+    };
+  }, []);
+  const handleSubmit = (content) => {
+    const trimmed = content.trim();
+    if (!trimmed) return;
+    if (SLASH_RESULTS[trimmed]) {
+      const r = SLASH_RESULTS[trimmed];
+      if (r === "__QUIT__") {
+        eventbus.emitAppQuit();
+        return;
+      }
+      if (r === "__CLEAR__") {
+        setMessages([]);
+        return;
+      }
+      setMessages((prev) => [...prev, { id: `s-${Date.now()}`, role: "system", content: r, timestamp: Date.now() }]);
+      return;
+    }
+    history2.push(trimmed);
+    if (history2.length > HISTORY_MAX) history2.shift();
+    const um = { id: `u-${Date.now()}`, role: "user", content: trimmed, timestamp: Date.now() };
+    setMessages((prev) => [...prev, um]);
+    eventbus.emitMessageSend({ content: trimmed });
+    const currentKey = keyRef.current || "";
+    if (!currentKey) {
+      setMessages((prev) => [...prev, {
+        id: `a-${Date.now()}`,
+        role: "system",
+        content: '\u26A0 \u672A\u914D\u7F6E API Key\u3002\n\n\u8BF7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u914D\u7F6E:\n  deeper config set apiKey "sk-\u4F60\u7684DeepSeek\u5BC6\u94A5"\n\n\u83B7\u53D6\u5BC6\u94A5: https://platform.deepseek.com',
+        timestamp: Date.now()
+      }]);
+      return;
+    }
+    setThinking(true);
+    callDeepSeek(trimmed, currentKey, modelRef.current, messages).then((responseText) => {
+      setThinking(false);
+      setMessages((prev) => [...prev, {
+        id: `a-${Date.now()}`,
+        role: "assistant",
+        content: responseText,
+        timestamp: Date.now()
+      }]);
+    }).catch((err) => {
+      setThinking(false);
+      setMessages((prev) => [...prev, {
+        id: `a-${Date.now()}`,
+        role: "system",
+        content: `\u274C API \u8BF7\u6C42\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+        timestamp: Date.now()
+      }]);
+    });
+  };
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingX: 1, children: [
+      messages.length === 0 && !thinking ? /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingY: 1, children: [
+        /* @__PURE__ */ jsxs10(Box10, { children: [
+          /* @__PURE__ */ jsx10(Text10, { bold: true, color: defaultTheme.primary, children: "DeeperCode" }),
+          /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: " \u2014 \u4E00\u53E5\u8BDD\u751F\u6210\u5B8C\u6574\u9879\u76EE" })
+        ] }),
+        /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u8F93\u5165\u4F60\u7684\u4EFB\u52A1\u6216 /help \u67E5\u770B\u547D\u4EE4" }) })
+      ] }) : null,
+      messages.map((m) => /* @__PURE__ */ jsx10(MessageBubble, { role: m.role, content: m.content, timestamp: m.timestamp }, m.id)),
+      thinking ? /* @__PURE__ */ jsx10(Box10, { marginY: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u601D\u8003\u4E2D..." }) }) : null
+    ] }),
+    /* @__PURE__ */ jsx10(InputLine, { onSubmit: handleSubmit })
+  ] });
+}
+async function callDeepSeek(prompt, apiKey, model, history3) {
+  const systemMsg = {
+    role: "system",
+    content: "\u4F60\u662F DeeperCode AI \u7F16\u7A0B\u52A9\u624B\uFF0C\u57FA\u4E8E DeepSeek-V4-Pro\u3002\u4F60\u64C5\u957F\u7F16\u5199\u4EE3\u7801\u3001\u8C03\u8BD5\u3001\u9879\u76EE\u6784\u5EFA\u548C\u6280\u672F\u95EE\u9898\u89E3\u7B54\u3002\u8BF7\u7528\u4E2D\u6587\u56DE\u590D\uFF0C\u4EE3\u7801\u4FDD\u6301\u539F\u6837\u3002"
+  };
+  const recentHistory = history3.slice(-20).map((m) => ({
+    role: m.role === "system" ? "system" : m.role,
+    content: m.content || ""
+  }));
+  const messages = [systemMsg, ...recentHistory, { role: "user", content: prompt }];
+  const response = await fetch("https://api.deepseek.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      messages,
+      stream: false,
+      max_tokens: 4096,
+      temperature: 0.7
+    })
+  });
+  if (!response.ok) {
+    const errText = await response.text().catch(() => "");
+    if (response.status === 401) throw new Error("API Key \u65E0\u6548\u6216\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u68C0\u67E5\u914D\u7F6E");
+    throw new Error(`HTTP ${response.status}: ${errText.slice(0, 200)}`);
+  }
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content || "(\u7A7A\u54CD\u5E94)";
+}
+function InputLine({ onSubmit }) {
+  const { stdin } = useStdin();
+  const [buf, setBuf] = useState5("");
+  const bufRef = useRef2("");
+  bufRef.current = buf;
+  const histIdx = useRef2(-1);
+  const cursorRef = useRef2(0);
+  useEffect4(() => {
+    if (!stdin) return;
+    readline.emitKeypressEvents(stdin);
+    const onKP = (str, key) => {
+      if (key.ctrl && key.name === "c") {
+        eventbus.emitAppQuit();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        if (bufRef.current.trim()) {
+          onSubmit(bufRef.current);
+        }
+        bufRef.current = "";
+        cursorRef.current = 0;
+        setBuf("");
+        histIdx.current = -1;
+        return;
+      }
+      if (key.name === "backspace") {
+        if (cursorRef.current > 0) {
+          const prev = bufRef.current;
+          bufRef.current = prev.slice(0, cursorRef.current - 1) + prev.slice(cursorRef.current);
+          cursorRef.current = Math.max(0, cursorRef.current - 1);
+          setBuf(bufRef.current);
+        }
+        return;
+      }
+      if (key.name === "delete") {
+        if (cursorRef.current < bufRef.current.length) {
+          const prev = bufRef.current;
+          bufRef.current = prev.slice(0, cursorRef.current) + prev.slice(cursorRef.current + 1);
+          setBuf(bufRef.current);
+        }
+        return;
+      }
+      if (key.name === "left") {
+        cursorRef.current = Math.max(0, cursorRef.current - 1);
+        return;
+      }
+      if (key.name === "right") {
+        cursorRef.current = Math.min(bufRef.current.length, cursorRef.current + 1);
+        return;
+      }
+      if (key.name === "home") {
+        cursorRef.current = 0;
+        return;
+      }
+      if (key.name === "end") {
+        cursorRef.current = bufRef.current.length;
+        return;
+      }
+      if (key.name === "up") {
+        if (history2.length === 0) return;
+        const idx = histIdx.current === -1 ? history2.length - 1 : Math.max(0, histIdx.current - 1);
+        histIdx.current = idx;
+        bufRef.current = history2[idx];
+        cursorRef.current = bufRef.current.length;
+        setBuf(bufRef.current);
+        return;
+      }
+      if (key.name === "down") {
+        if (histIdx.current === -1) return;
+        const idx = histIdx.current + 1;
+        if (idx >= history2.length) {
+          histIdx.current = -1;
+          bufRef.current = "";
+          cursorRef.current = 0;
+        } else {
+          histIdx.current = idx;
+          bufRef.current = history2[idx];
+          cursorRef.current = bufRef.current.length;
+        }
+        setBuf(bufRef.current);
+        return;
+      }
+      if (str) {
+        const prev = bufRef.current;
+        bufRef.current = prev.slice(0, cursorRef.current) + str + prev.slice(cursorRef.current);
+        cursorRef.current += str.length;
+        setBuf(bufRef.current);
+        histIdx.current = -1;
+      }
+    };
+    stdin.on("keypress", onKP);
+    return () => {
+      stdin.removeListener("keypress", onKP);
+    };
+  }, []);
+  const before = buf.slice(0, cursorRef.current);
+  const at = buf[cursorRef.current] || " ";
+  const after = buf.slice(cursorRef.current + 1);
+  return /* @__PURE__ */ jsxs10(Box10, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx10(Text10, { color: defaultTheme.primary, bold: true, children: "\u276F " }),
+    /* @__PURE__ */ jsx10(Text10, { children: before }),
+    /* @__PURE__ */ jsx10(Text10, { inverse: true, children: at }),
+    /* @__PURE__ */ jsx10(Text10, { children: after })
+  ] });
+}
+
+// src/ui/App.tsx
+import { useEffect as useEffect5, useState as useState6, useRef as useRef3 } from "react";
+import { Box as Box11 } from "ink";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function App({ apiKey, model, autoRun }) {
+  const [initialMessages, setInitialMessages] = useState6([]);
+  const startTimeRef = useRef3(Date.now());
+  useEffect5(() => {
+    const memTimer = setInterval(() => {
+      eventbus.emitStatusUpdate({
+        memoryUsage: Math.round(process.memoryUsage().heapUsed / (1024 * 1024)),
+        uptime: Date.now() - startTimeRef.current
+      });
+    }, 5e3);
+    if (autoRun) {
+      setInitialMessages([{
+        id: `auto-${Date.now()}`,
+        role: "user",
+        content: autoRun,
+        timestamp: Date.now()
+      }]);
+    }
+    return () => {
+      clearInterval(memTimer);
+      eventbus.reset();
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", width: "100%", children: [
+    /* @__PURE__ */ jsx11(
+      ChatView,
+      {
+        initialMessages,
+        apiKey,
+        model
+      }
+    ),
+    /* @__PURE__ */ jsx11(StatusBar, {})
+  ] });
+}
+
+// src/core/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join as join2 } from "path";
+import process3 from "process";
+
+// src/core/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+import process2 from "process";
+var DEEPER_VERSION = "1.0.0";
+var DEEPER_NAME = "DeeperCode";
+var DEEPER_HOME = join(process2.env.DEEPER_HOME || join(homedir(), ".deeper"));
+var DEEPER_CONFIG_FILE = join(DEEPER_HOME, "config.json");
+var DEEPER_MCP_FILE = join(DEEPER_HOME, "mcp.json");
+var DEEPER_SKILLS_DIR = join(DEEPER_HOME, "skills");
+var DEEPER_SESSIONS_DIR = join(DEEPER_HOME, "sessions");
+var DEEPER_LOGS_DIR = join(DEEPER_HOME, "logs");
+var DEEPER_MEMORY_FILE = join(DEEPER_HOME, "memory.json");
+var PROJECT_CONFIG_DIR = ".deeper";
+var PROJECT_CONFIG_FILE = join(PROJECT_CONFIG_DIR, "config.json");
+var PROJECT_SKILLS_DIR = join(PROJECT_CONFIG_DIR, "skills");
+var DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+var DEEPSEEK_DEFAULT_MODEL = "deepseek-v4-pro";
+var AGENT_MAX_SUB_AGENTS = 5;
+var CONTEXT_MAX_TOKENS = 1048576;
+var MCP_CONNECTION_TIMEOUT_MS = 1e4;
+var TOOL_CATEGORIES = [
+  "filesystem",
+  "search",
+  "shell",
+  "network",
+  "code",
+  "database",
+  "data",
+  "security",
+  "project",
+  "ai",
+  "system"
+];
+
+// src/core/config.ts
+var DEFAULT_CONFIG = {
+  model: DEEPSEEK_DEFAULT_MODEL,
+  apiKey: process3.env.DEEPSEEK_API_KEY || "",
+  baseUrl: DEEPSEEK_BASE_URL,
+  temperature: 0.7,
+  maxTokens: 8192,
+  thinkEnabled: true,
+  thinkBudget: 32e3,
+  thinkBudgetTokens: 32e3,
+  logLevel: "info",
+  maxRetries: 3,
+  timeoutMs: 12e4,
+  maxSubAgents: 5,
+  maxRecursionDepth: 2,
+  theme: "dark",
+  locale: "zh-CN",
+  mcpServers: [],
+  skills: []
+};
+var PROJECT_CONFIG_PATH = join2(process3.cwd(), PROJECT_CONFIG_FILE);
+var cachedConfig = null;
+var KEY_ALIASES = {
+  api_key: "apiKey",
+  "api-key": "apiKey",
+  base_url: "baseUrl",
+  "base-url": "baseUrl",
+  max_tokens: "maxTokens",
+  "max-tokens": "maxTokens",
+  think_enabled: "thinkEnabled",
+  "think-enabled": "thinkEnabled",
+  think_budget: "thinkBudget",
+  "think-budget": "thinkBudget",
+  log_level: "logLevel",
+  "log-level": "logLevel",
+  max_retries: "maxRetries",
+  "max-retries": "maxRetries",
+  timeout_ms: "timeoutMs",
+  "timeout-ms": "timeoutMs",
+  max_sub_agents: "maxSubAgents",
+  "max-sub-agents": "maxSubAgents",
+  max_recursion_depth: "maxRecursionDepth",
+  "max-recursion-depth": "maxRecursionDepth",
+  mcp_servers: "mcpServers",
+  "mcp-servers": "mcpServers"
+};
+function normalizeConfig(raw) {
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    const canonical = KEY_ALIASES[key] || key;
+    result[canonical] = value;
+  }
+  return result;
+}
+function loadConfig() {
+  if (cachedConfig) return cachedConfig;
+  try {
+    if (existsSync(DEEPER_CONFIG_FILE)) {
+      const raw = readFileSync(DEEPER_CONFIG_FILE, "utf-8");
+      const parsed = JSON.parse(raw);
+      cachedConfig = { ...DEFAULT_CONFIG, ...normalizeConfig(parsed) };
+    } else {
+      cachedConfig = { ...DEFAULT_CONFIG };
+    }
+  } catch {
+    cachedConfig = { ...DEFAULT_CONFIG };
+  }
+  return cachedConfig;
+}
+function saveConfig(config) {
+  if (config) cachedConfig = { ...config };
+  if (!cachedConfig) cachedConfig = { ...DEFAULT_CONFIG };
+  const dir = dirname(DEEPER_CONFIG_FILE);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(DEEPER_CONFIG_FILE, JSON.stringify(cachedConfig, null, 2), "utf-8");
+}
+function getConfig() {
+  return cachedConfig ?? loadConfig();
+}
+function updateConfig(partial) {
+  const current = getConfig();
+  cachedConfig = { ...current, ...partial };
+  saveConfig();
+  return cachedConfig;
+}
+function resetConfig() {
+  cachedConfig = { ...DEFAULT_CONFIG };
+  saveConfig();
+  return cachedConfig;
+}
+function getConfigValue(key) {
+  return getConfig()[key];
+}
+function setConfigValue(key, value) {
+  updateConfig({ [key]: value });
+}
+function getApiKey() {
+  return getConfig().apiKey || process3.env.DEEPSEEK_API_KEY || "";
+}
+function getModel() {
+  return getConfig().model;
+}
+function getBaseUrl() {
+  return getConfig().baseUrl;
+}
+
+// src/tools/tool-types.ts
+var TOOL_SAFETY_MAP = {
+  read_file: "safe",
+  list_dir: "safe",
+  glob_find: "safe",
+  file_info: "safe",
+  grep_search: "safe",
+  text_search: "safe",
+  fuzzy_find: "safe",
+  regex_find: "safe",
+  find_references: "safe",
+  find_definition: "safe",
+  symbol_search: "safe",
+  search_package: "safe",
+  search_docs: "safe",
+  codebase_search: "safe",
+  token_count: "safe",
+  system_info: "safe",
+  process_list: "safe",
+  resource_monitor: "safe",
+  log_viewer: "safe",
+  bug_scan: "safe",
+  web_fetch: "safe",
+  web_search: "safe",
+  check_url: "safe",
+  parse_html: "safe",
+  http_request: "safe",
+  watch_file: "safe",
+  batch_read: "safe",
+  create_dir: "safe",
+  json_parse: "safe",
+  csv_parse: "safe",
+  xml_parse: "safe",
+  yaml_parse: "safe",
+  toml_parse: "safe",
+  data_validate: "safe",
+  data_diff: "safe",
+  hash_generate: "safe",
+  jwt_decode: "safe",
+  coverage_report: "safe",
+  config_manage: "safe",
+  notify_user: "safe",
+  format_code: "safe",
+  lint_code: "safe",
+  type_check: "safe",
+  code_metrics: "safe",
+  analyze_deps: "safe",
+  import_organizer: "safe",
+  parse_ast: "safe",
+  db_schema: "safe",
+  context_summarize: "safe",
+  prompt_template: "safe",
+  skill_create: "safe",
+  tool_create: "safe",
+  memory_store: "safe",
+  todo_manager: "safe",
+  subagent: "safe",
+  background_terminal: "safe",
+  list_terminals: "safe",
+  read_terminal: "safe",
+  send_keys: "safe",
+  send_ctrl_keys: "safe",
+  send_text: "safe",
+  kill_terminal: "safe",
+  terminal_screenshot: "safe",
+  terminal_resize: "safe",
+  check_status: "safe",
+  stop_command: "safe",
+  download_file: "safe",
+  api_call: "safe",
+  graphql_query: "safe",
+  websocket_connect: "safe",
+  write_file: "safe",
+  edit_file: "safe",
+  delete_file: "confirm",
+  move_file: "confirm",
+  copy_file: "confirm",
+  batch_write: "safe",
+  merge_files: "confirm",
+  diff_files: "confirm",
+  run_command: "safe",
+  run_async: "safe",
+  pipe_commands: "safe",
+  shell_script: "confirm",
+  npm_manage: "confirm",
+  project_init: "confirm",
+  build_project: "confirm",
+  run_test: "confirm",
+  docker_manage: "confirm",
+  env_manage: "confirm",
+  sql_query: "confirm",
+  sql_migrate: "confirm",
+  nosql_query: "confirm",
+  db_backup: "confirm",
+  db_restore: "confirm",
+  redis_command: "confirm",
+  encrypt_file: "confirm",
+  decrypt_file: "confirm",
+  template_render: "confirm",
+  chart_generate: "confirm",
+  secret_scan: "confirm",
+  vulnerability_check: "confirm",
+  orm_generate: "confirm",
+  generate_code: "confirm",
+  refactor_code: "confirm",
+  extract_function: "confirm",
+  data_transform: "confirm",
+  proxy_request: "confirm",
+  interactive_terminal: "confirm",
+  browser_action: "confirm",
+  screenshot_page: "confirm"
+};
+
+// src/cli/bootstrap.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+async function bootstrap() {
+  const errors = [];
+  const warnings = [];
+  const nodeVersion = process.versions.node;
+  const majorVersion = parseInt(nodeVersion.split(".")[0], 10);
+  if (majorVersion < 20) {
+    errors.push(`Node.js \u7248\u672C\u8FC7\u4F4E: ${nodeVersion}\uFF0C\u9700\u8981 >= 20.0.0`);
+    return { success: false, errors, warnings, config: loadConfig() };
+  }
+  const dirs = [
+    DEEPER_HOME,
+    DEEPER_SKILLS_DIR,
+    DEEPER_SESSIONS_DIR,
+    DEEPER_LOGS_DIR
+  ];
+  for (const dir of dirs) {
+    try {
+      if (!existsSync2(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+    } catch {
+      errors.push(`\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55: ${dir}`);
+    }
+  }
+  let config;
+  try {
+    config = loadConfig();
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    errors.push(`\u914D\u7F6E\u52A0\u8F7D\u5931\u8D25: ${msg}`);
+    config = loadConfig();
+  }
+  if (!config.apiKey && !process.env.DEEPSEEK_API_KEY) {
+    warnings.push('\u672A\u8BBE\u7F6E API Key\u3002\u8BF7\u8FD0\u884C: deeper config set api_key "sk-\u4F60\u7684\u5BC6\u94A5"');
+  }
+  if (errors.length > 0) {
+    return { success: false, errors, warnings, config };
+  }
+  return { success: true, errors, warnings, config };
+}
+function checkNodeVersion() {
+  const nodeVersion = process.versions.node;
+  const majorVersion = parseInt(nodeVersion.split(".")[0], 10);
+  return majorVersion >= 20;
+}
+function getVersionInfo() {
+  return `DeeperCode v${DEEPER_VERSION} | Node.js ${process.versions.node} | ${process.platform} ${process.arch}`;
+}
+
+// src/cli/commands/chat.tsx
+import { render } from "ink";
+import { jsx as jsx12 } from "react/jsx-runtime";
+async function chat(opts = {}) {
+  const result = await bootstrap();
+  if (!result.success) {
+    for (const err of result.errors) {
+      console.error(`\u274C ${err}`);
+    }
+    process.exit(1);
+  }
+  for (const warn of result.warnings) {
+    console.warn(`\u26A0 ${warn}`);
+  }
+  const model = opts.model || result.config.model;
+  const apiKey = opts.apiKey || result.config.apiKey;
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx12(
+      App,
+      {
+        apiKey,
+        model,
+        verbose: opts.verbose,
+        autoRun: opts.autoRun
+      }
+    )
+  );
+  await waitUntilExit();
+}
+
+// src/cli/commands/run.ts
+async function run(task, opts = {}) {
+  const result = await bootstrap();
+  if (!result.success) {
+    for (const err of result.errors) {
+      console.error(`\u274C ${err}`);
+    }
+    process.exit(1);
+  }
+  if (!task) {
+    console.error('\u274C \u8BF7\u63D0\u4F9B\u4EFB\u52A1\u63CF\u8FF0\u3002\u7528\u6CD5: deeper run "\u4EFB\u52A1\u63CF\u8FF0"');
+    process.exit(1);
+  }
+  const config = opts.model || opts.apiKey ? { ...result.config, ...opts.model ? { model: opts.model } : {}, ...opts.apiKey ? { apiKey: opts.apiKey } : {} } : result.config;
+  if (!config.apiKey && !process.env.DEEPSEEK_API_KEY) {
+    console.error("\u274C \u672A\u8BBE\u7F6E API Key");
+    console.error("   \u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF DEEPSEEK_API_KEY \u6216\u4F7F\u7528 --api-key \u53C2\u6570");
+    process.exit(1);
+  }
+  console.log(`
+\u{1F680} DeeperCode \u6267\u884C\u4EFB\u52A1
+`);
+  console.log(`\u{1F4CB} \u4EFB\u52A1: ${task}`);
+  console.log(`\u{1F916} \u6A21\u578B: ${config.model}`);
+  console.log(`\u{1F517} API: ${config.baseUrl}`);
+  console.log();
+  console.log("\u23F3 \u6B63\u5728\u8FDE\u63A5 DeepSeek API...");
+  console.log();
+  try {
+    const apiKey = config.apiKey || process.env.DEEPSEEK_API_KEY || "";
+    const response = await fetch(`${config.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: config.model,
+        messages: [
+          {
+            role: "system",
+            content: "\u4F60\u662F\u4E00\u4E2A\u5F3A\u5927\u7684 AI \u7F16\u7A0B\u52A9\u624B\u3002\u8BF7\u5E2E\u52A9\u7528\u6237\u5B8C\u6210\u4EFB\u52A1\u3002"
+          },
+          {
+            role: "user",
+            content: task
+          }
+        ],
+        stream: true,
+        max_tokens: Math.max(1, Math.min(config.maxTokens || 4096, 131072))
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      console.error(`\u274C API \u8BF7\u6C42\u5931\u8D25 (${response.status}): ${text}`);
+      process.exit(1);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      console.error("\u274C \u65E0\u6CD5\u8BFB\u53D6\u54CD\u5E94\u6D41");
+      process.exit(1);
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let fullContent = "";
+    let thinkingContent = "";
+    console.log("\u{1F4DD} AI \u54CD\u5E94:\n");
+    console.log("\u2500".repeat(60));
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta;
+          if (delta?.thinking) {
+            thinkingContent += delta.thinking;
+          }
+          if (delta?.content) {
+            fullContent += delta.content;
+            process.stdout.write(delta.content);
+          }
+        } catch {
+        }
+      }
+    }
+    console.log("\n" + "\u2500".repeat(60));
+    console.log();
+    if (thinkingContent) {
+      console.log("\u{1F4AD} \u601D\u8003\u8FC7\u7A0B:");
+      console.log("\u2500".repeat(60));
+      console.log(thinkingContent.slice(0, 500));
+      if (thinkingContent.length > 500) {
+        console.log(`... (\u8FD8\u6709 ${thinkingContent.length - 500} \u5B57\u7B26)`);
+      }
+      console.log("\u2500".repeat(60));
+    }
+    const usage = `\u{1F4CA} Token: ~${fullContent.length} \u8F93\u51FA`;
+    console.log(usage);
+    console.log();
+    console.log("\u2705 \u4EFB\u52A1\u6267\u884C\u5B8C\u6210\uFF01");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`\u274C \u8BF7\u6C42\u5931\u8D25: ${msg}`);
+    process.exit(1);
+  }
+}
+export {
+  AGENT_MAX_SUB_AGENTS,
+  AgentTree,
+  App,
+  CONTEXT_MAX_TOKENS,
+  ChatView,
+  ConfirmDialog,
+  DEEPER_CONFIG_FILE,
+  DEEPER_HOME,
+  DEEPER_NAME,
+  DEEPER_VERSION,
+  DEEPSEEK_BASE_URL,
+  DEEPSEEK_DEFAULT_MODEL,
+  DiffView,
+  EventBusEvents,
+  FilePreview,
+  InputBox,
+  MCP_CONNECTION_TIMEOUT_MS,
+  MessageBubble,
+  SLASH_COMMANDS,
+  Spinner,
+  StatusBar,
+  TOOL_CATEGORIES,
+  TOOL_SAFETY_MAP,
+  ToolCallCard,
+  bootstrap,
+  chat,
+  checkNodeVersion,
+  darkTheme,
+  defaultTheme,
+  eventbus,
+  getApiKey,
+  getBaseUrl,
+  getConfig,
+  getConfigValue,
+  getModel,
+  getVersionInfo,
+  lightTheme,
+  loadConfig,
+  resetConfig,
+  run,
+  saveConfig,
+  setConfigValue,
+  updateConfig
+};
+//# sourceMappingURL=index.js.map