@aurora-foundation/obsidian-next 0.2.0

package/dist/index.js

@@ -0,0 +1,3736 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import React7 from "react";
+import { render } from "ink";
+
+// src/ui/Root.tsx
+import { useState as useState4, useEffect, useCallback as useCallback3 } from "react";
+import { Box as Box7, Text as Text7, useApp, useInput as useInput3 } from "ink";
+import TextInput from "ink-text-input";
+
+// src/core/bus.ts
+import { EventEmitter } from "events";
+var EventBus = class extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(20);
+  }
+  emitAgent(e) {
+    this.emit("agent", e);
+  }
+  emitUser(e) {
+    this.emit("user", e);
+  }
+};
+var bus = new EventBus();
+
+// src/components/AgentLine.tsx
+import React from "react";
+import { Box, Text } from "ink";
+
+// src/utils/syntax.ts
+import chalk from "chalk";
+var KEYWORDS = {
+  typescript: ["const", "let", "var", "function", "class", "interface", "type", "import", "export", "from", "return", "if", "else", "for", "while", "switch", "case", "break", "continue", "try", "catch", "throw", "async", "await", "new", "this", "super", "extends", "implements", "static", "public", "private", "protected", "readonly", "enum", "namespace", "module", "declare", "as", "is", "in", "of", "typeof", "instanceof", "void", "null", "undefined", "true", "false"],
+  javascript: ["const", "let", "var", "function", "class", "import", "export", "from", "return", "if", "else", "for", "while", "switch", "case", "break", "continue", "try", "catch", "throw", "async", "await", "new", "this", "super", "extends", "static", "typeof", "instanceof", "void", "null", "undefined", "true", "false"],
+  python: ["def", "class", "import", "from", "return", "if", "elif", "else", "for", "while", "try", "except", "finally", "with", "as", "pass", "break", "continue", "raise", "yield", "lambda", "and", "or", "not", "in", "is", "None", "True", "False", "self", "async", "await"],
+  bash: ["if", "then", "else", "elif", "fi", "for", "while", "do", "done", "case", "esac", "function", "return", "exit", "export", "local", "readonly", "declare", "echo", "cd", "ls", "rm", "cp", "mv", "mkdir", "cat", "grep", "sed", "awk", "npm", "npx", "node", "git"],
+  json: [],
+  default: ["const", "let", "var", "function", "class", "return", "if", "else", "for", "while", "import", "export", "true", "false", "null"]
+};
+var TYPES = ["string", "number", "boolean", "object", "any", "void", "never", "unknown", "Array", "Promise", "Map", "Set", "Record", "Partial", "Required", "Readonly"];
+function highlightCodeLine(line, lang) {
+  const keywords = KEYWORDS[lang] || KEYWORDS.default;
+  if (!line.trim()) return line;
+  let result = line;
+  const commentMatch = result.match(/(\/\/.*|#.*)$/);
+  if (commentMatch) {
+    const commentStart = result.indexOf(commentMatch[0]);
+    const before = result.slice(0, commentStart);
+    const comment = chalk.gray(commentMatch[0]);
+    result = before + comment;
+    line = before;
+  }
+  result = result.replace(/(["'`])(?:(?!\1)[^\\]|\\.)*\1/g, (match) => {
+    return chalk.green(match);
+  });
+  result = result.replace(/\b(\d+\.?\d*)\b/g, (match) => {
+    return chalk.yellow(match);
+  });
+  for (const kw of keywords) {
+    const regex = new RegExp(`\\b(${kw})\\b`, "g");
+    result = result.replace(regex, chalk.magenta("$1"));
+  }
+  if (lang === "typescript" || lang === "ts") {
+    for (const type of TYPES) {
+      const regex = new RegExp(`\\b(${type})\\b`, "g");
+      result = result.replace(regex, chalk.cyan("$1"));
+    }
+  }
+  result = result.replace(/\b([a-zA-Z_]\w*)\s*\(/g, (match, fn) => {
+    return chalk.blue(fn) + "(";
+  });
+  return result;
+}
+function highlightCodeBlock(code, lang = "default") {
+  const normalizedLang = lang.toLowerCase().replace("shell", "bash").replace("sh", "bash").replace("ts", "typescript").replace("js", "javascript").replace("py", "python");
+  const lines = code.split("\n");
+  return lines.map((line) => highlightCodeLine(line, normalizedLang)).join("\n");
+}
+function parseMarkdown(content) {
+  const segments = [];
+  const lines = content.split("\n");
+  let inCodeBlock = false;
+  let codeBlockLang = "";
+  let codeBlockContent = [];
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      if (inCodeBlock) {
+        segments.push({
+          type: "code",
+          content: codeBlockContent.join("\n"),
+          lang: codeBlockLang
+        });
+        codeBlockContent = [];
+        inCodeBlock = false;
+        codeBlockLang = "";
+      } else {
+        inCodeBlock = true;
+        codeBlockLang = line.slice(3).trim() || "default";
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockContent.push(line);
+      continue;
+    }
+    if (line.startsWith("#")) {
+      segments.push({ type: "heading", content: line });
+      continue;
+    }
+    if (line.match(/^\s*[-*]\s/) || line.match(/^\s*\d+\.\s/)) {
+      segments.push({ type: "list", content: line });
+      continue;
+    }
+    segments.push({ type: "text", content: line });
+  }
+  if (inCodeBlock && codeBlockContent.length > 0) {
+    segments.push({
+      type: "code",
+      content: codeBlockContent.join("\n"),
+      lang: codeBlockLang
+    });
+  }
+  return segments;
+}
+function renderMarkdown(content) {
+  const segments = parseMarkdown(content);
+  const output = [];
+  for (const seg of segments) {
+    switch (seg.type) {
+      case "code":
+        output.push(chalk.bgGray.black(" " + (seg.lang || "code") + " "));
+        const highlighted = highlightCodeBlock(seg.content, seg.lang);
+        for (const line2 of highlighted.split("\n")) {
+          output.push("  " + line2);
+        }
+        break;
+      case "heading":
+        const level = (seg.content.match(/^#+/) || [""])[0].length;
+        const text = seg.content.replace(/^#+\s*/, "");
+        if (level === 1) {
+          output.push(chalk.bold.white(text));
+        } else if (level === 2) {
+          output.push(chalk.bold.cyan(text));
+        } else {
+          output.push(chalk.bold.gray(text));
+        }
+        break;
+      case "list":
+        const listText = seg.content.replace(/^(\s*)([-*]|\d+\.)\s/, (_, indent, bullet) => {
+          return indent + chalk.cyan(bullet) + " ";
+        });
+        output.push(listText);
+        break;
+      case "text":
+        let line = seg.content;
+        line = line.replace(/`([^`]+)`/g, (_, code) => {
+          return chalk.bgGray.white(" " + code + " ");
+        });
+        line = line.replace(/\*\*([^*]+)\*\*/g, (_, text2) => {
+          return chalk.bold(text2);
+        });
+        line = line.replace(/\*([^*]+)\*/g, (_, text2) => {
+          return chalk.italic(text2);
+        });
+        output.push(line);
+        break;
+      default:
+        output.push(seg.content);
+    }
+  }
+  return output.join("\n");
+}
+
+// src/components/AgentLine.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var flareAnim = ["\xB7", "\u25AA", "\u259A", "\u2756", "\u2726", "\u2739", "\u2726", "\u25AA"];
+var isProcessingMessage = (content) => {
+  const lower = content.toLowerCase().trim();
+  if (content.length > 100) return false;
+  return lower.endsWith("...") || lower.startsWith("[safe]") || lower.startsWith("[plan]") || lower.startsWith("[auto]") || lower === "generating plan..." || lower === "executing plan...";
+};
+var AgentLine = ({ content, isStreaming }) => {
+  const isProcessing = isStreaming || isProcessingMessage(content);
+  const [frame, setFrame] = React.useState(0);
+  React.useEffect(() => {
+    if (!isProcessing) return;
+    const interval = setInterval(() => {
+      setFrame((prev) => (prev + 1) % flareAnim.length);
+    }, 100);
+    return () => clearInterval(interval);
+  }, [isProcessing]);
+  const hasMarkdown = content.includes("```") || content.includes("# ") || content.match(/^\s*[-*]\s/m) || content.includes("`");
+  const renderedContent = hasMarkdown && !isProcessing ? renderMarkdown(content) : content;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx(Box, { marginRight: 1, children: isProcessing ? /* @__PURE__ */ jsx(Text, { color: "yellow", children: flareAnim[frame] }) : /* @__PURE__ */ jsx(Text, { color: "cyan", children: "*" }) }),
+    /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexDirection: "column", children: renderedContent.split("\n").map((line, i) => /* @__PURE__ */ jsx(Text, { color: isProcessing ? "gray" : void 0, children: line }, i)) })
+  ] }) });
+};
+
+// src/components/ToolOutput.tsx
+import { useState } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var MAX_VISIBLE_LINES = 8;
+var colorizeLine = (line, isError) => {
+  if (isError) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "red", children: line });
+  }
+  if (line.match(/^\s*\d+\s*\+/) || line.startsWith("+") && !line.startsWith("+++")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "green", children: line });
+  }
+  if (line.match(/^\s*\d+\s*-/) || line.startsWith("-") && !line.startsWith("---")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "red", children: line });
+  }
+  if (line.startsWith("@@")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: line });
+  }
+  if (line.startsWith(">") || line.startsWith("$")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: line });
+  }
+  if (line.includes("success") || line.includes("Success") || line.includes("\u2713") || line.includes("Build success")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "green", children: line });
+  }
+  if (line.includes("warning") || line.includes("Warning") || line.includes("WARN")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: line });
+  }
+  if (line.includes("error") || line.includes("Error") || line.includes("ERR") || line.includes("failed")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "red", children: line });
+  }
+  if (line.match(/^[a-zA-Z].*\.(ts|js|tsx|jsx|json|md|css|html)/) || line.includes("dist/") || line.includes("src/")) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: line });
+  }
+  if (line.match(/\d+(\.\d+)?\s*(KB|MB|ms|s)\b/)) {
+    return /* @__PURE__ */ jsx2(Text2, { color: "magenta", children: line });
+  }
+  return /* @__PURE__ */ jsx2(Text2, { color: "white", children: line });
+};
+var ToolOutput = ({ tool, output, isError }) => {
+  const [expanded, setExpanded] = useState(false);
+  const lines = output.split("\n").filter((l) => l.trim());
+  const needsCollapse = lines.length > MAX_VISIBLE_LINES;
+  const visibleLines = expanded ? lines : lines.slice(0, MAX_VISIBLE_LINES);
+  const hiddenCount = lines.length - MAX_VISIBLE_LINES;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: isError ? "red" : "green", children: isError ? "  \u2717  " : "  \u23BF  " }),
+      colorizeLine(visibleLines[0] || "", isError)
+    ] }),
+    visibleLines.slice(1).map((line, i) => /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { children: "     " }),
+      colorizeLine(line, isError)
+    ] }, i)),
+    needsCollapse && !expanded && /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: "gray", dimColor: true, children: [
+      "     ... +",
+      hiddenCount,
+      " lines"
+    ] }) })
+  ] });
+};
+
+// src/components/ApprovalPrompt.tsx
+import { useState as useState2, useCallback } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var ApprovalPrompt = ({
+  requestId,
+  context: context2,
+  diff,
+  onResolve
+}) => {
+  const [resolved, setResolved] = useState2(false);
+  const handleApproval = useCallback((approved) => {
+    if (resolved) return;
+    setResolved(true);
+    bus.emitUser({
+      type: "approval_response",
+      approved,
+      requestId
+    });
+    onResolve();
+  }, [resolved, requestId, onResolve]);
+  useInput((input, key) => {
+    if (resolved) return;
+    if (input.toLowerCase() === "y" || key.return && !key.shift) {
+      handleApproval(true);
+    }
+    if (input.toLowerCase() === "n" || key.escape) {
+      handleApproval(false);
+    }
+  });
+  if (resolved) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "yellow",
+      paddingX: 1,
+      paddingY: 0,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { bold: true, color: "yellow", children: "[!] Approval Required" }) }),
+        /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { color: "white", children: context2 }) }),
+        diff && /* @__PURE__ */ jsxs3(
+          Box3,
+          {
+            flexDirection: "column",
+            borderStyle: "single",
+            borderColor: "gray",
+            paddingX: 1,
+            marginBottom: 1,
+            children: [
+              /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: "Preview:" }),
+              diff.split("\n").slice(0, 10).map((line, i) => /* @__PURE__ */ jsx3(
+                Text3,
+                {
+                  color: line.startsWith("+") ? "green" : line.startsWith("-") ? "red" : "gray",
+                  children: line
+                },
+                i
+              )),
+              diff.split("\n").length > 10 && /* @__PURE__ */ jsxs3(Text3, { color: "gray", dimColor: true, children: [
+                "... (",
+                diff.split("\n").length - 10,
+                " more lines)"
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "[Y]" }),
+          /* @__PURE__ */ jsx3(Text3, { color: "white", children: " Approve  " }),
+          /* @__PURE__ */ jsx3(Text3, { color: "red", bold: true, children: "[N]" }),
+          /* @__PURE__ */ jsx3(Text3, { color: "white", children: " Deny" })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/ChoicePrompt.tsx
+import { useState as useState3, useCallback as useCallback2 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var ChoicePrompt = ({
+  question,
+  options,
+  onResolve
+}) => {
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [resolved, setResolved] = useState3(false);
+  const handleSelect = useCallback2(() => {
+    if (resolved) return;
+    const selected = options[selectedIndex];
+    if (!selected) return;
+    setResolved(true);
+    bus.emitUser({
+      type: "user_choice",
+      selectionId: selected.id
+    });
+    onResolve();
+  }, [resolved, selectedIndex, options, onResolve]);
+  useInput2((input, key) => {
+    if (resolved) return;
+    if (key.upArrow) {
+      setSelectedIndex((prev) => prev > 0 ? prev - 1 : options.length - 1);
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => prev < options.length - 1 ? prev + 1 : 0);
+    }
+    const num = parseInt(input, 10);
+    if (num >= 1 && num <= options.length) {
+      setSelectedIndex(num - 1);
+    }
+    if (key.return) {
+      handleSelect();
+    }
+    if (key.escape) {
+      setResolved(true);
+      bus.emitUser({
+        type: "user_choice",
+        selectionId: "cancel"
+      });
+      onResolve();
+    }
+  });
+  if (resolved) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 1,
+      paddingY: 0,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "cyan", children: [
+          "[?] ",
+          question
+        ] }) }),
+        /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginBottom: 1, children: options.map((option, index) => {
+          const isSelected = index === selectedIndex;
+          return /* @__PURE__ */ jsxs4(Box4, { children: [
+            /* @__PURE__ */ jsx4(Text4, { color: isSelected ? "cyan" : "gray", children: isSelected ? ">" : " " }),
+            /* @__PURE__ */ jsxs4(Text4, { color: isSelected ? "white" : "gray", bold: isSelected, children: [
+              "[",
+              index + 1,
+              "] ",
+              option.label
+            ] })
+          ] }, option.id);
+        }) }),
+        /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { color: "gray", dimColor: true, children: "Use arrows or numbers to select, Enter to confirm, Esc to cancel" }) })
+      ]
+    }
+  );
+};
+
+// src/ui/Dashboard.tsx
+import React5 from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var flareAnim2 = ["\xB7", "\u25AA", "\u259A", "\u2756", "\u2726", "\u2739", "\u2726", "\u25AA"];
+var owlSprites = {
+  idle: `\u2590\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259C\u258C
+\u2590\u2588\u2588\u2580     \u2580\u2588\u2588\u258C
+\u2590\u2588\u2588   \u2584   \u2588\u2588\u258C
+\u2590\u2599\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u259F\u258C`,
+  blink_half: `\u2590\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259C\u258C
+\u2590\u2588\u2588\u2584     \u2584\u2588\u2588\u258C
+\u2590\u2588\u2588   \u2584   \u2588\u2588\u258C
+\u2590\u2599\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u259F\u258C`,
+  blink_full: `\u2590\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259C\u258C
+\u2590\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u258C
+\u2590\u2588\u2588\u2588\u2588\u2584\u2588\u2588\u2588\u2588\u2588\u2588\u258C
+\u2590\u2599\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u259F\u258C`,
+  suspicious: `\u2590\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259C\u258C
+\u2590\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u258C
+\u2590\u2588\u2588\u2580  \u2584  \u2580\u2588\u2588\u258C
+\u2590\u2599\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u259F\u258C`,
+  look_right: `\u2590\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259C\u258C
+\u2590\u2588\u2588\u2580      \u2590\u2588\u258C
+\u2590\u2588\u2588   \u2584   \u2590\u2588\u258C
+\u2590\u2599\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u259F\u258C`,
+  look_left: `\u2590\u259B\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u259C\u258C
+\u2590\u2588\u258C      \u2580\u2588\u2588\u258C
+\u2590\u2588\u258C   \u2584   \u2588\u2588\u258C
+\u2590\u2599\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u2584\u259F\u258C`
+};
+var Dashboard = ({
+  username = "User",
+  model = "Claude Sonnet 4.5",
+  workspace = process.cwd()
+}) => {
+  const [flareFrame, setFlareFrame] = React5.useState(0);
+  const [owlState, setOwlState] = React5.useState("idle");
+  const [columns, setColumns] = React5.useState(process.stdout.columns);
+  React5.useEffect(() => {
+    const onResize = () => setColumns(process.stdout.columns);
+    process.stdout.on("resize", onResize);
+    return () => {
+      process.stdout.off("resize", onResize);
+    };
+  }, []);
+  React5.useEffect(() => {
+    const interval = setInterval(() => {
+      setFlareFrame((prev) => (prev + 1) % flareAnim2.length);
+    }, 100);
+    return () => clearInterval(interval);
+  }, []);
+  React5.useEffect(() => {
+    let isActive = true;
+    const loop = async () => {
+      while (isActive) {
+        const delay = Math.random() * 5e3 + 3e3;
+        await new Promise((r) => setTimeout(r, delay));
+        if (!isActive) break;
+        setOwlState("blink_half");
+        await new Promise((r) => setTimeout(r, 50));
+        setOwlState("blink_full");
+        await new Promise((r) => setTimeout(r, 100));
+        setOwlState("blink_half");
+        await new Promise((r) => setTimeout(r, 50));
+        setOwlState("idle");
+      }
+    };
+    loop();
+    return () => {
+      isActive = false;
+    };
+  }, []);
+  const showRightColumn = columns >= 100;
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      borderStyle: "round",
+      borderColor: "red",
+      flexDirection: "row",
+      paddingX: 1,
+      paddingY: 0,
+      children: [
+        /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width: showRightColumn ? "60%" : "100%", paddingRight: showRightColumn ? 1 : 0, children: [
+          /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "white", children: [
+            "Welcome back, ",
+            username,
+            "!"
+          ] }) }),
+          /* @__PURE__ */ jsx5(Box5, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "red", children: owlSprites[owlState] }) }),
+          /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", alignItems: "center", children: [
+            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
+              model,
+              " ",
+              /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: flareAnim2[flareFrame] }),
+              " Obsidian Next"
+            ] }),
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: workspace })
+          ] })
+        ] }),
+        showRightColumn && /* @__PURE__ */ jsx5(Box5, { borderStyle: "single", borderTop: false, borderBottom: false, borderLeft: false, borderColor: "red", marginX: 1 }),
+        showRightColumn && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width: "40%", paddingLeft: 1, children: [
+          /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+            /* @__PURE__ */ jsx5(Text5, { bold: true, color: "red", children: "Commands" }),
+            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
+              /* @__PURE__ */ jsx5(Text5, { bold: true, children: "/help" }),
+              "  Show all commands"
+            ] }),
+            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
+              /* @__PURE__ */ jsx5(Text5, { bold: true, children: "/tool" }),
+              "  Execute tools"
+            ] }),
+            /* @__PURE__ */ jsxs5(Text5, { color: "white", children: [
+              /* @__PURE__ */ jsx5(Text5, { bold: true, children: "/clear" }),
+              " Clear history"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx5(Box5, { borderStyle: "single", borderTop: false, borderLeft: false, borderRight: false, borderColor: "red", marginBottom: 1 }),
+          /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx5(Text5, { bold: true, color: "red", children: "Quick Start" }),
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Ask me to read, edit, or" }),
+            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "run commands in your code." })
+          ] })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/ui/CommandPopup.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var COMMANDS = [
+  { name: "/help", desc: "Show available commands" },
+  { name: "/init", desc: "Initialize configuration" },
+  { name: "/config", desc: "View/edit configuration" },
+  { name: "/models", desc: "Select AI model" },
+  { name: "/mode", desc: "Set mode (auto/plan/safe)" },
+  { name: "/clear", desc: "Clear conversation" },
+  { name: "/cost", desc: "Show session cost" },
+  { name: "/usage", desc: "Show historical usage" },
+  { name: "/status", desc: "Show system status" },
+  { name: "/task", desc: "View current task" },
+  { name: "/tool", desc: "Execute tools manually" },
+  { name: "/sandbox", desc: "Toggle sandbox mode" },
+  { name: "/undo", desc: "Undo file changes" },
+  { name: "/doctor", desc: "Run diagnostics" },
+  { name: "/settings", desc: "View/edit settings" },
+  { name: "/exit", desc: "Exit the CLI" }
+];
+var CommandPopup = ({ matches, selectedIndex }) => {
+  if (matches.length === 0) return null;
+  return /* @__PURE__ */ jsx6(
+    Box6,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      marginBottom: 0,
+      width: "100%",
+      children: matches.map((cmd, i) => {
+        const isSelected = i === selectedIndex;
+        return /* @__PURE__ */ jsxs6(Box6, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs6(Text6, { color: isSelected ? "cyan" : "red", bold: isSelected, children: [
+            isSelected ? "> " : "  ",
+            cmd.name
+          ] }),
+          /* @__PURE__ */ jsx6(Text6, { color: isSelected ? "white" : "gray", children: cmd.desc })
+        ] }, cmd.name);
+      })
+    }
+  );
+};
+
+// src/core/history.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var HistoryManager = class {
+  historyPath;
+  saveTimer = null;
+  constructor(customPath) {
+    this.historyPath = customPath || path.join(os.homedir(), ".obsidian", "history.json");
+  }
+  async load() {
+    try {
+      const data = await fs.readFile(this.historyPath, "utf-8");
+      const events = JSON.parse(data);
+      return Array.isArray(events) ? events : [];
+    } catch {
+      return [];
+    }
+  }
+  async save(events) {
+    if (this.saveTimer) clearTimeout(this.saveTimer);
+    this.saveTimer = setTimeout(async () => {
+      try {
+        const dir = path.dirname(this.historyPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(this.historyPath, JSON.stringify(events, null, 2));
+      } catch (error) {
+        console.error("Failed to save history:", error);
+      }
+    }, 500);
+  }
+  async clear() {
+    if (this.saveTimer) clearTimeout(this.saveTimer);
+    try {
+      await fs.writeFile(this.historyPath, JSON.stringify([], null, 2));
+    } catch {
+    }
+  }
+};
+var history = new HistoryManager();
+
+// src/core/usage.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import os2 from "os";
+import { z } from "zod";
+var UsageSchema = z.object({
+  totalSessions: z.number().default(0),
+  totalRequests: z.number().default(0),
+  totalInputTokens: z.number().default(0),
+  totalOutputTokens: z.number().default(0),
+  totalCost: z.number().default(0)
+});
+var MODEL_PRICES = {
+  // Claude 4.5 Family (2025-2026)
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15 },
+  "claude-haiku-4-5-20251001": { input: 1, output: 5 },
+  "claude-opus-4-5-20251101": { input: 5, output: 25 },
+  // Claude 3.5 Family (backward compatibility)
+  "claude-3-5-sonnet": { input: 3, output: 15 },
+  "claude-3-5-haiku": { input: 0.25, output: 1.25 },
+  "claude-3-haiku": { input: 0.25, output: 1.25 },
+  "claude-3-opus": { input: 15, output: 75 },
+  "claude-3-sonnet": { input: 3, output: 15 }
+};
+var UsageTracker = class {
+  usagePath;
+  stats;
+  sessionCost = 0;
+  constructor(customPath) {
+    this.usagePath = customPath || path2.join(os2.homedir(), ".obsidian", "usage.json");
+    this.stats = UsageSchema.parse({});
+  }
+  async init() {
+    try {
+      const data = await fs2.readFile(this.usagePath, "utf-8");
+      this.stats = UsageSchema.parse(JSON.parse(data));
+    } catch {
+      await this.save();
+    }
+  }
+  async track(model, input, output) {
+    let prices = MODEL_PRICES[model];
+    if (!prices) {
+      const key = Object.keys(MODEL_PRICES).find((k) => model.includes(k));
+      prices = key ? MODEL_PRICES[key] : { input: 0, output: 0 };
+    }
+    const cost = input / 1e6 * prices.input + output / 1e6 * prices.output;
+    this.stats.totalRequests++;
+    this.stats.totalInputTokens += input;
+    this.stats.totalOutputTokens += output;
+    this.stats.totalCost += cost;
+    this.sessionCost += cost;
+    await this.save();
+  }
+  getSessionCost() {
+    return this.sessionCost;
+  }
+  async trackSession() {
+    this.stats.totalSessions++;
+    await this.save();
+  }
+  getStats() {
+    return this.stats;
+  }
+  async save() {
+    const dir = path2.dirname(this.usagePath);
+    await fs2.mkdir(dir, { recursive: true });
+    await fs2.writeFile(this.usagePath, JSON.stringify(this.stats, null, 2));
+  }
+};
+var usage = new UsageTracker();
+
+// src/core/config.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import os3 from "os";
+import { z as z2 } from "zod";
+import dotenv from "dotenv";
+dotenv.config();
+var ConfigSchema = z2.object({
+  apiKey: z2.string().optional(),
+  model: z2.string().default("claude-sonnet-4-5-20250929"),
+  workspaceRoot: z2.string().default(process.cwd()),
+  maxTokens: z2.number().default(8192),
+  language: z2.string().default("en")
+});
+var DEFAULT_CONFIG = {
+  model: "claude-3-5-sonnet",
+  maxTokens: 4096,
+  language: "en",
+  workspaceRoot: process.cwd()
+};
+var ConfigManager = class {
+  configPath;
+  cachedConfig = null;
+  constructor(customPath) {
+    this.configPath = customPath || path3.join(os3.homedir(), ".obsidian", "config.json");
+  }
+  async load() {
+    if (this.cachedConfig) return this.cachedConfig;
+    return this.reload();
+  }
+  async reload() {
+    let loadedConfig = DEFAULT_CONFIG;
+    try {
+      const data = await fs3.readFile(this.configPath, "utf-8");
+      const parsed = JSON.parse(data);
+      loadedConfig = { ...DEFAULT_CONFIG, ...parsed };
+    } catch {
+    }
+    const envKey = process.env.ANTHROPIC_API_KEY;
+    const finalConfig = ConfigSchema.parse({
+      ...loadedConfig,
+      apiKey: envKey || loadedConfig.apiKey
+    });
+    this.cachedConfig = finalConfig;
+    return finalConfig;
+  }
+  clearCache() {
+    this.cachedConfig = null;
+  }
+  async save(config2) {
+    const dir = path3.dirname(this.configPath);
+    await fs3.mkdir(dir, { recursive: true });
+    await fs3.writeFile(this.configPath, JSON.stringify(config2, null, 2));
+    this.clearCache();
+  }
+  async exists() {
+    try {
+      await fs3.access(this.configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getPath() {
+    return this.configPath;
+  }
+};
+var config = new ConfigManager();
+
+// src/core/context.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+
+// src/core/settings.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import { z as z3 } from "zod";
+var SETTINGS_DIR = ".obsidian";
+var SETTINGS_FILE = "settings.json";
+var SettingsSchema = z3.object({
+  // Execution mode
+  mode: z3.enum(["auto", "plan", "safe"]).default("safe"),
+  // Auto-accept settings
+  autoAccept: z3.object({
+    enabled: z3.boolean().default(false),
+    readOperations: z3.boolean().default(true),
+    safeCommands: z3.boolean().default(true)
+  }).default({}),
+  // Tool permissions
+  permissions: z3.object({
+    // Patterns always allowed without prompt: "tool:pattern"
+    allow: z3.array(z3.string()).default([]),
+    // Patterns always blocked
+    deny: z3.array(z3.string()).default([])
+  }).default({}),
+  // UI preferences
+  ui: z3.object({
+    syntaxHighlight: z3.boolean().default(true),
+    diffColors: z3.boolean().default(true),
+    showLineNumbers: z3.boolean().default(true)
+  }).default({})
+});
+var DEFAULT_SETTINGS = {
+  mode: "safe",
+  autoAccept: {
+    enabled: false,
+    readOperations: false,
+    safeCommands: false
+  },
+  permissions: {
+    allow: [],
+    // Empty - user builds their own allow list
+    deny: []
+  },
+  ui: {
+    syntaxHighlight: true,
+    diffColors: true,
+    showLineNumbers: true
+  }
+};
+var SettingsManager = class {
+  settingsPath;
+  cached = null;
+  constructor() {
+    this.settingsPath = path4.join(process.cwd(), SETTINGS_DIR, SETTINGS_FILE);
+  }
+  async load() {
+    if (this.cached) return this.cached;
+    return this.reload();
+  }
+  async reload() {
+    try {
+      const data = await fs4.readFile(this.settingsPath, "utf-8");
+      const parsed = JSON.parse(data);
+      this.cached = SettingsSchema.parse({ ...DEFAULT_SETTINGS, ...parsed });
+    } catch {
+      this.cached = DEFAULT_SETTINGS;
+      await this.save(DEFAULT_SETTINGS);
+    }
+    return this.cached;
+  }
+  /**
+   * Add a permission to the allow list (called when user approves a command)
+   */
+  async addAllowedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.allow.includes(pattern)) {
+      s.permissions.allow.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  /**
+   * Add a permission to the deny list
+   */
+  async addDeniedPermission(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    if (!s.permissions.deny.includes(pattern)) {
+      s.permissions.deny.push(pattern);
+      await this.save({ permissions: s.permissions });
+    }
+  }
+  async save(newSettings) {
+    const current = await this.load();
+    const merged = { ...current, ...newSettings };
+    if (newSettings.autoAccept) {
+      merged.autoAccept = { ...current.autoAccept, ...newSettings.autoAccept };
+    }
+    if (newSettings.permissions) {
+      merged.permissions = { ...current.permissions, ...newSettings.permissions };
+    }
+    if (newSettings.ui) {
+      merged.ui = { ...current.ui, ...newSettings.ui };
+    }
+    const validated = SettingsSchema.parse(merged);
+    const dir = path4.dirname(this.settingsPath);
+    await fs4.mkdir(dir, { recursive: true });
+    await fs4.writeFile(this.settingsPath, JSON.stringify(validated, null, 2));
+    this.cached = validated;
+  }
+  async get(key) {
+    const s = await this.load();
+    return s[key];
+  }
+  async set(key, value) {
+    await this.save({ [key]: value });
+  }
+  /**
+   * Check if a tool:command pattern is allowed
+   */
+  async isAllowed(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return false;
+      }
+    }
+    for (const allow of s.permissions.allow) {
+      if (this.matchPattern(pattern, allow)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool:command pattern is explicitly denied
+   */
+  async isDenied(tool, command) {
+    const s = await this.load();
+    const pattern = `${tool}:${command}`;
+    for (const deny of s.permissions.deny) {
+      if (this.matchPattern(pattern, deny)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Simple glob-like pattern matching
+   * Supports * as wildcard
+   */
+  matchPattern(value, pattern) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${regex}$`).test(value);
+  }
+  clearCache() {
+    this.cached = null;
+  }
+  getPath() {
+    return this.settingsPath;
+  }
+};
+var settings = new SettingsManager();
+
+// src/core/context.ts
+var CONTEXT_DIR = ".obsidian";
+var CONTEXT_FILE = "context.json";
+function generateSessionId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+function createEmptyContext() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    session_id: generateSessionId(),
+    mode: "safe",
+    current_task: null,
+    files_read: [],
+    files_modified: [],
+    working_set: [],
+    last_action: null,
+    created_at: now,
+    updated_at: now
+  };
+}
+var ContextManager = class {
+  ctx = createEmptyContext();
+  contextPath;
+  constructor() {
+    this.contextPath = path5.join(process.cwd(), CONTEXT_DIR, CONTEXT_FILE);
+  }
+  async init() {
+    const dir = path5.join(process.cwd(), CONTEXT_DIR);
+    try {
+      await fs5.mkdir(dir, { recursive: true });
+      await this.load();
+    } catch {
+      this.ctx = createEmptyContext();
+      await this.save();
+    }
+  }
+  async load() {
+    try {
+      const data = await fs5.readFile(this.contextPath, "utf-8");
+      this.ctx = JSON.parse(data);
+    } catch {
+      this.ctx = createEmptyContext();
+    }
+  }
+  async save() {
+    this.ctx.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await fs5.writeFile(this.contextPath, JSON.stringify(this.ctx, null, 2));
+  }
+  // Getters
+  get() {
+    return { ...this.ctx };
+  }
+  getMode() {
+    return this.ctx.mode;
+  }
+  async syncModeFromSettings() {
+    const s = await settings.load();
+    this.ctx.mode = s.mode;
+  }
+  getCurrentTask() {
+    return this.ctx.current_task;
+  }
+  getWorkingSet() {
+    return [...this.ctx.working_set];
+  }
+  // Setters
+  async setMode(mode) {
+    this.ctx.mode = mode;
+    await settings.set("mode", mode);
+    await this.save();
+  }
+  async setTask(task) {
+    this.ctx.current_task = task;
+    await this.save();
+  }
+  // Tracking
+  async trackRead(filePath) {
+    const normalized = path5.relative(process.cwd(), path5.resolve(filePath));
+    if (!this.ctx.files_read.includes(normalized)) {
+      this.ctx.files_read.push(normalized);
+    }
+    if (!this.ctx.working_set.includes(normalized)) {
+      this.ctx.working_set.push(normalized);
+    }
+    await this.save();
+  }
+  async trackModified(filePath) {
+    const normalized = path5.relative(process.cwd(), path5.resolve(filePath));
+    if (!this.ctx.files_modified.includes(normalized)) {
+      this.ctx.files_modified.push(normalized);
+    }
+    if (!this.ctx.working_set.includes(normalized)) {
+      this.ctx.working_set.push(normalized);
+    }
+    await this.save();
+  }
+  async setLastAction(action) {
+    this.ctx.last_action = action;
+    await this.save();
+  }
+  // Reset
+  async reset() {
+    this.ctx = createEmptyContext();
+    await this.save();
+  }
+  async clearWorkingSet() {
+    this.ctx.working_set = [];
+    await this.save();
+  }
+  // Summary for LLM
+  getSummary() {
+    const lines = [];
+    if (this.ctx.current_task) {
+      lines.push(`Task: ${this.ctx.current_task}`);
+    }
+    if (this.ctx.working_set.length > 0) {
+      lines.push(`Working set: ${this.ctx.working_set.slice(-5).join(", ")}`);
+    }
+    if (this.ctx.files_modified.length > 0) {
+      lines.push(`Modified: ${this.ctx.files_modified.slice(-3).join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+};
+var context = new ContextManager();
+
+// src/core/llm.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/core/tools.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import fs8 from "fs/promises";
+import path8 from "path";
+
+// src/core/auditor.ts
+import path6 from "path";
+import fs6 from "fs/promises";
+var BLOCKED_PATTERNS = [
+  "rm -rf /",
+  "rm -fr /",
+  ":(){:|:&};:",
+  // Fork bomb
+  "> /dev/sda",
+  // Disk overwrite
+  "mkfs",
+  "dd if=",
+  "chmod -R 777",
+  ":(){ :|:& };:",
+  "curl | sh",
+  // Pipe to shell
+  "wget | sh",
+  "curl | bash",
+  "wget | bash"
+];
+var APPROVAL_PATTERNS = [
+  { pattern: "rm -rf", reason: "Recursive delete operation" },
+  { pattern: "rm -r", reason: "Recursive delete operation" },
+  { pattern: "git push --force", reason: "Force push to remote" },
+  { pattern: "git reset --hard", reason: "Hard reset (loses changes)" },
+  { pattern: "npm publish", reason: "Publishing to npm registry" },
+  { pattern: "docker rm", reason: "Removing Docker containers" },
+  { pattern: "DROP TABLE", reason: "SQL table deletion" },
+  { pattern: "DROP DATABASE", reason: "SQL database deletion" },
+  { pattern: "truncate", reason: "Truncating data" }
+];
+var Auditor = class {
+  workspaceRoot;
+  constructor(root = process.cwd()) {
+    this.workspaceRoot = path6.resolve(root);
+  }
+  async checkCommand(command) {
+    const lowerCommand = command.toLowerCase();
+    if (BLOCKED_PATTERNS.some((p) => command.includes(p))) {
+      return {
+        approved: false,
+        reason: "Detected destructive command pattern",
+        isCritical: true
+      };
+    }
+    if (await settings.isDenied("bash", command)) {
+      return {
+        approved: false,
+        reason: "Command blocked by settings",
+        isCritical: false
+      };
+    }
+    if (await settings.isAllowed("bash", command)) {
+      return {
+        approved: true,
+        autoApproved: true
+      };
+    }
+    for (const { pattern, reason } of APPROVAL_PATTERNS) {
+      if (lowerCommand.includes(pattern.toLowerCase())) {
+        return {
+          approved: true,
+          requiresApproval: true,
+          reason
+        };
+      }
+    }
+    const s = await settings.load();
+    if (s.mode === "safe") {
+      return {
+        approved: true,
+        requiresApproval: true,
+        reason: "Safe mode requires approval for all commands"
+      };
+    }
+    return { approved: true };
+  }
+  checkPath(filePath) {
+    const resolved = path6.resolve(this.workspaceRoot, filePath);
+    if (!resolved.startsWith(this.workspaceRoot)) {
+      return { approved: false, reason: `Path outside workspace: ${filePath}`, isCritical: true };
+    }
+    return { approved: true };
+  }
+  async checkFileEdit(filePath) {
+    const pathCheck = this.checkPath(filePath);
+    if (!pathCheck.approved) return pathCheck;
+    try {
+      await fs6.access(filePath);
+      return { approved: true };
+    } catch {
+      return { approved: false, reason: `File not found: ${filePath}`, isCritical: false };
+    }
+  }
+};
+var auditor = new Auditor();
+
+// src/core/sandbox.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import os4 from "os";
+var execAsync = promisify(exec);
+var DEFAULT_SANDBOX_CONFIG = {
+  mode: "local",
+  allowedDomains: [
+    "*.github.com",
+    "*.npmjs.org",
+    "*.npmjs.com",
+    "api.anthropic.com",
+    "registry.npmjs.org"
+  ],
+  deniedDomains: [],
+  denyRead: [
+    "~/.ssh",
+    "~/.aws",
+    "~/.config/gcloud",
+    "~/.kube",
+    "~/.gnupg"
+  ],
+  allowWrite: [
+    ".",
+    // Current workspace
+    "/tmp"
+  ],
+  denyWrite: [
+    ".env",
+    ".env.*",
+    "*.key",
+    "*.pem",
+    ".git/config"
+  ]
+};
+var SandboxExecutor = class {
+  initialized = false;
+  mode = "local";
+  sandboxManager = null;
+  config = DEFAULT_SANDBOX_CONFIG;
+  /**
+   * Initialize sandbox with configuration
+   */
+  async initialize() {
+    try {
+      const cfg = await config.load();
+      this.mode = cfg.executionMode || "local";
+      this.config = {
+        ...DEFAULT_SANDBOX_CONFIG,
+        ...cfg.sandbox || {}
+      };
+      if (this.mode !== "sandbox") {
+        this.initialized = true;
+        return true;
+      }
+      try {
+        const { SandboxManager } = await import("@anthropic-ai/sandbox-runtime");
+        const runtimeConfig = {
+          network: {
+            allowedDomains: this.config.allowedDomains,
+            deniedDomains: this.config.deniedDomains
+          },
+          filesystem: {
+            denyRead: this.config.denyRead,
+            allowWrite: this.config.allowWrite,
+            denyWrite: this.config.denyWrite
+          }
+        };
+        await SandboxManager.initialize(runtimeConfig);
+        this.sandboxManager = SandboxManager;
+        this.initialized = true;
+        bus.emitAgent({
+          type: "thought",
+          content: "[SANDBOX] Initialized with OS-level isolation"
+        });
+        return true;
+      } catch (importError) {
+        bus.emitAgent({
+          type: "error",
+          message: `Sandbox runtime unavailable: ${importError.message}. Using local mode.`
+        });
+        this.mode = "local";
+        this.initialized = true;
+        return true;
+      }
+    } catch (error) {
+      bus.emitAgent({
+        type: "error",
+        message: `Sandbox initialization failed: ${error.message}`
+      });
+      return false;
+    }
+  }
+  /**
+   * Wrap a command with sandbox protection
+   */
+  async wrapCommand(command) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (this.mode === "local") {
+      return command;
+    }
+    if (this.sandboxManager) {
+      try {
+        return await this.sandboxManager.wrapWithSandbox(command);
+      } catch (error) {
+      }
+    }
+    return this.wrapWithNativeSandbox(command);
+  }
+  /**
+   * Wrap command with native OS sandbox (macOS sandbox-exec or Linux firejail)
+   */
+  async wrapWithNativeSandbox(command) {
+    const platform = os4.platform();
+    if (platform === "darwin") {
+      const profile = `
+(version 1)
+(allow default)
+(deny network*)
+(allow network-outbound (remote tcp "*:80" "*:443"))
+(deny file-read* (subpath "${os4.homedir()}/.ssh"))
+(deny file-read* (subpath "${os4.homedir()}/.aws"))
+(deny file-read* (subpath "${os4.homedir()}/.gnupg"))
+(deny file-write* (literal "${process.cwd()}/.env"))
+            `.trim();
+      const escapedCommand = command.replace(/"/g, '\\"');
+      return `sandbox-exec -p '${profile}' bash -c "${escapedCommand}"`;
+    }
+    if (platform === "linux") {
+      try {
+        await execAsync("which firejail");
+        const escapedCommand = command.replace(/'/g, "'\\''");
+        return `firejail --net=none --blacklist=~/.ssh --blacklist=~/.aws --blacklist=~/.gnupg bash -c '${escapedCommand}'`;
+      } catch {
+      }
+    }
+    return command;
+  }
+  /**
+   * Get current execution mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Set execution mode
+   */
+  async setMode(mode) {
+    this.mode = mode;
+    if (mode === "sandbox" && !this.sandboxManager) {
+      await this.initialize();
+    }
+    bus.emitAgent({
+      type: "thought",
+      content: `[SANDBOX] Execution mode set to: ${mode}`
+    });
+  }
+  /**
+   * Get current sandbox configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update sandbox configuration
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  /**
+   * Reset and cleanup sandbox resources
+   */
+  async reset() {
+    if (this.sandboxManager) {
+      try {
+        await this.sandboxManager.reset();
+      } catch {
+      }
+    }
+    this.initialized = false;
+    this.sandboxManager = null;
+  }
+  /**
+   * Check if sandbox mode is available on this system
+   */
+  async isAvailable() {
+    try {
+      await import("@anthropic-ai/sandbox-runtime");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var sandbox = new SandboxExecutor();
+
+// src/core/undo.ts
+import { PrismaClient } from "@prisma/client";
+import fs7 from "fs/promises";
+import path7 from "path";
+var UndoManager = class {
+  prisma = null;
+  sessionId = null;
+  changes = [];
+  // In-memory stack for fast access
+  dbEnabled = false;
+  async init(sessionId) {
+    this.sessionId = sessionId;
+    try {
+      this.prisma = new PrismaClient();
+      await this.prisma.$connect();
+      this.dbEnabled = true;
+      const dbChanges = await this.prisma.fileChange.findMany({
+        where: { sessionId, undone: false },
+        orderBy: { createdAt: "desc" },
+        take: 50
+      });
+      this.changes = dbChanges.map((c) => ({
+        id: c.id,
+        filePath: c.filePath,
+        operation: c.operation,
+        beforeContent: c.beforeContent,
+        afterContent: c.afterContent,
+        timestamp: c.createdAt,
+        undone: c.undone
+      }));
+    } catch {
+      this.dbEnabled = false;
+      this.changes = [];
+    }
+  }
+  async recordChange(filePath, operation, beforeContent, afterContent) {
+    const id = `chg_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const change = {
+      id,
+      filePath: path7.relative(process.cwd(), path7.resolve(filePath)),
+      operation,
+      beforeContent,
+      afterContent,
+      timestamp: /* @__PURE__ */ new Date(),
+      undone: false
+    };
+    this.changes.unshift(change);
+    if (this.dbEnabled && this.prisma && this.sessionId) {
+      try {
+        await this.prisma.fileChange.create({
+          data: {
+            id,
+            sessionId: this.sessionId,
+            filePath: change.filePath,
+            operation,
+            beforeContent,
+            afterContent
+          }
+        });
+      } catch {
+      }
+    }
+    if (this.changes.length > 100) {
+      this.changes = this.changes.slice(0, 100);
+    }
+    return id;
+  }
+  async undo(count = 1) {
+    const toUndo = this.changes.filter((c) => !c.undone).slice(0, count);
+    if (toUndo.length === 0) {
+      return { success: false, message: "Nothing to undo" };
+    }
+    const results = [];
+    for (const change of toUndo) {
+      try {
+        const fullPath = path7.resolve(process.cwd(), change.filePath);
+        switch (change.operation) {
+          case "create":
+            await fs7.unlink(fullPath);
+            results.push(`Deleted: ${change.filePath}`);
+            break;
+          case "edit":
+            if (change.beforeContent !== null) {
+              await fs7.writeFile(fullPath, change.beforeContent, "utf-8");
+              results.push(`Restored: ${change.filePath}`);
+            }
+            break;
+          case "delete":
+            if (change.beforeContent !== null) {
+              await fs7.mkdir(path7.dirname(fullPath), { recursive: true });
+              await fs7.writeFile(fullPath, change.beforeContent, "utf-8");
+              results.push(`Restored: ${change.filePath}`);
+            }
+            break;
+        }
+        change.undone = true;
+        if (this.dbEnabled && this.prisma) {
+          await this.prisma.fileChange.update({
+            where: { id: change.id },
+            data: { undone: true }
+          }).catch(() => {
+          });
+        }
+      } catch (error) {
+        results.push(`Failed: ${change.filePath} - ${error.message}`);
+      }
+    }
+    return {
+      success: true,
+      message: results.join("\n")
+    };
+  }
+  getHistory(limit = 10) {
+    return this.changes.filter((c) => !c.undone).slice(0, limit);
+  }
+  async close() {
+    if (this.prisma) {
+      await this.prisma.$disconnect();
+    }
+  }
+};
+var undo = new UndoManager();
+
+// src/core/tools.ts
+var execAsync2 = promisify2(exec2);
+var MAX_OUTPUT_LENGTH = 1e4;
+var MAX_FILE_READ_LINES = 500;
+var IGNORED_DIRS = ["node_modules", ".git", "dist", ".next", "__pycache__", ".cache", "coverage"];
+var APPROVAL_TIMEOUT = 3e4;
+function truncateOutput(output, maxLength = MAX_OUTPUT_LENGTH) {
+  if (output.length <= maxLength) return output;
+  const truncated = output.slice(0, maxLength);
+  const remaining = output.length - maxLength;
+  return `${truncated}
+
+... [TRUNCATED: ${remaining} more characters]`;
+}
+var pendingApprovals = /* @__PURE__ */ new Map();
+bus.on("user", (event) => {
+  if (event.type === "approval_response") {
+    const pending = pendingApprovals.get(event.requestId);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      pendingApprovals.delete(event.requestId);
+      pending.resolve(event.approved);
+    }
+  }
+});
+async function requestApproval(command, reason) {
+  const requestId = `approval_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      pendingApprovals.delete(requestId);
+      bus.emitAgent({
+        type: "error",
+        message: "Approval request timed out. Command denied."
+      });
+      resolve(false);
+    }, APPROVAL_TIMEOUT);
+    pendingApprovals.set(requestId, { resolve, timeout });
+    bus.emitAgent({
+      type: "approval_request",
+      requestId,
+      context: `Command: ${command}
+Reason: ${reason}`
+    });
+  });
+}
+var BashTool = {
+  name: "bash",
+  description: "Execute shell commands in the workspace",
+  async execute(args) {
+    const command = args.command;
+    if (!command) {
+      return { success: false, error: "No command provided" };
+    }
+    const audit = await auditor.checkCommand(command);
+    if (!audit.approved) {
+      return {
+        success: false,
+        error: `Security violation: ${audit.reason}`
+      };
+    }
+    if (audit.requiresApproval && !audit.autoApproved) {
+      const approved = await requestApproval(command, audit.reason || "Potentially dangerous operation");
+      if (!approved) {
+        await settings.addDeniedPermission("bash", command);
+        return {
+          success: false,
+          error: "Command rejected by user"
+        };
+      }
+      await settings.addAllowedPermission("bash", command);
+    }
+    try {
+      const execCommand = await sandbox.wrapCommand(command);
+      const { stdout, stderr } = await execAsync2(execCommand, {
+        cwd: process.cwd(),
+        timeout: 3e4,
+        // 30 second timeout
+        maxBuffer: 1024 * 1024
+        // 1MB buffer (reduced from 10MB)
+      });
+      const output = stdout || stderr || "Command executed successfully";
+      return {
+        success: true,
+        output: truncateOutput(output)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "Command execution failed"
+      };
+    }
+  }
+};
+var ReadTool = {
+  name: "read",
+  description: "Read file contents from the workspace",
+  async execute(args) {
+    const filePath = args.path;
+    if (!filePath) {
+      return { success: false, error: "No file path provided" };
+    }
+    const pathCheck = auditor.checkPath(filePath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    if (IGNORED_DIRS.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`))) {
+      return {
+        success: false,
+        error: `Cannot read from ignored directory. Paths containing ${IGNORED_DIRS.join(", ")} are blocked to prevent context explosion.`
+      };
+    }
+    try {
+      const fullPath = path8.resolve(process.cwd(), filePath);
+      const content = await fs8.readFile(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const limitedLines = lines.slice(0, MAX_FILE_READ_LINES);
+      const numbered = limitedLines.map((line, i) => `${String(i + 1).padStart(4)} | ${line}`).join("\n");
+      const truncationNote = lines.length > MAX_FILE_READ_LINES ? `
+
+... [TRUNCATED: ${lines.length - MAX_FILE_READ_LINES} more lines. Use offset parameter to read more.]` : "";
+      await context.trackRead(filePath);
+      return {
+        success: true,
+        output: truncateOutput(`File: ${filePath} (${lines.length} lines)
+${"=".repeat(60)}
+${numbered}${truncationNote}`)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to read file: ${error.message}`
+      };
+    }
+  }
+};
+var WriteTool = {
+  name: "write",
+  description: "Create new files in the workspace",
+  async execute(args) {
+    const filePath = args.path;
+    const content = args.content;
+    if (!filePath) {
+      return { success: false, error: "No file path provided" };
+    }
+    if (content === void 0) {
+      return { success: false, error: "No content provided" };
+    }
+    const pathCheck = auditor.checkPath(filePath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    try {
+      const fullPath = path8.resolve(process.cwd(), filePath);
+      try {
+        await fs8.access(fullPath);
+        return {
+          success: false,
+          error: `File already exists: ${filePath}. Use 'edit' tool to modify.`
+        };
+      } catch {
+      }
+      await fs8.mkdir(path8.dirname(fullPath), { recursive: true });
+      await fs8.writeFile(fullPath, content, "utf-8");
+      await context.trackModified(filePath);
+      await undo.recordChange(filePath, "create", null, content);
+      return {
+        success: true,
+        output: `Created file: ${filePath} (${content.length} bytes)`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to write file: ${error.message}`
+      };
+    }
+  }
+};
+var EditTool = {
+  name: "edit",
+  description: "Edit existing files using search and replace",
+  async execute(args) {
+    const filePath = args.path;
+    const search = args.search;
+    const replace = args.replace;
+    if (!filePath) {
+      return { success: false, error: "No file path provided" };
+    }
+    if (!search) {
+      return { success: false, error: "No search string provided" };
+    }
+    if (replace === void 0) {
+      return { success: false, error: "No replacement string provided" };
+    }
+    const fileCheck = await auditor.checkFileEdit(filePath);
+    if (!fileCheck.approved) {
+      return {
+        success: false,
+        error: fileCheck.reason
+      };
+    }
+    try {
+      const fullPath = path8.resolve(process.cwd(), filePath);
+      const original = await fs8.readFile(fullPath, "utf-8");
+      if (!original.includes(search)) {
+        return {
+          success: false,
+          error: `Search string not found in ${filePath}`
+        };
+      }
+      const modified = original.replace(search, replace);
+      const diffPreview = generateDiffPreview(search, replace);
+      await fs8.writeFile(fullPath, modified, "utf-8");
+      const originalLines = original.split("\n").length;
+      const modifiedLines = modified.split("\n").length;
+      const delta = modifiedLines - originalLines;
+      await context.trackModified(filePath);
+      await undo.recordChange(filePath, "edit", original, modified);
+      return {
+        success: true,
+        output: `Edited ${filePath}:
+${diffPreview}
+Lines: ${originalLines} -> ${modifiedLines} (${delta >= 0 ? "+" : ""}${delta})`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to edit file: ${error.message}`
+      };
+    }
+  }
+};
+function generateDiffPreview(search, replace) {
+  const searchLines = search.split("\n").slice(0, 5);
+  const replaceLines = replace.split("\n").slice(0, 5);
+  let preview = "";
+  for (const line of searchLines) {
+    preview += `- ${line}
+`;
+  }
+  if (search.split("\n").length > 5) {
+    preview += `- ... (${search.split("\n").length - 5} more lines)
+`;
+  }
+  for (const line of replaceLines) {
+    preview += `+ ${line}
+`;
+  }
+  if (replace.split("\n").length > 5) {
+    preview += `+ ... (${replace.split("\n").length - 5} more lines)
+`;
+  }
+  return preview.trim();
+}
+var ListTool = {
+  name: "list",
+  description: "List files and directories in the workspace",
+  async execute(args) {
+    const dirPath = args.path || ".";
+    const pathCheck = auditor.checkPath(dirPath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    try {
+      const fullPath = path8.resolve(process.cwd(), dirPath);
+      const entries = await fs8.readdir(fullPath, { withFileTypes: true });
+      const filtered = entries.filter(
+        (entry) => !IGNORED_DIRS.includes(entry.name) && !entry.name.startsWith(".")
+      );
+      const formatted = filtered.map((entry) => {
+        const prefix = entry.isDirectory() ? "[DIR]" : "[FILE]";
+        return `${prefix} ${entry.name}`;
+      }).join("\n");
+      const hiddenCount = entries.length - filtered.length;
+      const hiddenNote = hiddenCount > 0 ? `
+
+(${hiddenCount} hidden: node_modules, .git, etc.)` : "";
+      return {
+        success: true,
+        output: `Directory: ${dirPath}
+${"=".repeat(60)}
+${formatted}${hiddenNote}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to list directory: ${error.message}`
+      };
+    }
+  }
+};
+var GrepTool = {
+  name: "grep",
+  description: "Search for patterns in files using regex",
+  async execute(args) {
+    const pattern = args.pattern;
+    const searchPath = args.path || ".";
+    const maxResults = args.limit || 50;
+    if (!pattern) {
+      return { success: false, error: "No search pattern provided" };
+    }
+    const pathCheck = auditor.checkPath(searchPath);
+    if (!pathCheck.approved) {
+      return {
+        success: false,
+        error: pathCheck.reason
+      };
+    }
+    try {
+      const fullPath = path8.resolve(process.cwd(), searchPath);
+      const results = [];
+      await searchDirectory(fullPath, pattern, results, maxResults);
+      if (results.length === 0) {
+        return {
+          success: true,
+          output: `No matches found for: ${pattern}`
+        };
+      }
+      return {
+        success: true,
+        output: truncateOutput(`Found ${results.length} matches for "${pattern}":
+${"=".repeat(60)}
+${results.join("\n")}`)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Search failed: ${error.message}`
+      };
+    }
+  }
+};
+async function searchDirectory(dir, pattern, results, maxResults, depth = 0) {
+  if (results.length >= maxResults || depth > 10) return;
+  try {
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
+    const regex = new RegExp(pattern, "gi");
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      const fullPath = path8.join(dir, entry.name);
+      const relativePath = path8.relative(process.cwd(), fullPath);
+      if (entry.name.startsWith(".") || IGNORED_DIRS.includes(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await searchDirectory(fullPath, pattern, results, maxResults, depth + 1);
+      } else if (entry.isFile()) {
+        const ext = path8.extname(entry.name).toLowerCase();
+        const textExtensions = [".ts", ".tsx", ".js", ".jsx", ".json", ".md", ".txt", ".yaml", ".yml", ".css", ".html", ".sh"];
+        if (textExtensions.includes(ext) || ext === "") {
+          try {
+            const content = await fs8.readFile(fullPath, "utf-8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+              if (regex.test(lines[i])) {
+                results.push(`${relativePath}:${i + 1}: ${lines[i].trim().slice(0, 100)}`);
+              }
+              regex.lastIndex = 0;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+}
+var GlobTool = {
+  name: "glob",
+  description: "Find files matching a glob pattern (e.g., **/*.ts, src/**/*.tsx)",
+  async execute(args) {
+    const pattern = args.pattern;
+    const basePath = args.path || ".";
+    if (!pattern) {
+      return { success: false, error: "No pattern provided" };
+    }
+    try {
+      const results = [];
+      const fullBase = path8.resolve(process.cwd(), basePath);
+      await globSearch(fullBase, pattern, results, 100);
+      if (results.length === 0) {
+        return {
+          success: true,
+          output: `No files matching: ${pattern}`
+        };
+      }
+      return {
+        success: true,
+        output: truncateOutput(`Found ${results.length} files:
+${results.join("\n")}`)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Glob failed: ${error.message}`
+      };
+    }
+  }
+};
+async function globSearch(dir, pattern, results, maxResults, depth = 0) {
+  if (results.length >= maxResults || depth > 15) return;
+  try {
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
+    const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/{{GLOBSTAR}}/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      if (entry.name.startsWith(".") || IGNORED_DIRS.includes(entry.name)) {
+        continue;
+      }
+      const fullPath = path8.join(dir, entry.name);
+      const relativePath = path8.relative(process.cwd(), fullPath);
+      if (entry.isDirectory()) {
+        if (pattern.includes("**") || pattern.includes("/")) {
+          await globSearch(fullPath, pattern, results, maxResults, depth + 1);
+        }
+      } else if (entry.isFile()) {
+        if (regex.test(relativePath) || regex.test(entry.name)) {
+          results.push(relativePath);
+        }
+      }
+    }
+  } catch {
+  }
+}
+var WebFetchTool = {
+  name: "web_fetch",
+  description: "Fetch content from a URL (for documentation, APIs, etc.)",
+  async execute(args) {
+    const url = args.url;
+    if (!url) {
+      return { success: false, error: "No URL provided" };
+    }
+    try {
+      new URL(url);
+    } catch {
+      return { success: false, error: "Invalid URL format" };
+    }
+    const blockedDomains = ["localhost", "127.0.0.1", "0.0.0.0", "169.254"];
+    const urlObj = new URL(url);
+    if (blockedDomains.some((d) => urlObj.hostname.includes(d))) {
+      return {
+        success: false,
+        error: "Cannot fetch from local/private addresses"
+      };
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 1e4);
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "Obsidian-Next/1.0 (AI Agent CLI)",
+          "Accept": "text/html,application/json,text/plain,*/*"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const contentType = response.headers.get("content-type") || "";
+      let content = await response.text();
+      if (content.length > MAX_OUTPUT_LENGTH) {
+        content = content.slice(0, MAX_OUTPUT_LENGTH) + `
+
+... [TRUNCATED: ${content.length - MAX_OUTPUT_LENGTH} more characters]`;
+      }
+      if (contentType.includes("text/html")) {
+        content = content.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      }
+      return {
+        success: true,
+        output: truncateOutput(`URL: ${url}
+Content-Type: ${contentType}
+${"=".repeat(60)}
+${content}`)
+      };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        return { success: false, error: "Request timed out after 10 seconds" };
+      }
+      return {
+        success: false,
+        error: `Fetch failed: ${error.message}`
+      };
+    }
+  }
+};
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register(BashTool);
+    this.register(ReadTool);
+    this.register(WriteTool);
+    this.register(EditTool);
+    this.register(ListTool);
+    this.register(GrepTool);
+    this.register(GlobTool);
+    this.register(WebFetchTool);
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  async execute(name, args) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        success: false,
+        error: `Unknown tool: ${name}`
+      };
+    }
+    bus.emitAgent({
+      type: "tool_start",
+      tool: name,
+      args: JSON.stringify(args, null, 2)
+    });
+    const result = await tool.execute(args);
+    bus.emitAgent({
+      type: "tool_result",
+      tool: name,
+      output: result.success ? result.output || "Success" : result.error || "Failed",
+      isError: !result.success
+    });
+    return result;
+  }
+};
+var tools = new ToolRegistry();
+
+// src/core/llm.ts
+var MAX_TOOL_ITERATIONS = 10;
+var LLMClient = class {
+  client = null;
+  lastConfig = null;
+  conversationHistory = [];
+  toolIterations = 0;
+  accumulatedInputTokens = 0;
+  accumulatedOutputTokens = 0;
+  async initialize() {
+    const cfg = await config.load();
+    await usage.init();
+    if (!cfg.apiKey) {
+      bus.emitAgent({
+        type: "error",
+        message: "Missing ANTHROPIC_API_KEY. Please set it in .env or via /init."
+      });
+      return false;
+    }
+    this.client = new Anthropic({
+      apiKey: cfg.apiKey
+    });
+    this.lastConfig = cfg;
+    return true;
+  }
+  async streamChat(userMessage) {
+    if (!this.client) {
+      const initialized = await this.initialize();
+      if (!initialized || !this.client) return null;
+    }
+    try {
+      const modelMap = {
+        // New 4.5 Aliases
+        "claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
+        "claude-haiku-4-5": "claude-haiku-4-5-20251001",
+        "claude-opus-4-5": "claude-opus-4-5-20251101",
+        "ollama": "llama3"
+      };
+      const requestedModel = this.lastConfig?.model || "claude-sonnet-4-5-20250929";
+      let apiModel = modelMap[requestedModel] || requestedModel;
+      if (userMessage.trim()) {
+        this.toolIterations = 0;
+        this.accumulatedInputTokens = 0;
+        this.accumulatedOutputTokens = 0;
+        this.conversationHistory.push({
+          role: "user",
+          content: userMessage
+        });
+      } else {
+        this.toolIterations++;
+        if (this.toolIterations > MAX_TOOL_ITERATIONS) {
+          bus.emitAgent({
+            type: "error",
+            message: `Tool iteration limit (${MAX_TOOL_ITERATIONS}) exceeded. Stopping to prevent infinite loop.`
+          });
+          return null;
+        }
+      }
+      const toolDefinitions = tools.list().map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: {
+          type: "object",
+          properties: this.getToolSchema(tool.name),
+          required: this.getRequiredParams(tool.name)
+        }
+      }));
+      const toolList = tools.list().map((t) => `- ${t.name}: ${t.description}`).join("\n");
+      const systemPrompt = `You are a CLI coding agent. You have tools. Use them.
+
+Available: ${tools.list().map((t) => t.name).join(", ")}
+
+- Dont explain. Just do it.
+- No markdown. No ** or \` or #. Plain text.
+- Read files before editing.
+- Grep to find code. Read to understand. Edit to change.
+- One thought, then act. No preamble.
+- If asked to do something, do it. Dont ask for confirmation.
+- Errors: fix them, dont apologize.
+- Never read node_modules or .git.
+
+cwd: ${process.cwd()}`;
+      const createMessage = async (model) => {
+        return await this.client.messages.create({
+          model,
+          max_tokens: this.lastConfig?.maxTokens || 8192,
+          system: systemPrompt,
+          messages: [...this.conversationHistory],
+          tools: toolDefinitions,
+          stream: true
+        });
+      };
+      let stream;
+      let currentModel = apiModel;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      try {
+        stream = await createMessage(apiModel);
+      } catch (error) {
+        const isNotFound = error.status === 404 || error.message && error.message.includes("not_found_error") || error.error && error.error.type === "not_found_error";
+        if (isNotFound) {
+          bus.emitAgent({
+            type: "error",
+            message: `Model ${apiModel} not available. Falling back to claude-haiku-4-5.`
+          });
+          currentModel = "claude-haiku-4-5-20251001";
+          stream = await createMessage(currentModel);
+        } else {
+          throw error;
+        }
+      }
+      let fullResponse = "";
+      let buffer = "";
+      let toolUses = [];
+      let currentToolUse = null;
+      for await (const chunk of stream) {
+        if (chunk.type === "message_start" && chunk.message && chunk.message.usage) {
+          inputTokens += chunk.message.usage.input_tokens || 0;
+          this.accumulatedInputTokens += chunk.message.usage.input_tokens || 0;
+        }
+        if (chunk.type === "message_delta" && chunk.usage) {
+          outputTokens += chunk.usage.output_tokens || 0;
+          this.accumulatedOutputTokens += chunk.usage.output_tokens || 0;
+        }
+        if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+          currentToolUse = {
+            id: chunk.content_block.id,
+            name: chunk.content_block.name,
+            input: ""
+          };
+        }
+        if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+          if (currentToolUse) {
+            currentToolUse.input += chunk.delta.partial_json;
+          }
+        }
+        if (chunk.type === "content_block_stop" && currentToolUse) {
+          try {
+            currentToolUse.input = JSON.parse(currentToolUse.input);
+            toolUses.push(currentToolUse);
+            currentToolUse = null;
+          } catch (e) {
+            bus.emitAgent({
+              type: "error",
+              message: `Failed to parse tool input: ${e}`
+            });
+          }
+        }
+        if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+          const text = chunk.delta.text;
+          fullResponse += text;
+          buffer += text;
+          const shouldEmit = buffer.length >= 50 || buffer.match(/[.!?]\s*$/) || buffer.match(/\n/);
+          if (shouldEmit) {
+            bus.emitAgent({
+              type: "thought",
+              content: fullResponse
+            });
+            buffer = "";
+          }
+        }
+      }
+      if (buffer.length > 0) {
+        bus.emitAgent({
+          type: "thought",
+          content: fullResponse
+        });
+      }
+      if (toolUses.length > 0) {
+        const toolResults = [];
+        for (const toolUse of toolUses) {
+          const result = await tools.execute(toolUse.name, toolUse.input);
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolUse.id,
+            content: result.success ? result.output || "Success" : result.error || "Failed",
+            is_error: !result.success
+          });
+        }
+        this.conversationHistory.push({
+          role: "assistant",
+          content: [
+            ...fullResponse ? [{ type: "text", text: fullResponse }] : [],
+            ...toolUses.map((tu) => ({
+              type: "tool_use",
+              id: tu.id,
+              name: tu.name,
+              input: tu.input
+            }))
+          ]
+        });
+        this.conversationHistory.push({
+          role: "user",
+          content: toolResults
+        });
+        return await this.streamChat("");
+      }
+      if (fullResponse) {
+        this.conversationHistory.push({
+          role: "assistant",
+          content: fullResponse
+        });
+      }
+      await usage.track(currentModel, this.accumulatedInputTokens, this.accumulatedOutputTokens);
+      return fullResponse;
+    } catch (error) {
+      bus.emitAgent({
+        type: "error",
+        message: `LLM Error: ${error.message}`
+      });
+      return null;
+    }
+  }
+  getToolSchema(toolName) {
+    const schemas = {
+      bash: {
+        command: {
+          type: "string",
+          description: "The shell command to execute"
+        }
+      },
+      read: {
+        path: {
+          type: "string",
+          description: "Path to the file to read (relative to workspace)"
+        }
+      },
+      write: {
+        path: {
+          type: "string",
+          description: "Path where to create the new file"
+        },
+        content: {
+          type: "string",
+          description: "Content to write to the file"
+        }
+      },
+      edit: {
+        path: {
+          type: "string",
+          description: "Path to the file to edit"
+        },
+        search: {
+          type: "string",
+          description: "Text to search for (must match exactly)"
+        },
+        replace: {
+          type: "string",
+          description: "Text to replace with"
+        }
+      },
+      list: {
+        path: {
+          type: "string",
+          description: "Directory path to list (defaults to current directory)"
+        }
+      },
+      grep: {
+        pattern: {
+          type: "string",
+          description: "Regex pattern to search for"
+        },
+        path: {
+          type: "string",
+          description: "Directory to search in (defaults to current directory)"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results (default: 50)"
+        }
+      },
+      glob: {
+        pattern: {
+          type: "string",
+          description: "Glob pattern like **/*.ts or src/**/*.tsx"
+        },
+        path: {
+          type: "string",
+          description: "Base directory (defaults to current directory)"
+        }
+      },
+      web_fetch: {
+        url: {
+          type: "string",
+          description: "URL to fetch content from"
+        }
+      }
+    };
+    return schemas[toolName] || {};
+  }
+  getRequiredParams(toolName) {
+    const required = {
+      bash: ["command"],
+      read: ["path"],
+      write: ["path", "content"],
+      edit: ["path", "search", "replace"],
+      list: [],
+      grep: ["pattern"],
+      glob: ["pattern"],
+      web_fetch: ["url"]
+    };
+    return required[toolName] || [];
+  }
+  clearHistory() {
+    this.conversationHistory = [];
+  }
+};
+var llm = new LLMClient();
+
+// src/core/tasks.ts
+import fs9 from "fs/promises";
+import path9 from "path";
+var TASKS_DIR = ".obsidian";
+var TASKS_FILE = "tasks.md";
+var TaskTracker = class {
+  task = null;
+  tasksPath;
+  constructor() {
+    this.tasksPath = path9.join(process.cwd(), TASKS_DIR, TASKS_FILE);
+  }
+  async init() {
+    const dir = path9.join(process.cwd(), TASKS_DIR);
+    await fs9.mkdir(dir, { recursive: true });
+    await this.load();
+  }
+  async load() {
+    try {
+      const content = await fs9.readFile(this.tasksPath, "utf-8");
+      this.task = this.parse(content);
+    } catch {
+      this.task = null;
+    }
+  }
+  parse(content) {
+    const lines = content.split("\n");
+    let title = "";
+    let status = "pending";
+    const subtasks = [];
+    const context2 = [];
+    for (const line of lines) {
+      if (line.startsWith("# ")) {
+        title = line.slice(2).trim();
+        continue;
+      }
+      if (line.startsWith("Status: ")) {
+        const s = line.slice(8).trim().toLowerCase();
+        if (["pending", "in_progress", "blocked", "done"].includes(s)) {
+          status = s;
+        }
+        continue;
+      }
+      const subtaskMatch = line.match(/^- \[([ x])\] (.+)$/);
+      if (subtaskMatch) {
+        subtasks.push({
+          done: subtaskMatch[1] === "x",
+          text: subtaskMatch[2]
+        });
+        continue;
+      }
+      if (line.startsWith("- Modified: ") || line.startsWith("- Read: ")) {
+        context2.push(line.slice(2));
+      }
+    }
+    if (!title) return null;
+    return {
+      id: Date.now().toString(36),
+      title,
+      status,
+      subtasks,
+      context: context2,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  serialize() {
+    if (!this.task) return "# No active task\n";
+    const lines = [
+      `# ${this.task.title}`,
+      "",
+      `Status: ${this.task.status}`,
+      "",
+      "## Progress"
+    ];
+    for (const st of this.task.subtasks) {
+      lines.push(`- [${st.done ? "x" : " "}] ${st.text}`);
+    }
+    if (this.task.context.length > 0) {
+      lines.push("", "## Context");
+      for (const c of this.task.context) {
+        lines.push(`- ${c}`);
+      }
+    }
+    lines.push("", `Updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    return lines.join("\n");
+  }
+  async save() {
+    const content = this.serialize();
+    await fs9.writeFile(this.tasksPath, content);
+  }
+  // Task management
+  async create(title) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.task = {
+      id: Date.now().toString(36),
+      title,
+      status: "in_progress",
+      subtasks: [],
+      context: [],
+      created_at: now,
+      updated_at: now
+    };
+    await this.save();
+    return this.task;
+  }
+  async addSubtask(text) {
+    if (!this.task) return;
+    this.task.subtasks.push({ text, done: false });
+    this.task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save();
+  }
+  async completeSubtask(index) {
+    if (!this.task || index >= this.task.subtasks.length) return;
+    this.task.subtasks[index].done = true;
+    this.task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save();
+  }
+  async setStatus(status) {
+    if (!this.task) return;
+    this.task.status = status;
+    this.task.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save();
+  }
+  async addContext(ctx) {
+    if (!this.task) return;
+    if (!this.task.context.includes(ctx)) {
+      this.task.context.push(ctx);
+      await this.save();
+    }
+  }
+  async complete() {
+    if (!this.task) return;
+    this.task.status = "done";
+    for (const st of this.task.subtasks) {
+      st.done = true;
+    }
+    await this.save();
+  }
+  async clear() {
+    this.task = null;
+    await this.save();
+  }
+  // Getters
+  get() {
+    return this.task ? { ...this.task } : null;
+  }
+  getProgress() {
+    if (!this.task) return "No active task";
+    const done = this.task.subtasks.filter((s) => s.done).length;
+    const total = this.task.subtasks.length;
+    return `${this.task.title} [${done}/${total}]`;
+  }
+  hasActiveTask() {
+    return this.task !== null && this.task.status !== "done";
+  }
+};
+var tasks = new TaskTracker();
+
+// src/core/agent.ts
+var Agent = class {
+  initialized = false;
+  pendingPlan = null;
+  async init() {
+    if (this.initialized) return;
+    await context.init();
+    await tasks.init();
+    this.initialized = true;
+  }
+  async run(input) {
+    await this.init();
+    const mode = context.getMode();
+    if (this.isNewTask(input)) {
+      await tasks.create(this.extractTaskTitle(input));
+      await context.setTask(tasks.getProgress());
+    }
+    bus.emitAgent({ type: "thought", content: `[${mode}] Processing...` });
+    if (mode === "plan") {
+      await this.runPlanMode(input);
+    } else {
+      await this.runDirectMode(input);
+    }
+  }
+  isNewTask(input) {
+    const actionWords = ["create", "add", "implement", "fix", "update", "refactor", "build", "make", "write"];
+    const lower = input.toLowerCase();
+    return input.length > 20 && actionWords.some((w) => lower.includes(w));
+  }
+  extractTaskTitle(input) {
+    const firstSentence = input.split(/[.!?\n]/)[0];
+    return firstSentence.slice(0, 50) + (firstSentence.length > 50 ? "..." : "");
+  }
+  async runPlanMode(input) {
+    bus.emitAgent({ type: "thought", content: "Generating plan (read-only)..." });
+    const planPrompt = `Analyze this request and create a plan.
+
+IMPORTANT: You are in PLANNING mode. You may ONLY use read operations (read, list, grep, glob) to understand the codebase. Do NOT execute any writes or modifications yet.
+
+OUTPUT a structured plan:
+
+REQUEST: ${input}
+
+FORMAT:
+TASK: <one line summary>
+STEPS:
+1. <step>
+2. <step>
+FILES_READ: <comma separated paths or "none">
+FILES_MODIFY: <comma separated paths or "none">
+APPROVAL: <yes if destructive, no otherwise>`;
+    const planResponse = await llm.streamChat(planPrompt);
+    if (!planResponse) {
+      bus.emitAgent({ type: "error", message: "Failed to generate plan" });
+      return;
+    }
+    const plan = this.parsePlan(planResponse);
+    this.pendingPlan = { plan, originalInput: input };
+    bus.emitAgent({
+      type: "thought",
+      content: this.formatPlan(plan)
+    });
+    bus.emitAgent({
+      type: "approval_request",
+      requestId: `plan_${Date.now()}`,
+      context: `Execute this plan?
+
+${this.formatPlan(plan)}`
+    });
+  }
+  async runDirectMode(input) {
+    const startTime = Date.now();
+    const ctxSummary = context.getSummary();
+    const taskProgress = tasks.getProgress();
+    let enhancedInput = input;
+    if (ctxSummary || taskProgress !== "No active task") {
+      enhancedInput = `${input}
+
+[Context: ${ctxSummary}]
+[${taskProgress}]`;
+    }
+    const response = await llm.streamChat(enhancedInput);
+    if (response) {
+      await context.setLastAction(input.slice(0, 50));
+      const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
+      bus.emitAgent({ type: "done", summary: `Completed in ${duration}s` });
+    } else {
+      bus.emitAgent({ type: "error", message: "Failed to get response" });
+    }
+  }
+  async handleApprovalResponse(approved, requestId) {
+    if (!this.pendingPlan) {
+      return;
+    }
+    if (!approved) {
+      bus.emitAgent({ type: "thought", content: "Plan rejected. Awaiting new instructions." });
+      this.pendingPlan = null;
+      return;
+    }
+    const { plan, originalInput } = this.pendingPlan;
+    this.pendingPlan = null;
+    await this.executePlan(plan, originalInput);
+  }
+  async executePlan(plan, originalInput) {
+    const startTime = Date.now();
+    const previousMode = context.getMode();
+    await context.setMode("auto");
+    bus.emitAgent({ type: "thought", content: "Executing approved plan (auto-accept enabled)..." });
+    const executionPrompt = `Execute this plan step by step:
+
+ORIGINAL REQUEST: ${originalInput}
+
+PLAN:
+${this.formatPlan(plan)}
+
+Execute each step carefully. Use available tools as needed.`;
+    try {
+      const response = await llm.streamChat(executionPrompt);
+      if (response) {
+        await context.setLastAction(`Executed: ${plan.task.slice(0, 40)}`);
+        const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
+        bus.emitAgent({ type: "done", summary: `Plan executed in ${duration}s` });
+      } else {
+        bus.emitAgent({ type: "error", message: "Failed to execute plan" });
+      }
+    } finally {
+      await context.setMode(previousMode);
+      bus.emitAgent({ type: "thought", content: `Mode restored to: ${previousMode}` });
+    }
+  }
+  parsePlan(response) {
+    const lines = response.split("\n");
+    const plan = {
+      task: "",
+      steps: [],
+      files_to_read: [],
+      files_to_modify: [],
+      requires_approval: false
+    };
+    for (const line of lines) {
+      if (line.startsWith("TASK:")) {
+        plan.task = line.slice(5).trim();
+      } else if (line.match(/^\d+\./)) {
+        plan.steps.push(line.replace(/^\d+\.\s*/, "").trim());
+      } else if (line.startsWith("FILES_READ:")) {
+        const files = line.slice(11).trim();
+        if (files !== "none") {
+          plan.files_to_read = files.split(",").map((f) => f.trim());
+        }
+      } else if (line.startsWith("FILES_MODIFY:")) {
+        const files = line.slice(13).trim();
+        if (files !== "none") {
+          plan.files_to_modify = files.split(",").map((f) => f.trim());
+        }
+      } else if (line.startsWith("APPROVAL:")) {
+        plan.requires_approval = line.toLowerCase().includes("yes");
+      }
+    }
+    return plan;
+  }
+  formatPlan(plan) {
+    const lines = [`Task: ${plan.task}`, "", "Steps:"];
+    plan.steps.forEach((s, i) => lines.push(`  ${i + 1}. ${s}`));
+    if (plan.files_to_read.length > 0) {
+      lines.push("", `Read: ${plan.files_to_read.join(", ")}`);
+    }
+    if (plan.files_to_modify.length > 0) {
+      lines.push(`Modify: ${plan.files_to_modify.join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+  // Mode control
+  async setMode(mode) {
+    await context.setMode(mode);
+    bus.emitAgent({ type: "thought", content: `Mode: ${mode}` });
+  }
+  getMode() {
+    return context.getMode();
+  }
+};
+var agent = new Agent();
+
+// src/ui/Root.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var MAX_EVENTS = 50;
+var Root = () => {
+  const [events, setEvents] = useState4([]);
+  const [input, setInput] = useState4("");
+  const [pendingPrompt, setPendingPrompt] = useState4(null);
+  const { exit } = useApp();
+  const [stats, setStats] = useState4({ cost: 0, model: "Loading...", mode: "safe" });
+  const handlePromptResolve = useCallback3(() => {
+    setPendingPrompt(null);
+  }, []);
+  useEffect(() => {
+    const updateStats = async () => {
+      const cfg = await config.load();
+      setStats({
+        cost: usage.getSessionCost(),
+        model: cfg.model,
+        mode: context.getMode()
+      });
+    };
+    updateStats();
+    const statHandler = (event) => {
+      if (event.type === "done" || event.type === "tool_result" || event.type === "thought") {
+        updateStats();
+      }
+    };
+    bus.on("agent", statHandler);
+    return () => {
+      bus.off("agent", statHandler);
+    };
+  }, []);
+  useEffect(() => {
+    history.load().then((loadedEvents) => {
+      if (loadedEvents.length > 0) {
+        setEvents(loadedEvents);
+      }
+    });
+  }, []);
+  useEffect(() => {
+    if (events.length > 0) {
+      history.save(events);
+    }
+  }, [events]);
+  useEffect(() => {
+    const handler = (event) => {
+      if (event.type === "clear_history") {
+        setEvents([]);
+        history.clear();
+        setPendingPrompt(null);
+        return;
+      }
+      if (event.type === "approval_request") {
+        setPendingPrompt({
+          type: "approval",
+          requestId: event.requestId,
+          context: event.context,
+          diff: event.diff
+        });
+        return;
+      }
+      if (event.type === "choice_request") {
+        setPendingPrompt({
+          type: "choice",
+          question: event.question,
+          options: event.options
+        });
+        return;
+      }
+      setEvents((prev) => {
+        const last = prev[prev.length - 1];
+        if (event.type === "thought" && last && last.type === "thought") {
+          if (last.content === event.content) return prev;
+          const newEvents = [...prev];
+          newEvents[newEvents.length - 1] = event;
+          return newEvents;
+        }
+        return [...prev, event];
+      });
+    };
+    const userHandler = (event) => {
+      if (event.type === "user_input") {
+        setEvents((prev) => [...prev, { type: "user_input", content: event.content }]);
+      }
+    };
+    bus.on("agent", handler);
+    bus.on("user", userHandler);
+    return () => {
+      bus.off("agent", handler);
+      bus.off("user", userHandler);
+    };
+  }, []);
+  const [inputKey, setInputKey] = useState4(0);
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const query = input.toLowerCase();
+  const isCommand = input.startsWith("/");
+  const matches = isCommand ? COMMANDS.filter((c) => c.name.startsWith(query)) : [];
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [input]);
+  const cycleMode = useCallback3(async () => {
+    const modes = ["auto", "plan", "safe"];
+    const currentIndex = modes.indexOf(stats.mode);
+    const nextMode = modes[(currentIndex + 1) % modes.length];
+    await agent.setMode(nextMode);
+    setStats((prev) => ({ ...prev, mode: nextMode }));
+  }, [stats.mode]);
+  useInput3((input2, key) => {
+    if (key.shift && key.tab) {
+      cycleMode();
+      return;
+    }
+    if (matches.length === 0) return;
+    if (key.upArrow) {
+      setSelectedIndex((prev) => prev > 0 ? prev - 1 : matches.length - 1);
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => prev < matches.length - 1 ? prev + 1 : 0);
+    }
+    if (key.return || key.tab) {
+      const selected = matches[selectedIndex];
+      if (selected && input2 !== selected.name) {
+        setInput(selected.name);
+        setInputKey((prev) => prev + 1);
+      }
+    }
+  });
+  const handleSubmit = (value) => {
+    if (!value.trim()) return;
+    if (matches.length > 0 && value !== matches[selectedIndex]?.name) {
+      const selected = matches[selectedIndex];
+      if (selected && selected.name.startsWith(value) && selected.name !== value) {
+        return;
+      }
+    }
+    if (value.trim() === "/exit") {
+      exit();
+      return;
+    }
+    bus.emitUser({ type: "user_input", content: value });
+    setInput("");
+  };
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx7(Dashboard, {}),
+    /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", flexGrow: 1, marginY: 1, overflowY: "hidden", justifyContent: "flex-end", children: events.slice(-MAX_EVENTS).map((event, i) => {
+      let content = null;
+      if (event.type === "user_input") {
+        content = /* @__PURE__ */ jsx7(Box7, { flexDirection: "row", paddingX: 1, marginBottom: 0, children: /* @__PURE__ */ jsxs7(Text7, { backgroundColor: "#222222", dimColor: true, children: [
+          /* @__PURE__ */ jsx7(Text7, { color: "gray", children: " > " }),
+          /* @__PURE__ */ jsx7(Text7, { color: "white", children: event.content }),
+          /* @__PURE__ */ jsx7(Text7, { children: " " })
+        ] }) }, i);
+      } else if (event.type === "thought") {
+        content = /* @__PURE__ */ jsx7(AgentLine, { content: event.content }, i);
+      } else if (event.type === "tool_start") {
+        let argsSummary = "";
+        try {
+          const args = JSON.parse(event.args);
+          const firstVal = Object.values(args)[0];
+          if (typeof firstVal === "string") {
+            argsSummary = firstVal.length > 60 ? firstVal.slice(0, 60) + "..." : firstVal;
+          }
+        } catch {
+        }
+        content = /* @__PURE__ */ jsxs7(Box7, { children: [
+          /* @__PURE__ */ jsx7(Text7, { backgroundColor: "#1a1a2e", color: "cyan", children: " \u23FA " }),
+          /* @__PURE__ */ jsxs7(Text7, { backgroundColor: "#1a1a2e", color: "white", bold: true, children: [
+            " ",
+            event.tool
+          ] }),
+          /* @__PURE__ */ jsxs7(Text7, { backgroundColor: "#1a1a2e", color: "gray", children: [
+            "(",
+            argsSummary,
+            ") "
+          ] })
+        ] }, i);
+      } else if (event.type === "tool_result") {
+        content = /* @__PURE__ */ jsx7(ToolOutput, { tool: event.tool, output: event.output, isError: event.isError }, i);
+      } else if (event.type === "done") {
+        content = /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+          "[OK] ",
+          event.summary
+        ] }, i);
+      } else if (event.type === "error") {
+        content = /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+          "[ERR] ",
+          event.message
+        ] }, i);
+      } else if (event.type === "clear_history") {
+        content = /* @__PURE__ */ jsx7(Text7, { color: "gray", children: "[SYS] History cleared" }, i);
+      }
+      if (!content) return null;
+      return /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: content }, i);
+    }) }),
+    pendingPrompt?.type === "approval" && /* @__PURE__ */ jsx7(
+      ApprovalPrompt,
+      {
+        requestId: pendingPrompt.requestId,
+        context: pendingPrompt.context,
+        diff: pendingPrompt.diff,
+        onResolve: handlePromptResolve
+      }
+    ),
+    pendingPrompt?.type === "choice" && /* @__PURE__ */ jsx7(
+      ChoicePrompt,
+      {
+        question: pendingPrompt.question,
+        options: pendingPrompt.options,
+        onResolve: handlePromptResolve
+      }
+    ),
+    /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx7(
+        CommandPopup,
+        {
+          matches,
+          selectedIndex
+        }
+      ),
+      /* @__PURE__ */ jsxs7(Box7, { borderStyle: "round", borderColor: pendingPrompt ? "gray" : "gray", paddingX: 1, children: [
+        /* @__PURE__ */ jsx7(Text7, { color: "red", bold: true, children: "> " }),
+        /* @__PURE__ */ jsx7(
+          TextInput,
+          {
+            value: input,
+            onChange: pendingPrompt ? () => {
+            } : setInput,
+            onSubmit: pendingPrompt ? () => {
+            } : handleSubmit,
+            placeholder: pendingPrompt ? "Respond to prompt above..." : "Type a message or command..."
+          },
+          inputKey
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs7(
+      Box7,
+      {
+        borderStyle: "single",
+        borderTop: false,
+        borderLeft: false,
+        borderRight: false,
+        borderColor: "gray",
+        marginTop: 0,
+        paddingX: 1,
+        flexDirection: "row",
+        justifyContent: "space-between",
+        children: [
+          /* @__PURE__ */ jsx7(Box7, { minWidth: 22, children: /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+            "[ ",
+            /* @__PURE__ */ jsx7(Text7, { color: stats.mode === "plan" ? "yellow" : stats.mode === "auto" ? "green" : "white", children: stats.mode === "auto" ? "auto-accept ON" : stats.mode === "plan" ? "plan mode" : "default" }),
+            " ]"
+          ] }) }),
+          /* @__PURE__ */ jsx7(Box7, { minWidth: 20, children: /* @__PURE__ */ jsx7(Text7, { color: "gray", children: "[ Context: 0 files ]" }) }),
+          /* @__PURE__ */ jsx7(Box7, { minWidth: 25, justifyContent: "center", children: /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+            "[ Model: ",
+            /* @__PURE__ */ jsx7(Text7, { color: "white", children: stats.model }),
+            " ]"
+          ] }) }),
+          /* @__PURE__ */ jsx7(Box7, { minWidth: 15, justifyContent: "flex-end", children: /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+            "[ Cost: ",
+            /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+              "$",
+              stats.cost.toFixed(4)
+            ] }),
+            " ]"
+          ] }) })
+        ]
+      }
+    )
+  ] });
+};
+
+// src/commands/init.ts
+var initCommand = async (_args) => {
+  bus.emitAgent({ type: "thought", content: "Checking configuration..." });
+  if (await config.exists()) {
+    bus.emitAgent({
+      type: "tool_result",
+      tool: "System",
+      output: `Configuration already exists at ${config.getPath()}`
+    });
+    return;
+  }
+  bus.emitAgent({ type: "thought", content: "Creating default configuration..." });
+  await config.save({
+    model: "claude-3-5-sonnet",
+    maxTokens: 8192,
+    language: "en"
+  });
+  bus.emitAgent({
+    type: "tool_result",
+    tool: "System",
+    output: `Initialized configuration at ${config.getPath()}`
+  });
+};
+
+// src/commands/clear.ts
+var clearCommand = async (_args) => {
+  bus.emitAgent({
+    type: "clear_history"
+  });
+  llm.clearHistory();
+  await context.reset();
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  bus.emitAgent({
+    type: "done",
+    summary: "History, conversation, and context cleared."
+  });
+};
+
+// src/commands/cost.ts
+var costCommand = async (_args) => {
+  await usage.init();
+  const stats = usage.getStats();
+  bus.emitAgent({
+    type: "tool_result",
+    tool: "Cost Tracker",
+    output: `Session Cost Report:
+   Input tokens:  ${stats.totalInputTokens.toLocaleString()}
+   Output tokens: ${stats.totalOutputTokens.toLocaleString()}
+   Total cost:    $${stats.totalCost.toFixed(4)}`
+  });
+};
+
+// src/commands/usage.ts
+var usageCommand = async (_args) => {
+  await usage.init();
+  const stats = usage.getStats();
+  bus.emitAgent({
+    type: "tool_result",
+    tool: "Usage Tracker",
+    output: `Historical Usage Report:
+   Total sessions:    ${stats.totalSessions}
+   Total messages:    ${stats.totalRequests}
+   Total tokens:      ${(stats.totalInputTokens + stats.totalOutputTokens).toLocaleString()}
+   Total cost:        $${stats.totalCost.toFixed(4)}`
+  });
+};
+
+// src/commands/models.ts
+var modelsCommand = async (args) => {
+  const currentConfig = await config.load();
+  if (args.length === 0) {
+    bus.emitAgent({
+      type: "tool_result",
+      tool: "Model Selector",
+      output: `Available AI Models:
+   1. claude-sonnet-4-5    [Current/Default]
+   2. claude-opus-4-5      [Powerful]
+   3. claude-haiku-4-5     [Fast/Cheap]
+   4. ollama               [Local]
+
+Current model: ${currentConfig.model}
+
+Usage: /models <number> to select a model`
+    });
+    return;
+  }
+  const selection = args[0];
+  let newModel;
+  switch (selection) {
+    case "1":
+    case "sonnet":
+    case "claude-sonnet-4-5":
+      newModel = "claude-sonnet-4-5-20250929";
+      break;
+    case "2":
+    case "opus":
+    case "claude-opus-4-5":
+      newModel = "claude-opus-4-5-20251101";
+      break;
+    case "3":
+    case "haiku":
+    case "claude-haiku-4-5":
+      newModel = "claude-haiku-4-5-20251001";
+      break;
+    case "4":
+    case "ollama":
+      newModel = "ollama";
+      break;
+    default:
+      bus.emitAgent({
+        type: "error",
+        message: `Invalid model selection: ${selection}. Use /models to see available options.`
+      });
+      return;
+  }
+  await config.save({
+    ...currentConfig,
+    model: newModel
+  });
+  bus.emitAgent({
+    type: "done",
+    summary: `Model switched to ${newModel}`
+  });
+};
+
+// src/commands/tool.ts
+var toolCommand = async (args) => {
+  if (args.length === 0) {
+    const toolList = tools.list();
+    const formatted = toolList.map((t) => `  \u2022 ${t.name}: ${t.description}`).join("\n");
+    bus.emitAgent({
+      type: "thought",
+      content: `Available tools:
+${formatted}
+
+Usage: /tool <name> <json-args>`
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: "Tools listed"
+    });
+    return;
+  }
+  const toolName = args[0];
+  const jsonArgs = args.slice(1).join(" ");
+  if (!tools.has(toolName)) {
+    bus.emitAgent({
+      type: "error",
+      message: `Unknown tool: ${toolName}`
+    });
+    return;
+  }
+  try {
+    const parsedArgs = jsonArgs ? JSON.parse(jsonArgs) : {};
+    const result = await tools.execute(toolName, parsedArgs);
+    bus.emitAgent({
+      type: "done",
+      summary: result.success ? "Tool executed successfully" : "Tool execution failed"
+    });
+  } catch (error) {
+    bus.emitAgent({
+      type: "error",
+      message: `Failed to execute tool: ${error.message}`
+    });
+  }
+};
+
+// src/commands/status.ts
+import os5 from "os";
+import path10 from "path";
+var statusCommand = async (_args) => {
+  const cfg = await config.load();
+  const stats = usage.getStats();
+  const platform = `${os5.type()} ${os5.release()}`;
+  const nodeVersion = process.version;
+  const workspace = process.cwd();
+  const workspaceName = path10.basename(workspace);
+  const sessionCost = usage.getSessionCost();
+  const toolList = tools.list().map((t) => t.name).join(", ");
+  const statusLines = [
+    "=".repeat(50),
+    "OBSIDIAN NEXT - System Status",
+    "=".repeat(50),
+    "",
+    "[System]",
+    `  Platform:    ${platform}`,
+    `  Node.js:     ${nodeVersion}`,
+    `  Workspace:   ${workspaceName}`,
+    `  Path:        ${workspace}`,
+    "",
+    "[Configuration]",
+    `  Model:       ${cfg.model || "claude-sonnet-4-5"}`,
+    `  Max Tokens:  ${cfg.maxTokens || 8192}`,
+    `  API Key:     ${cfg.apiKey ? "[SET]" : "[NOT SET]"}`,
+    "",
+    "[Session]",
+    `  Cost:        $${sessionCost.toFixed(4)}`,
+    `  Input:       ${stats.totalInputTokens.toLocaleString()} tokens`,
+    `  Output:      ${stats.totalOutputTokens.toLocaleString()} tokens`,
+    "",
+    "[Tools]",
+    `  Available:   ${toolList}`,
+    "",
+    "=".repeat(50)
+  ];
+  bus.emitAgent({
+    type: "thought",
+    content: statusLines.join("\n")
+  });
+  bus.emitAgent({
+    type: "done",
+    summary: "Status displayed"
+  });
+};
+
+// src/commands/sandbox.ts
+var sandboxCommand = async (args) => {
+  const subcommand = args[0]?.toLowerCase();
+  if (!subcommand) {
+    const mode = sandbox.getMode();
+    const available = await sandbox.isAvailable();
+    const statusLines = [
+      "=".repeat(50),
+      "SANDBOX EXECUTION MODE",
+      "=".repeat(50),
+      "",
+      `Current Mode:    ${mode.toUpperCase()}`,
+      `Runtime:         ${available ? "Available" : "Not installed"}`,
+      "",
+      "Modes:",
+      "  local   - Direct execution with auditor checks",
+      "  sandbox - OS-level isolation (filesystem/network)",
+      "",
+      "Usage:",
+      "  /sandbox local   - Switch to local mode",
+      "  /sandbox sandbox - Switch to sandbox mode",
+      "  /sandbox config  - Show sandbox configuration",
+      "",
+      "=".repeat(50)
+    ];
+    bus.emitAgent({
+      type: "thought",
+      content: statusLines.join("\n")
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: "Sandbox status displayed"
+    });
+    return;
+  }
+  if (subcommand === "local" || subcommand === "sandbox") {
+    const available = await sandbox.isAvailable();
+    if (subcommand === "sandbox" && !available) {
+      bus.emitAgent({
+        type: "error",
+        message: "Sandbox runtime not available. Install with: npm install @anthropic-ai/sandbox-runtime"
+      });
+      return;
+    }
+    await sandbox.setMode(subcommand);
+    bus.emitAgent({
+      type: "done",
+      summary: `Execution mode: ${subcommand.toUpperCase()}`
+    });
+    return;
+  }
+  if (subcommand === "config") {
+    const config2 = sandbox.getConfig();
+    const configLines = [
+      "=".repeat(50),
+      "SANDBOX CONFIGURATION",
+      "=".repeat(50),
+      "",
+      "[Network]",
+      `  Allowed: ${config2.allowedDomains.join(", ") || "none"}`,
+      `  Denied:  ${config2.deniedDomains.join(", ") || "none"}`,
+      "",
+      "[Filesystem]",
+      `  Deny Read:   ${config2.denyRead.join(", ") || "none"}`,
+      `  Allow Write: ${config2.allowWrite.join(", ") || "none"}`,
+      `  Deny Write:  ${config2.denyWrite.join(", ") || "none"}`,
+      "",
+      "=".repeat(50)
+    ];
+    bus.emitAgent({
+      type: "thought",
+      content: configLines.join("\n")
+    });
+    bus.emitAgent({
+      type: "done",
+      summary: "Sandbox config displayed"
+    });
+    return;
+  }
+  bus.emitAgent({
+    type: "error",
+    message: `Unknown sandbox command: ${subcommand}. Use: local, sandbox, or config`
+  });
+};
+
+// src/commands/mode.ts
+var MODES = ["auto", "plan", "safe"];
+async function modeCommand(args) {
+  const mode = args[0]?.toLowerCase();
+  if (!mode) {
+    const current = agent.getMode();
+    bus.emitAgent({
+      type: "thought",
+      content: `Current mode: ${current}
+
+Available modes:
+- auto: Execute without confirmation
+- plan: Think -> Approve -> Execute
+- safe: Auto reads, approve writes (default)`
+    });
+    return;
+  }
+  if (!MODES.includes(mode)) {
+    bus.emitAgent({
+      type: "error",
+      message: `Invalid mode: ${mode}. Use: auto, plan, safe`
+    });
+    return;
+  }
+  await agent.setMode(mode);
+}
+
+// src/commands/task.ts
+async function taskCommand(args) {
+  await tasks.init();
+  const subcommand = args[0]?.toLowerCase();
+  if (!subcommand || subcommand === "show") {
+    const task = tasks.get();
+    if (!task) {
+      bus.emitAgent({ type: "thought", content: "No active task" });
+      return;
+    }
+    const lines = [
+      `Task: ${task.title}`,
+      `Status: ${task.status}`,
+      "",
+      "Progress:"
+    ];
+    task.subtasks.forEach((st, i) => {
+      lines.push(`  ${st.done ? "[x]" : "[ ]"} ${st.text}`);
+    });
+    if (task.context.length > 0) {
+      lines.push("", "Context:");
+      task.context.forEach((c) => lines.push(`  - ${c}`));
+    }
+    bus.emitAgent({ type: "thought", content: lines.join("\n") });
+    return;
+  }
+  if (subcommand === "new") {
+    const title = args.slice(1).join(" ");
+    if (!title) {
+      bus.emitAgent({ type: "error", message: "Usage: /task new <title>" });
+      return;
+    }
+    await tasks.create(title);
+    bus.emitAgent({ type: "thought", content: `Task created: ${title}` });
+    return;
+  }
+  if (subcommand === "add") {
+    const text = args.slice(1).join(" ");
+    if (!text) {
+      bus.emitAgent({ type: "error", message: "Usage: /task add <subtask>" });
+      return;
+    }
+    await tasks.addSubtask(text);
+    bus.emitAgent({ type: "thought", content: `Added: ${text}` });
+    return;
+  }
+  if (subcommand === "done") {
+    const index = parseInt(args[1]);
+    if (isNaN(index)) {
+      await tasks.complete();
+      bus.emitAgent({ type: "thought", content: "Task completed" });
+    } else {
+      await tasks.completeSubtask(index - 1);
+      bus.emitAgent({ type: "thought", content: `Subtask ${index} done` });
+    }
+    return;
+  }
+  if (subcommand === "clear") {
+    await tasks.clear();
+    bus.emitAgent({ type: "thought", content: "Task cleared" });
+    return;
+  }
+  bus.emitAgent({
+    type: "thought",
+    content: `Usage:
+  /task           - Show current task
+  /task new <t>   - Create new task
+  /task add <st>  - Add subtask
+  /task done [n]  - Complete task or subtask n
+  /task clear     - Clear task`
+  });
+}
+
+// src/commands/undo.ts
+async function undoCommand(args) {
+  const count = parseInt(args[0]) || 1;
+  const history2 = undo.getHistory(10);
+  if (args[0] === "list" || args[0] === "history") {
+    if (history2.length === 0) {
+      bus.emitAgent({ type: "thought", content: "No changes to undo" });
+      return;
+    }
+    const lines = ["Recent changes:", ""];
+    history2.forEach((c, i) => {
+      const op = c.operation === "create" ? "+" : c.operation === "delete" ? "-" : "~";
+      lines.push(`  ${i + 1}. [${op}] ${c.filePath}`);
+    });
+    bus.emitAgent({ type: "thought", content: lines.join("\n") });
+    return;
+  }
+  const result = await undo.undo(count);
+  if (result.success) {
+    bus.emitAgent({ type: "thought", content: result.message });
+  } else {
+    bus.emitAgent({ type: "error", message: result.message });
+  }
+}
+
+// src/commands/config.ts
+async function configCommand(args) {
+  const subcommand = args[0];
+  const cfg = await config.load();
+  if (!subcommand) {
+    const display = [
+      "Current Configuration:",
+      "=".repeat(40),
+      `  model:      ${cfg.model}`,
+      `  maxTokens:  ${cfg.maxTokens}`,
+      `  apiKey:     ${cfg.apiKey ? "***" + cfg.apiKey.slice(-4) : "not set"}`,
+      "",
+      "Usage:",
+      "  /config set <key> <value>",
+      "  /config reset",
+      "",
+      "Keys: model, maxTokens"
+    ];
+    bus.emitAgent({ type: "thought", content: display.join("\n") });
+    return;
+  }
+  if (subcommand === "set") {
+    const key = args[1];
+    const value = args.slice(2).join(" ");
+    if (!key || !value) {
+      bus.emitAgent({ type: "error", message: "Usage: /config set <key> <value>" });
+      return;
+    }
+    const validKeys = ["model", "maxTokens"];
+    if (!validKeys.includes(key)) {
+      bus.emitAgent({ type: "error", message: `Invalid key. Valid keys: ${validKeys.join(", ")}` });
+      return;
+    }
+    const updates = {};
+    if (key === "maxTokens") {
+      const num = parseInt(value);
+      if (isNaN(num) || num < 100 || num > 2e5) {
+        bus.emitAgent({ type: "error", message: "maxTokens must be between 100 and 200000" });
+        return;
+      }
+      updates.maxTokens = num;
+    } else {
+      updates[key] = value;
+    }
+    await config.save(updates);
+    bus.emitAgent({ type: "thought", content: `Config updated: ${key} = ${value}` });
+    return;
+  }
+  if (subcommand === "reset") {
+    await config.save({
+      model: "claude-sonnet-4-5-20250929",
+      maxTokens: 8192
+    });
+    bus.emitAgent({ type: "thought", content: "Config reset to defaults" });
+    return;
+  }
+  bus.emitAgent({ type: "error", message: `Unknown subcommand: ${subcommand}` });
+}
+
+// src/commands/doctor.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+async function doctorCommand(args) {
+  const results = [];
+  bus.emitAgent({ type: "thought", content: "Running diagnostics..." });
+  try {
+    const cfg = await config.load();
+    if (cfg.apiKey) {
+      results.push({
+        name: "API Key",
+        status: "ok",
+        message: `Configured (***${cfg.apiKey.slice(-4)})`
+      });
+    } else {
+      results.push({
+        name: "API Key",
+        status: "error",
+        message: "Not set. Run /init or set ANTHROPIC_API_KEY"
+      });
+    }
+    results.push({
+      name: "Model",
+      status: "ok",
+      message: cfg.model
+    });
+  } catch (e) {
+    results.push({
+      name: "Config",
+      status: "error",
+      message: `Failed to load: ${e}`
+    });
+  }
+  const toolList = tools.list();
+  results.push({
+    name: "Tools",
+    status: "ok",
+    message: `${toolList.length} registered: ${toolList.map((t) => t.name).join(", ")}`
+  });
+  const sandboxAvailable = await sandbox.isAvailable();
+  results.push({
+    name: "Sandbox",
+    status: sandboxAvailable ? "ok" : "warn",
+    message: sandboxAvailable ? "Available" : "Not available (commands run directly)"
+  });
+  try {
+    const cfg = await config.load();
+    if (cfg.apiKey) {
+      const client = new Anthropic2({ apiKey: cfg.apiKey });
+      results.push({
+        name: "API Client",
+        status: "ok",
+        message: "Anthropic SDK initialized"
+      });
+    }
+  } catch (e) {
+    results.push({
+      name: "API Client",
+      status: "error",
+      message: e.message || "Failed to initialize"
+    });
+  }
+  const cwd = process.cwd();
+  results.push({
+    name: "Workspace",
+    status: "ok",
+    message: cwd
+  });
+  const nodeVersion = process.version;
+  const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0]);
+  results.push({
+    name: "Node.js",
+    status: majorVersion >= 18 ? "ok" : "warn",
+    message: nodeVersion + (majorVersion < 18 ? " (recommend v18+)" : "")
+  });
+  const statusIcons = {
+    ok: "[OK]",
+    warn: "[!!]",
+    error: "[X]"
+  };
+  const statusColors = {
+    ok: "green",
+    warn: "yellow",
+    error: "red"
+  };
+  const output = [
+    "System Diagnostics",
+    "=".repeat(50),
+    "",
+    ...results.map((r) => {
+      const icon = statusIcons[r.status];
+      return `${icon.padEnd(6)} ${r.name.padEnd(12)} ${r.message}`;
+    }),
+    "",
+    "=".repeat(50),
+    `Total: ${results.filter((r) => r.status === "ok").length} OK, ${results.filter((r) => r.status === "warn").length} warnings, ${results.filter((r) => r.status === "error").length} errors`
+  ];
+  bus.emitAgent({ type: "thought", content: output.join("\n") });
+}
+
+// src/commands/settings.ts
+var settingsCommand = async (args) => {
+  const s = await settings.load();
+  if (args.length === 0) {
+    bus.emitAgent({
+      type: "thought",
+      content: `Settings (${settings.getPath()}):
+${JSON.stringify(s, null, 2)}`
+    });
+    return;
+  }
+  const [key, ...valueParts] = args;
+  const value = valueParts.join(" ");
+  if (!value) {
+    const keys = key.split(".");
+    let current = s;
+    for (const k of keys) {
+      if (current && typeof current === "object" && k in current) {
+        current = current[k];
+      } else {
+        bus.emitAgent({
+          type: "error",
+          message: `Unknown setting: ${key}`
+        });
+        return;
+      }
+    }
+    bus.emitAgent({
+      type: "thought",
+      content: `${key} = ${JSON.stringify(current, null, 2)}`
+    });
+    return;
+  }
+  try {
+    const keys = key.split(".");
+    let parsed;
+    if (value === "true") parsed = true;
+    else if (value === "false") parsed = false;
+    else if (!isNaN(Number(value))) parsed = Number(value);
+    else if (value.startsWith("[") || value.startsWith("{")) parsed = JSON.parse(value);
+    else parsed = value;
+    if (keys.length === 1) {
+      await settings.save({ [keys[0]]: parsed });
+    } else if (keys.length === 2) {
+      const current = await settings.load();
+      const topKey = keys[0];
+      const subKey = keys[1];
+      if (typeof current[topKey] === "object" && current[topKey] !== null) {
+        await settings.save({
+          [topKey]: {
+            ...current[topKey],
+            [subKey]: parsed
+          }
+        });
+      }
+    }
+    const updated = await settings.reload();
+    bus.emitAgent({
+      type: "done",
+      summary: `Set ${key} = ${JSON.stringify(parsed)}`
+    });
+  } catch (err) {
+    bus.emitAgent({
+      type: "error",
+      message: `Failed to set ${key}: ${err.message}`
+    });
+  }
+};
+
+// src/core/commands.ts
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register("help", "Show available commands", async () => {
+      const validCommands = Array.from(this.commands.values()).map((c) => `  /${c.name.padEnd(10)} - ${c.description}`).join("\n");
+      bus.emitAgent({
+        type: "thought",
+        content: `Available Commands:
+${validCommands}`
+      });
+    });
+    this.register("init", "Initialize configuration", initCommand);
+    this.register("clear", "Clear conversation history", clearCommand);
+    this.register("cost", "Show session cost", costCommand);
+    this.register("usage", "Show historical usage", usageCommand);
+    this.register("models", "Select AI model", modelsCommand);
+    this.register("tool", "Execute tools manually", toolCommand);
+    this.register("status", "Show system status", statusCommand);
+    this.register("sandbox", "Toggle sandbox mode", sandboxCommand);
+    this.register("mode", "Set execution mode (auto/plan/safe)", modeCommand);
+    this.register("task", "View/manage current task", taskCommand);
+    this.register("undo", "Undo recent file changes", undoCommand);
+    this.register("config", "View/edit configuration", configCommand);
+    this.register("doctor", "Run system diagnostics", doctorCommand);
+    this.register("settings", "View/edit settings (mode, permissions, ui)", settingsCommand);
+  }
+  register(name, description, handler) {
+    this.commands.set(name, { name, description, handler });
+  }
+  has(name) {
+    return this.commands.has(name);
+  }
+  async execute(name, args) {
+    const cmd = this.commands.get(name);
+    if (!cmd) {
+      bus.emitAgent({
+        type: "error",
+        message: `Unknown command: /${name}`
+      });
+      return;
+    }
+    try {
+      await cmd.handler(args);
+    } catch (error) {
+      bus.emitAgent({
+        type: "error",
+        message: `Command /${name} failed: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+};
+var commands = new CommandRegistry();
+
+// src/agents/supervisor.ts
+var Supervisor = class {
+  constructor() {
+    this.setupListeners();
+  }
+  setupListeners() {
+    bus.on("user", async (event) => {
+      if (event.type === "user_input") {
+        await this.handleInput(event.content);
+      }
+      if (event.type === "approval_response") {
+        await agent.handleApprovalResponse(event.approved, event.requestId);
+      }
+    });
+  }
+  async handleInput(input) {
+    if (input.startsWith("/")) {
+      const [cmdName, ...args] = input.slice(1).split(" ");
+      if (commands.has(cmdName)) {
+        await commands.execute(cmdName, args);
+        return;
+      }
+      bus.emitAgent({
+        type: "error",
+        message: `Unknown command: /${cmdName}. Try /help`
+      });
+      return;
+    }
+    await agent.run(input);
+  }
+};
+var supervisor = new Supervisor();
+
+// src/index.ts
+async function main() {
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1Bc");
+  const { waitUntilExit, cleanup } = render(React7.createElement(Root), {
+    patchConsole: false,
+    exitOnCtrlC: true
+  });
+  try {
+    await waitUntilExit();
+  } catch (error) {
+    console.error("Runtime Error:", error);
+  } finally {
+    process.stdout.write("\x1B[?1049l");
+    process.exit(0);
+  }
+}
+if (!supervisor) {
+  console.error("Fatal: Supervisor failed to initialize");
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error("Fatal Error:", err);
+  process.exit(1);
+});