miii-agent 0.1.9 → 0.1.11

package/dist/cli.js

@@ -145,27 +145,64 @@ var init_client = __esm({
 });
 
 // src/tools/paths.ts
-import { resolve, relative as relative2, isAbsolute, sep } from "path";
+import { resolve, relative as relative2, isAbsolute, sep, join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+function isUnder(parent, child) {
+  const rel = relative2(parent, child);
+  return rel === "" || !rel.startsWith(".." + sep) && rel !== ".." && !isAbsolute(rel);
+}
 function confinePath(p) {
   if (typeof p !== "string" || p.length === 0) {
     throw new Error("Path is required.");
   }
   const root = process.cwd();
   const abs = resolve(root, p);
-  const rel = relative2(root, abs);
-  if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
-    throw new Error(`Path "${p}" is outside the working directory (${root}). Access denied.`);
+  if (isUnder(root, abs) || isUnder(SPILL_DIR, abs)) {
+    return abs;
   }
-  return abs;
+  throw new Error(`Path "${p}" is outside the working directory (${root}). Access denied.`);
 }
+var SPILL_DIR;
 var init_paths = __esm({
   "src/tools/paths.ts"() {
     "use strict";
+    SPILL_DIR = resolve(join4(homedir3(), ".miii", "output"));
   }
 });
 
 // src/tools/edit_file.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+function similarity(a, b) {
+  const x = a.trim();
+  const y = b.trim();
+  if (!x && !y) return 1;
+  const len = Math.max(x.length, y.length);
+  if (len === 0) return 0;
+  let same = 0;
+  for (let i = 0; i < Math.min(x.length, y.length); i++) if (x[i] === y[i]) same++;
+  return same / len;
+}
+function nearMiss(src, old_str) {
+  const srcLines = src.split("\n");
+  const needle = old_str.split("\n").find((l) => l.trim()) ?? old_str;
+  let bestIdx = -1;
+  let bestScore = 0;
+  for (let i = 0; i < srcLines.length; i++) {
+    const s = similarity(srcLines[i], needle);
+    if (s > bestScore) {
+      bestScore = s;
+      bestIdx = i;
+    }
+  }
+  if (bestIdx === -1 || bestScore < 0.4) return "";
+  const from = Math.max(0, bestIdx - 3);
+  const to = Math.min(srcLines.length, bestIdx + 4);
+  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}):
+${ctx}`;
+}
 var edit_file;
 var init_edit_file = __esm({
   "src/tools/edit_file.ts"() {
@@ -173,29 +210,39 @@ var init_edit_file = __esm({
     init_paths();
     edit_file = {
       name: "edit_file",
-      description: "Replace an exact string in a file. old_str must be unique.",
+      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.",
       input_schema: {
         type: "object",
         properties: {
           path: { type: "string", description: "File path" },
-          old_str: { type: "string", description: "Exact text to replace" },
-          new_str: { type: "string", description: "Replacement text" }
+          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" }
         },
         required: ["path", "old_str", "new_str"]
       },
-      handler: ({ path, old_str, new_str }) => {
+      handler: ({ path, old_str, new_str, replace_all }) => {
         try {
+          if (old_str === new_str) {
+            return { content: `old_str and new_str are identical \u2014 nothing to change in ${path}.`, is_error: true };
+          }
           const abs = confinePath(path);
           const src = readFileSync3(abs, "utf-8");
           const first = src.indexOf(old_str);
           if (first === -1) {
-            return { content: `old_str not found in ${path}`, is_error: true };
+            return { content: `old_str not found in ${path}.${nearMiss(src, old_str)}`, is_error: true };
           }
-          if (src.indexOf(old_str, first + 1) !== -1) {
-            return { content: `old_str not unique in ${path}`, 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.`,
+              is_error: true
+            };
           }
