miii-agent 0.1.31 → 0.1.32

package/dist/cli.js

@@ -790,6 +790,43 @@ function nearMiss(src, old_str) {
 Closest text in file (lines ${from + 1}-${to}):
 ${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 [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)}` };
+}
+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.` };
+    }
+    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.` };
+    const r = locate(src, old_str);
+    if (!Array.isArray(r)) return { error: `edits[${i}]: ${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.` };
+    }
+  }
+  let out = src;
+  for (const r of [...ranges].sort((a, b) => b.start - a.start)) {
+    out = out.slice(0, r.start) + r.new_str + out.slice(r.end);
+  }
+  return { out, count: ranges.length };
+}
 var edit_file;
 var init_edit_file = __esm({
   "src/tools/edit_file.ts"() {
@@ -798,19 +835,42 @@ var init_edit_file = __esm({
     init_verifyHint();
     edit_file = {
       name: "edit_file",
-      description: "Replace an exact string in a file. old_str must be unique unless replace_all is set. On no match, returns the closest text in the file.",
+      description: "Replace an exact string in a file. old_str must be unique unless replace_all is set. On no match, returns the closest text in the file. To make several edits to one file at once, pass an `edits` array of {old_str,new_str} \u2014 they apply atomically (all or nothing).",
       input_schema: {
         type: "object",
         properties: {
           path: { type: "string", description: "File path" },
-          old_str: { type: "string", description: "Exact text to replace (whitespace-sensitive)" },
-          new_str: { type: "string", description: "Replacement text" },
-          replace_all: { type: "boolean", description: "Replace every occurrence instead of requiring uniqueness" }
+          old_str: { type: "string", description: "Exact text to replace (whitespace-sensitive). Omit when using edits[]." },
+          new_str: { type: "string", description: "Replacement text. Omit when using edits[]." },
+          replace_all: { type: "boolean", description: "Replace every occurrence instead of requiring uniqueness" },
+          edits: {
+            type: "array",
+            description: "Batch mode: several edits applied atomically. Each old_str must be unique in the file. Alternative to old_str/new_str.",
+            items: {
+              type: "object",
+              properties: {
+                old_str: { type: "string", description: "Exact text to replace (whitespace-sensitive)" },
+                new_str: { type: "string", description: "Replacement text" }
+              },
+              required: ["old_str", "new_str"]
+            }
+          }
         },
-        required: ["path", "old_str", "new_str"]
+        required: ["path"]
       },
-      handler: ({ path, old_str, new_str, replace_all }) => {
+      handler: ({ path, old_str, new_str, replace_all, edits }) => {
         try {
+          if (Array.isArray(edits) && edits.length > 0) {
+            const abs2 = confinePath(path);
+            const src2 = readFileSync4(abs2, "utf-8");
+            const res = applyBatch(src2, edits);
+            if ("error" in res) return { content: `${res.error} (in ${path})`, is_error: true };
+            writeFileSync4(abs2, res.out, "utf-8");
+            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 };
+          }
           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.`,
@@ -857,11 +917,22 @@ function numbered(lines, start) {
   const width = String(start + lines.length - 1).length;
   return lines.map((l, i) => `${String(start + i).padStart(width, " ")}	${l}`).join("\n");
 }
-var read_file;
+function looksImage(buf) {
+  if (buf.length < 4) return false;
+  if (buf[0] === 137 && buf[1] === 80) return true;
+  if (buf[0] === 255 && buf[1] === 216) return true;
+  if (buf[0] === 71 && buf[1] === 73) return true;
+  if (buf[0] === 66 && buf[1] === 77) return true;
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP") return true;
+  return false;
+}
+var IMAGE_EXT, MAX_IMAGE_BYTES, read_file;
 var init_read_file = __esm({
   "src/tools/read_file.ts"() {
     "use strict";
     init_paths();
+    IMAGE_EXT = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp"]);
+    MAX_IMAGE_BYTES = 8 * 1024 * 1024;
     read_file = {
       name: "read_file",
       description: "Read file contents as UTF-8 text with line numbers. Use offset/limit to read a range of a large file instead of the whole thing.",
@@ -878,6 +949,19 @@ var init_read_file = __esm({
         try {
           const MAX_CHARS = 2e5;
           const buf = readFileSync5(confinePath(path));
+          const ext = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+          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.`,
+                is_error: true
+              };
+            }
+            return {
+              content: `[image ${path} \u2014 ${buf.length} bytes, attached for viewing]`,
+              images: [buf.toString("base64")]
+            };
+          }
           if (buf.subarray(0, 8e3).includes(0)) {
             return { content: `${path} looks binary (${buf.length} bytes); not reading as text.`, is_error: true };
           }
@@ -992,6 +1076,17 @@ var init_spill = __esm({
 
 // src/tools/run_bash.ts
 import { execa } from "execa";
+function killTree(pid, isWin) {
+  if (!pid) return;
+  try {
+    if (isWin) {
+      execa("taskkill", ["/pid", String(pid), "/T", "/F"], { reject: false });
+    } else {
+      process.kill(-pid, "SIGKILL");
+    }
+  } catch {
+  }
+}
 var run_bash;
 var init_run_bash = __esm({
   "src/tools/run_bash.ts"() {
@@ -1008,27 +1103,44 @@ var init_run_bash = __esm({
         },
         required: ["command"]
       },
-      handler: async ({ command, timeout_ms }) => {
+      handler: async ({ command, timeout_ms }, ctx) => {
+        const isWin = process.platform === "win32";
+        const shell = isWin ? "cmd" : "bash";
+        const shellArgs = isWin ? ["/c", command] : ["-c", command];
+        const timeout = timeout_ms ?? 12e4;
+        const child = execa(shell, shellArgs, {
+          reject: false,
+          all: true,
+          detached: !isWin
+          // POSIX: new process group so killTree(-pid) hits the whole tree
+        });
+        let timedOut = false;
+        let aborted = false;
+        const timer = setTimeout(() => {
+          timedOut = true;
+          killTree(child.pid, isWin);
+        }, timeout);
+        const onAbort = () => {
+          aborted = true;
+          killTree(child.pid, isWin);
+        };
+        ctx?.signal?.addEventListener("abort", onAbort, { once: true });
         try {
-          const isWin = process.platform === "win32";
-          const shell = isWin ? "cmd" : "bash";
-          const shellArgs = isWin ? ["/c", command] : ["-c", command];
-          const { stdout, stderr, exitCode } = await execa(shell, shellArgs, {
-            timeout: timeout_ms ?? 12e4,
-            reject: false,
-            all: false
-          });
-          const out = [stdout, stderr].filter(Boolean).join("\n");
-          const is_error = exitCode !== 0;
+          const { all, exitCode } = await child;
+          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]` : "";
           const body = out || (is_error ? `(no output)` : "");
           const content = `${spillIfLarge(body, "command output")}
-[exit ${exitCode}]`;
-          return {
-            content,
-            is_error
-          };
+[exit ${exitCode ?? "killed"}]${note}`;
+          return { content, is_error };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
+        } finally {
+          clearTimeout(timer);
+          ctx?.signal?.removeEventListener("abort", onAbort);
         }
       }
     };
@@ -1535,6 +1647,9 @@ function toOllamaMessages(history, system) {
       const texts = msg.content.filter((b) => b.type === "text");
       for (const tr of tool_results) {
         out.push({ role: "tool", content: tr.content, tool_call_id: tr.tool_use_id });
+        if (tr.images && tr.images.length > 0) {
+          out.push({ role: "user", content: "Image content from the previous tool result:", images: tr.images });
+        }
       }
       if (texts.length > 0) {
         out.push({ role: "user", content: texts.map((t) => t.text).join("") });
@@ -1977,12 +2092,13 @@ async function* runAgent(opts) {
       }
       let r;
       try {
-        const out = await tool.handler(use.input);
+        const out = await tool.handler(use.input, { signal });
         r = {
           type: "tool_result",
           tool_use_id: use.id,
           content: out.content,
-          is_error: out.is_error
+          is_error: out.is_error,
+          ...out.images && out.images.length > 0 ? { images: out.images } : {}
         };
       } catch (err) {
         r = {
@@ -3732,14 +3848,16 @@ function ToolUseLine({ use, result }) {
   }
   if (use.name === "edit_file" && !result?.is_error) {
     const input = use.input;
-    const oldS = input.old_str ?? "";
-    const newS = input.new_str ?? "";
-    const added = countLines(newS);
-    const removed = countLines(oldS);
-    const preview = [
-      ...oldS.split("\n").map((t) => ({ sign: "-", text: t })),
-      ...newS.split("\n").map((t) => ({ sign: "+", text: t }))
-    ];
+    const pairs = Array.isArray(input.edits) && input.edits.length > 0 ? input.edits.map((e) => ({ oldS: e.old_str ?? "", newS: e.new_str ?? "" })) : [{ oldS: input.old_str ?? "", newS: input.new_str ?? "" }];
+    let added = 0;
+    let removed = 0;
+    const preview = [];
+    for (const { oldS, newS } of pairs) {
+      added += countLines(newS);
+      removed += countLines(oldS);
+      preview.push(...oldS.split("\n").map((t) => ({ sign: "-", text: t })));
+      preview.push(...newS.split("\n").map((t) => ({ sign: "+", text: t })));
+    }
     return /* @__PURE__ */ jsx9(FileEditBlock, { label: "Update", path: input.path ?? "", added, removed, previewLines: preview });
   }
   const { label, arg } = toolHeader(use);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-agent",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "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": {