miii-agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,1860 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/ui/App.tsx
+import { useState as useState4, useEffect as useEffect3 } from "react";
+import { Box as Box9, Text as Text9, useApp } from "ink";
+import { homedir as homedir2 } from "os";
+import { sep } from "path";
+
+// src/ollama/client.ts
+import { Ollama } from "ollama";
+var ollama = new Ollama({
+  host: process.env.OLLAMA_HOST ?? "http://localhost:11434"
+});
+var OLLAMA_NOT_RUNNING = "Ollama is not running. Start it with: ollama serve";
+var HARMONY_RE = /<\|?\/?(?:channel|message|start|end|return|constrain|assistant|user|system|developer|tool|tool_call|tool_response|final|analysis|commentary)\|?>/gi;
+var CHANNEL_LABEL_RE = /^(?:analysis|commentary|final)\s*(?=\w)/i;
+function stripHarmony(s) {
+  if (s == null) return s;
+  let out = s.replace(HARMONY_RE, "");
+  out = out.replace(CHANNEL_LABEL_RE, "");
+  return out;
+}
+function isConnectionError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.includes("ECONNREFUSED") || msg.includes("fetch failed") || msg.includes("connect");
+}
+async function listModels() {
+  try {
+    const { models } = await ollama.list();
+    return models.map((m) => m.name);
+  } catch (err) {
+    if (isConnectionError(err)) {
+      throw new Error(OLLAMA_NOT_RUNNING);
+    }
+    throw err;
+  }
+}
+async function modelContext(model) {
+  try {
+    const info = await ollama.show({ model });
+    const modelInfo = info.model_info;
+    if (modelInfo) {
+      const ctxKey = Object.keys(modelInfo).find((k) => k.includes("context_length"));
+      if (ctxKey) {
+        const val = Number(modelInfo[ctxKey]);
+        if (!isNaN(val) && val > 0) return val;
+      }
+    }
+    return 2048;
+  } catch (err) {
+    if (isConnectionError(err)) {
+      throw new Error(OLLAMA_NOT_RUNNING);
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.toLowerCase().includes("not found") || msg.toLowerCase().includes("unknown model")) {
+      throw new Error(`Model "${model}" not found. Run: ollama pull ${model}`);
+    }
+    throw err;
+  }
+}
+async function* chat(model, messages, tools, opts) {
+  if (opts?.signal?.aborted) return;
+  const signal = opts?.signal;
+  const client = signal ? new Ollama({
+    host: process.env.OLLAMA_HOST ?? "http://localhost:11434",
+    fetch: ((input, init) => fetch(input, { ...init, signal }))
+  }) : ollama;
+  let stream;
+  const onAbort = () => {
+    try {
+      client.abort();
+    } catch {
+    }
+  };
+  if (signal) signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    const numPredict = opts?.num_predict;
+    const options = {
+      temperature: opts?.temperature ?? 0.2,
+      num_ctx: opts?.num_ctx ?? 8192
+    };
+    if (numPredict !== void 0 && numPredict > 0) options.num_predict = numPredict;
+    stream = await client.chat({
+      model,
+      messages,
+      tools,
+      stream: true,
+      think: true,
+      keep_alive: opts?.keep_alive ?? "10m",
+      options
+    });
+  } catch (err) {
+    if (signal?.aborted) return;
+    if (isConnectionError(err)) {
+      throw new Error(OLLAMA_NOT_RUNNING);
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.toLowerCase().includes("not found") || msg.toLowerCase().includes("unknown model")) {
+      throw new Error(`Model "${model}" not found. Run: ollama pull ${model}`);
+    }
+    throw err;
+  }
+  try {
+    for await (const chunk of stream) {
+      if (signal?.aborted) break;
+      yield {
+        content: stripHarmony(chunk.message.content),
+        thinking: stripHarmony(chunk.message.thinking),
+        done: chunk.done,
+        tool_calls: chunk.message.tool_calls,
+        prompt_eval_count: chunk.prompt_eval_count,
+        eval_count: chunk.eval_count
+      };
+      if (opts?.signal?.aborted) break;
+    }
+  } catch (err) {
+    if (opts?.signal?.aborted) return;
+    if (isConnectionError(err)) {
+      throw new Error(OLLAMA_NOT_RUNNING);
+    }
+    throw err;
+  } finally {
+    if (opts?.signal) opts.signal.removeEventListener("abort", onAbort);
+  }
+}
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".miii");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function setModel(model) {
+  saveConfig({ ...loadConfig(), model });
+}
+function setEffort(effort) {
+  saveConfig({ ...loadConfig(), effort });
+}
+
+// src/ui/WelcomeBlock.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function WelcomeBlock({ model, activeCtx, effort, cwd }) {
+  const ctxLabel = activeCtx != null ? `${Math.round(activeCtx / 1024)}k ctx` : "\u2014 ctx";
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 2,
+      marginBottom: 1,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: "blue", children: "MIII CLI" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+          /* @__PURE__ */ jsx(Text, { children: model ?? "/models" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+          /* @__PURE__ */ jsx(Text, { children: ctxLabel }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7" }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            effort,
+            " effort"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: cwd })
+      ]
+    }
+  );
+}
+
+// src/ui/ModelList.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ModelList({ models, cursor, activeModel, showActive }) {
+  if (models.length === 0) {
+    return /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "no models found. run: ollama pull ",
+      "<model>"
+    ] });
+  }
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: models.map((m, i) => /* @__PURE__ */ jsxs2(Text2, { color: i === cursor ? "white" : void 0, dimColor: i !== cursor, children: [
+    i === cursor ? "\u25B6 " : "  ",
+    m,
+    showActive && m === activeModel ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  (active)" }) : null
+  ] }, m)) });
+}
+
+// src/ui/InputBar.tsx
+import { useEffect, useState } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var SPIN = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function InputBar({ input, disabled, processingLabel }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    if (!disabled) return;
+    const t = setInterval(() => setFrame((f) => (f + 1) % SPIN.length), 150);
+    return () => clearInterval(t);
+  }, [disabled]);
+  return /* @__PURE__ */ jsx3(
+    Box3,
+    {
+      borderStyle: "single",
+      borderTop: true,
+      borderBottom: true,
+      borderLeft: false,
+      borderRight: false,
+      borderColor: disabled ? "yellow" : "white dim",
+      paddingX: 1,
+      children: disabled ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: SPIN[frame] + " " }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, italic: true, children: processingLabel ?? "processing\u2026" }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "  (esc to cancel)" })
+      ] }) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "> " }),
+        /* @__PURE__ */ jsx3(Text3, { children: input }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u258C" })
+      ] })
+    }
+  );
+}
+
+// src/ui/ModelsView.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function ModelsView({ models, cursor, model, ollamaHost, effort }) {
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "config" }),
+      /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "model   " }),
+          /* @__PURE__ */ jsx4(Text4, { children: model ?? "\u2014" })
+        ] }),
+        /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "host    " }),
+          /* @__PURE__ */ jsx4(Text4, { children: ollamaHost ?? "http://localhost:11434" })
+        ] }),
+        /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "effort  " }),
+          /* @__PURE__ */ jsx4(Text4, { children: effort }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  (\u2190 \u2192)" })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "switch model" }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(ModelList, { models, cursor, activeModel: model, showActive: true }) }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2191\u2193 navigate   enter switch   \u2190\u2192 effort   esc close" }) })
+  ] });
+}
+
+// src/ui/CommandPalette.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var COMMANDS = [
+  { name: "/models", description: "switch model or adjust effort" },
+  { name: "/clear", description: "clear chat and reset context" },
+  { name: "/exit", description: "quit miii" }
+];
+function CommandPalette({ filter, cursor }) {
+  const filtered = COMMANDS.filter((c) => c.name.startsWith(filter));
+  if (filtered.length === 0) return null;
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "white dim",
+      marginX: 1,
+      marginBottom: 0,
+      paddingX: 1,
+      children: [
+        filtered.map((cmd, i) => {
+          const active = i === cursor;
+          return /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
+            /* @__PURE__ */ jsx5(Text5, { bold: active, color: active ? "white" : void 0, dimColor: !active, children: cmd.name }),
+            /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: cmd.description })
+          ] }, cmd.name);
+        }),
+        /* @__PURE__ */ jsx5(Box5, { marginTop: 0, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2191\u2193 navigate   tab/enter autocomplete   esc dismiss" }) })
+      ]
+    }
+  );
+}
+function filteredCommands(filter) {
+  return COMMANDS.filter((c) => c.name.startsWith(filter));
+}
+
+// src/ui/FilePicker.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { readdirSync } from "fs";
+import { join as join2, relative } from "path";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var IGNORE = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "coverage", ".miii"]);
+var MAX_RESULTS = 10;
+var MAX_SCAN = 2e3;
+var cache = null;
+function listFiles(cwd) {
+  if (cache && cache.cwd === cwd) return cache.files;
+  const out = [];
+  const stack = [cwd];
+  while (stack.length && out.length < MAX_SCAN) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (IGNORE.has(e.name) || e.name.startsWith(".")) continue;
+      const full = join2(dir, e.name);
+      if (e.isDirectory()) stack.push(full);
+      else if (e.isFile()) out.push(relative(cwd, full));
+      if (out.length >= MAX_SCAN) break;
+    }
+  }
+  cache = { cwd, files: out };
+  return out;
+}
+function parseMention(input) {
+  const m = input.match(/(?:^|\s)@([^\s]*)$/);
+  if (!m) return null;
+  return { query: m[1], start: input.length - m[1].length - 1 };
+}
+function searchFiles(cwd, query) {
+  const files = listFiles(cwd);
+  const q = query.toLowerCase();
+  if (!q) return files.slice(0, MAX_RESULTS);
+  const scored = [];
+  for (const f of files) {
+    const lf = f.toLowerCase();
+    const idx = lf.indexOf(q);
+    if (idx === -1) continue;
+    const base = lf.split("/").pop() ?? lf;
+    const baseIdx = base.indexOf(q);
+    const score = baseIdx === 0 ? 0 : baseIdx > -1 ? 1 : 2 + idx;
+    scored.push([score, f]);
+    if (scored.length > 500) break;
+  }
+  scored.sort((a, b) => a[0] - b[0] || a[1].length - b[1].length);
+  return scored.slice(0, MAX_RESULTS).map(([, f]) => f);
+}
+function FilePicker({ matches, cursor }) {
+  if (matches.length === 0) return null;
+  return /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "white dim",
+      marginX: 1,
+      marginBottom: 0,
+      paddingX: 1,
+      children: [
+        matches.map((f, i) => {
+          const active = i === cursor;
+          return /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsxs6(Text6, { bold: active, color: active ? "white" : void 0, dimColor: !active, children: [
+            active ? "\u203A " : "  ",
+            f
+          ] }) }, f);
+        }),
+        /* @__PURE__ */ jsx6(Box6, { marginTop: 0, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u2191\u2193 navigate   tab insert   esc dismiss" }) })
+      ]
+    }
+  );
+}
+
+// src/ui/ChatView.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+
+// src/ui/ThinkingBlock.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var globalThinkingVisible = false;
+var listeners = /* @__PURE__ */ new Set();
+function toggleThinkingVisible() {
+  globalThinkingVisible = !globalThinkingVisible;
+  listeners.forEach((fn) => fn());
+}
+function useThinkingVisible() {
+  const [visible, setVisible] = useState2(globalThinkingVisible);
+  useEffect2(() => {
+    const handler = () => setVisible(globalThinkingVisible);
+    listeners.add(handler);
+    return () => {
+      listeners.delete(handler);
+    };
+  }, []);
+  return visible;
+}
+function ThinkingBlock({ content }) {
+  const [frame, setFrame] = useState2(0);
+  const visible = useThinkingVisible();
+  useEffect2(() => {
+    const t = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), 80);
+    return () => clearInterval(t);
+  }, []);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsxs7(Text7, { color: "blue", children: [
+        FRAMES[frame],
+        " "
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, italic: true, children: "thinking\u2026" }),
+      /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+        " \xB7 ctrl+t to ",
+        visible ? "hide" : "show",
+        " thoughts"
+      ] })
+    ] }),
+    visible && content ? /* @__PURE__ */ jsx7(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, italic: true, children: content }) }) : null
+  ] });
+}
+
+// src/ui/ChatView.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function formatTokens(n) {
+  if (n >= 1e3) return (n / 1e3).toFixed(n >= 1e4 ? 0 : 1) + "k";
+  return String(n);
+}
+function formatDuration(ms) {
+  const totalSec = ms / 1e3;
+  if (totalSec < 60) return `${totalSec.toFixed(1)}s`;
+  const m = Math.floor(totalSec / 60);
+  const s = Math.round(totalSec - m * 60);
+  return `${m}m ${s}s`;
+}
+function countLines(s) {
+  if (!s) return 0;
+  return s.split("\n").length;
+}
+function FileEditBlock({
+  label,
+  path,
+  added,
+  removed,
+  previewLines
+}) {
+  const MAX = 16;
+  const shown = previewLines.slice(0, MAX);
+  const extra = previewLines.length - shown.length;
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs8(Box8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "\u25CF " }),
+      /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+        label,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx8(Text8, { children: "(" }),
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: path }),
+      /* @__PURE__ */ jsx8(Text8, { children: ")" })
+    ] }),
+    /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      "\u23BF  ",
+      removed > 0 ? `Added ${added} lines, removed ${removed} lines` : `Added ${added} lines`
+    ] }) }),
+    shown.map((ln, i) => /* @__PURE__ */ jsx8(Box8, { marginLeft: 4, children: /* @__PURE__ */ jsxs8(Text8, { color: ln.sign === "+" ? "green" : ln.sign === "-" ? "red" : void 0, dimColor: ln.sign === " ", children: [
+      ln.sign,
+      " ",
+      ln.text
+    ] }) }, i)),
+    extra > 0 && /* @__PURE__ */ jsx8(Box8, { marginLeft: 4, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      "\u2026 ",
+      extra,
+      " more lines"
+    ] }) })
+  ] });
+}
+var TOOL_LABEL = {
+  write_file: "Write",
+  edit_file: "Update",
+  read_file: "Read",
+  run_bash: "Bash",
+  glob: "Glob",
+  grep: "Grep"
+};
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+function toolHeader(use) {
+  const label = TOOL_LABEL[use.name] ?? use.name;
+  const input = use.input ?? {};
+  let arg = "";
+  switch (use.name) {
+    case "write_file":
+    case "edit_file":
+    case "read_file":
+      arg = String(input.path ?? input.file_path ?? "");
+      break;
+    case "run_bash": {
+      const cmd = String(input.command ?? "").replace(/\s+/g, " ");
+      arg = truncate(cmd, 120);
+      break;
+    }
+    case "glob":
+    case "grep":
+      arg = truncate(String(input.pattern ?? ""), 120);
+      break;
+    default: {
+      arg = truncate(JSON.stringify(input), 80);
+    }
+  }
+  return { label, arg };
+}
+function summarizeResult(res, toolName) {
+  const content = res.content ?? "";
+  const lines = content.split("\n");
+  if (!res.is_error) {
+    if (toolName === "read_file") {
+      const total = lines.length;
+      return `Read ${total} line${total === 1 ? "" : "s"}`;
+    }
+    if (toolName === "grep") {
+      if (content === "No matches.") return "No matches";
+      const n = lines.filter(Boolean).length;
+      return `${n} match${n === 1 ? "" : "es"}`;
+    }
+    if (toolName === "glob") {
+      if (content === "No files matched.") return "No files";
+      const n = lines.filter(Boolean).length;
+      return `${n} file${n === 1 ? "" : "s"}`;
+    }
+  }
+  const firstNonEmpty = lines.find((l) => l.trim().length > 0) ?? "";
+  const extra = lines.length - 1;
+  const head = firstNonEmpty.length > 100 ? firstNonEmpty.slice(0, 97) + "..." : firstNonEmpty;
+  return extra > 0 ? `${head} (+${extra} lines)` : head;
+}
+function ToolResultBlock({ result, toolName }) {
+  const content = result.content ?? "";
+  const lines = content.split("\n");
+  const showMulti = (toolName === "run_bash" || toolName === "grep" || toolName === "glob" || result.is_error) && lines.length > 1;
+  if (!showMulti) {
+    return /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { color: result.is_error ? "red" : void 0, dimColor: !result.is_error, children: [
+      "\u23BF  ",
+      summarizeResult(result, toolName)
+    ] }) });
+  }
+  const MAX_LINES = 10;
+  const MAX_LINE_WIDTH = 200;
+  const shown = lines.slice(0, MAX_LINES).map((l) => truncate(l, MAX_LINE_WIDTH));
+  const extra = lines.length - shown.length;
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs8(Text8, { color: result.is_error ? "red" : void 0, dimColor: !result.is_error, children: [
+      "\u23BF  ",
+      summarizeResult(result, toolName)
+    ] }),
+    shown.map((ln, i) => /* @__PURE__ */ jsx8(Box8, { marginLeft: 4, children: /* @__PURE__ */ jsx8(Text8, { color: result.is_error ? "red" : void 0, dimColor: true, children: ln || " " }) }, i)),
+    extra > 0 && /* @__PURE__ */ jsx8(Box8, { marginLeft: 4, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      "\u2026 ",
+      extra,
+      " more lines"
+    ] }) })
+  ] });
+}
+function ToolUseLine({ use, result }) {
+  if (use.name === "write_file" && !result?.is_error) {
+    const input = use.input;
+    const content = input.content ?? "";
+    const added = countLines(content);
+    const preview = content.split("\n").map((t) => ({ sign: "+", text: t }));
+    return /* @__PURE__ */ jsx8(FileEditBlock, { label: "Write", path: input.path ?? "", added, removed: 0, previewLines: preview });
+  }
+  if (use.name === "edit_file" && !result?.is_error) {
+    const input = use.input;
+    const oldS = input.old_str ?? "";
+    const newS = input.new_str ?? "";
+    const added = countLines(newS);
+    const removed = countLines(oldS);
+    const preview = [
+      ...oldS.split("\n").map((t) => ({ sign: "-", text: t })),
+      ...newS.split("\n").map((t) => ({ sign: "+", text: t }))
+    ];
+    return /* @__PURE__ */ jsx8(FileEditBlock, { label: "Update", path: input.path ?? "", added, removed, previewLines: preview });
+  }
+  const { label, arg } = toolHeader(use);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs8(Box8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "\u25CF " }),
+      /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+        label,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx8(Text8, { children: "(" }),
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: arg }),
+      /* @__PURE__ */ jsx8(Text8, { children: ")" })
+    ] }),
+    result && /* @__PURE__ */ jsx8(ToolResultBlock, { result, toolName: use.name })
+  ] });
+}
+function AssistantMessage({ msg }) {
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginBottom: 1, children: [
+    msg.content && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "white", children: "\u25CF " }),
+      /* @__PURE__ */ jsx8(Box8, { flexGrow: 1, children: /* @__PURE__ */ jsx8(Text8, { children: msg.content }) })
+    ] }),
+    msg.tool_uses?.map((u) => {
+      const r = msg.tool_results?.find((x) => x.tool_use_id === u.id);
+      return /* @__PURE__ */ jsx8(ToolUseLine, { use: u, result: r }, u.id);
+    }),
+    msg.tokens && /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      `\u21B3 Completed \xB7 ${formatTokens(msg.tokens.prompt_eval + msg.tokens.eval)} tokens`,
+      msg.duration != null ? ` \xB7 ${formatDuration(msg.duration)}` : ""
+    ] }) })
+  ] });
+}
+function summarizeInput(input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  const priority = ["path", "file_path", "command", "pattern", "query"];
+  for (const k of priority) {
+    const v = obj[k];
+    if (typeof v === "string" && v.length > 0) return `${k}: ${v}`;
+  }
+  const first = Object.entries(obj).find(([, v]) => typeof v === "string");
+  if (first) {
+    const [k, v] = first;
+    const trimmed = v.length > 80 ? v.slice(0, 80) + "\u2026" : v;
+    return `${k}: ${trimmed}`;
+  }
+  return "";
+}
+function PermissionPrompt({ req, cursor }) {
+  const options = [
+    { label: "Yes", key: "yes" },
+    { label: "No, and tell me what to do differently", key: "no" }
+  ];
+  const summary = summarizeInput(req.input);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginBottom: 1, borderStyle: "round", borderColor: "blue", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", bold: true, children: "Tool use" }),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+      "Allow ",
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: req.toolName }),
+      "?"
+    ] }) }),
+    summary && /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: summary }) }),
+    /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ jsxs8(Text8, { color: i === cursor ? "blue" : void 0, children: [
+      i === cursor ? "\u276F " : "  ",
+      i + 1,
+      ". ",
+      opt.label
+    ] }, opt.key)) })
+  ] });
+}
+function ChatView({
+  messages,
+  streaming,
+  streamingContent,
+  thinking,
+  thinkingContent,
+  error,
+  pendingPermission,
+  permissionCursor = 0,
+  activeToolUses,
+  activeToolResults
+}) {
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginLeft: 1, marginBottom: 1, children: [
+    messages.map(
+      (msg, i) => msg.role === "user" ? /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", marginBottom: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "\u25CF " }),
+        /* @__PURE__ */ jsx8(Box8, { flexGrow: 1, children: /* @__PURE__ */ jsx8(Text8, { children: msg.content }) })
+      ] }, i) : /* @__PURE__ */ jsx8(AssistantMessage, { msg }, i)
+    ),
+    thinking && /* @__PURE__ */ jsx8(ThinkingBlock, { content: thinkingContent }),
+    streaming && streamingContent && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "white", children: "\u25CF " }),
+      /* @__PURE__ */ jsx8(Box8, { flexGrow: 1, children: /* @__PURE__ */ jsx8(Text8, { children: streamingContent }) })
+    ] }),
+    activeToolUses?.map((u) => {
+      const r = activeToolResults?.find((x) => x.tool_use_id === u.id);
+      return /* @__PURE__ */ jsx8(ToolUseLine, { use: u, result: r }, u.id);
+    }),
+    pendingPermission && /* @__PURE__ */ jsx8(PermissionPrompt, { req: pendingPermission, cursor: permissionCursor }),
+    error && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "red", children: "\u25CF " }),
+      /* @__PURE__ */ jsx8(Text8, { color: "red", children: error })
+    ] })
+  ] });
+}
+
+// src/ui/hooks/useAgentRunner.ts
+import { useState as useState3, useRef } from "react";
+
+// src/tools/edit_file.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+var edit_file = {
+  name: "edit_file",
+  description: "Replace an exact string in a file. old_str must be unique.",
+  input_schema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path" },
+      old_str: { type: "string", description: "Exact text to replace" },
+      new_str: { type: "string", description: "Replacement text" }
+    },
+    required: ["path", "old_str", "new_str"]
+  },
+  handler: ({ path, old_str, new_str }) => {
+    const src = readFileSync2(path, "utf-8");
+    const first = src.indexOf(old_str);
+    if (first === -1) {
+      return { content: `old_str not found in ${path}`, is_error: true };
+    }
+    if (src.indexOf(old_str, first + 1) !== -1) {
+      return { content: `old_str not unique in ${path}`, is_error: true };
+    }
+    writeFileSync2(path, src.slice(0, first) + new_str + src.slice(first + old_str.length), "utf-8");
+    return { content: `Edited ${path}` };
+  }
+};
+
+// src/tools/read_file.ts
+import { readFileSync as readFileSync3 } from "fs";
+var read_file = {
+  name: "read_file",
+  description: "Read entire file contents as UTF-8 text.",
+  input_schema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path" }
+    },
+    required: ["path"]
+  },
+  handler: ({ path }) => {
+    try {
+      const MAX = 2e5;
+      const raw = readFileSync3(path, "utf-8");
+      const truncated = raw.length > MAX;
+      const body = truncated ? raw.slice(0, MAX) + `
+[truncated: ${raw.length - MAX} more chars]` : raw;
+      return { content: body };
+    } catch (err) {
+      return { content: err instanceof Error ? err.message : String(err), is_error: true };
+    }
+  }
+};
+
+// src/tools/write_file.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+var write_file = {
+  name: "write_file",
+  description: "Create or overwrite a file with the given content. Parent dirs auto-created.",
+  input_schema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path" },
+      content: { type: "string", description: "Full file content" }
+    },
+    required: ["path", "content"]
+  },
+  handler: ({ path, content }) => {
+    try {
+      mkdirSync2(dirname(path), { recursive: true });
+      writeFileSync3(path, content, "utf-8");
+      return { content: `Wrote ${path} (${content.length} bytes)` };
+    } catch (err) {
+      return { content: err instanceof Error ? err.message : String(err), is_error: true };
+    }
+  }
+};
+
+// src/tools/run_bash.ts
+import { execa } from "execa";
+var run_bash = {
+  name: "run_bash",
+  description: "Execute a shell command (bash on Unix, cmd on Windows). Returns stdout+stderr. Non-interactive only.",
+  input_schema: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "Shell command to run" },
+      timeout_ms: { type: "number", description: "Timeout in ms (default 30000)" }
+    },
+    required: ["command"]
+  },
+  handler: async ({ command, timeout_ms }) => {
+    try {
+      const isWin = process.platform === "win32";
+      const shell = isWin ? "cmd" : "bash";
+      const shellArgs = isWin ? ["/c", command] : ["-c", command];
+      const { stdout, stderr, exitCode } = await execa(shell, shellArgs, {
+        timeout: timeout_ms ?? 3e4,
+        reject: false,
+        all: false
+      });
+      const out = [stdout, stderr].filter(Boolean).join("\n");
+      const is_error = exitCode !== 0;
+      const body = out || (is_error ? `(no output)` : "");
+      const content = is_error ? `${body}
+[exit ${exitCode}]` : body;
+      return {
+        content: content.slice(0, 32e3),
+        is_error
+      };
+    } catch (err) {
+      return { content: err instanceof Error ? err.message : String(err), is_error: true };
+    }
+  }
+};
+
+// src/tools/grep.ts
+import { execa as execa2 } from "execa";
+var grep = {
+  name: "grep",
+  description: "Search file contents for a regex pattern. Uses ripgrep if available, falls back to grep -R.",
+  input_schema: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Regex pattern" },
+      path: { type: "string", description: "Root path to search (default cwd)" },
+      glob: { type: "string", description: 'File glob filter, e.g. "*.ts"' },
+      case_insensitive: { type: "string", description: 'Set "true" for case-insensitive' },
+      max_results: { type: "number", description: "Max matching lines (default 200)" }
+    },
+    required: ["pattern"]
+  },
+  handler: async ({ pattern, path, glob: glob2, case_insensitive, max_results }) => {
+    const root = path ?? process.cwd();
+    const limit = max_results ?? 200;
+    const ci = case_insensitive === true || String(case_insensitive) === "true";
+    const tryRg = async () => {
+      const args = ["--line-number", "--no-heading", "--color=never", "-m", String(limit)];
+      if (ci) args.push("-i");
+      if (glob2) args.push("--glob", glob2);
+      args.push("--", pattern, root);
+      return execa2("rg", args, { reject: false, timeout: 2e4 });
+    };
+    const tryGrep = async () => {
+      const args = ["-R", "-n", "--color=never"];
+      if (ci) args.push("-i");
+      if (glob2) args.push("--include", glob2);
+      args.push("--", pattern, root);
+      return execa2("grep", args, { reject: false, timeout: 2e4 });
+    };
+    try {
+      let res;
+      try {
+        res = await tryRg();
+        if (res.exitCode === 127 || (res.stderr ?? "").includes("command not found")) {
+          res = await tryGrep();
+        }
+      } catch {
+        res = await tryGrep();
+      }
+      const lines = (res.stdout ?? "").split("\n").slice(0, limit);
+      const out = lines.join("\n");
+      const code = res.exitCode ?? 0;
+      if (!out && code === 1) return { content: "No matches." };
+      return { content: out || res.stderr || "No matches.", is_error: code > 1 };
+    } catch (err) {
+      return { content: err instanceof Error ? err.message : String(err), is_error: true };
+    }
+  }
+};
+
+// src/tools/glob.ts
+import { execa as execa3 } from "execa";
+function globToFindName(glob2) {
+  return glob2;
+}
+var glob = {
+  name: "glob",
+  description: 'List files matching a glob pattern (e.g. "**/*.ts"). Uses ripgrep --files if available.',
+  input_schema: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: 'Glob pattern, e.g. "**/*.ts"' },
+      path: { type: "string", description: "Root path (default cwd)" },
+      max_results: { type: "number", description: "Max paths returned (default 500)" }
+    },
+    required: ["pattern"]
+  },
+  handler: async ({ pattern, path, max_results }) => {
+    const root = path ?? process.cwd();
+    const limit = max_results ?? 500;
+    const tryRg = () => execa3("rg", ["--files", "--hidden", "--glob", pattern, root], {
+      reject: false,
+      timeout: 2e4
+    });
+    const tryFind = () => {
+      const name = globToFindName(pattern.replace(/^\*\*\//, ""));
+      return execa3("find", [root, "-type", "f", "-name", name], {
+        reject: false,
+        timeout: 2e4
+      });
+    };
+    try {
+      let res;
+      try {
+        res = await tryRg();
+        if (res.exitCode === 127 || (res.stderr ?? "").includes("command not found")) {
+          res = await tryFind();
+        }
+      } catch {
+        res = await tryFind();
+      }
+      const lines = (res.stdout ?? "").split("\n").filter(Boolean).slice(0, limit);
+      if (lines.length === 0) return { content: "No files matched." };
+      return { content: lines.join("\n") };
+    } catch (err) {
+      return { content: err instanceof Error ? err.message : String(err), is_error: true };
+    }
+  }
+};
+
+// src/tools/registry.ts
+var TOOLS = [
+  edit_file,
+  read_file,
+  write_file,
+  run_bash,
+  grep,
+  glob
+];
+function getTool(name) {
+  return TOOLS.find((t) => t.name === name);
+}
+function toOllamaTools(tools = TOOLS) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: {
+        type: "object",
+        properties: t.input_schema.properties,
+        required: t.input_schema.required
+      }
+    }
+  }));
+}
+
+// src/prompt/system.ts
+function buildSystemPrompt(tools, cwd) {
+  const toolLines = tools.map((t) => `- ${t.name}: ${t.description}`).join("\n");
+  return `You are miii, a senior software engineer running in a terminal.
+
+Working directory: ${cwd}
+
+# Goal Understanding (read this first, every turn)
+Before acting on any request, extract and hold three things:
+  GOAL: what the user ultimately wants (outcome, not steps)
+  CRITERION: how you will know the goal is met
+  GAPS: anything unclear that would force you to guess
+
+If GAPS is non-empty, ask the minimum questions needed to fill them \u2014 one message, numbered list \u2014 before touching any file or running any command. Do not guess. Do not act on assumptions.
+
+Re-read GOAL before every tool call. If a tool call does not move toward GOAL, skip it.
+
+# Attention: re-attend to goal at each step
+After each tool result, answer silently: "Does this result move me toward GOAL?"
+  YES \u2192 continue
+  NO  \u2192 stop, re-derive plan from GOAL, explain the correction in one line
+
+This prevents drift. Each step attends to the original goal, not just the previous step.
+
+# Output format
+- Always reply in plain text. Never use Markdown syntax: no \`#\` headings, no \`**bold**\`, no \`-\` bullet lists, no fenced \`\`\` code blocks, no inline backticks.
+- Quote code, paths, and identifiers inline as plain text. Do not wrap them.
+- Keep prose terse.
+
+# Engineering mindset
+- Treat every request as one of: bug, feature, or fix. Name which one before you start.
+- Apply first principles: decompose unclear tasks into smallest concrete sub-problems, solve each explicitly, compose the result.
+- Never guess. If a fact (file path, function signature, current behavior) is unknown, read or search for it first.
+
+# Clarifying questions \u2014 when to ask
+Ask BEFORE acting when:
+  - The goal has more than one valid interpretation
+  - Success criterion is ambiguous (e.g. "make it better" \u2014 better how?)
+  - Required context is missing (which file? which behavior? which user?)
+  - Two reasonable approaches have different tradeoffs the user should choose
+
+Do NOT ask when:
+  - The answer is findable by reading the codebase
+  - There is only one sensible interpretation
+  - The user has already answered this implicitly
+
+Ask in a numbered list. One round of questions per turn. Then wait.
+
+# Tool calls
+- When you need a tool, emit the tool call directly. No preamble, no narration, no "I will use X".
+- Never describe a tool call instead of emitting it. If you cannot emit the call, answer in plain text.
+- After a tool result, move directly to the next tool call or the final answer. Do not restate what the previous tool did.
+
+# Tools
+You have access to the following tools. Call them via the function-calling interface.
+${toolLines}
+
+# Loop semantics
+- When you need to act on the filesystem or run a command, emit a tool call.
+- After each tool result, decide: more tool calls, or a final plain-text answer.
+- Stop emitting tool calls when GOAL is met. Reply with a concise plain-text final message confirming CRITERION is satisfied.
+
+# Rules
+- Prefer editing existing files over creating new ones.
+- For edit_file, ensure old_str is unique within the target file.
+- Never invent file paths. Read, glob, or grep before editing.
+- No filler, no pleasantries, no apologies.
+
+# Testing and verification
+- Always test the code after a change. Run the project's tests (e.g. npm test, pytest, go test) or the relevant script via run_bash before declaring a task done.
+- If no test exists for the change, run the affected entry point via run_bash to verify it behaves correctly.
+- Treat a green test run or a successful command as the completion signal. If it fails, fix and re-run.
+
+# Permissions
+- When a new bash command pattern, file path, or glob pattern is needed, ask the user once; on approval it persists as a Tool(pattern) rule (e.g. Bash(npm test *), WriteFile(src/*)).
+`;
+}
+
+// src/permissions/policy.ts
+var DEFAULT_ALLOW = /* @__PURE__ */ new Set(["read_file"]);
+async function check(toolName, input, ctx) {
+  if (DEFAULT_ALLOW.has(toolName)) return "allow";
+  const answer = await ctx.ask(toolName, input);
+  return answer === "no" ? "deny" : "allow";
+}
+
+// src/agent/adapter.ts
+function mintToolUseId() {
+  const rand = Math.random().toString(36).slice(2, 14);
+  return `toolu_${rand}`;
+}
+function toOllamaMessages(history, system) {
+  const out = [{ role: "system", content: system }];
+  for (const msg of history) {
+    if (typeof msg.content === "string") {
+      out.push({ role: msg.role === "system" ? "system" : msg.role, content: msg.content });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const tool_uses = msg.content.filter((b) => b.type === "tool_use");
+      const ollamaMsg = { role: "assistant", content: text };
+      if (tool_uses.length > 0) {
+        ollamaMsg.tool_calls = tool_uses.map((u) => ({
+          function: { name: u.name, arguments: u.input }
+        }));
+      }
+      out.push(ollamaMsg);
+      continue;
+    }
+    if (msg.role === "user") {
+      const tool_results = msg.content.filter((b) => b.type === "tool_result");
+      const texts = msg.content.filter((b) => b.type === "text");
+      for (const tr of tool_results) {
+        out.push({ role: "tool", content: tr.content });
+      }
+      if (texts.length > 0) {
+        out.push({ role: "user", content: texts.map((t) => t.text).join("") });
+      }
+    }
+  }
+  return out;
+}
+function parseTextToolCalls(text, knownToolNames) {
+  if (!text) return { calls: [], cleanedText: text };
+  const calls = [];
+  let cleaned = text;
+  const tagRe = /<\|?tool_call\|?>\s*([\s\S]*?)\s*<\|?\/?tool_call\|?>/g;
+  cleaned = cleaned.replace(tagRe, (_m, body) => {
+    const c = tryParse(body, knownToolNames);
+    if (c) calls.push(c);
+    return "";
+  });
+  const fenceRe = /```(?:json|tool_call)?\s*([\s\S]*?)```/g;
+  cleaned = cleaned.replace(fenceRe, (_m, body) => {
+    const c = tryParse(body, knownToolNames);
+    if (c) {
+      calls.push(c);
+      return "";
+    }
+    return _m;
+  });
+  if (calls.length === 0) {
+    const candidate = extractFirstJsonObject(cleaned);
+    if (candidate) {
+      const c = tryParse(candidate.json, knownToolNames);
+      if (c) {
+        calls.push(c);
+        cleaned = (cleaned.slice(0, candidate.start) + cleaned.slice(candidate.end)).trim();
+      }
+    }
+  }
+  return { calls, cleanedText: cleaned.trim() };
+}
+function tryParse(raw, knownToolNames) {
+  const s = raw.trim();
+  if (!s.startsWith("{")) return null;
+  try {
+    const obj = JSON.parse(s);
+    const name = typeof obj.name === "string" ? obj.name : void 0;
+    const args = obj.arguments ?? obj.parameters ?? obj.input ?? {};
+    if (!name || !knownToolNames.includes(name)) return null;
+    return { function: { name, arguments: args } };
+  } catch {
+    return null;
+  }
+}
+function extractFirstJsonObject(s) {
+  const start = s.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') {
+      inStr = true;
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return { json: s.slice(start, i + 1), start, end: i + 1 };
+    }
+  }
+  return null;
+}
+function blocksFromOllama(text, tool_calls, knownToolNames = []) {
+  const blocks = [];
+  let finalText = text;
+  let finalCalls = tool_calls ?? [];
+  if (finalCalls.length === 0 && knownToolNames.length > 0) {
+    const parsed = parseTextToolCalls(text, knownToolNames);
+    if (parsed.calls.length > 0) {
+      finalCalls = parsed.calls;
+      finalText = parsed.cleanedText;
+    }
+  }
+  if (finalText) blocks.push({ type: "text", text: finalText });
+  for (const tc of finalCalls) {
+    blocks.push({
+      type: "tool_use",
+      id: mintToolUseId(),
+      name: tc.function.name,
+      input: tc.function.arguments ?? {}
+    });
+  }
+  return blocks;
+}
+
+// src/agent/loop.ts
+var MAX_TURNS = 25;
+var NUM_PREDICT = 4096;
+var REPEAT_TAIL = 120;
+var REPEAT_KILL = 4;
+async function* runAgent(opts) {
+  const { model, cwd, permissions, hooks, signal, num_ctx } = opts;
+  const startTime = Date.now();
+  const system = buildSystemPrompt(TOOLS, cwd);
+  const ollamaTools = toOllamaTools(TOOLS);
+  const history = [
+    ...opts.history,
+    { role: "user", content: opts.userText }
+  ];
+  let promptTokens = 0;
+  let evalTokens = 0;
+  let lastAssistantSig = "";
+  let repeatCount = 0;
+  for (let turn = 0; turn < MAX_TURNS; turn++) {
+    let text = "";
+    let tool_calls;
+    let lastTail = "";
+    let tailRepeats = 0;
+    let streamLooped = false;
+    const ac = new AbortController();
+    const composedSignal = signal ? AbortSignal.any ? AbortSignal.any([signal, ac.signal]) : ac.signal : ac.signal;
+    if (signal) signal.addEventListener("abort", () => ac.abort(), { once: true });
+    try {
+      for await (const chunk of chat(model, toOllamaMessages(history, system), ollamaTools, { signal: composedSignal, num_ctx, num_predict: NUM_PREDICT })) {
+        if (signal?.aborted) break;
+        if (chunk.content) {
+          text += chunk.content;
+          yield { type: "text-delta", text: chunk.content };
+          if (text.length >= REPEAT_TAIL) {
+            const tail = text.slice(-REPEAT_TAIL);
+            if (tail === lastTail) {
+              tailRepeats++;
+              if (tailRepeats >= REPEAT_KILL) {
+                streamLooped = true;
+                ac.abort();
+                break;
+              }
+            } else {
+              tailRepeats = 0;
+              lastTail = tail;
+            }
+          }
+        }
+        if (chunk.thinking) {
+          yield { type: "thinking-delta", text: chunk.thinking };
+        }
+        if (chunk.tool_calls && chunk.tool_calls.length > 0) {
+          tool_calls = chunk.tool_calls;
+        }
+        if (chunk.done) {
+          promptTokens += chunk.prompt_eval_count ?? 0;
+          evalTokens += chunk.eval_count ?? 0;
+        }
+      }
+    } catch (err) {
+      if (streamLooped) {
+        yield { type: "error", message: "Model stuck in repetition. Aborted stream. Try a different model or shorten context." };
+        return history;
+      }
+      yield { type: "error", message: err instanceof Error ? err.message : String(err) };
+      return history;
+    }
+    if (streamLooped) {
+      yield { type: "error", message: "Model stuck in repetition. Aborted stream. Try a different model or shorten context." };
+      return history;
+    }
+    if (signal?.aborted) {
+      yield {
+        type: "aborted",
+        prompt_tokens: promptTokens,
+        eval_tokens: evalTokens,
+        duration_ms: Date.now() - startTime
+      };
+      return history;
+    }
+    const blocks = blocksFromOllama(text, tool_calls, TOOLS.map((t) => t.name));
+    const tool_uses = blocks.filter((b) => b.type === "tool_use");
+    history.push({ role: "assistant", content: blocks });
+    if (tool_uses.length === 0) {
+      yield { type: "turn-end", stop_reason: "end_turn" };
+      break;
+    }
+    const sig = JSON.stringify(
+      blocks.map(
+        (b) => b.type === "tool_use" ? { t: "u", n: b.name, i: b.input } : b.type === "text" ? { t: "t", x: b.text.trim() } : b
+      )
+    );
+    if (sig === lastAssistantSig) {
+      repeatCount++;
+      if (repeatCount >= 2) {
+        yield { type: "error", message: "Agent loop detected: assistant produced identical output 3 turns in a row" };
+        return history;
+      }
+    } else {
+      repeatCount = 0;
+      lastAssistantSig = sig;
+    }
+    for (const u of tool_uses) yield { type: "tool-use", block: u };
+    const results = [];
+    for (const use of tool_uses) {
+      const tool = getTool(use.name);
+      if (!tool) {
+        const r2 = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Unknown tool: ${use.name}`,
+          is_error: true
+        };
+        results.push(r2);
+        yield { type: "tool-result", block: r2 };
+        continue;
+      }
+      const decision = await check(use.name, use.input, permissions);
+      if (decision === "deny") {
+        const r2 = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Permission denied for ${use.name}.`,
+          is_error: true
+        };
+        results.push(r2);
+        yield { type: "permission-denied", toolName: use.name, tool_use_id: use.id };
+        yield { type: "tool-result", block: r2 };
+        continue;
+      }
+      await hooks?.firePre(use);
+      let r;
+      try {
+        const out = await tool.handler(use.input);
+        r = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: out.content,
+          is_error: out.is_error
+        };
+      } catch (err) {
+        r = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: err instanceof Error ? err.message : String(err),
+          is_error: true
+        };
+      }
+      await hooks?.firePost(use, r);
+      results.push(r);
+      yield { type: "tool-result", block: r };
+    }
+    history.push({ role: "user", content: results });
+    yield { type: "turn-end", stop_reason: "tool_use" };
+  }
+  yield { type: "done", prompt_tokens: promptTokens, eval_tokens: evalTokens };
+  return history;
+}
+
+// src/ui/hooks/useAgentRunner.ts
+var FLUSH_MS = 100;
+function useAgentRunner(model, activeCtx) {
+  const [messages, setMessages] = useState3([]);
+  const [thinking, setThinking] = useState3(false);
+  const [thinkingContent, setThinkingContent] = useState3("");
+  const [streaming, setStreaming] = useState3(false);
+  const [streamingContent, setStreamingContent] = useState3("");
+  const [error, setError] = useState3(null);
+  const [busy, setBusy] = useState3(false);
+  const [processingLabel, setProcessingLabel] = useState3(void 0);
+  const [agentHistory, setAgentHistory] = useState3([]);
+  const [pendingPermission, setPendingPermission] = useState3(null);
+  const [permissionCursor, setPermissionCursor] = useState3(0);
+  const [activeToolUses, setActiveToolUses] = useState3([]);
+  const [activeToolResults, setActiveToolResults] = useState3([]);
+  const busyRef = useRef(false);
+  const abortRef = useRef(null);
+  const pendingPermissionRef = useRef(null);
+  function askPermission(toolName, input) {
+    return new Promise((resolve) => {
+      const req = { toolName, input, resolve };
+      pendingPermissionRef.current = req;
+      setPermissionCursor(0);
+      setPendingPermission(req);
+    });
+  }
+  function resolvePermission(cursor) {
+    const req = pendingPermissionRef.current;
+    if (!req) return;
+    const answers = ["yes", "no"];
+    pendingPermissionRef.current = null;
+    setPendingPermission(null);
+    req.resolve(answers[cursor]);
+  }
+  async function sendMessage(text) {
+    if (busyRef.current || !model) return;
+    busyRef.current = true;
+    setBusy(true);
+    setProcessingLabel("thinking\u2026");
+    setError(null);
+    setMessages((prev) => [...prev, { role: "user", content: text }]);
+    setThinking(true);
+    let accumulated = "";
+    let thinkingAcc = "";
+    let firstToken = true;
+    setThinkingContent("");
+    let streamFlushAt = 0;
+    let thinkFlushAt = 0;
+    const flushStream = (force = false) => {
+      const now = Date.now();
+      if (force || now - streamFlushAt >= FLUSH_MS) {
+        streamFlushAt = now;
+        setStreamingContent(accumulated);
+      }
+    };
+    const flushThink = (force = false) => {
+      const now = Date.now();
+      if (force || now - thinkFlushAt >= FLUSH_MS) {
+        thinkFlushAt = now;
+        setThinkingContent(thinkingAcc);
+      }
+    };
+    let turnUses = [];
+    let turnResults = [];
+    const startTime = Date.now();
+    const flushTurn = (final) => {
+      const msg = {
+        role: "assistant",
+        content: accumulated,
+        tool_uses: turnUses.length ? turnUses : void 0,
+        tool_results: turnResults.length ? turnResults : void 0
+      };
+      if (final) {
+        msg.tokens = { prompt_eval: final.prompt, eval: final.eval };
+        msg.duration = Date.now() - startTime;
+      }
+      setMessages((prev) => [...prev, msg]);
+      accumulated = "";
+      turnUses = [];
+      turnResults = [];
+      setStreamingContent("");
+      setActiveToolUses([]);
+      setActiveToolResults([]);
+    };
+    const controller = new AbortController();
+    abortRef.current = controller;
+    try {
+      const gen = runAgent({
+        model,
+        cwd: process.cwd(),
+        history: agentHistory,
+        userText: text,
+        permissions: { ask: askPermission },
+        signal: controller.signal,
+        num_ctx: activeCtx ?? void 0
+      });
+      let finalTokens = { prompt: 0, eval: 0 };
+      let result;
+      while (true) {
+        result = await gen.next();
+        if (result.done) {
+          setAgentHistory(result.value);
+          break;
+        }
+        const ev = result.value;
+        switch (ev.type) {
+          case "text-delta": {
+            if (firstToken) {
+              firstToken = false;
+              setStreaming(true);
+            }
+            setThinking(false);
+            setProcessingLabel("responding\u2026");
+            accumulated += ev.text;
+            flushStream();
+            break;
+          }
+          case "thinking-delta": {
+            thinkingAcc += ev.text;
+            setThinking(true);
+            setProcessingLabel("thinking\u2026");
+            flushThink();
+            break;
+          }
+          case "tool-use": {
+            turnUses.push({ id: ev.block.id, name: ev.block.name, input: ev.block.input });
+            setActiveToolUses([...turnUses]);
+            setProcessingLabel(`running ${ev.block.name}\u2026`);
+            break;
+          }
+          case "tool-result": {
+            turnResults.push({
+              tool_use_id: ev.block.tool_use_id,
+              content: ev.block.content,
+              is_error: ev.block.is_error
+            });
+            setActiveToolResults([...turnResults]);
+            setProcessingLabel("thinking\u2026");
+            break;
+          }
+          case "turn-end": {
+            flushStream(true);
+            flushThink(true);
+            setStreaming(false);
+            if (ev.stop_reason === "tool_use") {
+              flushTurn(null);
+              setThinking(true);
+              thinkingAcc = "";
+              setThinkingContent("");
+              firstToken = true;
+            }
+            break;
+          }
+          case "done": {
+            finalTokens = { prompt: ev.prompt_tokens, eval: ev.eval_tokens };
+            break;
+          }
+          case "aborted": {
+            finalTokens = { prompt: ev.prompt_tokens, eval: ev.eval_tokens };
+            setStreaming(false);
+            setThinking(false);
+            flushTurn(finalTokens);
+            setError(`Aborted \xB7 ${ev.prompt_tokens + ev.eval_tokens} tokens \xB7 ${(ev.duration_ms / 1e3).toFixed(1)}s`);
+            break;
+          }
+          case "error": {
+            setError(ev.message);
+            break;
+          }
+        }
+      }
+      setStreaming(false);
+      setThinking(false);
+      if (accumulated || turnUses.length || turnResults.length) flushTurn(finalTokens);
+    } catch (err) {
+      const aborted = controller.signal.aborted;
+      const msg = err instanceof Error ? err.message : String(err);
+      setThinking(false);
+      setStreaming(false);
+      if (accumulated || turnUses.length || turnResults.length) flushTurn(null);
+      setError(aborted ? `Aborted \xB7 ${((Date.now() - startTime) / 1e3).toFixed(1)}s` : msg);
+    }
+    abortRef.current = null;
+    busyRef.current = false;
+    setBusy(false);
+    setProcessingLabel(void 0);
+  }
+  return {
+    // state
+    messages,
+    setMessages,
+    thinking,
+    thinkingContent,
+    setThinkingContent,
+    streaming,
+    streamingContent,
+    setStreamingContent,
+    error,
+    setError,
+    busy,
+    processingLabel,
+    agentHistory,
+    setAgentHistory,
+    pendingPermission,
+    permissionCursor,
+    setPermissionCursor,
+    activeToolUses,
+    setActiveToolUses,
+    activeToolResults,
+    setActiveToolResults,
+    // refs (for keyboard handler)
+    busyRef,
+    abortRef,
+    pendingPermissionRef,
+    // actions
+    sendMessage,
+    resolvePermission
+  };
+}
+
+// src/ui/hooks/useKeyboard.ts
+import { useInput } from "ink";
+var EFFORTS = ["low", "medium", "high"];
+function useKeyboard(opts) {
+  const {
+    exit,
+    state,
+    setState,
+    models,
+    cursor,
+    setCursor,
+    contexts,
+    cfg,
+    setCfg,
+    setActiveCtx,
+    pendingPermissionRef,
+    permissionCursor,
+    setPermissionCursor,
+    resolvePermission,
+    busyRef,
+    abortRef,
+    input,
+    setInput,
+    paletteCursor,
+    setPaletteCursor,
+    filePickerCursor,
+    setFilePickerCursor,
+    sendMessage,
+    setMessages,
+    setAgentHistory,
+    setStreamingContent,
+    setThinkingContent,
+    setActiveToolUses,
+    setActiveToolResults,
+    setError
+  } = opts;
+  const effort = cfg.effort ?? "medium";
+  useInput((char, key) => {
+    if (key.ctrl && char === "c") {
+      exit();
+      return;
+    }
+    if (key.ctrl && char === "t") {
+      toggleThinkingVisible();
+      return;
+    }
+    if (key.escape && busyRef.current && abortRef.current) {
+      abortRef.current.abort();
+      return;
+    }
+    if (state === "select-model" || state === "models") {
+      if (key.upArrow) {
+        setCursor((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setCursor((i) => Math.min(models.length - 1, i + 1));
+        return;
+      }
+      if (key.return && models[cursor]) {
+        const chosen = models[cursor];
+        setModel(chosen);
+        setCfg((c) => ({ ...c, model: chosen }));
+        if (contexts[chosen]) setActiveCtx(contexts[chosen]);
+        setState("ready");
+        return;
+      }
+      if (state === "models") {
+        if (key.rightArrow) {
+          const next = EFFORTS[Math.min(EFFORTS.indexOf(effort) + 1, EFFORTS.length - 1)];
+          setEffort(next);
+          setCfg((c) => ({ ...c, effort: next }));
+        } else if (key.leftArrow) {
+          const next = EFFORTS[Math.max(EFFORTS.indexOf(effort) - 1, 0)];
+          setEffort(next);
+          setCfg((c) => ({ ...c, effort: next }));
+        } else if (key.escape) {
+          setState("ready");
+        }
+      }
+      return;
+    }
+    if (state === "ready" && pendingPermissionRef.current) {
+      if (key.upArrow) {
+        setPermissionCursor((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setPermissionCursor((i) => Math.min(1, i + 1));
+        return;
+      }
+      if (key.return) {
+        resolvePermission(permissionCursor);
+        return;
+      }
+      return;
+    }
+    if (state === "ready") {
+      if (busyRef.current) return;
+      const paletteOpen = input.startsWith("/");
+      const matches = paletteOpen ? filteredCommands(input) : [];
+      const mention = !paletteOpen ? parseMention(input) : null;
+      const fileMatches = mention ? searchFiles(process.cwd(), mention.query) : [];
+      const fileOpen = mention !== null && fileMatches.length > 0;
+      if (paletteOpen && key.upArrow) {
+        setPaletteCursor((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (paletteOpen && key.downArrow) {
+        setPaletteCursor((i) => Math.min(matches.length - 1, i + 1));
+        return;
+      }
+      if (paletteOpen && (key.tab || key.return) && matches[paletteCursor] && input !== matches[paletteCursor].name) {
+        setInput(() => matches[paletteCursor].name);
+        setPaletteCursor(() => 0);
+        return;
+      }
+      if (paletteOpen && key.escape) {
+        setInput(() => "");
+        setPaletteCursor(() => 0);
+        return;
+      }
+      if (fileOpen && key.upArrow) {
+        setFilePickerCursor((i) => Math.max(0, i - 1));
+        return;
+      }
+      if (fileOpen && key.downArrow) {
+        setFilePickerCursor((i) => Math.min(fileMatches.length - 1, i + 1));
+        return;
+      }
+      if (fileOpen && key.tab && fileMatches[filePickerCursor]) {
+        const picked = fileMatches[filePickerCursor];
+        setInput((s) => s.slice(0, mention.start) + "@" + picked + " ");
+        setFilePickerCursor(() => 0);
+        return;
+      }
+      if (fileOpen && key.escape) {
+        setFilePickerCursor(() => 0);
+        return;
+      }
+      if (key.return) {
+        const trimmed = input.trim();
+        if (trimmed === "/models") {
+          setCursor(() => Math.max(0, models.findIndex((m) => m === cfg.model)));
+          setState("models");
+        } else if (trimmed === "/clear") {
+          setMessages(() => []);
+          setAgentHistory([]);
+          setStreamingContent("");
+          setThinkingContent("");
+          setActiveToolUses([]);
+          setActiveToolResults([]);
+          setError(null);
+        } else if (trimmed === "/exit") {
+          exit();
+        } else if (trimmed) {
+          sendMessage(trimmed);
+        }
+        setInput(() => "");
+        setPaletteCursor(() => 0);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setInput((s) => {
+          setPaletteCursor(() => 0);
+          setFilePickerCursor(() => 0);
+          return s.slice(0, -1);
+        });
+      } else if (char && !key.ctrl && !key.meta && !key.tab) {
+        setInput((s) => {
+          setPaletteCursor(() => 0);
+          setFilePickerCursor(() => 0);
+          return s + char;
+        });
+      }
+    }
+  });
+}
+
+// src/ui/App.tsx
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function App() {
+  const { exit } = useApp();
+  const cwd = process.cwd().replace(homedir2(), "~").split(sep).join("/");
+  const [cfg, setCfg] = useState4(loadConfig());
+  const [models, setModels] = useState4([]);
+  const [contexts, setContexts] = useState4({});
+  const [activeCtx, setActiveCtx] = useState4(null);
+  const [state, setState] = useState4("loading");
+  const [cursor, setCursor] = useState4(0);
+  const [input, setInput] = useState4("");
+  const [paletteCursor, setPaletteCursor] = useState4(0);
+  const [filePickerCursor, setFilePickerCursor] = useState4(0);
+  const agent = useAgentRunner(cfg.model, activeCtx);
+  useEffect3(() => {
+    listModels().then((m) => {
+      setModels(m);
+      setState(cfg.model ? "ready" : "select-model");
+      Promise.all(m.map((name) => modelContext(name).then((ctx) => [name, ctx]))).then((pairs) => {
+        const map = Object.fromEntries(pairs);
+        setContexts(map);
+        const active = cfg.model ?? m[0];
+        if (active && map[active]) setActiveCtx(map[active]);
+      }).catch(() => {
+      });
+    }).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      agent.setError(msg);
+      setModels([]);
+      setState(cfg.model ? "ready" : "select-model");
+    });
+  }, []);
+  useKeyboard({
+    exit,
+    state,
+    setState,
+    models,
+    cursor,
+    setCursor,
+    contexts,
+    cfg,
+    setCfg,
+    setActiveCtx,
+    pendingPermissionRef: agent.pendingPermissionRef,
+    permissionCursor: agent.permissionCursor,
+    setPermissionCursor: agent.setPermissionCursor,
+    resolvePermission: agent.resolvePermission,
+    busyRef: agent.busyRef,
+    abortRef: agent.abortRef,
+    input,
+    setInput,
+    paletteCursor,
+    setPaletteCursor,
+    filePickerCursor,
+    setFilePickerCursor,
+    sendMessage: agent.sendMessage,
+    setMessages: agent.setMessages,
+    setAgentHistory: agent.setAgentHistory,
+    setStreamingContent: agent.setStreamingContent,
+    setThinkingContent: agent.setThinkingContent,
+    setActiveToolUses: agent.setActiveToolUses,
+    setActiveToolResults: agent.setActiveToolResults,
+    setError: agent.setError
+  });
+  const effort = cfg.effort ?? "medium";
+  const contextWarning = (() => {
+    if (!activeCtx) return null;
+    const last = [...agent.messages].reverse().find((m) => m.role === "assistant" && m.tokens);
+    const used = last?.tokens ? last.tokens.prompt_eval + last.tokens.eval : 0;
+    if (used < activeCtx * 0.7) return null;
+    return Math.round(used / activeCtx * 100);
+  })();
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx9(WelcomeBlock, { model: cfg.model, activeCtx, effort, cwd, error: agent.error }),
+    state === "loading" && !agent.error && /* @__PURE__ */ jsx9(Box9, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "connecting to ollama\u2026" }) }),
+    agent.error && state !== "ready" && /* @__PURE__ */ jsx9(
+      ChatView,
+      {
+        messages: [],
+        streaming: false,
+        streamingContent: "",
+        thinking: false,
+        error: agent.error
+      }
+    ),
+    state === "select-model" && /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginLeft: 2, children: [
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "no model configured \u2014 select one" }),
+      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(ModelList, { models, cursor }) }),
+      models.length > 0 && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "\u2191\u2193 navigate   enter select   ctrl+c quit" }) })
+    ] }),
+    state === "models" && /* @__PURE__ */ jsx9(
+      ModelsView,
+      {
+        models,
+        cursor,
+        model: cfg.model,
+        ollamaHost: cfg.ollamaHost,
+        effort
+      }
+    ),
+    state === "ready" && /* @__PURE__ */ jsxs9(Fragment2, { children: [
+      /* @__PURE__ */ jsx9(
+        ChatView,
+        {
+          messages: agent.messages,
+          streaming: agent.streaming,
+          streamingContent: agent.streamingContent,
+          thinking: agent.thinking,
+          thinkingContent: agent.thinkingContent,
+          error: agent.error,
+          pendingPermission: agent.pendingPermission,
+          permissionCursor: agent.permissionCursor,
+          activeToolUses: agent.activeToolUses,
+          activeToolResults: agent.activeToolResults
+        }
+      ),
+      input.startsWith("/") && /* @__PURE__ */ jsx9(CommandPalette, { filter: input, cursor: paletteCursor }),
+      contextWarning !== null && /* @__PURE__ */ jsx9(Box9, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx9(Text9, { color: "yellow", children: `\u26A0 context ${contextWarning}% full \u2014 run /clear and start fresh` }) }),
+      !input.startsWith("/") && (() => {
+        const m = parseMention(input);
+        if (!m) return null;
+        return /* @__PURE__ */ jsx9(FilePicker, { matches: searchFiles(process.cwd(), m.query), cursor: filePickerCursor });
+      })(),
+      /* @__PURE__ */ jsx9(InputBar, { input, disabled: agent.busy, processingLabel: agent.processingLabel }),
+      !agent.busy && /* @__PURE__ */ jsx9(Box9, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "type / to see commands" }) })
+    ] })
+  ] });
+}
+
+// src/cli.tsx
+render(createElement(App));