-          writeFileSync3(abs, src.slice(0, first) + new_str + src.slice(first + old_str.length), "utf-8");
-          return { content: `Edited ${path}` };
+          const out = all ? src.split(old_str).join(new_str) : src.slice(0, first) + new_str + src.slice(first + old_str.length);
+          const n = all ? src.split(old_str).length - 1 : 1;
+          writeFileSync3(abs, out, "utf-8");
+          return { content: `Edited ${path}${all ? ` (${n} occurrences)` : ""}` };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
         }
@@ -206,6 +253,10 @@ var init_edit_file = __esm({
 
 // src/tools/read_file.ts
 import { readFileSync as readFileSync4 } from "fs";
+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;
 var init_read_file = __esm({
   "src/tools/read_file.ts"() {
@@ -213,21 +264,40 @@ var init_read_file = __esm({
     init_paths();
     read_file = {
       name: "read_file",
-      description: "Read entire file contents as UTF-8 text.",
+      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.",
       input_schema: {
         type: "object",
         properties: {
-          path: { type: "string", description: "File path" }
+          path: { type: "string", description: "File path" },
+          offset: { type: "number", description: "1-based line to start from (default 1)" },
+          limit: { type: "number", description: "Max lines to return (default all / capped)" }
         },
         required: ["path"]
       },
-      handler: ({ path }) => {
+      handler: ({ path, offset, limit }) => {
         try {
-          const MAX = 2e5;
-          const raw = readFileSync4(confinePath(path), "utf-8");
-          const truncated = raw.length > MAX;
-          const body = truncated ? raw.slice(0, MAX) + `
-[truncated: ${raw.length - MAX} more chars]` : raw;
+          const MAX_CHARS = 2e5;
+          const buf = readFileSync4(confinePath(path));
+          if (buf.subarray(0, 8e3).includes(0)) {
+            return { content: `${path} looks binary (${buf.length} bytes); not reading as text.`, is_error: true };
+          }
+          const raw = buf.toString("utf-8").replace(/\r\n/g, "\n");
+          const allLines = raw.split("\n");
+          const total = allLines.length;
+          const start = Math.max(1, Math.floor(offset ?? 1));
+          const ranged = offset != null || limit != null;
+          const count = limit != null ? Math.max(0, Math.floor(limit)) : total;
+          const slice = allLines.slice(start - 1, start - 1 + count);
+          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]`;
+          }
+          if (ranged) {
+            const end = start - 1 + slice.length;
+            body += `
+[showing lines ${start}-${end} of ${total}]`;
+          }
           return { content: body };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
@@ -270,12 +340,63 @@ var init_write_file = __esm({
   }
 });
 
+// src/tools/spill.ts
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, rmSync as rmSync2, readdirSync as readdirSync3, statSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { randomBytes } from "crypto";
+function ensureDir() {
+  mkdirSync4(OUTPUT_DIR, { recursive: true });
+  return OUTPUT_DIR;
+}
+function spillIfLarge(full, label = "output", budget = INLINE_BUDGET) {
+  if (full.length <= budget) return full;
+  const id = randomBytes(6).toString("hex");
+  const file = join5(ensureDir(), `${id}.txt`);
+  let path = file;
+  try {
+    writeFileSync5(file, full, "utf-8");
+  } catch {
+    path = "";
+  }
+  const head = Math.floor(budget * HEAD_FRACTION);
+  const tail = budget - head;
+  const totalLines = full.split("\n").length;
+  const preview = full.slice(0, head) + "\n\u2026\n" + full.slice(-tail);
+  const notice = path ? `[${label} truncated: ${totalLines} lines / ${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.]`;
+  return `${preview}
+${notice}`;
+}
+function cleanupSpill(maxAgeMs = 24 * 60 * 60 * 1e3) {
+  try {
+    const now = Date.now();
+    for (const name of readdirSync3(OUTPUT_DIR)) {
+      const f = join5(OUTPUT_DIR, name);
+      try {
+        if (now - statSync(f).mtimeMs > maxAgeMs) rmSync2(f, { force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var OUTPUT_DIR, INLINE_BUDGET, HEAD_FRACTION;
+var init_spill = __esm({
+  "src/tools/spill.ts"() {
+    "use strict";
+    OUTPUT_DIR = join5(homedir4(), ".miii", "output");
+    INLINE_BUDGET = 1e4;
+    HEAD_FRACTION = 0.3;
+  }
+});
+
 // src/tools/run_bash.ts
 import { execa } from "execa";
 var run_bash;
 var init_run_bash = __esm({
   "src/tools/run_bash.ts"() {
     "use strict";
+    init_spill();
     run_bash = {
       name: "run_bash",
       description: "Execute a shell command (bash on Unix, cmd on Windows). Returns stdout+stderr. Non-interactive only.",
@@ -300,10 +421,10 @@ var init_run_bash = __esm({
           const out = [stdout, stderr].filter(Boolean).join("\n");
           const is_error = exitCode !== 0;
           const body = out || (is_error ? `(no output)` : "");
-          const content = is_error ? `${body}
-[exit ${exitCode}]` : body;
+          const content = `${spillIfLarge(body, "command output")}
+[exit ${exitCode}]`;
           return {
-            content: content.slice(0, 32e3),
+            content,
             is_error
           };
         } catch (err) {
@@ -329,7 +450,7 @@ var init_grep = __esm({
           pattern: { type: "string", description: "Regex pattern" },
           path: { type: "string", description: "Root path to search (default cwd)" },
           glob: { type: "string", description: 'File glob filter, e.g. "*.ts"' },
-          case_insensitive: { type: "string", description: 'Set "true" for case-insensitive' },
+          case_insensitive: { type: "boolean", description: "Case-insensitive match" },
           max_results: { type: "number", description: "Max matching lines (default 200)" }
         },
         required: ["pattern"]
@@ -377,8 +498,25 @@ var init_grep = __esm({
 
 // src/tools/glob.ts
 import { execa as execa3 } from "execa";
-function globToFindName(glob2) {
-  return glob2;
+import { statSync as statSync2 } from "fs";
+function byMtimeDesc(paths) {
+  const mtime = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    try {
+      mtime.set(p, statSync2(p).mtimeMs);
+    } catch {
+      mtime.set(p, 0);
+    }
+  }
+  return [...paths].sort((a, b) => (mtime.get(b) ?? 0) - (mtime.get(a) ?? 0));
+}
+function globToFindArgs(root, glob2) {
+  const stripped = glob2.replace(/^\*\*\//, "");
+  if (!stripped.includes("/")) {
+    return [root, "-type", "f", "-name", stripped];
+  }
+  const pathPat = "*/" + glob2.replace(/\*\*/g, "*");
+  return [root, "-type", "f", "-path", pathPat];
 }
 var glob;
 var init_glob = __esm({
@@ -403,13 +541,10 @@ var init_glob = __esm({
           reject: false,
           timeout: 2e4
         });
-        const tryFind = () => {
-          const name = globToFindName(pattern.replace(/^\*\*\//, ""));
-          return execa3("find", [root, "-type", "f", "-name", name], {
-            reject: false,
-            timeout: 2e4
-          });
-        };
+        const tryFind = () => execa3("find", globToFindArgs(root, pattern), {
+          reject: false,
+          timeout: 2e4
+        });
         try {
           let res;
           try {
@@ -420,8 +555,9 @@ var init_glob = __esm({
           } catch {
             res = await tryFind();
           }
-          const lines = (res.stdout ?? "").split("\n").filter(Boolean).slice(0, limit);
-          if (lines.length === 0) return { content: "No files matched." };
+          const all = (res.stdout ?? "").split("\n").filter(Boolean);
+          if (all.length === 0) return { content: "No files matched." };
+          const lines = byMtimeDesc(all).slice(0, limit);
           return { content: lines.join("\n") };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
@@ -576,10 +712,14 @@ ${toolLines}
 # Rules
 - Always read a file before updating it. Never edit, overwrite, or create-over a file you have not read first this turn.
 - Prefer editing existing files over creating new ones.
-- For edit_file, ensure old_str is unique within the target file.
+- For edit_file, make old_str unique by including surrounding context, or set replace_all to change every occurrence.
 - Never invent file paths. Read, glob, or grep before editing.
 - No filler, no pleasantries, no apologies.
 
+# Context discipline
+- read_file returns line numbers and accepts offset/limit. For large files, grep or glob to the relevant region first, then read only that range with offset/limit. Do not read a whole large file when you need a few functions \u2014 it wastes the context window.
+- Reference code by the line numbers read_file returns.
+
 # Testing and verification
 - Always test the code after a change. Run the project's tests (e.g. npm test, pytest, go test) or the relevant script via run_bash before declaring a task done.
 - If no test exists for the change, run the affected entry point via run_bash to verify it behaves correctly.
@@ -597,9 +737,9 @@ var init_system = __esm({
 });
 
 // src/permissions/policy.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync3, renameSync } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync3, renameSync } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 function loadRules() {
   if (!existsSync3(RULES_PATH)) return [];
   try {
@@ -610,9 +750,9 @@ function loadRules() {
   }
 }
 function saveRules(rules) {
-  mkdirSync4(RULES_DIR, { recursive: true });
+  mkdirSync5(RULES_DIR, { recursive: true });
   const tmp = RULES_PATH + ".tmp";
-  writeFileSync5(tmp, JSON.stringify({ rules }, null, 2), "utf-8");
+  writeFileSync6(tmp, JSON.stringify({ rules }, null, 2), "utf-8");
   renameSync(tmp, RULES_PATH);
 }
 function addRule(tool, pattern) {
@@ -641,6 +781,7 @@ function matches(rule, toolName, subject) {
   }
 }
 async function check(toolName, input, ctx) {
+  if (ALWAYS_ALLOW.has(toolName)) return "allow";
   const subject = subjectFor(toolName, input);
   const rules = loadRules();
   if (rules.some((r) => matches(r, toolName, subject))) return "allow";
@@ -649,12 +790,13 @@ async function check(toolName, input, ctx) {
   if (answer === "always") addRule(toolName, subject);
   return "allow";
 }
-var RULES_DIR, RULES_PATH;
+var RULES_DIR, RULES_PATH, ALWAYS_ALLOW;
 var init_policy = __esm({
   "src/permissions/policy.ts"() {
     "use strict";
-    RULES_DIR = join4(homedir3(), ".miii");
-    RULES_PATH = join4(RULES_DIR, "permissions.json");
+    RULES_DIR = join6(homedir5(), ".miii");
+    RULES_PATH = join6(RULES_DIR, "permissions.json");
+    ALWAYS_ALLOW = /* @__PURE__ */ new Set(["read_file", "grep", "glob"]);
   }
 });
 
@@ -983,16 +1125,16 @@ var init_loop = __esm({
 });
 
 // eval/runner.ts
-import { mkdtempSync, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, rmSync as rmSync2 } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
+import { mkdtempSync, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, rmSync as rmSync3 } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
 import { tmpdir } from "os";
 async function runScenario(model, s) {
-  const dir = mkdtempSync(join5(tmpdir(), "miii-eval-"));
+  const dir = mkdtempSync(join7(tmpdir(), "miii-eval-"));
   const prevCwd = process.cwd();
   for (const [rel, content] of Object.entries(s.files ?? {})) {
-    const abs = join5(dir, rel);
-    mkdirSync5(dirname2(abs), { recursive: true });
-    writeFileSync6(abs, content, "utf-8");
+    const abs = join7(dir, rel);
+    mkdirSync6(dirname2(abs), { recursive: true });
+    writeFileSync7(abs, content, "utf-8");
   }
   const r = {
     name: s.name,
@@ -1030,7 +1172,7 @@ async function runScenario(model, s) {
   r.durationMs = Date.now() - start;
   if (r.error) {
     r.reason = `loop error: ${r.error}`;
-    rmSync2(dir, { recursive: true, force: true });
+    rmSync3(dir, { recursive: true, force: true });
     return r;
   }
   try {
@@ -1040,7 +1182,7 @@ async function runScenario(model, s) {
   } catch (err) {
     r.reason = `check threw: ${err instanceof Error ? err.message : String(err)}`;
   }
-  rmSync2(dir, { recursive: true, force: true });
+  rmSync3(dir, { recursive: true, force: true });
   return r;
 }
 var autoYes;
@@ -1054,12 +1196,12 @@ var init_runner = __esm({
 
 // eval/scenarios.ts
 import { readFileSync as readFileSync6, existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 var read, scenarios;
 var init_scenarios = __esm({
   "eval/scenarios.ts"() {
     "use strict";
-    read = (dir, f) => existsSync4(join6(dir, f)) ? readFileSync6(join6(dir, f), "utf-8") : null;
+    read = (dir, f) => existsSync4(join8(dir, f)) ? readFileSync6(join8(dir, f), "utf-8") : null;
     scenarios = [
       {
         name: "edit-exact-string",
@@ -1208,7 +1350,7 @@ import { createElement } from "react";
 init_client();
 import { useState as useState4, useEffect as useEffect3 } from "react";
 import { Box as Box10, Text as Text10, useApp } from "ink";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir6 } from "os";
 import { sep as sep2 } from "path";
 
 // src/config.ts
@@ -2495,7 +2637,7 @@ async function checkForUpdate() {
 import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
 function App() {
   const { exit } = useApp();
-  const cwd = process.cwd().replace(homedir4(), "~").split(sep2).join("/");
+  const cwd = process.cwd().replace(homedir6(), "~").split(sep2).join("/");
   const [cfg, setCfg] = useState4(loadConfig());
   const [models, setModels] = useState4([]);
   const [contexts, setContexts] = useState4({});
@@ -2572,7 +2714,7 @@ function App() {
   })();
   return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsx10(WelcomeBlock, { model: cfg.model, activeCtx, effort, cwd, error: agent.error }),
-    updateAvailable && /* @__PURE__ */ jsx10(Box10, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { color: "yellow", children: `\u2191 update available: v${updateAvailable} \u2014 run: npm i -g miii-agent` }) }),
+    updateAvailable && /* @__PURE__ */ jsx10(Box10, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { color: "yellow", children: `\u2191 update available: v${updateAvailable} \u2014 run: miii --update` }) }),
     state === "loading" && !agent.error && /* @__PURE__ */ jsx10(Box10, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "connecting to ollama\u2026" }) }),
     agent.error && state !== "ready" && /* @__PURE__ */ jsx10(
       ChatView,
@@ -2633,8 +2775,15 @@ function App() {
 }
 
 // src/cli.tsx
+init_spill();
+cleanupSpill();
 var [, , cmd, ...rest] = process.argv;
-if (cmd === "doctor" || cmd === "eval") {
+if (cmd === "update" || cmd === "--update" || cmd === "-u") {
+  const { spawnSync } = await import("child_process");
+  console.log("Updating miii-agent\u2026");
+  const r = spawnSync("npm", ["i", "-g", "miii-agent@latest"], { stdio: "inherit", shell: process.platform === "win32" });
+  process.exit(r.status ?? 1);
+} else if (cmd === "doctor" || cmd === "eval") {
   const { runEval: runEval2 } = await Promise.resolve().then(() => (init_run(), run_exports));
   process.exit(await runEval2(rest));
 } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-agent",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Terminal AI coding agent powered by Ollama",
   "type": "module",
   "bin": {