nimi-code 0.0.0-stage → 1.0.0

package/dist/main.js

@@ -0,0 +1,2081 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/providers/models.ts
+function getModelInfo(id) {
+  for (const m of MODELS) {
+    if (m.id === id) return m;
+  }
+  return void 0;
+}
+var MODELS;
+var init_models = __esm({
+  "src/providers/models.ts"() {
+    "use strict";
+    MODELS = [
+      { id: "claude-sonnet-5", provider: "anthropic", contextWindow: 2e5 },
+      { id: "qwen/qwen3.8-27b", provider: "groq", contextWindow: 128e3 },
+      { id: "muse-spark-1.3-contributor", provider: "meta", contextWindow: 128e3 },
+      { id: "deepseek-flash", provider: "deepseek", contextWindow: 128e3 },
+      { id: "gpt-4o-mini", provider: "openai", contextWindow: 128e3 }
+    ];
+  }
+});
+
+// src/agent/compaction.ts
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    if (m.role === "user") chars += m.content.length;
+    else if (m.role === "assistant") {
+      for (const b of m.content) {
+        if (b.type === "text") chars += b.text.length;
+        else chars += b.name.length + JSON.stringify(b.arguments).length;
+      }
+    } else chars += m.toolName.length + m.content.length;
+  }
+  return Math.ceil(chars / 4);
+}
+function getContextLimit(model2, override) {
+  if (override && override > 0) return override;
+  return getModelInfo(model2)?.contextWindow;
+}
+function shouldCompact(messages, model2, override) {
+  const limit = getContextLimit(model2, override);
+  if (!limit) return false;
+  return estimateTokens(messages) > limit * COMPACT_FRACTION;
+}
+function findSafeSplit(messages, keepRecent) {
+  let index = Math.max(0, messages.length - keepRecent);
+  while (index > 0 && messages[index].role === "toolResult") {
+    index--;
+  }
+  return index;
+}
+function renderForSummary(m) {
+  if (m.role === "user") return "user: " + m.content;
+  if (m.role === "toolResult") return "tool " + m.toolName + ": " + m.content.slice(0, 200);
+  const parts = [];
+  for (const b of m.content) {
+    if (b.type === "text") parts.push(b.text);
+    else parts.push("[called " + b.name + " " + JSON.stringify(b.arguments).slice(0, 200) + "]");
+  }
+  return "assistant: " + parts.join(" ");
+}
+async function compactMessages(messages, provider2, model2) {
+  const unchanged = () => ({ messages, summary: "", compacted: false });
+  const split = findSafeSplit(messages, KEEP_RECENT);
+  if (split <= 0) return unchanged();
+  const history = messages.slice(0, split).map(renderForSummary).join("\n");
+  const prompt = "Summarize this conversation concisely: what was accomplished, which files were read or changed, and what the next turns need.\n\nHISTORY:\n" + history;
+  let summary = "";
+  for await (const e of provider2.stream({
+    messages: [{ role: "user", content: prompt }],
+    model: model2,
+    system: "You summarize conversations concisely.",
+    tools: []
+  })) {
+    if (e.type === "text_delta") summary += e.delta;
+  }
+  summary = summary.trim();
+  if (!summary) return unchanged();
+  return {
+    messages: [{ role: "user", content: "[Previous conversation summary]: " + summary }, ...messages.slice(split)],
+    summary,
+    compacted: true
+  };
+}
+var KEEP_RECENT, COMPACT_FRACTION;
+var init_compaction = __esm({
+  "src/agent/compaction.ts"() {
+    "use strict";
+    init_models();
+    KEEP_RECENT = 6;
+    COMPACT_FRACTION = 0.75;
+  }
+});
+
+// src/agent.ts
+async function* runAgent(options) {
+  const maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS;
+  yield { type: "agent_start" };
+  for (let round = 0; round < maxTurns; round++) {
+    options.signal?.throwIfAborted();
+    if (shouldCompact(options.messages, options.model, options.contextLimit)) {
+      const before = options.messages.length;
+      const result = await compactMessages(options.messages, options.provider, options.model);
+      if (result.compacted) {
+        options.messages.length = 0;
+        options.messages.push(...result.messages);
+        yield { type: "compacted", before, after: options.messages.length };
+      }
+    }
+    let reply = void 0;
+    for await (const event of options.provider.stream({
+      messages: options.messages,
+      model: options.model,
+      tools: options.tools,
+      system: options.system
+    })) {
+      options.signal?.throwIfAborted();
+      if (event.type === "text_delta") {
+        yield { type: "text_delta", delta: event.delta };
+      } else {
+        reply = event.message;
+      }
+    }
+    if (reply === void 0) {
+      throw new Error("Provider stream ended without a final message");
+    }
+    options.messages.push(reply);
+    const toolCalls = [];
+    for (const block of reply.content) {
+      if (block.type === "toolCall") {
+        toolCalls.push(block);
+      }
+    }
+    if (toolCalls.length === 0) {
+      yield { type: "turn_end" };
+      yield { type: "agent_end", message: reply };
+      return;
+    }
+    yield { type: "turn_end" };
+    for (const call of toolCalls) {
+      options.signal?.throwIfAborted();
+      yield { type: "tool_start", id: call.id, name: call.name, input: call.arguments };
+      let toolToRun = void 0;
+      for (const candidate of options.tools) {
+        if (candidate.name === call.name) {
+          toolToRun = candidate;
+        }
+      }
+      if (toolToRun === void 0) {
+        const content = "Unknown tool: " + call.name;
+        options.messages.push({
+          role: "toolResult",
+          toolCallId: call.id,
+          toolName: call.name,
+          content,
+          isError: true
+        });
+        yield { type: "tool_end", id: call.id, name: call.name, result: content, isError: true };
+        continue;
+      }
+      if (toolToRun.readOnly !== true && options.canUseTool !== void 0) {
+        const decision = await options.canUseTool(call.name, call.arguments);
+        if (decision.behavior === "deny") {
+          const content = decision.message;
+          options.messages.push({
+            role: "toolResult",
+            toolCallId: call.id,
+            toolName: call.name,
+            content,
+            isError: true
+          });
+          yield { type: "denied", id: call.id, name: call.name, reason: content };
+          yield { type: "tool_end", id: call.id, name: call.name, result: content, isError: true };
+          continue;
+        }
+      }
+      try {
+        const output = await toolToRun.execute(call.arguments);
+        options.messages.push({
+          role: "toolResult",
+          toolCallId: call.id,
+          toolName: call.name,
+          content: output,
+          isError: false
+        });
+        yield { type: "tool_end", id: call.id, name: call.name, result: output, isError: false };
+      } catch (error) {
+        let message;
+        if (error instanceof Error) {
+          message = error.message;
+        } else {
+          message = String(error);
+        }
+        options.messages.push({
+          role: "toolResult",
+          toolCallId: call.id,
+          toolName: call.name,
+          content: message,
+          isError: true
+        });
+        yield { type: "tool_end", id: call.id, name: call.name, result: message, isError: true };
+      }
+    }
+  }
+  throw new Error("Agent exceeded max turns (" + maxTurns + ")");
+}
+var DEFAULT_MAX_TURNS;
+var init_agent = __esm({
+  "src/agent.ts"() {
+    "use strict";
+    init_compaction();
+    DEFAULT_MAX_TURNS = 20;
+  }
+});
+
+// src/tools/output.ts
+function truncateOutput(text) {
+  if (text.length <= MAX_OUTPUT_CHARS) return text;
+  return text.slice(0, MAX_OUTPUT_CHARS) + "\n[truncated at 20000 chars]";
+}
+var MAX_OUTPUT_CHARS;
+var init_output = __esm({
+  "src/tools/output.ts"() {
+    "use strict";
+    MAX_OUTPUT_CHARS = 2e4;
+  }
+});
+
+// src/tools/bash.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var run, BASH_TIMEOUT_MS, bashTool;
+var init_bash = __esm({
+  "src/tools/bash.ts"() {
+    "use strict";
+    init_output();
+    run = promisify(exec);
+    BASH_TIMEOUT_MS = 3e4;
+    bashTool = {
+      name: "bash",
+      description: "Run a shell command in the current folder and return its output",
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "The shell command to run"
+          }
+        },
+        required: ["command"]
+      },
+      async execute(args2) {
+        const { stdout, stderr } = await run(String(args2.command), {
+          cwd: process.cwd(),
+          timeout: BASH_TIMEOUT_MS
+        });
+        return truncateOutput(stdout + stderr);
+      }
+    };
+  }
+});
+
+// src/tools/edit.ts
+import { readFile, writeFile } from "fs/promises";
+import { resolve } from "path";
+var editTool;
+var init_edit = __esm({
+  "src/tools/edit.ts"() {
+    "use strict";
+    editTool = {
+      name: "edit",
+      description: "Edit a text file by replacing old text with new text",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file, relative to the current folder"
+          },
+          oldText: {
+            type: "string",
+            description: "The exact text to find in the file"
+          },
+          newText: {
+            type: "string",
+            description: "The text to replace it with"
+          }
+        },
+        required: ["path", "oldText", "newText"]
+      },
+      async execute(args2) {
+        const filePath = resolve(process.cwd(), String(args2.path));
+        const oldText = String(args2.oldText);
+        const newText = String(args2.newText);
+        const content = await readFile(filePath, "utf-8");
+        if (!content.includes(oldText)) {
+          throw new Error("oldText not found in " + String(args2.path));
+        }
+        const updated = content.replace(oldText, newText);
+        await writeFile(filePath, updated, "utf-8");
+        return "Edited " + String(args2.path);
+      }
+    };
+  }
+});
+
+// src/tools/find.ts
+import { readdir } from "fs/promises";
+import { join, relative, resolve as resolve2 } from "path";
+function globToRegExp(glob) {
+  let out = "";
+  for (const ch of glob) {
+    if (ch === "*") out += ".*";
+    else if (ch === "?") out += ".";
+    else if ("+()^$.{}|[]\\".includes(ch)) out += "\\" + ch;
+    else out += ch;
+  }
+  return new RegExp("^" + out + "$");
+}
+var SKIP, findTool;
+var init_find = __esm({
+  "src/tools/find.ts"() {
+    "use strict";
+    SKIP = ["node_modules", ".git", "dist", "build", ".next"];
+    findTool = {
+      name: "find",
+      description: "Find files by glob pattern, e.g. *.ts",
+      readOnly: true,
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Glob, e.g. *.ts" },
+          path: { type: "string", description: "Dir to search (default: .)" }
+        },
+        required: ["pattern"]
+      },
+      async execute(args2) {
+        const root = resolve2(process.cwd(), String(args2.path ?? "."));
+        const match = globToRegExp(String(args2.pattern));
+        const found = [];
+        const stack = [root];
+        while (stack.length > 0 && found.length < 100) {
+          const dir = stack.pop();
+          for (const e of await readdir(dir, { withFileTypes: true })) {
+            if (e.isDirectory()) {
+              if (!SKIP.includes(e.name)) stack.push(join(dir, e.name));
+            } else if (match.test(e.name)) found.push(relative(process.cwd(), join(dir, e.name)));
+          }
+        }
+        return found.length > 0 ? found.join("\n") : "(no matches)";
+      }
+    };
+  }
+});
+
+// src/tools/git.ts
+import { spawn } from "child_process";
+function runGit(args2) {
+  return new Promise((resolve7, reject) => {
+    const child = spawn("git", args2, { cwd: process.cwd() });
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error("git timed out after 30s"));
+    }, 3e4);
+    child.stdout.on("data", (d) => {
+      out += String(d);
+    });
+    child.stderr.on("data", (d) => {
+      err += String(d);
+    });
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const full = out + (err ? "\n" + err : "");
+      if (code !== 0) reject(new Error(full.trim() || "git exited " + code));
+      else resolve7(truncateOutput(full.trim() || "(no output)"));
+    });
+  });
+}
+var gitStatusTool, gitLogTool, gitDiffTool, gitAddTool, gitCommitTool, gitBranchTool, gitCheckoutTool, gitResetTool;
+var init_git = __esm({
+  "src/tools/git.ts"() {
+    "use strict";
+    init_output();
+    gitStatusTool = {
+      name: "git_status",
+      description: "Show git working tree status",
+      readOnly: true,
+      parameters: {
+        type: "object",
+        properties: { porcelain: { type: "boolean", description: "Machine-readable short format" } },
+        required: []
+      },
+      async execute(args2) {
+        const a = ["status"];
+        if (args2.porcelain) a.push("--porcelain");
+        return runGit(a);
+      }
+    };
+    gitLogTool = {
+      name: "git_log",
+      description: "Show recent commit history",
+      readOnly: true,
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "How many commits (default 10)" },
+          oneline: { type: "boolean", description: "One line per commit (default true)" }
+        },
+        required: []
+      },
+      async execute(args2) {
+        const limit = Number(args2.limit ?? 10);
+        const a = ["log", "-n", String(limit)];
+        if (args2.oneline !== false) a.push("--oneline");
+        return runGit(a);
+      }
+    };
+    gitDiffTool = {
+      name: "git_diff",
+      description: "Show unstaged/staged diff, optionally stat only or for a file",
+      readOnly: true,
+      parameters: {
+        type: "object",
+        properties: {
+          cached: { type: "boolean", description: "Show staged (--cached) instead of unstaged" },
+          stat: { type: "boolean", description: "Show --stat summary only" },
+          file: { type: "string", description: "Limit diff to one file" }
+        },
+        required: []
+      },
+      async execute(args2) {
+        const a = ["diff"];
+        if (args2.cached) a.push("--cached");
+        if (args2.stat) a.push("--stat");
+        if (args2.file) a.push("--", String(args2.file));
+        return runGit(a);
+      }
+    };
+    gitAddTool = {
+      name: "git_add",
+      description: "Stage files for commit",
+      parameters: {
+        type: "object",
+        properties: {
+          paths: { type: "array", description: 'Files to stage, e.g. ["src/a.ts"]' },
+          all: { type: "boolean", description: "Stage all changes including deletions" }
+        },
+        required: []
+      },
+      async execute(args2) {
+        const paths = args2.paths ?? [];
+        const a = ["add"];
+        if (args2.all) a.push("--all");
+        else if (paths.length > 0) a.push(...paths.map(String));
+        else throw new Error("No files specified. Pass paths or set all=true.");
+        return runGit(a);
+      }
+    };
+    gitCommitTool = {
+      name: "git_commit",
+      description: "Create a commit with staged changes",
+      parameters: {
+        type: "object",
+        properties: {
+          message: { type: "string", description: "Commit message (required)" },
+          amend: { type: "boolean", description: "Amend the previous commit" }
+        },
+        required: ["message"]
+      },
+      async execute(args2) {
+        const message = String(args2.message ?? "").trim();
+        if (!message) throw new Error("Commit message is required and cannot be empty.");
+        const a = ["commit", "-m", message];
+        if (args2.amend) a.push("--amend");
+        return runGit(a);
+      }
+    };
+    gitBranchTool = {
+      name: "git_branch",
+      description: "List, create, or delete branches",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", description: "list, create, or delete (default list)" },
+          name: { type: "string", description: "Branch name for create/delete" },
+          all: { type: "boolean", description: "List local and remote branches" }
+        },
+        required: []
+      },
+      async execute(args2) {
+        const action = String(args2.action ?? "list");
+        const a = ["branch"];
+        if (action === "list") {
+          if (args2.all) a.push("-a");
+        } else if (action === "create" || action === "delete") {
+          if (!args2.name) throw new Error("Branch name required for " + action + ".");
+          if (action === "delete") a.push("-d");
+          a.push(String(args2.name));
+        } else throw new Error("Unknown action: " + action + " (use list/create/delete).");
+        return runGit(a);
+      }
+    };
+    gitCheckoutTool = {
+      name: "git_checkout",
+      description: "Switch branches or restore a file from HEAD",
+      parameters: {
+        type: "object",
+        properties: {
+          branch: { type: "string", description: "Branch name to checkout" },
+          createNew: { type: "boolean", description: "Create and checkout a new branch (-b)" },
+          file: { type: "string", description: "File path to restore instead of switching" }
+        },
+        required: []
+      },
+      async execute(args2) {
+        const a = ["checkout"];
+        if (args2.file) a.push("--", String(args2.file));
+        else if (args2.branch) {
+          if (args2.createNew) a.push("-b");
+          a.push(String(args2.branch));
+        } else throw new Error("Specify either branch or file.");
+        return runGit(a);
+      }
+    };
+    gitResetTool = {
+      name: "git_reset",
+      description: "Unstage changes or reset to a commit",
+      parameters: {
+        type: "object",
+        properties: {
+          target: { type: "string", description: "Commit to reset to (default HEAD)" },
+          mode: { type: "string", description: "soft, mixed, or hard (default mixed)" },
+          file: { type: "string", description: "Specific file to unstage" }
+        },
+        required: []
+      },
+      async execute(args2) {
+        const mode = String(args2.mode ?? "mixed");
+        if (mode !== "soft" && mode !== "mixed" && mode !== "hard") throw new Error("Unknown mode: " + mode + ".");
+        const a = ["reset"];
+        if (mode !== "mixed") a.push("--" + mode);
+        a.push(String(args2.target ?? "HEAD"));
+        if (args2.file) a.push(String(args2.file));
+        return runGit(a);
+      }
+    };
+  }
+});
+
+// src/tools/grep.ts
+import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
+import { join as join2, relative as relative2, resolve as resolve3 } from "path";
+function globToRegExp2(glob) {
+  let out = "";
+  for (const ch of glob) {
+    if (ch === "*") out += ".*";
+    else if (ch === "?") out += ".";
+    else if ("+()^$.{}|[]\\".includes(ch)) out += "\\" + ch;
+    else out += ch;
+  }
+  return new RegExp("^" + out + "$");
+}
+var SKIP2, grepTool;
+var init_grep = __esm({
+  "src/tools/grep.ts"() {
+    "use strict";
+    SKIP2 = ["node_modules", ".git", "dist", "build", ".next"];
+    grepTool = {
+      name: "grep",
+      description: "Search file contents with a regex, returns file:line matches",
+      readOnly: true,
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: { type: "string", description: "Regex, e.g. TODO|FIXME" },
+          path: { type: "string", description: "File or dir to search (default: .)" },
+          include: { type: "string", description: "Only files matching glob, e.g. *.ts" }
+        },
+        required: ["pattern"]
+      },
+      async execute(args2) {
+        let regex;
+        try {
+          regex = new RegExp(String(args2.pattern));
+        } catch {
+          throw new Error("Invalid regex: " + String(args2.pattern));
+        }
+        const include = args2.include ? globToRegExp2(String(args2.include)) : null;
+        const start = resolve3(process.cwd(), String(args2.path ?? "."));
+        const stack = [start];
+        const targets = [];
+        while (stack.length > 0) {
+          const cur = stack.pop();
+          const s = await stat(cur);
+          if (s.isDirectory()) {
+            for (const e of await readdir2(cur, { withFileTypes: true })) {
+              if (e.isDirectory()) {
+                if (!SKIP2.includes(e.name)) stack.push(join2(cur, e.name));
+              } else if (!include || include.test(e.name)) targets.push(join2(cur, e.name));
+            }
+          } else targets.push(cur);
+        }
+        const hits = [];
+        for (const file of targets) {
+          if (hits.length >= 100) break;
+          if ((await stat(file)).size > 5e5) continue;
+          let content;
+          try {
+            content = await readFile2(file, "utf-8");
+          } catch {
+            continue;
+          }
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              hits.push(relative2(process.cwd(), file) + ":" + (i + 1) + ": " + lines[i].trim().slice(0, 120));
+              if (hits.length >= 100) break;
+            }
+          }
+        }
+        return hits.length > 0 ? hits.join("\n") + (hits.length >= 100 ? "\n[truncated]" : "") : "(no matches)";
+      }
+    };
+  }
+});
+
+// src/tools/ls.ts
+import { readdir as readdir3, stat as stat2 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+var lsTool;
+var init_ls = __esm({
+  "src/tools/ls.ts"() {
+    "use strict";
+    lsTool = {
+      name: "ls",
+      description: "List files in a directory with types and sizes",
+      readOnly: true,
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string", description: "Dir to list (default: .)" } },
+        required: []
+      },
+      async execute(args2) {
+        const dir = resolve4(process.cwd(), String(args2.path ?? "."));
+        const entries = await readdir3(dir, { withFileTypes: true });
+        const lines = [];
+        for (const e of entries) {
+          if (e.isDirectory()) lines.push("dir  - " + e.name + "/");
+          else lines.push("file " + String((await stat2(resolve4(dir, e.name))).size) + " " + e.name);
+        }
+        return lines.length > 0 ? lines.join("\n") : "(empty directory)";
+      }
+    };
+  }
+});
+
+// src/tools/read.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+var readTool;
+var init_read = __esm({
+  "src/tools/read.ts"() {
+    "use strict";
+    init_output();
+    readTool = {
+      name: "read",
+      description: "Read a text file and return its contents",
+      readOnly: true,
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file, relative to the current folder"
+          }
+        },
+        required: ["path"]
+      },
+      async execute(args2) {
+        const text = await readFile3(
+          resolve5(process.cwd(), String(args2.path)),
+          "utf-8"
+        );
+        return truncateOutput(text);
+      }
+    };
+  }
+});
+
+// src/tools/write.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import { dirname, resolve as resolve6 } from "path";
+var writeTool;
+var init_write = __esm({
+  "src/tools/write.ts"() {
+    "use strict";
+    writeTool = {
+      name: "write",
+      description: "Write text to a file, creating it or overwriting it",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file, relative to the current folder"
+          },
+          content: {
+            type: "string",
+            description: "The full text to write to the file"
+          }
+        },
+        required: ["path", "content"]
+      },
+      async execute(args2) {
+        const filePath = resolve6(process.cwd(), String(args2.path));
+        const content = String(args2.content);
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile2(filePath, content, "utf-8");
+        return "Wrote " + content.length + " chars to " + String(args2.path);
+      }
+    };
+  }
+});
+
+// src/types.ts
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/index.ts
+var ALL_TOOLS;
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    "use strict";
+    init_bash();
+    init_edit();
+    init_find();
+    init_git();
+    init_grep();
+    init_ls();
+    init_read();
+    init_write();
+    init_types();
+    ALL_TOOLS = [readTool, writeTool, editTool, bashTool, lsTool, findTool, grepTool, gitStatusTool, gitLogTool, gitDiffTool, gitAddTool, gitCommitTool, gitBranchTool, gitCheckoutTool, gitResetTool];
+  }
+});
+
+// src/permissions.ts
+function allowAll() {
+  return async () => ({ behavior: "allow" });
+}
+function createPromptPermission(rl) {
+  const always = /* @__PURE__ */ new Set();
+  return async (name, input) => {
+    if (always.has(name)) return { behavior: "allow" };
+    const what = input.command ?? input.path ?? input.file ?? JSON.stringify(input);
+    console.log(`
+Permission needed: ${name} ${String(what).slice(0, 120)}`);
+    console.log("[y]es / [a]lways / [n]o (default)");
+    const answer = await new Promise((resolve7) => rl.question("> ", resolve7));
+    const choice = answer.trim().toLowerCase();
+    if (choice === "a" || choice === "always") {
+      always.add(name);
+      return { behavior: "allow" };
+    }
+    if (choice === "y" || choice === "yes") return { behavior: "allow" };
+    return { behavior: "deny", message: `User denied ${name}. Do not retry; ask what to do instead.` };
+  };
+}
+var init_permissions = __esm({
+  "src/permissions.ts"() {
+    "use strict";
+  }
+});
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+function toAnthropic(message) {
+  return message.map((m) => {
+    if (m.role === "user") return { role: "user", content: m.content };
+    if (m.role === "assistant") {
+      return {
+        role: "assistant",
+        content: m.content.map(
+          (b) => b.type === "text" ? { type: "text", text: b.text } : { type: "tool_use", id: b.id, name: b.name, input: b.arguments }
+        )
+      };
+    }
+    ;
+    return {
+      role: "user",
+      content: [{ type: "tool_result", tool_use_id: m.toolCallId, content: m.content, is_error: m.isError }]
+    };
+  });
+}
+function createAnthropic() {
+  const client = new Anthropic();
+  return {
+    name: "anthropic",
+    defaultModel: "claude-sonnet-5",
+    async *stream({ messages, model: model2, system: system2, tools = [] }) {
+      const stream = client.messages.stream({
+        model: model2,
+        max_tokens: 4096,
+        system: system2,
+        messages: toAnthropic(messages),
+        tools: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.parameters
+        }))
+      });
+      let text = "";
+      const content = [];
+      const jsonParts = [];
+      for await (const event of stream) {
+        const idx = event.index ?? content.length - 1;
+        if (event.type === "content_block_start") {
+          const b = event.content_block;
+          if (b.type === "text") {
+            content.push({ type: "text", text: "" });
+            jsonParts.push("");
+          } else if (b.type === "tool_use") {
+            content.push({ type: "toolCall", id: b.id, name: b.name, arguments: {} });
+            jsonParts.push("");
+          }
+        } else if (event.type === "content_block_delta") {
+          const block = content[idx] ?? content.at(-1);
+          if (event.delta.type === "text_delta" && block?.type === "text") {
+            block.text += event.delta.text;
+            yield { type: "text_delta", delta: event.delta.text };
+          } else if (event.delta.type === "input_json_delta") {
+            jsonParts[idx] += event.delta.partial_json;
+          }
+        } else if (event.type === "content_block_stop") {
+          const at = event.index ?? content.length - 1;
+          const block = content[at];
+          if (block?.type === "toolCall") {
+            try {
+              block.arguments = jsonParts[at] ? JSON.parse(jsonParts[at]) : {};
+            } catch {
+              block.arguments = {};
+            }
+          }
+        }
+      }
+      const final = await stream.finalMessage();
+      const stopReason = final.stop_reason === "tool_use" ? "toolUse" : final.stop_reason === "max_tokens" ? "length" : "stop";
+      yield {
+        type: "done",
+        message: {
+          role: "assistant",
+          content,
+          usage: { input: final.usage.input_tokens, output: final.usage.output_tokens },
+          stopReason
+        }
+      };
+    }
+  };
+}
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+  }
+});
+
+// src/providers/openai-compat.ts
+import OpenAI from "openai";
+function toOpenAI(messages) {
+  return messages.map((message) => {
+    if (message.role === "user") {
+      return { role: "user", content: message.content };
+    }
+    if (message.role === "assistant") {
+      const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+      const toolCalls = message.content.filter(
+        (block) => block.type === "toolCall"
+      );
+      if (toolCalls.length > 0) {
+        return {
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.map((tool) => ({
+            id: tool.id,
+            type: "function",
+            function: {
+              name: tool.name,
+              arguments: JSON.stringify(tool.arguments)
+            }
+          }))
+        };
+      }
+      return { role: "assistant", content: text };
+    }
+    return {
+      role: "tool",
+      tool_call_id: message.toolCallId,
+      content: message.content
+    };
+  });
+}
+function createOpenAICompat(name, baseURL, apiKey, defaultModel) {
+  const client = new OpenAI({ baseURL, apiKey });
+  return {
+    name,
+    defaultModel,
+    async *stream({ messages, model: model2, system: system2, tools = [] }) {
+      const response = await client.chat.completions.create({
+        model: model2,
+        stream: true,
+        stream_options: { include_usage: true },
+        messages: [
+          ...system2 ? [{ role: "system", content: system2 }] : [],
+          ...toOpenAI(messages)
+        ],
+        tools: tools.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+          }
+        })),
+        tool_choice: tools.length ? "auto" : void 0
+      });
+      let fullText = "";
+      const toolCalls = [];
+      let usage = { input: 0, output: 0 };
+      let stopReason = "stop";
+      for await (const chunk of response) {
+        const choice = chunk.choices[0];
+        const delta = choice?.delta;
+        if (delta?.content) {
+          fullText += delta.content;
+          yield { type: "text_delta", delta: delta.content };
+        }
+        for (const tool of delta?.tool_calls ?? []) {
+          const index = tool.index;
+          if (!toolCalls[index]) {
+            toolCalls[index] = { id: "", name: "", arguments: "" };
+          }
+          if (tool.id) toolCalls[index].id = tool.id;
+          if (tool.function?.name) {
+            toolCalls[index].name += tool.function.name;
+          }
+          if (tool.function?.arguments) {
+            toolCalls[index].arguments += tool.function.arguments;
+          }
+        }
+        if (choice?.finish_reason === "tool_calls") {
+          stopReason = "toolUse";
+        } else if (choice?.finish_reason === "length") {
+          stopReason = "length";
+        }
+        if (chunk.usage) {
+          usage = {
+            input: chunk.usage.prompt_tokens,
+            output: chunk.usage.completion_tokens
+          };
+        }
+      }
+      const content = [];
+      if (fullText) {
+        content.push({ type: "text", text: fullText });
+      }
+      for (const tool of toolCalls) {
+        if (!tool) continue;
+        let parsed = {};
+        if (tool.arguments) {
+          try {
+            parsed = JSON.parse(tool.arguments);
+          } catch {
+            parsed = {};
+          }
+        }
+        content.push({
+          type: "toolCall",
+          id: tool.id,
+          name: tool.name,
+          arguments: parsed
+        });
+      }
+      yield {
+        type: "done",
+        message: { role: "assistant", content, usage, stopReason }
+      };
+    }
+  };
+}
+var init_openai_compat = __esm({
+  "src/providers/openai-compat.ts"() {
+    "use strict";
+  }
+});
+
+// src/providers/index.ts
+function requireKey(envVar, provider2) {
+  const key = process.env[envVar];
+  if (!key) throw new Error(`Missing ${envVar} for ${provider2}. Add it to .env or environment.`);
+  return key;
+}
+function getProvider(name) {
+  const create = providers[name];
+  if (!create) {
+    throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(providers).join(", ")}`);
+  }
+  return create();
+}
+var providers;
+var init_providers = __esm({
+  "src/providers/index.ts"() {
+    "use strict";
+    init_anthropic();
+    init_openai_compat();
+    providers = {
+      anthropic: createAnthropic,
+      "anthropic-openai": () => createOpenAICompat("anthropic-openai", "https://api.anthropic.com/v1/", requireKey("ANTHROPIC_API_KEY", "anthropic-openai"), "claude-sonnet-5"),
+      "groq": () => createOpenAICompat("groq", "https://api.groq.com/openai/v1", requireKey("GROQ_API_KEY", "groq"), "qwen/qwen3.8-27b"),
+      "meta": () => createOpenAICompat("meta", "https://api.meta.ai/v1", requireKey("META_API_KEY", "meta"), "muse-spark-1.3-contributor"),
+      "deepseek": () => createOpenAICompat("deepseek", "https://api.deepseek.com", requireKey("DEEPSEEK_API_KEY", "deepseek"), "deepseek-flash"),
+      "openai": () => createOpenAICompat("openai", "https://api.openai.com/v1", requireKey("OPENAI_API_KEY", "openai"), "gpt-4o-mini")
+    };
+  }
+});
+
+// src/session/store.ts
+import { existsSync as existsSync3 } from "fs";
+import { appendFile, mkdir as mkdir2, readdir as readdir4, readFile as readFile6 } from "fs/promises";
+import { join as join5 } from "path";
+function getSessionDir() {
+  return join5(process.cwd(), ".nimi", "sessions");
+}
+function getSessionPath(id) {
+  return join5(getSessionDir(), id + ".jsonl");
+}
+function newSessionId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+async function appendEntry(id, entry) {
+  await mkdir2(getSessionDir(), { recursive: true });
+  await appendFile(getSessionPath(id), JSON.stringify(entry) + "\n", "utf-8");
+}
+async function appendMessages(id, messages) {
+  for (const message of messages) {
+    await appendEntry(id, { type: "message", message });
+  }
+}
+async function loadSession(id) {
+  if (!existsSync3(getSessionPath(id))) return null;
+  const raw = await readFile6(getSessionPath(id), "utf-8");
+  let info = null;
+  const messages = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type === "session_info") info = entry;
+    else if (entry.type === "message") messages.push(entry.message);
+  }
+  if (!info) return null;
+  return { info, messages };
+}
+async function listSessions() {
+  await mkdir2(getSessionDir(), { recursive: true });
+  const files = await readdir4(getSessionDir());
+  const ids = [];
+  for (const f of files) {
+    if (f.endsWith(".jsonl")) ids.push(f.slice(0, -6));
+  }
+  ids.sort();
+  return ids;
+}
+var init_store = __esm({
+  "src/session/store.ts"() {
+    "use strict";
+  }
+});
+
+// src/trace/recorder.ts
+import { appendFileSync, mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+function isSnapshotEvent(type) {
+  return type === "turn_end" || type === "agent_end" || type === "compacted";
+}
+function createTraceRecorder(path, info) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(
+    path,
+    JSON.stringify({
+      v: V,
+      type: "header",
+      session: info.session,
+      provider: info.provider,
+      model: info.model,
+      prompt: info.prompt,
+      started_at: (/* @__PURE__ */ new Date()).toISOString(),
+      argv: info.argv,
+      tools: info.tools ?? []
+    }) + "\n"
+  );
+  let i = 0;
+  let turns = 0;
+  let tools = 0;
+  let done = false;
+  const writeLine = (obj) => {
+    appendFileSync(path, JSON.stringify(obj) + "\n");
+  };
+  return {
+    path,
+    record(event, messages) {
+      const index = i++;
+      if (event.type === "turn_end") turns++;
+      if (event.type === "tool_start") tools++;
+      writeLine({ v: V, type: "event", i: index, event });
+      if (isSnapshotEvent(event.type)) {
+        writeLine({ v: V, type: "messages", afterEvent: index, messages });
+      }
+    },
+    finish(messages) {
+      if (done) return;
+      done = true;
+      writeLine({
+        v: V,
+        type: "end",
+        messageCount: messages.length,
+        counts: { turns, tools }
+      });
+    }
+  };
+}
+async function* withTrace(events, trace, messages) {
+  try {
+    for await (const event of events) {
+      trace.record(event, messages);
+      yield event;
+    }
+  } finally {
+    trace.finish(messages);
+  }
+}
+var V;
+var init_recorder = __esm({
+  "src/trace/recorder.ts"() {
+    "use strict";
+    V = 1;
+  }
+});
+
+// src/tui/format.ts
+function argValue(args2) {
+  const pick = args2.path ?? args2.file ?? args2.command ?? args2.cmd ?? args2.query ?? args2.text ?? args2.content;
+  if (typeof pick === "string" && pick.length > 0) return pick;
+  const keys = Object.keys(args2);
+  if (keys.length === 0) return "";
+  const first = args2[keys[0]];
+  return typeof first === "string" ? first : keys.join(", ");
+}
+function shortLabel(name, args2) {
+  const value = argValue(args2);
+  const label = value ? `${name} ${value}` : name;
+  return label.length > MAX_LABEL ? label.slice(0, MAX_LABEL - 3) + "..." : label;
+}
+function resultSummary(toolName, content, isError) {
+  const firstLine = content.split("\n")[0] ?? "";
+  if (isError) {
+    const msg = firstLine.length > MAX_SUMMARY ? firstLine.slice(0, MAX_SUMMARY - 3) + "..." : firstLine;
+    return msg || "error";
+  }
+  if (toolName === "read") {
+    const lines = content.split("\n").length;
+    return `(${lines} line${lines === 1 ? "" : "s"})`;
+  }
+  if (toolName === "bash") {
+    const lines = content.trim() ? content.trim().split("\n").length : 0;
+    return lines > 0 ? `(${lines} line${lines === 1 ? "" : "s"})` : "(ok)";
+  }
+  if (toolName === "write" || toolName === "edit") return "(ok)";
+  const summary = firstLine.length > MAX_SUMMARY ? firstLine.slice(0, MAX_SUMMARY - 3) + "..." : firstLine;
+  return summary ? summary : "(ok)";
+}
+var MAX_LABEL, MAX_SUMMARY;
+var init_format = __esm({
+  "src/tui/format.ts"() {
+    "use strict";
+    MAX_LABEL = 80;
+    MAX_SUMMARY = 100;
+  }
+});
+
+// src/tui/slash.ts
+function parseSlash(input) {
+  if (!input.startsWith("/")) return null;
+  const parts = input.slice(1).trim().split(/\s+/);
+  const name = parts[0] ?? "";
+  return nameToAction(name, parts.slice(1).join(" "));
+}
+function parseBare(input) {
+  const word = input.trim().toLowerCase();
+  if (word === "help" || word === "clear" || word === "quit" || word === "exit" || word === "q") {
+    return nameToAction(word);
+  }
+  return null;
+}
+function nameToAction(name, arg = "") {
+  if (name === "help") return { type: "help" };
+  if (name === "clear") return { type: "clear" };
+  if (name === "compact") return { type: "compact" };
+  if (name === "context") return { type: "context" };
+  if (name === "model") return { type: "model", arg: arg.trim() };
+  if (name === "tools") return { type: "tools" };
+  if (name === "sessions") return { type: "sessions" };
+  if (name === "session") return { type: "session" };
+  if (name === "quit" || name === "exit" || name === "q") return { type: "quit" };
+  return { type: "unknown", name: name || "/" };
+}
+var HELP_TEXT;
+var init_slash = __esm({
+  "src/tui/slash.ts"() {
+    "use strict";
+    HELP_TEXT = "Commands:\n  /help      Show this help\n  /clear     Clear the transcript\n  /compact   Summarize old history to free context\n  /context   Show token usage vs the window\n  /model [id]  List models, or switch (keeps history)\n  /tools     List the tools the model can call\n  /sessions  List saved sessions\n  /session   Show this session's resume command\n  /quit      Exit nimi";
+  }
+});
+
+// src/tui/App.tsx
+var App_exports = {};
+__export(App_exports, {
+  default: () => App
+});
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Static, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import Spinner from "ink-spinner";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({ model: model2, sessionId }) {
+  const width = process.stdout.columns ?? 60;
+  const count = Math.max(20, Math.min(width - 2, DIVIDER_MAX));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "nimi" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " ",
+        "\xB7 ",
+        model2,
+        " \xB7 ",
+        process.cwd(),
+        " \xB7 ",
+        sessionId.slice(-6)
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(count) })
+  ] });
+}
+function renderRow(row) {
+  if (row.kind === "user") {
+    return /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "\u203A " }),
+      /* @__PURE__ */ jsx(Text, { children: row.text })
+    ] }, row.id);
+  }
+  if (row.kind === "text") {
+    return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: row.text }) }, row.id);
+  }
+  return /* @__PURE__ */ jsx(Box, { marginTop: 0, children: /* @__PURE__ */ jsx(ToolRow, { row }) }, row.id);
+}
+function ToolRow({ row }) {
+  if (row.status === "running") {
+    return /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u21B3 " }),
+      /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " ",
+        row.label
+      ] })
+    ] });
+  }
+  const mark = row.status === "ok" ? "\u2713" : "\u2715";
+  const color = row.status === "ok" ? "green" : "red";
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u21B3 " }),
+    /* @__PURE__ */ jsx(Text, { color, children: mark }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " ",
+      row.label,
+      " ",
+      row.summary
+    ] })
+  ] });
+}
+function App({ provider: provider2, model: model2, system: system2, tools, initialPrompt, yolo, sessionId, initialMessages, contextLimit }) {
+  const { exit } = useApp();
+  const [rows, setRows] = useState([]);
+  const [draft, setDraft] = useState("");
+  const [working, setWorking] = useState(false);
+  const [error, setError] = useState(null);
+  const [session, setSession] = useState(0);
+  const [pending, setPending] = useState(null);
+  const idRef = useRef(1);
+  const messagesRef = useRef([...initialMessages]);
+  const savedCount = useRef(initialMessages.length);
+  const abortRef = useRef(null);
+  const workingRef = useRef(false);
+  const textIdRef = useRef(null);
+  const startedRef = useRef(false);
+  const alwaysAllowed = useRef(/* @__PURE__ */ new Set());
+  const [activeProvider, setActiveProvider] = useState(provider2);
+  const [activeModel, setActiveModel] = useState(model2);
+  const nextId = useCallback(() => idRef.current++, []);
+  const appendText = useCallback((delta) => {
+    const id = textIdRef.current;
+    if (id === null) {
+      const newId = nextId();
+      textIdRef.current = newId;
+      setRows((prev) => [...prev, { kind: "text", id: newId, text: delta }]);
+    } else {
+      setRows((prev) => prev.map((r) => r.kind === "text" && r.id === id ? { ...r, text: r.text + delta } : r));
+    }
+  }, [nextId]);
+  const canUseTool = useCallback(
+    async (name, input) => {
+      if (yolo || alwaysAllowed.current.has(name)) return { behavior: "allow" };
+      const answer = await new Promise((resolve7) => {
+        setPending({ name, input, resolve: resolve7 });
+      });
+      setPending(null);
+      if (answer === "always") {
+        alwaysAllowed.current.add(name);
+        return { behavior: "allow" };
+      }
+      if (answer === "yes") return { behavior: "allow" };
+      return { behavior: "deny", message: `User denied ${name}. Do not retry; ask what to do instead.` };
+    },
+    [yolo]
+  );
+  const submitPrompt = useCallback(
+    async (prompt) => {
+      const text = prompt.trim();
+      if (!text || workingRef.current) return;
+      setError(null);
+      const slash = parseSlash(text) ?? parseBare(text);
+      if (slash) {
+        if (slash.type === "quit") {
+          exit();
+          return;
+        }
+        if (slash.type === "clear") {
+          messagesRef.current = [];
+          textIdRef.current = null;
+          setRows([]);
+          setSession((s) => s + 1);
+          return;
+        }
+        if (slash.type === "model") {
+          const id2 = nextId();
+          if (!slash.arg) {
+            const lines = MODELS.map((m) => `  ${m.id}${m.id === activeModel ? "  \u2190 current" : ""}`);
+            setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: "Models (use /model <id>):\n" + lines.join("\n") }]);
+          } else {
+            const info = getModelInfo(slash.arg);
+            if (!info) {
+              setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: `Unknown model: ${slash.arg}  (try /model)` }]);
+            } else {
+              try {
+                setActiveProvider(getProvider(info.provider));
+                setActiveModel(info.id);
+                setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: `Switched to ${info.id} \u2014 history kept.` }]);
+              } catch (e) {
+                setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: e instanceof Error ? e.message : String(e) }]);
+              }
+            }
+          }
+          idRef.current++;
+          return;
+        }
+        if (slash.type === "tools") {
+          const id2 = nextId();
+          const lines = tools.map((t) => `  ${t.name}${t.readOnly ? "  [read-only]" : "  [asks permission]"}`);
+          setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: "Tools:\n" + lines.join("\n") }]);
+          idRef.current++;
+          return;
+        }
+        if (slash.type === "sessions") {
+          const id2 = nextId();
+          const ids = await listSessions();
+          const lines = [];
+          for (let i = ids.length - 1; i >= 0 && lines.length < 10; i--) {
+            const loaded = await loadSession(ids[i]);
+            if (loaded) lines.push(`  ${loaded.info.id}  ${loaded.info.provider}/${loaded.info.model}`);
+          }
+          setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: lines.length > 0 ? "Sessions (resume with --session <id>):\n" + lines.join("\n") : "No saved sessions yet." }]);
+          idRef.current++;
+          return;
+        }
+        if (slash.type === "session") {
+          const id2 = nextId();
+          setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: `Session ${sessionId} \u2014 resume with: nimi --session ${sessionId}` }]);
+          idRef.current++;
+          return;
+        }
+        if (slash.type === "context") {
+          const id2 = nextId();
+          const used = estimateTokens(messagesRef.current);
+          const limit = getContextLimit(activeModel, contextLimit);
+          const text2 = limit ? `~${used} / ${limit} tokens (${Math.round(used / limit * 100)}%) \u2014 auto-compacts at 75%` : `~${used} tokens (window unknown)`;
+          setRows((prev) => [...prev, { kind: "user", id: id2, text: text2 }, { kind: "text", id: id2 + 1, text: text2 }]);
+          idRef.current++;
+          return;
+        }
+        if (slash.type === "compact") {
+          if (workingRef.current) return;
+          const id2 = nextId();
+          if (messagesRef.current.length === 0) {
+            setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: "Nothing to compact." }]);
+            idRef.current++;
+            return;
+          }
+          workingRef.current = true;
+          setWorking(true);
+          try {
+            const result = await compactMessages(messagesRef.current, activeProvider, activeModel);
+            if (!result.compacted) {
+              setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: "History is already short." }]);
+            } else {
+              messagesRef.current = result.messages;
+              textIdRef.current = null;
+              setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: "Compacted. Summary:\n" + result.summary }]);
+            }
+          } catch (e) {
+            setRows((prev) => [...prev, { kind: "user", id: id2, text }, { kind: "text", id: id2 + 1, text: "Compact failed: " + (e instanceof Error ? e.message : String(e)) }]);
+          } finally {
+            workingRef.current = false;
+            setWorking(false);
+          }
+          idRef.current++;
+          return;
+        }
+        const id = nextId();
+        if (slash.type === "help") {
+          setRows((prev) => [...prev, { kind: "user", id, text }, { kind: "text", id: id + 1, text: HELP_TEXT }]);
+          idRef.current++;
+        } else {
+          setRows((prev) => [
+            ...prev,
+            { kind: "user", id, text },
+            { kind: "text", id: id + 1, text: `Unknown command: ${slash.name}. Try /help.` }
+          ]);
+          idRef.current++;
+        }
+        return;
+      }
+      const userId = nextId();
+      setRows((prev) => [...prev, { kind: "user", id: userId, text }]);
+      messagesRef.current.push({ role: "user", content: text });
+      workingRef.current = true;
+      setWorking(true);
+      textIdRef.current = null;
+      const controller = new AbortController();
+      abortRef.current = controller;
+      try {
+        for await (const event of runAgent({
+          provider: activeProvider,
+          model: activeModel,
+          system: system2,
+          tools,
+          messages: messagesRef.current,
+          signal: controller.signal,
+          contextLimit,
+          canUseTool
+        })) {
+          if (event.type === "text_delta") {
+            appendText(event.delta);
+          } else if (event.type === "tool_start") {
+            textIdRef.current = null;
+            const id = nextId();
+            const label = shortLabel(event.name, event.input);
+            setRows((prev) => [
+              ...prev,
+              { kind: "tool", id, toolCallId: event.id, label, status: "running", summary: "" }
+            ]);
+          } else if (event.type === "denied") {
+            textIdRef.current = null;
+          } else if (event.type === "compacted") {
+            textIdRef.current = null;
+            const id = nextId();
+            setRows((prev) => [...prev, { kind: "text", id, text: `Auto-compacted context: ${event.before} \u2192 ${event.after} messages.` }]);
+          } else if (event.type === "tool_end") {
+            textIdRef.current = null;
+            const summary = resultSummary(event.name, event.result, event.isError);
+            setRows(
+              (prev) => prev.map(
+                (r) => r.kind === "tool" && r.toolCallId === event.id ? { ...r, status: event.isError ? "error" : "ok", summary } : r
+              )
+            );
+          } else if (event.type === "turn_end" || event.type === "agent_end") {
+            textIdRef.current = null;
+          }
+        }
+      } catch (err) {
+        textIdRef.current = null;
+        if (err instanceof Error && err.name === "AbortError") {
+          const id = nextId();
+          setRows((prev) => [...prev, { kind: "text", id, text: "(interrupted)" }]);
+        } else {
+          setError(err instanceof Error ? err.message : String(err));
+        }
+      } finally {
+        abortRef.current = null;
+        workingRef.current = false;
+        setWorking(false);
+        const fresh = messagesRef.current.slice(savedCount.current);
+        if (fresh.length > 0) {
+          savedCount.current = messagesRef.current.length;
+          void appendMessages(sessionId, fresh).catch((e) => {
+            setError(e instanceof Error ? e.message : String(e));
+          });
+        }
+      }
+    },
+    [appendText, canUseTool, contextLimit, exit, activeModel, activeProvider, nextId, sessionId, system2, tools]
+  );
+  useInput((input, key) => {
+    if (pending) {
+      const ch = input.toLowerCase();
+      if (ch === "y") pending.resolve("yes");
+      else if (ch === "a") pending.resolve("always");
+      else if (ch === "n" || key.escape) pending.resolve("no");
+      return;
+    }
+    if (key.escape && workingRef.current) {
+      abortRef.current?.abort();
+    }
+  });
+  useEffect(() => {
+    if (!startedRef.current && initialPrompt) {
+      startedRef.current = true;
+      void submitPrompt(initialPrompt);
+    }
+  }, [initialPrompt, submitPrompt]);
+  const settled = rows.length > 0 ? rows.slice(0, -1) : [];
+  const live = rows.length > 0 ? rows[rows.length - 1] : null;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Header, { model: activeModel, sessionId }),
+    rows.length === 0 && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: initialMessages.length > 0 ? `Resumed session \u2014 ${initialMessages.length} messages restored. Type, or /help.` : "Type a message, or /help." }) }),
+    /* @__PURE__ */ jsx(Static, { items: settled, children: (row) => renderRow(row) }, session),
+    live && renderRow(live),
+    pending && /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        "Permission needed: ",
+        shortLabel(pending.name, pending.input)
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "y = yes \xB7 a = always \xB7 n = no (esc)" })
+    ] }),
+    error && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      "\u2715 ",
+      error
+    ] }) }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: working, children: "\u203A " }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: draft,
+          onChange: setDraft,
+          onSubmit: (value) => {
+            if (pending) return;
+            setDraft("");
+            void submitPrompt(value);
+          },
+          placeholder: pending ? "answer y/a/n\u2026" : working ? "working\u2026" : "Ask nimi\u2026"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: working ? "working\u2026 esc to interrupt" : "enter send \xB7 /help /clear /quit \xB7 esc interrupt" }) })
+  ] });
+}
+var DIVIDER_MAX;
+var init_App = __esm({
+  "src/tui/App.tsx"() {
+    "use strict";
+    init_agent();
+    init_compaction();
+    init_models();
+    init_providers();
+    init_store();
+    init_format();
+    init_slash();
+    DIVIDER_MAX = 80;
+  }
+});
+
+// src/modes/classic.ts
+var classic_exports = {};
+__export(classic_exports, {
+  runClassic: () => runClassic
+});
+import { createInterface } from "readline";
+async function runClassic(opts) {
+  let provider2 = opts.provider;
+  let model2 = opts.model;
+  const messages = [...opts.initialMessages];
+  let saved = messages.length;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const canUseTool = opts.yolo ? allowAll() : createPromptPermission(rl);
+  let trace = null;
+  const ask = (q) => new Promise((resolve7) => rl.question(q, resolve7));
+  console.log(`nimi ${model2} \xB7 session ${opts.sessionId.slice(-6)} \xB7 /help for commands`);
+  if (messages.length > 0) console.log(`Resumed \u2014 ${messages.length} messages restored.`);
+  if (opts.yolo) console.log("Permission prompts off (--yolo).");
+  while (true) {
+    const line = (await ask("\u203A ")).trim();
+    if (!line) continue;
+    const slash = parseSlash(line) ?? parseBare(line);
+    if (slash) {
+      if (slash.type === "quit") break;
+      if (slash.type === "clear") {
+        messages.length = 0;
+        continue;
+      }
+      if (slash.type === "help") {
+        console.log(HELP_TEXT);
+        continue;
+      }
+      if (slash.type === "context") {
+        const used = estimateTokens(messages);
+        const limit = getContextLimit(model2, opts.contextLimit);
+        console.log(limit ? `~${used} / ${limit} tokens` : `~${used} tokens (window unknown)`);
+        continue;
+      }
+      if (slash.type === "compact") {
+        const result = await compactMessages(messages, provider2, model2);
+        if (!result.compacted) console.log("History is already short.");
+        else {
+          messages.length = 0;
+          messages.push(...result.messages);
+          console.log("Compacted. Summary:\n" + result.summary);
+        }
+        continue;
+      }
+      if (slash.type === "model") {
+        if (!slash.arg) {
+          for (const m of MODELS) console.log(`  ${m.id}${m.id === model2 ? "  \u2190 current" : ""}`);
+        } else {
+          const info = getModelInfo(slash.arg);
+          if (!info) console.log(`Unknown model: ${slash.arg}`);
+          else {
+            try {
+              provider2 = getProvider(info.provider);
+              model2 = info.id;
+              console.log(`Switched to ${model2} \u2014 history kept.`);
+            } catch (e) {
+              console.log(e instanceof Error ? e.message : String(e));
+            }
+          }
+        }
+        continue;
+      }
+      if (slash.type === "tools") {
+        for (const t of ALL_TOOLS) console.log(`  ${t.name}${t.readOnly ? "  [read-only]" : "  [asks permission]"}`);
+        continue;
+      }
+      if (slash.type === "sessions") {
+        const ids = await listSessions();
+        if (ids.length === 0) console.log("No saved sessions yet.");
+        for (let i = ids.length - 1; i >= 0 && i >= ids.length - 10; i--) {
+          const loaded = await loadSession(ids[i]);
+          if (loaded) console.log(`  ${loaded.info.id}  ${loaded.info.provider}/${loaded.info.model}`);
+        }
+        continue;
+      }
+      if (slash.type === "session") {
+        console.log(`Session ${opts.sessionId} \u2014 resume with: nimi --session ${opts.sessionId}`);
+        continue;
+      }
+      console.log(`Unknown command: ${slash.name}. Try /help.`);
+      continue;
+    }
+    messages.push({ role: "user", content: line });
+    if (opts.tracePath && !trace) {
+      trace = createTraceRecorder(opts.tracePath, {
+        session: opts.sessionId,
+        provider: provider2.name,
+        model: model2,
+        prompt: line,
+        argv: process.argv.slice(2),
+        tools: opts.tools.map((t) => ({ name: t.name, readOnly: t.readOnly }))
+      });
+    }
+    for await (const event of runAgent({ provider: provider2, model: model2, system: opts.system, tools: opts.tools, messages, contextLimit: opts.contextLimit, canUseTool })) {
+      trace?.record(event, messages);
+      if (event.type === "text_delta") process.stdout.write(event.delta);
+      else if (event.type === "tool_start") console.log(`
+[tool] ${event.name} ${JSON.stringify(event.input)}`);
+      else if (event.type === "denied") console.log(`
+[denied] ${event.name}: ${event.reason}`);
+      else if (event.type === "compacted") console.log(`
+[compacted ${event.before} \u2192 ${event.after} messages]`);
+      else if (event.type === "tool_end") {
+        const preview = event.result.length > 300 ? event.result.slice(0, 300) + "..." : event.result;
+        console.log(`
+[result] ${event.name}${event.isError ? " (error)" : ""}:
+${preview}`);
+      } else if (event.type === "turn_end" || event.type === "agent_end") process.stdout.write("\n");
+    }
+    const fresh = messages.slice(saved);
+    if (fresh.length > 0) {
+      saved = messages.length;
+      await appendMessages(opts.sessionId, fresh);
+    }
+  }
+  trace?.finish(messages);
+  rl.close();
+}
+var init_classic = __esm({
+  "src/modes/classic.ts"() {
+    "use strict";
+    init_agent();
+    init_compaction();
+    init_providers();
+    init_models();
+    init_permissions();
+    init_store();
+    init_tools();
+    init_recorder();
+    init_slash();
+  }
+});
+
+// src/main.tsx
+init_agent();
+import { config } from "dotenv";
+import { createInterface as createInterface2 } from "readline";
+
+// src/cli/arg.ts
+var DEFAULT_PROVIDER = "meta";
+function parseArgs(argv) {
+  const args2 = {
+    provider: void 0,
+    listSessions: false,
+    classic: false,
+    print: false,
+    yolo: false,
+    version: false,
+    help: false
+  };
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const eq = arg.startsWith("--") ? arg.indexOf("=") : -1;
+    const flag = eq === -1 ? arg : arg.slice(0, eq);
+    const inline = eq === -1 ? void 0 : arg.slice(eq + 1);
+    const value = () => {
+      if (inline !== void 0) return inline;
+      const next = argv[++i];
+      if (next === void 0 || next.startsWith("-")) {
+        throw new Error(`${flag} needs a value`);
+      }
+      return next;
+    };
+    switch (flag) {
+      case "--prompt":
+      case "-p":
+        args2.prompt = value();
+        break;
+      case "--provider":
+      case "-z":
+        args2.provider = value();
+        break;
+      case "--model":
+        args2.model = value();
+        break;
+      case "--session":
+        args2.session = value();
+        break;
+      case "--list-sessions":
+        args2.listSessions = true;
+        break;
+      case "--context-limit": {
+        const n = Number(value());
+        if (!Number.isInteger(n) || n <= 0) throw new Error("--context-limit needs a positive integer");
+        args2.contextLimit = n;
+        break;
+      }
+      case "--trace":
+        args2.trace = value();
+        break;
+      case "--classic":
+        args2.classic = true;
+        break;
+      case "--print":
+        args2.print = true;
+        break;
+      case "--yolo":
+        args2.yolo = true;
+        break;
+      case "--version":
+      case "-v":
+        args2.version = true;
+        break;
+      case "--help":
+      case "-h":
+        args2.help = true;
+        break;
+      default:
+        if (flag.startsWith("-")) {
+          throw new Error(`Unknown option: ${flag}`);
+        }
+        positional.push(arg);
+    }
+  }
+  if (positional.length > 0) {
+    if (args2.prompt !== void 0) {
+      throw new Error("Prompt given twice (use either -p or a positional message)");
+    }
+    args2.prompt = positional.join(" ");
+  }
+  return args2;
+}
+function printHelp() {
+  console.log(`
+nimi \u2014 minimal coding agent
+
+USAGE
+  nimi -p "prompt" [options]
+  nimi "prompt" [options]
+
+OPTIONS
+  -p, --prompt <text>    The prompt to send to the model
+  -z, --provider <name>  Provider to use (default: ${DEFAULT_PROVIDER})
+      --model <id>       Model ID (defaults to the provider's model)
+      --session <id>     Resume a saved session
+      --list-sessions    Print saved sessions, then exit
+      --context-limit <n> Override the model's context window
+      --trace <path>     Write a JSONL showcase trace (print mode)
+      --classic          Plain readline REPL instead of the TUI
+      --print            Force one-shot print mode even in a TTY
+      --yolo             Run all tools without asking
+  -v, --version          Show version
+  -h, --help             Show this help
+
+PROVIDERS
+  anthropic, anthropic-openai, groq, meta, deepseek
+
+EXAMPLES
+  nimi -p "explain this codebase"
+  nimi "list all ts files" --provider deepseek
+  nimi -p "read package.json" --model <id>
+`);
+}
+function printVersion() {
+  console.log(`nimi ${true ? "1.0.0" : "dev"}`);
+}
+
+// src/config/system-prompt.ts
+init_tools();
+import { existsSync } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join3 } from "path";
+var CONTEXT_FILES = ["AGENTS.md", "CLAUDE.md", ".context", ".nimi/context.md"];
+async function buildSystemPrompt(extra) {
+  const base = `You are nimi, an autonomous coding assistant.
+You are running in: ${process.cwd()}
+Today: ${(/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })}
+
+You have access to tools to read files, write files, run shell commands, and search code.
+Use tools proactively to understand the codebase before making changes.
+For greetings, small talk, or questions that need no codebase context, reply directly without calling tools.
+Always read a file before editing it. Verify your changes work.
+Be concise. No sycophantic openers. No unnecessary explanation.`;
+  const toolsList = ALL_TOOLS.map((t) => `- ${t.name}: ${t.description}`).join("\n");
+  const toolsSection = `
+Available tools:
+${toolsList}`;
+  let contextSection = "";
+  for (const filename of CONTEXT_FILES) {
+    const filepath = join3(process.cwd(), filename);
+    if (existsSync(filepath)) {
+      const content = await readFile4(filepath, "utf-8");
+      contextSection += `
+
+--- ${filename} ---
+${content}`;
+    }
+  }
+  const extraSection = extra ? `
+
+${extra}` : "";
+  return base + toolsSection + contextSection + extraSection;
+}
+
+// src/config/settings.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import { homedir } from "os";
+import { join as join4 } from "path";
+function getGlobalSettingsPath() {
+  return join4(homedir(), ".nimi", "settings.json");
+}
+function getProjectSettingsPath() {
+  return join4(process.cwd(), ".nimi", "settings.json");
+}
+async function loadSettings() {
+  const global = await readJsonSafe(getGlobalSettingsPath());
+  const project = await readJsonSafe(getProjectSettingsPath());
+  const merged = { ...global, ...project };
+  if (process.env.NIMI_PROVIDER) merged.provider = process.env.NIMI_PROVIDER;
+  if (process.env.NIMI_MODEL) merged.model = process.env.NIMI_MODEL;
+  return merged;
+}
+async function readJsonSafe(path) {
+  if (!existsSync2(path)) return {};
+  try {
+    return JSON.parse(await readFile5(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+// src/main.tsx
+init_permissions();
+init_providers();
+init_store();
+init_recorder();
+init_tools();
+import { jsx as jsx2 } from "react/jsx-runtime";
+config({ quiet: true });
+var args;
+try {
+  args = parseArgs(process.argv.slice(2));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  console.error('Run "nimi --help" for usage.');
+  process.exit(1);
+}
+if (args.help) {
+  printHelp();
+  process.exit(0);
+}
+if (args.version) {
+  printVersion();
+  process.exit(0);
+}
+var settings = await loadSettings();
+var provider = getProvider(args.provider ?? settings.provider ?? "meta");
+var model = args.model ?? settings.model ?? provider.defaultModel;
+var system = await buildSystemPrompt(settings.systemPromptExtra);
+if (args.listSessions) {
+  const ids = await listSessions();
+  if (ids.length === 0) console.log("No saved sessions yet.");
+  for (let i = ids.length - 1; i >= 0; i--) {
+    const loaded = await loadSession(ids[i]);
+    let first = "(no prompt)";
+    if (loaded) {
+      for (const m of loaded.messages) {
+        if (m.role === "user") {
+          first = m.content.replace(/\s+/g, " ").slice(0, 60);
+          break;
+        }
+      }
+      console.log(`${loaded.info.id} ${loaded.info.created_at} [${loaded.info.provider}/${loaded.info.model}] ${first}`);
+    }
+  }
+  process.exit(0);
+}
+if (!args.classic && (args.print || !process.stdin.isTTY || !process.stdout.isTTY)) {
+  if (!args.prompt) {
+    console.error('No prompt given. Run "nimi --help" for usage.');
+    process.exit(1);
+  }
+  let messages;
+  let sessionId;
+  if (args.session) {
+    const loaded = await loadSession(args.session);
+    if (!loaded) {
+      console.error(`No such session: ${args.session}. Run "--list-sessions" to see saved ids.`);
+      process.exit(1);
+    }
+    messages = [...loaded.messages, { role: "user", content: args.prompt }];
+    sessionId = loaded.info.id;
+  } else {
+    sessionId = newSessionId();
+    messages = [{ role: "user", content: args.prompt }];
+    await appendEntry(sessionId, { type: "session_info", id: sessionId, created_at: (/* @__PURE__ */ new Date()).toISOString(), model, provider: provider.name });
+  }
+  console.error(`Session ${sessionId} \u2014 resume with: --session ${sessionId}`);
+  const before = messages.length;
+  const trace = args.trace ? createTraceRecorder(args.trace, {
+    session: sessionId,
+    provider: provider.name,
+    model,
+    prompt: args.prompt,
+    argv: process.argv.slice(2),
+    tools: ALL_TOOLS.map((t) => ({ name: t.name, readOnly: t.readOnly }))
+  }) : null;
+  const rl = args.yolo ? null : createInterface2({ input: process.stdin, output: process.stdout });
+  const canUseTool = args.yolo ? allowAll() : createPromptPermission(rl);
+  try {
+    const stream = runAgent({
+      provider,
+      model,
+      system,
+      messages,
+      tools: ALL_TOOLS,
+      contextLimit: args.contextLimit,
+      canUseTool
+    });
+    for await (const event of trace ? withTrace(stream, trace, messages) : stream) {
+      if (event.type === "text_delta") process.stdout.write(event.delta);
+      else if (event.type === "compacted") {
+        console.log(`
+[compacted ${event.before} \u2192 ${event.after} messages]`);
+      } else if (event.type === "tool_start") {
+        console.log(`
+
+[tool] ${event.name} ${JSON.stringify(event.input)}`);
+      } else if (event.type === "denied") {
+        console.log(`
+[denied] ${event.name}: ${event.reason}`);
+      } else if (event.type === "tool_end") {
+        const preview = event.result.length > 500 ? event.result.slice(0, 500) + "..." : event.result;
+        console.log(`[result] ${event.name}${event.isError ? " (error)" : ""}:
+${preview}`);
+      }
+    }
+  } finally {
+    rl?.close();
+  }
+  await appendMessages(sessionId, messages.slice(before));
+  process.exit(0);
+}
+var { render } = await import("ink");
+var { default: App2 } = await Promise.resolve().then(() => (init_App(), App_exports));
+var tuiMessages;
+var tuiSessionId;
+if (args.session) {
+  const loaded = await loadSession(args.session);
+  if (!loaded) {
+    console.error(`No such session: ${args.session}. Run "--list-sessions" to see saved ids.`);
+    process.exit(1);
+  }
+  tuiMessages = loaded.messages;
+  tuiSessionId = loaded.info.id;
+} else {
+  tuiSessionId = newSessionId();
+  tuiMessages = [];
+  await appendEntry(tuiSessionId, { type: "session_info", id: tuiSessionId, created_at: (/* @__PURE__ */ new Date()).toISOString(), model, provider: provider.name });
+}
+if (args.classic) {
+  const { runClassic: runClassic2 } = await Promise.resolve().then(() => (init_classic(), classic_exports));
+  await runClassic2({ provider, model, system, tools: ALL_TOOLS, sessionId: tuiSessionId, initialMessages: tuiMessages, yolo: args.yolo, contextLimit: args.contextLimit, tracePath: args.trace });
+  process.exit(0);
+}
+render(
+  /* @__PURE__ */ jsx2(App2, { provider, model, system, tools: ALL_TOOLS, initialPrompt: args.prompt, yolo: args.yolo, sessionId: tuiSessionId, initialMessages: tuiMessages, contextLimit: args.contextLimit })
+);