@wrongstack/tools 0.319.0 → 0.320.1

package/dist/{chunk-N5O3FK5Q.js → chunk-XSSFBS5I.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-Q5JPPCZC.js";
 import {
   mapWithConcurrency
-} from "./chunk-NWZ6XGBJ.js";
+} from "./chunk-ZBMANLYH.js";
 import {
   loadGitignoreMatcher
 } from "./chunk-DTQ75VBC.js";
 import {
   isBinaryBuffer,
   safeResolveReal
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/grep.ts
 import { spawn } from "node:child_process";
@@ -99,7 +99,8 @@ var grepTool = {
     }
     const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
     const mode = input.output_mode ?? "content";
-    const limit = Math.max(1, Math.min(input.limit ?? 200, 2e3));
+    const rawLimit = typeof input.limit === "number" && Number.isFinite(input.limit) ? input.limit : 200;
+    const limit = Math.max(1, Math.min(Math.floor(rawLimit), 2e3));
     const validation = compileUserRegex(input.pattern, input.case_insensitive ? "i" : "");
     if (!validation.ok) {
       throw new ToolValidationError({
@@ -125,6 +126,9 @@ var rgAvailabilityCache;
 function __resetRgDetectionForTests() {
   rgAvailabilityCache = void 0;
 }
+function __setRgAvailableForTests(available) {
+  rgAvailabilityCache = available !== void 0 ? Promise.resolve(available) : void 0;
+}
 function detectRg() {
   rgAvailabilityCache ??= new Promise((resolve) => {
     try {
@@ -143,7 +147,19 @@ function detectRg() {
   return rgAvailabilityCache;
 }
 async function* runRgStream(input, base, mode, limit, signal) {
-  const args = ["--no-heading"];
+  if (signal.aborted) {
+    yield {
+      type: "final",
+      output: {
+        matches: [],
+        count: 0,
+        truncated: false,
+        used: "rg"
+      }
+    };
+    return;
+  }
+  const args = ["--no-heading", "--with-filename"];
   if (input.case_insensitive) args.push("-i");
   if (mode === "files_with_matches") args.push("-l");
   if (mode === "count") args.push("-c");
@@ -161,7 +177,14 @@ async function* runRgStream(input, base, mode, limit, signal) {
   )) {
     args.push("--ignore-file", gitignorePath);
   }
-  if (input.glob) args.push("--glob", input.glob);
+  if (input.glob) {
+    const g = input.glob.trim();
+    if (g.startsWith("!") || g.startsWith("**/") || g.startsWith("*")) {
+      args.push("--glob", g);
+    } else {
+      args.push("--glob", `**/${g}`);
+    }
+  }
   args.push("--", input.pattern, base);
   const matches = [];
   let buf = "";
@@ -319,11 +342,22 @@ async function* runRgStream(input, base, mode, limit, signal) {
 }
 function parseRgCountLine(line) {
   const idx = line.lastIndexOf(":");
-  if (idx === -1) return 0;
+  if (idx === -1) {
+    const direct = Number.parseInt(line.trim(), 10);
+    return Number.isFinite(direct) ? direct : 0;
+  }
   const n = Number.parseInt(line.slice(idx + 1), 10);
   return Number.isFinite(n) ? n : 0;
 }
 async function runNative(input, base, mode, limit, signal) {
+  if (signal.aborted) {
+    return {
+      matches: [],
+      count: 0,
+      truncated: false,
+      used: "native"
+    };
+  }
   const flags = input.case_insensitive ? "i" : "";
   const compiled = compileUserRegex(input.pattern, flags);
   if (!compiled.ok) {
@@ -337,13 +371,19 @@ async function runNative(input, base, mode, limit, signal) {
   const isGitIgnored = await loadGitignoreMatcher(base);
   const matches = [];
   const countOnlyFirstHit = mode === "count" && limit === 1;
-  const maxBytes = mode === "content" ? NATIVE_MAX_FILE_BYTES : Math.min(NATIVE_MAX_FILE_BYTES, 256 * 1024);
+  const maxBytes = NATIVE_MAX_FILE_BYTES;
   let total = 0;
   let stopped = false;
-  const scanFile = async (full, name) => {
+  const scanFile = async (full, name, rel) => {
     if (stopped || signal.aborted) return;
-    if (globRe && !globRe.test(name) && !globRe.test(full)) return;
-    if (globRe) globRe.lastIndex = 0;
+    if (globRe) {
+      globRe.lastIndex = 0;
+      const normRel = rel.replace(/\\/g, "/");
+      const normFull = full.replace(/\\/g, "/");
+      const matchesGlob = globRe.test(name) || globRe.test(normRel) || globRe.test(normFull);
+      globRe.lastIndex = 0;
+      if (!matchesGlob) return;
+    }
     try {
       const stat2 = await fs.stat(full);
       if (!stat2.isFile() || stat2.size > maxBytes || stopped || signal.aborted) return;
@@ -376,8 +416,8 @@ async function runNative(input, base, mode, limit, signal) {
           for (const rawLine of lines) {
             if (stopped || signal.aborted) break;
             lineNumber++;
-            const ln = capSubject(rawLine);
-            re.lastIndex = 0;
+            const ln = rawLine.length > 4096 ? capSubject(rawLine) : rawLine;
+            if (re.global || re.sticky) re.lastIndex = 0;
             if (!re.test(ln)) continue;
             fileHits++;
             total++;
@@ -386,10 +426,8 @@ async function runNative(input, base, mode, limit, signal) {
             } else if (mode === "files_with_matches") {
               if (fileHits === 1 && matches.length < limit) matches.push(full);
               break;
-            } else if (fileHits === 1 && matches.length < limit) {
-              matches.push(`${full}:${countOnlyFirstHit ? 1 : 0}`);
             }
-            if (countOnlyFirstHit || mode !== "content" && matches.length >= limit) {
+            if (countOnlyFirstHit || mode === "content" && matches.length >= limit) {
               stopped = true;
               break;
             }
@@ -398,8 +436,8 @@ async function runNative(input, base, mode, limit, signal) {
         }
         if (!stopped && !signal.aborted && leftover.length > 0) {
           lineNumber++;
-          const ln = capSubject(leftover);
-          re.lastIndex = 0;
+          const ln = leftover.length > 4096 ? capSubject(leftover) : leftover;
+          if (re.global || re.sticky) re.lastIndex = 0;
           if (re.test(ln)) {
             fileHits++;
             total++;
@@ -407,21 +445,17 @@ async function runNative(input, base, mode, limit, signal) {
               if (matches.length < limit) matches.push(`${full}:${lineNumber}:${ln}`);
             } else if (mode === "files_with_matches") {
               if (matches.length < limit) matches.push(full);
-            } else if (matches.length < limit) {
-              matches.push(`${full}:${countOnlyFirstHit ? 1 : fileHits}`);
             }
           }
         }
         if (fileHits > 0) {
-          if (mode === "count") {
-            const idx = matches.findIndex((entry) => entry.startsWith(`${full}:`));
-            if (idx !== -1) matches[idx] = `${full}:${fileHits}`;
+          if (mode === "count" && matches.length < limit) {
+            matches.push(`${full}:${fileHits}`);
           }
           if (mode === "files_with_matches" && matches.length >= limit) stopped = true;
         }
         if (mode === "content" && matches.length >= limit) stopped = true;
-        if (mode === "count" && matches.length >= limit && (countOnlyFirstHit || mode !== "count"))
-          stopped = true;
+        if (mode === "count" && matches.length >= limit && countOnlyFirstHit) stopped = true;
       } finally {
         await file.close();
       }
@@ -449,13 +483,13 @@ async function runNative(input, base, mode, limit, signal) {
         subdirs.push({ full, rel });
       } else if (e.isFile()) {
         if (isGitIgnored(rel, false)) continue;
-        files.push({ full, name: e.name });
+        files.push({ full, name: e.name, rel });
       }
     }
     await mapWithConcurrency(
       files,
       NATIVE_SCAN_CONCURRENCY,
-      ({ full, name }) => scanFile(full, name)
+      ({ full, name, rel }) => scanFile(full, name, rel)
     );
     await mapWithConcurrency(
       subdirs,
@@ -463,7 +497,13 @@ async function runNative(input, base, mode, limit, signal) {
       ({ full, rel }) => walk(full, rel)
     );
   };
-  await walk(base, "");
+  const baseStat = await fs.stat(base).catch(() => null);
+  if (baseStat?.isFile()) {
+    const rel = input.path ? input.path.replace(/\\/g, "/") : path.basename(base);
+    await scanFile(base, path.basename(base), rel);
+  } else {
+    await walk(base, "");
+  }
   return {
     matches,
     count: total,
@@ -474,6 +514,7 @@ async function runNative(input, base, mode, limit, signal) {
 
 export {
   grepTool,
-  __resetRgDetectionForTests
+  __resetRgDetectionForTests,
+  __setRgAvailableForTests
 };
-//# sourceMappingURL=chunk-N5O3FK5Q.js.map
+//# sourceMappingURL=chunk-XSSFBS5I.js.map

package/dist/{chunk-Y7QXSE7N.js → chunk-YTKSNTT4.js}

@@ -1,16 +1,17 @@
 import {
   tryLegacyCodeOperation
-} from "./chunk-ZDUGI5BC.js";
+} from "./chunk-I7FBZOEP.js";
 import {
   spawnStream
-} from "./chunk-ZHH3BEWU.js";
+} from "./chunk-OYP27E3I.js";
 import {
   normalizeCommandOutput,
   safeResolveReal
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/test.ts
 import * as path from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 var testTool = {
   name: "test",
   category: "Code Quality",
@@ -57,6 +58,14 @@ var testTool = {
   async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
+    const VALID_RUNNERS = /* @__PURE__ */ new Set(["vitest", "jest", "mocha", "auto", "none"]);
+    if (input.runner !== void 0 && !VALID_RUNNERS.has(input.runner)) {
+      throw new ToolValidationError({
+        message: `test: unsupported runner "${input.runner}". Allowed runners: vitest, jest, mocha, auto, none`,
+        field: "runner"
+      });
+    }
     const runner = input.runner ?? "auto";
     if (runner === "auto") {
       const bridge = await tryLegacyCodeOperation("test", {
@@ -83,7 +92,7 @@ var testTool = {
       }
     }
     const detected = runner === "auto" ? await detectRunner(cwd) : runner;
-    if (!detected) {
+    if (!detected || detected === "none") {
       yield {
         type: "final",
         output: {
@@ -115,7 +124,21 @@ var testTool = {
 };
 async function detectRunner(cwd) {
   const { stat } = await import("node:fs/promises");
-  const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
+  const candidates = [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mjs",
+    "vitest.config.mts",
+    "vitest.config.cjs",
+    "vitest.config.cts",
+    "jest.config.ts",
+    "jest.config.js",
+    "jest.config.mjs",
+    "jest.config.cjs",
+    ".mocharc.json",
+    ".mocharc.js",
+    ".mocharc.cjs"
+  ];
   for (const f of candidates) {
     try {
       await stat(path.join(cwd, f));
@@ -129,7 +152,8 @@ async function detectRunner(cwd) {
 }
 function buildArgs(runner, input) {
   const args = [];
-  const timeout = input.timeout ?? 3e4;
+  const rawTimeout = typeof input.timeout === "number" && Number.isFinite(input.timeout) && input.timeout > 0 ? Math.floor(input.timeout) : 3e4;
+  const timeout = Math.max(100, rawTimeout);
   switch (runner) {
     case "vitest":
       args.push(input.watch ? "watch" : "run");
@@ -152,8 +176,10 @@ function buildArgs(runner, input) {
       break;
   }
   if (input.files) {
-    const files = Array.isArray(input.files) ? input.files : input.files.split(",");
-    args.push("--", ...files.map((f) => f.trim()));
+    const files = (Array.isArray(input.files) ? input.files : input.files.split(",")).map((f) => f.trim().replace(/\\/g, "/")).filter(Boolean);
+    if (files.length > 0) {
+      args.push("--", ...files);
+    }
   }
   return args;
 }
@@ -175,7 +201,15 @@ function parseResult(runner, result, duration) {
     tests_run = Number.parseInt(suitesMatch?.[1] ?? "0", 10);
     passed = Number.parseInt(passedMatch?.[1] ?? "0", 10);
     failed = Number.parseInt(failedMatch?.[1] ?? "0", 10);
+  } else if (runner === "mocha") {
+    const passedMatch = out.match(/(\d+)\s+passing/);
+    const failedMatch = out.match(/(\d+)\s+failing/);
+    if (passedMatch?.[1]) passed = Number.parseInt(passedMatch[1], 10);
+    if (failedMatch?.[1]) failed = Number.parseInt(failedMatch[1], 10);
+    tests_run = passed + failed;
   }
+  const rawOutput = result.stdout && result.stderr ? `${result.stdout}
+${result.stderr}` : result.stdout || result.stderr || result.error || "";
   return {
     runner,
     exit_code: result.exitCode,
@@ -187,7 +221,7 @@ function parseResult(runner, result, duration) {
     // already parsed above and the FULL log is on disk (spool marker rides
     // the stdout tail). Failures keep the standard command-output cap so
     // the agent sees the failure details inline.
-    output: normalizeCommandOutput(result.stdout || result.error || "", {
+    output: normalizeCommandOutput(rawOutput, {
       maxBytes: result.exitCode === 0 ? 4096 : void 0
     }),
     truncated: result.truncated
@@ -197,4 +231,4 @@ function parseResult(runner, result, duration) {
 export {
   testTool
 };
-//# sourceMappingURL=chunk-Y7QXSE7N.js.map
+//# sourceMappingURL=chunk-YTKSNTT4.js.map

package/dist/{chunk-MRKWZCHZ.js → chunk-Z5Q3TXRY.js}

@@ -9,7 +9,7 @@ import {
   projectIndexServerBuildId,
   projectIndexServerEndpoint,
   projectIndexServerMetadataPath
-} from "./chunk-W4GAAI3M.js";
+} from "./chunk-PV6HIZQD.js";
 import {
   CircuitOpenError,
   IndexTimeoutError,
@@ -24,7 +24,7 @@ import {
   searchService,
   statsService,
   symbolGraphService
-} from "./chunk-TFMVHYJI.js";
+} from "./chunk-J43O3BOX.js";
 import {
   isIndexablePath
 } from "./chunk-YOHO4DVT.js";
@@ -1269,4 +1269,4 @@ export {
   checkCodebaseIndexServerHealth,
   ensureCodebaseIndexServer
 };
-//# sourceMappingURL=chunk-MRKWZCHZ.js.map
+//# sourceMappingURL=chunk-Z5Q3TXRY.js.map

package/dist/{chunk-PRXZOIEW.js → chunk-Z6IHMJMC.js}

@@ -1,14 +1,14 @@
 import {
   checkSyntax
-} from "./chunk-FQZOHLG3.js";
+} from "./chunk-JSNSMG5R.js";
 import {
   enqueueReindex
-} from "./chunk-MRKWZCHZ.js";
+} from "./chunk-Z5Q3TXRY.js";
 import {
   safeResolveReal,
   sha256hex,
   truncateDiffPayload
-} from "./chunk-QLF74MSV.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/edit.ts
 import * as fs from "node:fs/promises";
@@ -39,45 +39,55 @@ var FUZZY_MIN_SIMILARITY = 0.9;
 var FUZZY_AMBIGUITY_MARGIN = 0.05;
 var FUZZY_MAX_INTERIOR_CHARS = 2e3;
 function findLadderMatches(fileLf, oldLf) {
+  if (typeof fileLf !== "string" || typeof oldLf !== "string" || oldLf.length === 0) {
+    return void 0;
+  }
   const exact = [];
   let idx = fileLf.indexOf(oldLf);
+  let currentLine = 1;
+  let lastPos = 0;
   while (idx !== -1) {
-    exact.push({ start: idx, end: idx + oldLf.length, startLine: lineAt(fileLf, idx) });
+    while (lastPos < idx) {
+      const nextNewline = fileLf.indexOf("\n", lastPos);
+      if (nextNewline === -1 || nextNewline >= idx) break;
+      currentLine++;
+      lastPos = nextNewline + 1;
+    }
+    exact.push({ start: idx, end: idx + oldLf.length, startLine: currentLine });
     idx = fileLf.indexOf(oldLf, idx + 1);
   }
   if (exact.length > 0) return { tier: "exact", matches: exact };
   const fileLines = fileLf.split("\n");
-  const needleLines = oldLf.split("\n");
-  if (needleLines.length > fileLines.length) return void 0;
+  const needleEndsWithNewline = oldLf.endsWith("\n");
+  const rawNeedleLines = oldLf.split("\n");
+  const needleLines = needleEndsWithNewline && rawNeedleLines[rawNeedleLines.length - 1] === "" ? rawNeedleLines.slice(0, -1) : rawNeedleLines;
+  if (needleLines.length === 0 || needleLines.length > fileLines.length) return void 0;
   const offsets = lineOffsets(fileLines);
   const fileTrimEnd = fileLines.map((l) => l.trimEnd());
   const needleTrimEnd = needleLines.map((l) => l.trimEnd());
-  const trailing = windowScan(fileTrimEnd, needleTrimEnd, offsets, fileLines, (a, b) => a === b);
+  const trailing = windowScan(
+    fileTrimEnd,
+    needleTrimEnd,
+    offsets,
+    fileLines,
+    (a, b) => a === b,
+    needleEndsWithNewline
+  );
   if (trailing.length > 0) return { tier: "trailing-whitespace", matches: trailing };
   const normalizedLen = needleTrimEnd.reduce((n, l) => n + l.trimStart().length, 0);
   if (normalizedLen < MIN_NORMALIZED_NEEDLE_CHARS) return void 0;
   const fileTrimmed = fileTrimEnd.map((l) => l.trimStart());
   const needleTrimmed = needleTrimEnd.map((l) => l.trimStart());
-  const normalized = windowScan(fileTrimmed, needleTrimmed, offsets, fileLines, (a, b) => a === b);
+  const normalized = windowScan(
+    fileTrimmed,
+    needleTrimmed,
+    offsets,
+    fileLines,
+    (a, b) => a === b,
+    needleEndsWithNewline
+  );
   if (normalized.length > 0) return { tier: "whitespace-normalized", matches: normalized };
-  return fuzzyScan(fileLines, needleLines, offsets);
-}
-function lineAt(text, pos) {
-  if (pos < 512) {
-    let line2 = 1;
-    for (let i = 0; i < pos; i++) {
-      if (text.charCodeAt(i) === 10) line2++;
-    }
-    return line2;
-  }
-  let line = 1;
-  let search = 0;
-  while (true) {
-    const idx = text.indexOf("\n", search);
-    if (idx === -1 || idx >= pos) return line;
-    search = idx + 1;
-    line++;
-  }
+  return fuzzyScan(fileLines, needleLines, offsets, needleEndsWithNewline);
 }
 function lineOffsets(lines) {
   const out = new Array(lines.length);
@@ -88,15 +98,17 @@ function lineOffsets(lines) {
   }
   return out;
 }
-function windowToMatch(fileLines, offsets, start, windowLen) {
+function windowToMatch(fileLines, offsets, start, windowLen, includeTrailingNewline = false) {
   const lastLine = start + windowLen - 1;
+  const lineEnd = offsets[lastLine] + fileLines[lastLine].length;
+  const end = includeTrailingNewline && lastLine < fileLines.length - 1 ? lineEnd + 1 : lineEnd;
   return {
     start: offsets[start],
-    end: offsets[lastLine] + fileLines[lastLine].length,
+    end,
     startLine: start + 1
   };
 }
-function windowScan(comparisonLines, needleLines, offsets, originalLines, eq) {
+function windowScan(comparisonLines, needleLines, offsets, originalLines, eq, includeTrailingNewline = false) {
   const n = needleLines.length;
   const out = [];
   for (let i = 0; i + n <= comparisonLines.length; i++) {
@@ -108,28 +120,32 @@ function windowScan(comparisonLines, needleLines, offsets, originalLines, eq) {
       }
     }
     if (all) {
-      out.push(windowToMatch(originalLines, offsets, i, n));
+      out.push(windowToMatch(originalLines, offsets, i, n, includeTrailingNewline));
       i += n - 1;
     }
   }
   return out;
 }
-function fuzzyScan(fileLines, needleLines, offsets) {
+function fuzzyScan(fileLines, needleLines, offsets, includeTrailingNewline = false) {
   const n = needleLines.length;
   if (n < 3) return void 0;
   const firstNeedle = needleLines[0].trim();
   const lastNeedle = needleLines[n - 1].trim();
   const needleInterior = needleLines.slice(1, -1).map((l) => l.trim()).join("\n");
   if (needleInterior.length > FUZZY_MAX_INTERIOR_CHARS) return void 0;
+  const fileTrimmed = fileLines.map((l) => l.trim());
   const candidates = [];
   for (let i = 0; i + n <= fileLines.length; i++) {
-    if (fileLines[i].trim() !== firstNeedle) continue;
-    if (fileLines[i + n - 1].trim() !== lastNeedle) continue;
-    const windowInterior = fileLines.slice(i + 1, i + n - 1).map((l) => l.trim()).join("\n");
+    if (fileTrimmed[i] !== firstNeedle) continue;
+    if (fileTrimmed[i + n - 1] !== lastNeedle) continue;
+    const windowInterior = fileTrimmed.slice(i + 1, i + n - 1).join("\n");
     if (windowInterior.length > FUZZY_MAX_INTERIOR_CHARS) continue;
     const score = similarity(needleInterior, windowInterior);
     if (score >= FUZZY_MIN_SIMILARITY) {
-      candidates.push({ match: windowToMatch(fileLines, offsets, i, n), score });
+      candidates.push({
+        match: windowToMatch(fileLines, offsets, i, n, includeTrailingNewline),
+        score
+      });
     }
   }
   if (candidates.length === 0) return void 0;
@@ -150,21 +166,29 @@ function similarity(a, b) {
   if (a === b) return 1;
   const max = Math.max(a.length, b.length);
   if (max === 0) return 1;
-  if (Math.abs(a.length - b.length) / max > 1 - FUZZY_MIN_SIMILARITY + 0.05) {
-    return 1 - Math.abs(a.length - b.length) / max;
+  const lenDiff = Math.abs(a.length - b.length);
+  if (lenDiff / max > 1 - FUZZY_MIN_SIMILARITY) {
+    return 1 - lenDiff / max;
   }
   return 1 - levenshtein(a, b) / max;
 }
 function levenshtein(a, b) {
   if (a.length === 0) return b.length;
   if (b.length === 0) return a.length;
-  let prev = new Array(b.length + 1);
-  let cur = new Array(b.length + 1);
-  for (let j = 0; j <= b.length; j++) prev[j] = j;
-  for (let i = 1; i <= a.length; i++) {
+  if (a.length < b.length) {
+    const tmp = a;
+    a = b;
+    b = tmp;
+  }
+  const bLen = b.length;
+  const aLen = a.length;
+  let prev = new Int32Array(bLen + 1);
+  let cur = new Int32Array(bLen + 1);
+  for (let j = 0; j <= bLen; j++) prev[j] = j;
+  for (let i = 1; i <= aLen; i++) {
     cur[0] = i;
     const ca = a.charCodeAt(i - 1);
-    for (let j = 1; j <= b.length; j++) {
+    for (let j = 1; j <= bLen; j++) {
       const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
       cur[j] = Math.min(
         prev[j] + 1,
@@ -172,9 +196,11 @@ function levenshtein(a, b) {
         prev[j - 1] + cost
       );
     }
-    [prev, cur] = [cur, prev];
+    const tmp = prev;
+    prev = cur;
+    cur = tmp;
   }
-  return prev[b.length];
+  return prev[bLen];
 }
 function firstLineIndent(text) {
   for (const line of text.split("\n")) {
@@ -189,14 +215,17 @@ function adjustIndent(newLf, fromIndent, toIndent) {
   if (toIndent.startsWith(fromIndent)) {
     const extra = toIndent.slice(fromIndent.length);
     return {
-      text: lines.map((l) => l.trim() === "" ? l : extra + l).join("\n"),
+      text: lines.map((l) => l.trim() === "" ? "" : extra + l).join("\n"),
       adjusted: true
     };
   }
   if (fromIndent.startsWith(toIndent)) {
     const remove = fromIndent.slice(toIndent.length);
     return {
-      text: lines.map((l) => l.startsWith(remove) ? l.slice(remove.length) : l).join("\n"),
+      text: lines.map((l) => {
+        if (l.trim() === "") return "";
+        return l.startsWith(remove) ? l.slice(remove.length) : l;
+      }).join("\n"),
       adjusted: true
     };
   }
@@ -204,34 +233,50 @@ function adjustIndent(newLf, fromIndent, toIndent) {
 }
 function nearestMatchHint(fileLf, oldLf) {
   const fileLines = fileLf.split("\n");
-  const needleLines = oldLf.split("\n");
-  if (needleLines.length > fileLines.length) return void 0;
+  const rawNeedle = oldLf.split("\n");
+  const needleLines = oldLf.endsWith("\n") && rawNeedle[rawNeedle.length - 1] === "" ? rawNeedle.slice(0, -1) : rawNeedle;
+  const n = needleLines.length;
+  if (n === 0 || n > fileLines.length) return void 0;
   const needleTrimmed = needleLines.map((l) => l.trim());
+  const fileTrimmed = fileLines.map((l) => l.trim());
   let bestScore = 0;
   let bestStart = -1;
-  for (let i = 0; i + needleLines.length <= fileLines.length; i++) {
+  const maxI = fileLines.length - n;
+  for (let i = 0; i <= maxI; i++) {
     let sum = 0;
-    for (let j = 0; j < needleLines.length; j++) {
-      sum += prefixSimilarity(needleTrimmed[j], fileLines[i + j].trim());
+    let possible = true;
+    for (let j = 0; j < n; j++) {
+      sum += lineSimilarity(needleTrimmed[j], fileTrimmed[i + j]);
+      if (sum + (n - 1 - j) <= bestScore * n) {
+        possible = false;
+        break;
+      }
     }
-    const score = sum / needleLines.length;
-    if (score > bestScore) {
-      bestScore = score;
-      bestStart = i;
+    if (possible) {
+      const score = sum / n;
+      if (score > bestScore) {
+        bestScore = score;
+        bestStart = i;
+      }
     }
   }
   if (bestStart === -1 || bestScore < 0.5) return void 0;
-  const snippet = fileLines.slice(bestStart, bestStart + Math.min(3, needleLines.length)).map((l) => l.length > 120 ? `${l.slice(0, 120)}\u2026` : l).join("\n");
+  const snippet = fileLines.slice(bestStart, bestStart + Math.min(3, n)).map((l) => l.length > 120 ? `${l.slice(0, 120)}\u2026` : l).join("\n");
   return { line: bestStart + 1, snippet };
 }
-function prefixSimilarity(a, b) {
+function lineSimilarity(a, b) {
   if (a === b) return 1;
   const max = Math.max(a.length, b.length);
   if (max === 0) return 1;
+  if (a.includes(b) || b.includes(a)) {
+    return Math.min(a.length, b.length) / max;
+  }
   let p = 0;
   const lim = Math.min(a.length, b.length);
   while (p < lim && a.charCodeAt(p) === b.charCodeAt(p)) p++;
-  return p / max;
+  let s = 0;
+  while (s < lim - p && a.charCodeAt(a.length - 1 - s) === b.charCodeAt(b.length - 1 - s)) s++;
+  return (p + s) / max;
 }
 
 // src/edit.ts
@@ -473,4 +518,4 @@ Compare this against your old_string and retry with the file's actual text.` : "
 export {
   editTool
 };
-//# sourceMappingURL=chunk-PRXZOIEW.js.map
+//# sourceMappingURL=chunk-Z6IHMJMC.js.map

package/dist/{chunk-NWZ6XGBJ.js → chunk-ZBMANLYH.js}

@@ -1,8 +1,10 @@
 // src/_concurrency.ts
 async function mapWithConcurrency(items, limit, fn) {
-  if (items.length === 0) return [];
+  if (!Array.isArray(items) || items.length === 0) return [];
+  if (typeof fn !== "function") return [];
   if (items.length === 1) return [await fn(items[0])];
-  const effectiveLimit = Math.max(1, Math.min(limit | 0, items.length));
+  const parsedLimit = Number.isFinite(limit) ? Math.floor(limit) : items.length;
+  const effectiveLimit = Math.max(1, Math.min(parsedLimit, items.length));
   const results = new Array(items.length);
   let nextIndex = 0;
   const worker = async () => {
@@ -19,4 +21,4 @@ async function mapWithConcurrency(items, limit, fn) {
 export {
   mapWithConcurrency
 };
-//# sourceMappingURL=chunk-NWZ6XGBJ.js.map
+//# sourceMappingURL=chunk-ZBMANLYH.js.map