miii-agent 0.1.32 → 0.1.34

package/dist/cli.js

@@ -184,7 +184,7 @@ async function modelContext(entry, model) {
     }
     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 new Error(`I don't see a model called "${model}" on Ollama. Pull it first with: ollama pull ${model}`);
     }
     throw err;
   }
@@ -240,13 +240,17 @@ async function* chat(entry, model, messages, tools, opts) {
     }
     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 new Error(`I don't see a model called "${model}" on Ollama. Pull it first with: ollama pull ${model}`);
     }
     throw err;
   }
+  let sawOutput = false;
   try {
     for await (const chunk of stream) {
       if (signal?.aborted) break;
+      if (chunk.message.content || chunk.message.thinking || (chunk.message.tool_calls?.length ?? 0) > 0) {
+        sawOutput = true;
+      }
       yield {
         content: stripHarmony(chunk.message.content),
         thinking: stripHarmony(chunk.message.thinking),
@@ -266,8 +270,13 @@ async function* chat(entry, model, messages, tools, opts) {
     }
     const msg = err instanceof Error ? err.message : String(err);
     if (msg.includes("Did not receive done or success response in stream")) {
-      yield { content: "", done: true, prompt_eval_count: 0, eval_count: 0 };
-      return;
+      if (sawOutput) {
+        yield { content: "", done: true, prompt_eval_count: 0, eval_count: 0 };
+        return;
+      }
+      throw new Error(
+        "Ollama closed the stream before sending any output \u2014 the model likely unloaded, ran out of memory, or crashed mid-request. Check `ollama ps`, then retry or switch to a smaller model."
+      );
     }
     throw err;
   } finally {
@@ -278,8 +287,8 @@ var NOT_INSTALLED, NOT_RUNNING, LOCAL_HOST_RE, HARMONY_RE, CHANNEL_LABEL_RE;
 var init_ollama = __esm({
   "src/llm/ollama.ts"() {
     "use strict";
-    NOT_INSTALLED = "Ollama is not installed. Install it with: npm i -g ollama\nOr download from https://ollama.com/download";
-    NOT_RUNNING = "Ollama is not running. Start it with: ollama serve";
+    NOT_INSTALLED = "I can't find Ollama on this machine. Install it with: npm i -g ollama\nOr download it from https://ollama.com/download";
+    NOT_RUNNING = "Ollama isn't running, so I can't reach it. Start it with: ollama serve";
     LOCAL_HOST_RE = /localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]/;
     HARMONY_RE = /<\|?\/?(?:channel|message|start|end|return|constrain|assistant|user|system|developer|tool|tool_call|tool_response|final|analysis|commentary)\|?>/gi;
     CHANNEL_LABEL_RE = /^(?:analysis|commentary|final)\s*(?=\w)/i;
@@ -288,7 +297,7 @@ var init_ollama = __esm({
 
 // src/llm/openai.ts
 function notAvailable(entry) {
-  return `Cannot reach OpenAI-compatible provider at ${entry.baseUrl}. Make sure the server is running and the baseUrl is correct.`;
+  return `I couldn't reach the provider at ${entry.baseUrl}. Check that the server is running and the baseUrl is correct.`;
 }
 function headers(entry) {
   const h = { "Content-Type": "application/json" };
@@ -314,7 +323,7 @@ async function listModels2(entry) {
         detail = await res.text();
       } catch {
       }
-      throw new Error(`Provider error (HTTP ${res.status}): ${detail || res.statusText}`);
+      throw new Error(`The provider came back with an error (HTTP ${res.status}): ${detail || res.statusText}`);
     }
     const body = await res.json();
     return body.data.map((m) => m.id);
@@ -406,12 +415,12 @@ async function* chat2(entry, model, messages, tools, opts) {
       } catch {
       }
       if (res.status === 404) {
-        throw new Error(`Model "${model}" not found at ${entry.baseUrl}. Make sure it's available.`);
+        throw new Error(`The provider at ${entry.baseUrl} has no model called "${model}". Double-check the name, or pick another with /models.`);
       }
-      throw new Error(`Provider error (HTTP ${res.status}): ${detail || res.statusText}`);
+      throw new Error(`The provider came back with an error (HTTP ${res.status}): ${detail || res.statusText}`);
     }
     const reader = res.body?.getReader();
-    if (!reader) throw new Error("No response body");
+    if (!reader) throw new Error("The provider answered but sent no body to read.");
     const decoder = new TextDecoder();
     let buffer = "";
     try {
@@ -470,7 +479,7 @@ async function* chat2(entry, model, messages, tools, opts) {
       throw new Error(notAvailable(entry));
     }
     if (timeoutSignal.aborted && !opts?.signal?.aborted) {
-      throw new Error(`Provider request timed out after ${TIMEOUT_MS / 1e3}s. The model may still be loading or thinking.`);
+      throw new Error(`The provider didn't respond within ${TIMEOUT_MS / 1e3}s, so I stopped waiting. The model may still be loading or thinking \u2014 give it another try.`);
     }
     throw err;
   }
@@ -678,14 +687,14 @@ function isUnder(parent, child) {
 }
 function confinePath(p) {
   if (typeof p !== "string" || p.length === 0) {
-    throw new Error("Path is required.");
+    throw new Error("I need a file path here, but none was given.");
   }
   const root = process.cwd();
   const abs = resolve(root, p);
   if (isUnder(root, abs) || isUnder(SPILL_DIR, abs)) {
     return abs;
   }
-  throw new Error(`Path "${p}" is outside the working directory (${root}). Access denied.`);
+  throw new Error(`"${p}" sits outside the working directory (${root}), so I can't touch it. Stay within the project folder.`);
 }
 var SPILL_DIR;
 var init_paths = __esm({
@@ -787,38 +796,38 @@ function nearMiss(src, old_str) {
   const width = String(to).length;
   const ctx = srcLines.slice(from, to).map((l, i) => `${String(from + i + 1).padStart(width, " ")}	${l}`).join("\n");
   return `
-Closest text in file (lines ${from + 1}-${to}):
+Here's the closest text I could find (lines ${from + 1}-${to}) \u2014 copy it exactly:
 ${ctx}`;
 }
 function locate(src, old_str) {
   const first = src.indexOf(old_str);
   if (first !== -1) {
     if (src.indexOf(old_str, first + 1) !== -1) {
-      return { error: `old_str not unique \u2014 add surrounding context to disambiguate.` };
+      return { error: `That text shows up in more than one place, so I can't tell which one you mean. Add a line or two around it to make it unique.` };
     }
     return [first, first + old_str.length];
   }
   const fuzzy = fuzzyRange(src, old_str);
   if (fuzzy) return fuzzy;
-  return { error: `old_str not found.${nearMiss(src, old_str)}` };
+  return { error: `I couldn't find that text \u2014 it may differ by whitespace or a stray character.${nearMiss(src, old_str)}` };
 }
 function applyBatch(src, edits) {
   const ranges = [];
   for (let i = 0; i < edits.length; i++) {
     const { old_str, new_str } = edits[i];
     if (typeof old_str !== "string" || typeof new_str !== "string") {
-      return { error: `edits[${i}] must have string old_str and new_str.` };
+      return { error: `Edit #${i + 1} is missing text \u2014 each edit needs both an old_str and a new_str string.` };
     }
-    if (old_str === "") return { error: `edits[${i}].old_str is empty.` };
-    if (old_str === new_str) return { error: `edits[${i}] old_str and new_str are identical \u2014 nothing to change.` };
+    if (old_str === "") return { error: `Edit #${i + 1} has an empty old_str, so there's nothing to look for. Give it the exact text you want to replace.` };
+    if (old_str === new_str) return { error: `Edit #${i + 1} has the same old_str and new_str, so it wouldn't change anything.` };
     const r = locate(src, old_str);
-    if (!Array.isArray(r)) return { error: `edits[${i}]: ${r.error}` };
+    if (!Array.isArray(r)) return { error: `Edit #${i + 1}: ${r.error}` };
     ranges.push({ start: r[0], end: r[1], new_str });
   }
   const sorted = [...ranges].sort((a, b) => a.start - b.start);
   for (let i = 1; i < sorted.length; i++) {
     if (sorted[i].start < sorted[i - 1].end) {
-      return { error: `edits overlap in the file \u2014 split them into separate calls or widen the context.` };
+      return { error: `Two of these edits touch the same spot, so I can't apply them together. Split them into separate calls, or widen each old_str so they don't overlap.` };
     }
   }
   let out = src;
@@ -869,11 +878,11 @@ var init_edit_file = __esm({
             return { content: `Edited ${path} (${res.count} edits).${verifyHint(path)}` };
           }
           if (typeof old_str !== "string" || typeof new_str !== "string") {
-            return { content: `edit_file needs old_str and new_str (or an edits[] array) for ${path}.`, is_error: true };
+            return { content: `To edit ${path} I need either an old_str/new_str pair or an edits[] array \u2014 neither came through.`, is_error: true };
           }
           if (old_str === new_str) {
             return {
-              content: `old_str and new_str are identical \u2014 nothing to change in ${path}. If the file is already correct, do NOT edit again: finish with the respond action and tell the user it is done.`,
+              content: `old_str and new_str are the same, so there's nothing to change in ${path}. If the file is already correct, don't edit it again \u2014 finish with the respond action and tell the user it's done.`,
               is_error: true
             };
           }
@@ -890,12 +899,12 @@ var init_edit_file = __esm({
                 return { content: `Edited ${path} (whitespace-tolerant match).${verifyHint(path)}` };
               }
             }
-            return { content: `old_str not found in ${path}.${nearMiss(src, old_str)}`, is_error: true };
+            return { content: `I couldn't find that text in ${path} \u2014 it may differ by whitespace or a stray character.${nearMiss(src, old_str)}`, is_error: true };
           }
           const all = replace_all === true;
           if (!all && src.indexOf(old_str, first + 1) !== -1) {
             return {
-              content: `old_str not unique in ${path}. Add surrounding context to disambiguate, or set replace_all.`,
+              content: `That text appears more than once in ${path}, so I don't know which one to change. Add a line or two around it to single it out, or set replace_all to change them all.`,
               is_error: true
             };
           }
@@ -953,7 +962,7 @@ var init_read_file = __esm({
           if (IMAGE_EXT.has(ext) || looksImage(buf)) {
             if (buf.length > MAX_IMAGE_BYTES) {
               return {
-                content: `${path} is an image but too large to attach (${buf.length} bytes > ${MAX_IMAGE_BYTES}). Resize it first.`,
+                content: `${path} is an image, but at ${buf.length} bytes it's too big to attach (limit is ${MAX_IMAGE_BYTES}). Resize it and try again.`,
                 is_error: true
               };
             }
@@ -963,7 +972,7 @@ var init_read_file = __esm({
             };
           }
           if (buf.subarray(0, 8e3).includes(0)) {
-            return { content: `${path} looks binary (${buf.length} bytes); not reading as text.`, is_error: true };
+            return { content: `${path} looks like a binary file (${buf.length} bytes), so I'm not reading it as text.`, is_error: true };
           }
           const raw = buf.toString("utf-8").replace(/\r\n/g, "\n");
           const allLines = raw.split("\n");
@@ -975,7 +984,7 @@ var init_read_file = __esm({
           let body = numbered(slice, start);
           if (body.length > MAX_CHARS) {
             body = body.slice(0, MAX_CHARS) + `
-[truncated: output exceeded ${MAX_CHARS} chars \u2014 use offset/limit]`;
+[There's more \u2014 this hit the ${MAX_CHARS}-char limit. Use offset/limit to read the rest.]`;
           }
           if (ranged) {
             const end = start - 1 + slice.length;
@@ -1047,7 +1056,7 @@ function spillIfLarge(full, label = "output", budget = INLINE_BUDGET) {
   const head = Math.floor(budget * HEAD_FRACTION);
   const tail = budget - head;
   const preview = full.slice(0, head) + "\n\u2026\n" + full.slice(-tail);
-  const notice = path ? `[${label} truncated: ${full.length} bytes. Full output at ${path} \u2014 read it with read_file offset/limit to see the elided middle.]` : `[${label} truncated to ${budget} bytes; spill to disk failed, middle is lost.]`;
+  const notice = path ? `[This ${label} was long (${full.length} bytes), so I'm showing the start and end. The full text is saved at ${path} \u2014 read it with read_file offset/limit to see the middle.]` : `[This ${label} was too long to show in full, and I couldn't save the rest to disk, so the middle is missing.]`;
   return `${preview}
 ${notice}`;
 }
@@ -1130,8 +1139,8 @@ var init_run_bash = __esm({
           const out = all ?? "";
           const is_error = aborted || timedOut || exitCode !== 0;
           const note = timedOut ? `
-[timed out after ${timeout}ms \u2014 process tree killed]` : aborted ? `
-[aborted \u2014 process tree killed]` : "";
+[Timed out after ${timeout}ms, so I stopped the command and everything it started. Raise timeout_ms for long builds or test suites.]` : aborted ? `
+[Cancelled \u2014 I stopped the command and everything it started.]` : "";
           const body = out || (is_error ? `(no output)` : "");
           const content = `${spillIfLarge(body, "command output")}
 [exit ${exitCode ?? "killed"}]${note}`;
@@ -1240,8 +1249,9 @@ var init_grep = __esm({
           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 };
+          const noMatch = `Nothing matched "${pattern}". Try a looser pattern, case_insensitive, or a wider path.`;
+          if (!out && code === 1) return { content: noMatch };
+          return { content: out || res.stderr || noMatch, is_error: code > 1 };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
         }
@@ -1316,7 +1326,7 @@ var init_glob = __esm({
             res = await tryFind();
           }
           const all = (res.stdout ?? "").split("\n").filter(Boolean);
-          if (all.length === 0) return { content: "No files matched." };
+          if (all.length === 0) return { content: `Nothing matched "${pattern}". Try a broader pattern or a different path.` };
           const lines = byMtimeDesc(all).slice(0, limit);
           return { content: lines.join("\n") };
         } catch (err) {
@@ -1327,6 +1337,70 @@ var init_glob = __esm({
   }
 });
 
+// src/tools/write_todos.ts
+function render(todos) {
+  const done = todos.filter((t) => t.status === "completed").length;
+  const header = `Todos (${done}/${todos.length} done):`;
+  const lines = todos.map((t) => `${MARK[t.status]} ${t.content}`);
+  return [header, ...lines].join("\n");
+}
+var STATUSES, MARK, write_todos;
+var init_write_todos = __esm({
+  "src/tools/write_todos.ts"() {
+    "use strict";
+    STATUSES = ["pending", "in_progress", "completed"];
+    MARK = {
+      completed: "[x]",
+      in_progress: "[~]",
+      pending: "[ ]"
+    };
+    write_todos = {
+      name: "write_todos",
+      description: "Create and maintain a task list for the current session, shown to the user as a live checklist. Pass the FULL list every call \u2014 it replaces the previous one (all or nothing), so include finished items too. Each todo is {content, status} where status is pending | in_progress | completed. Keep exactly one item in_progress at a time and mark it completed before starting the next. Use for multi-step work (features, refactors, multi-file changes) so the user can see what is done, in progress, and left. Skip it for single trivial actions.",
+      input_schema: {
+        type: "object",
+        properties: {
+          todos: {
+            type: "array",
+            description: "The full, ordered task list. Replaces the prior list entirely.",
+            items: {
+              type: "object",
+              properties: {
+                content: { type: "string", description: 'Short task description (imperative, e.g. "Add webfetch tool").' },
+                status: { type: "string", enum: STATUSES, description: "pending | in_progress | completed" }
+              },
+              required: ["content", "status"]
+            }
+          }
+        },
+        required: ["todos"]
+      },
+      handler: ({ todos }) => {
+        if (!Array.isArray(todos)) {
+          return { content: "I need a todos array here \u2014 pass the full list of tasks.", is_error: true };
+        }
+        if (todos.length === 0) {
+          return { content: "The todo list is empty \u2014 give me at least one task.", is_error: true };
+        }
+        for (let i = 0; i < todos.length; i++) {
+          const t = todos[i];
+          if (!t || typeof t.content !== "string" || t.content.trim() === "") {
+            return { content: `Task #${i + 1} needs some text \u2014 its content can't be empty.`, is_error: true };
+          }
+          if (!STATUSES.includes(t.status)) {
+            return { content: `Task #${i + 1} has an unknown status. Use one of: ${STATUSES.join(", ")}.`, is_error: true };
+          }
+        }
+        const active2 = todos.filter((t) => t.status === "in_progress").length;
+        if (active2 > 1) {
+          return { content: `Keep just one task in progress at a time \u2014 I see ${active2}. Finish one before starting the next.`, is_error: true };
+        }
+        return { content: render(todos) };
+      }
+    };
+  }
+});
+
 // src/tools/registry.ts
 function getTool(name) {
   return TOOLS.find((t) => t.name === name);
@@ -1355,13 +1429,15 @@ var init_registry = __esm({
     init_run_bash();
     init_grep();
     init_glob();
+    init_write_todos();
     TOOLS = [
       edit_file,
       read_file,
       write_file,
       run_bash,
       grep,
-      glob
+      glob,
+      write_todos
     ];
   }
 });
@@ -1424,7 +1500,7 @@ function validateInput(schema, input) {
   const result = toZod(schema).safeParse(input ?? {});
   if (result.success) return null;
   const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
-  return `Invalid arguments: ${issues}`;
+  return `Some arguments didn't look right: ${issues}`;
 }
 var init_validate = __esm({
   "src/tools/validate.ts"() {
@@ -1563,6 +1639,14 @@ Ask in a numbered list. One round of questions per turn. Then wait.
 You have access to the following tools. Call them via the function-calling interface.
 ${toolLines}
 
+# Task list (write_todos)
+For multi-step work \u2014 a feature, a refactor, anything touching multiple files or more than ~3 steps \u2014 track it with write_todos so the user sees a live checklist of what is done, in progress, and left.
+- Create the list right after your plan, before the first real action. Each item is {content, status}: short imperative content, status pending | in_progress | completed.
+- Pass the FULL list every call; it replaces the previous one. Include already-finished items so nothing disappears.
+- Mark exactly ONE item in_progress at a time. Set it in_progress when you start it, completed the moment it is done, then move the next to in_progress. Never leave a finished task pending or two tasks in_progress.
+- Keep items outcome-sized, not tool-sized \u2014 "Add webfetch tool and wire it in", not "call edit_file". Aim for a handful, not twenty.
+- Do NOT use write_todos for trivial single-step work \u2014 a lone read, one edit, a quick search. It is overhead there.
+
 # 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.
@@ -1858,7 +1942,7 @@ function readGuard(name, input, seen) {
   if (seen.has(abs)) return null;
   if (name === "write_file" && !existsSync5(abs)) return null;
   const verb = name === "edit_file" ? "edit" : "overwrite";
-  return `Refusing to ${verb} ${p}: you have not read it this turn. Call read_file on ${p} first, then retry the ${name}.`;
+  return `I won't ${verb} ${p} without seeing it first \u2014 I don't want to clobber something. Read it with read_file, then retry the ${name}.`;
 }
 function unwrapEnvelope(name, input) {
   if (!("arguments" in input)) return input;
@@ -2028,6 +2112,14 @@ async function* runAgent(opts) {
         yield { type: "turn-end", stop_reason: "tool_use" };
         continue;
       }
+      if (assistantText.trim() === "") {
+        yield {
+          type: "error",
+          message: "The model returned an empty response \u2014 likely unloaded/OOM mid-stream or the output cap was consumed by thinking before any answer. Retry, switch models, or lower the context/effort."
+        };
+        yield { type: "done", prompt_tokens: promptTokens, eval_tokens: evalTokens };
+        return history;
+      }
       endedCleanly = true;
       yield { type: "turn-end", stop_reason: "end_turn" };
       break;
@@ -2040,7 +2132,7 @@ async function* runAgent(opts) {
         const r2 = {
           type: "tool_result",
           tool_use_id: use.id,
-          content: `Unknown tool: ${use.name}`,
+          content: `Unknown tool: ${use.name}. There's no tool by that name \u2014 check the spelling against the tools you were given.`,
           is_error: true
         };
         results.push(r2);
@@ -2066,7 +2158,7 @@ async function* runAgent(opts) {
         const r2 = {
           type: "tool_result",
           tool_use_id: use.id,
-          content: `Permission denied for ${use.name}.`,
+          content: `Permission denied \u2014 the user chose not to run ${use.name}. Try a different approach, or ask them what they'd prefer.`,
           is_error: true
         };
         results.push(r2);
@@ -2368,7 +2460,7 @@ var init_run = __esm({
 });
 
 // src/cli.tsx
-import { render } from "ink";
+import { render as render2 } from "ink";
 import { createElement } from "react";
 
 // src/ui/App.tsx
@@ -3658,7 +3750,8 @@ var TOOL_LABEL = {
   read_file: "Read",
   run_bash: "Bash",
   glob: "Glob",
-  grep: "Grep"
+  grep: "Grep",
+  write_todos: "Todos"
 };
 var EXT_LANG = {
   ts: "typescript",
@@ -3760,6 +3853,43 @@ function FileEditBlock({
     ] }) })
   ] });
 }
+function TodoBlock({ todos }) {
+  const done = todos.filter((t) => t.status === "completed").length;
+  const doing = todos.filter((t) => t.status === "in_progress").length;
+  const glyph = { completed: "\u2714", in_progress: "\u25B6", pending: "\u25CB" };
+  const color = { completed: "green", in_progress: "yellow", pending: "gray" };
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs9(Box9, { children: [
+      /* @__PURE__ */ jsx9(Text9, { color: "green", children: "\u25CF " }),
+      /* @__PURE__ */ jsx9(Text9, { color: "white", children: "Todos " }),
+      /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "(",
+        done,
+        "/",
+        todos.length,
+        " done",
+        doing > 0 ? `, ${doing} in progress` : "",
+        ")"
+      ] })
+    ] }),
+    todos.map((t, i) => /* @__PURE__ */ jsxs9(Box9, { marginLeft: 4, children: [
+      /* @__PURE__ */ jsxs9(Text9, { color: color[t.status], children: [
+        glyph[t.status],
+        " "
+      ] }),
+      /* @__PURE__ */ jsx9(
+        Text9,
+        {
+          color: t.status === "in_progress" ? "yellow" : void 0,
+          dimColor: t.status !== "in_progress",
+          strikethrough: t.status === "completed",
+          bold: t.status === "in_progress",
+          children: t.content
+        }
+      )
+    ] }, i))
+  ] });
+}
 function toolHeader(use) {
   const label = TOOL_LABEL[use.name] ?? use.name;
   const input = use.input ?? {};
@@ -3839,6 +3969,10 @@ function ToolResultBlock({ result, toolName }) {
   ] });
 }
 function ToolUseLine({ use, result }) {
+  if (use.name === "write_todos" && !result?.is_error) {
+    const todos = use.input.todos;
+    if (Array.isArray(todos) && todos.length > 0) return /* @__PURE__ */ jsx9(TodoBlock, { todos });
+  }
   if (use.name === "write_file" && !result?.is_error) {
     const input = use.input;
     const content = input.content ?? "";
@@ -5196,5 +5330,5 @@ if (cmd === "version" || cmd === "--version" || cmd === "-v") {
   process.on("exit", () => {
     if (process.stdout.isTTY) process.stdout.write("\x1B]2;\x07");
   });
-  render(createElement(App));
+  render2(createElement(App));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-agent",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Local AI coding agent for your terminal — an open-source, offline alternative to Claude Code, Cursor, and GitHub Copilot, powered by Ollama. Private by default, free forever.",
   "type": "module",
   "bin": {