@wrongstack/tools 0.318.0 → 0.319.1

package/dist/{chunk-WI3VDXHD.js → chunk-BSJSNVGA.js}

@@ -20,10 +20,11 @@ import {
   COMMAND_OUTPUT_MAX_BYTES,
   normalizeCommandOutput,
   safeResolveReal
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/exec.ts
 import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
 import {
   emitProcessCompleted,
   emitProcessOutput,
@@ -32,13 +33,12 @@ import {
 import { toErrorMessage } from "@wrongstack/core/utils/error";
 
 // src/_danger-detect.ts
-var argHas = (args, value) => args.includes(value);
 var argMatches = (args, re) => args.some((a) => re.test(a));
 var flagLetters = (args) => {
   const seen = /* @__PURE__ */ new Set();
   for (const a of args) {
     if (/^-[a-zA-Z]+$/.test(a)) {
-      for (const ch of a.slice(1)) seen.add(ch);
+      for (const ch of a.slice(1)) seen.add(ch.toLowerCase());
     } else if (a === "--recursive") {
       seen.add("r");
     } else if (a === "--force") {
@@ -54,13 +54,29 @@ var RULES = [
   // want to do intentionally. We downgrade it to 'destructive' so the
   // confirm prompt can approve. Short clusters, GNU long forms
   // (`--recursive --force`), and mixed shapes all classify identically.
+  // The Windows cmd.exe shape classifies identically too: `rmdir /s /q`
+  // (and its `rd` alias) is the same operation — /s is the recursive half,
+  // /q the quiet (no per-directory prompt, i.e. the "force") half. /s alone
+  // still prompts in cmd, so it stays safe, mirroring the PowerShell rule's
+  // requirement for both -Recurse and -Force. `del`/`erase` (erase is a cmd
+  // alias of del) with /s is classified as well: `del /s` deletes matching
+  // files in the whole subtree WITHOUT any per-file prompt, so there /s
+  // alone is the recursive-force half (/f only overrides read-only, /q only
+  // mutes the global-wildcard "are you sure"). Non-recursive del/erase
+  // (single files, or a quiet single-directory wildcard) stays safe.
   {
     id: "rm-recursive",
     level: "destructive",
     test: (cmd, args) => {
-      if (cmd !== "rm" && cmd !== "rmdir") return false;
+      if (cmd !== "rm" && cmd !== "rmdir" && cmd !== "rd" && cmd !== "del" && cmd !== "erase") {
+        return false;
+      }
       const letters = flagLetters(args);
-      return letters.has("r") && letters.has("f");
+      if (letters.has("r") && letters.has("f")) return true;
+      const has = (flag) => args.some((a) => a.toLowerCase() === `/${flag}`);
+      if (cmd === "rmdir" || cmd === "rd") return has("s") && has("q");
+      if (cmd === "del" || cmd === "erase") return has("s");
+      return false;
     },
     reason: "recursive force-delete"
   },
@@ -70,9 +86,9 @@ var RULES = [
     level: "destructive",
     test: (cmd, args) => {
       if (cmd !== "powershell" && cmd !== "pwsh") return false;
-      const hasRecurse = argMatches(args, /^-(?:R|Recurse|Recurse\s)/);
-      const hasForce = argHas(args, "-Force") || argHas(args, "-F");
-      if (argHas(args, "-WhatIf")) return false;
+      const hasRecurse = argMatches(args, /^-(?:r|recurse)(?::\$true)?$/i);
+      const hasForce = argMatches(args, /^-(?:f|force)(?::\$true)?$/i);
+      if (argMatches(args, /^-whatif(?::\$true)?$/i)) return false;
       return hasRecurse && hasForce;
     },
     reason: "Remove-Item with -Recurse -Force"
@@ -84,7 +100,9 @@ var RULES = [
     test: (cmd, args) => {
       if (cmd !== "powershell" && cmd !== "pwsh") return false;
       return args.some(
-        (a) => /^(?:Format-Volume|Clear-Disk|Initialize-Disk|Remove-Partition|Clear-Volume)(?:\s|$)/i.test(a)
+        (a) => /^(?:Format-Volume|Clear-Disk|Initialize-Disk|Remove-Partition|Clear-Volume)(?:\s|$)/i.test(
+          a
+        )
       );
     },
     reason: "PowerShell disk/volume partition destruction"
@@ -191,6 +209,15 @@ var RULES = [
   // ----- VCS history rewrite (destructive) -----
   // `git push --force` / `-f` rewrites remote history. `--force-with-lease`
   // is the safer variant (checks remote hasn't moved) but still rewrites.
+  // A refspec prefixed with `+` (`git push origin +main`,
+  // `+HEAD:refs/heads/main`) is per-refspec force — documented git shorthand
+  // equivalent to `--force` for that ref — so it classifies identically. A
+  // `+` anywhere else in a refspec (branch `feature+fix`) is just a
+  // character, and a leading `^` EXCLUDES the ref (with --all/--mirror);
+  // neither is force syntax. `--dry-run` / `-n` rewrites nothing and is
+  // exempt, like the PowerShell -WhatIf carve-out above (combined short
+  // clusters like `-nf` count as dry-run too — git push's short flags are
+  // only -q -v -f -n -u -o, so an 'n' in a cluster means dry-run).
   {
     id: "git-push-force",
     level: "destructive",
@@ -198,11 +225,18 @@ var RULES = [
       if (cmd !== "git") return false;
       const pushIdx = args.indexOf("push");
       if (pushIdx < 0) return false;
+      if (args.slice(pushIdx + 1).some((a) => a === "--dry-run" || a === "-n" || /^-[a-z]*n[a-z]*$/i.test(a))) {
+        return false;
+      }
       for (let i = pushIdx + 1; i < args.length; i++) {
         const a = args[i];
         if (a === "--force" || a === "-f" || a === "--force-with-lease") return true;
-        if (!a.startsWith("-") && !a.includes("=")) continue;
+        if (!a.startsWith("-") && !a.includes("=")) {
+          if (a.startsWith("+")) return true;
+          continue;
+        }
         if (a.startsWith("--force")) return true;
+        if (/^-[a-z]+$/i.test(a) && a.toLowerCase().includes("f")) return true;
       }
       return false;
     },
@@ -1507,7 +1541,8 @@ var execTool = {
       };
     }
     const args = (input.args ?? []).slice(0, MAX_ARGS);
-    const timeout = Math.max(1, Math.min(input.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS));
+    const rawTimeout = typeof input.timeout === "number" && !Number.isNaN(input.timeout) ? input.timeout : DEFAULT_TIMEOUT_MS;
+    const timeout = Math.max(1, Math.min(rawTimeout, MAX_TIMEOUT_MS));
     const danger = detectDanger(cmd, args, dangerBypass);
     const killCheck = await checkExecKillCommand(cmd, args);
     if (killCheck.blocked) {
@@ -1552,7 +1587,30 @@ var execTool = {
       };
     }
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    if (signal.aborted) {
+      return {
+        command: cmd,
+        args,
+        stdout: "",
+        stderr: "Aborted",
+        exitCode: 124,
+        truncated: false,
+        allowed: true,
+        danger
+      };
+    }
     return runCommand(cmd, args, cwd, timeout, signal, ctx.session?.id, danger);
+  },
+  async cleanup(_input, ctx) {
+    const registry = getProcessRegistry();
+    const sessionId = ctx.session?.id;
+    if (!sessionId) return;
+    for (const entry of registry.bySession(sessionId)) {
+      if (entry.name !== "exec") continue;
+      if (entry.child && entry.child.exitCode !== null) continue;
+      if (entry.protected) continue;
+      registry.kill(entry.pid, { force: true });
+    }
   }
 };
 function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
@@ -1572,6 +1630,20 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     let telemetryCompleted = false;
     let timedOut = false;
     const spool = createOutputSpool({ tool: `exec-${cmd}`, thresholdBytes: MAX_OUTPUT });
+    if (signal.aborted) {
+      spool.finalize();
+      finish({
+        command: cmd,
+        args,
+        stdout: "",
+        stderr: "Aborted",
+        exitCode: 124,
+        truncated: false,
+        allowed: true,
+        danger
+      });
+      return;
+    }
     const resolved = resolveWin32Command(cmd);
     const needsShell = isWin2 && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
     const shim = needsShell ? buildWin32CmdShimInvocation(resolved, args) : null;
@@ -1681,19 +1753,25 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
       if (signal.aborted) onAbort();
       else signal.addEventListener("abort", onAbort, { once: true });
     }
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
     child.stdout?.on("data", (chunk) => {
-      const text = chunk.toString();
+      const text = stdoutDecoder.write(chunk);
       stdoutBytes += chunk.byteLength;
       emitProcessOutput({ pid, stream: "stdout", chunk });
-      if (stdout.length < MAX_OUTPUT) stdout += text;
-      spool.write(text);
+      if (text.length > 0) {
+        if (stdout.length < MAX_OUTPUT) stdout += text.slice(0, MAX_OUTPUT - stdout.length);
+        spool.write(text);
+      }
     });
     child.stderr?.on("data", (chunk) => {
-      const text = chunk.toString();
+      const text = stderrDecoder.write(chunk);
       stderrBytes += chunk.byteLength;
       emitProcessOutput({ pid, stream: "stderr", chunk });
-      if (stderr.length < MAX_OUTPUT) stderr += text;
-      spool.write(text);
+      if (text.length > 0) {
+        if (stderr.length < MAX_OUTPUT) stderr += text.slice(0, MAX_OUTPUT - stderr.length);
+        spool.write(text);
+      }
     });
     child.on("close", (code) => {
       clearTimeout(timer);
@@ -1703,14 +1781,25 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
       const exitCode = killed ? 124 : code ?? 1;
       emitCompletedOnce(exitCode, pid);
       registry.afterCall(durationMs, exitCode !== 0);
+      const stdoutTail = stdoutDecoder.end();
+      if (stdoutTail) {
+        if (stdout.length < MAX_OUTPUT) stdout += stdoutTail.slice(0, MAX_OUTPUT - stdout.length);
+        spool.write(stdoutTail);
+      }
+      const stderrTail = stderrDecoder.end();
+      if (stderrTail) {
+        if (stderr.length < MAX_OUTPUT) stderr += stderrTail.slice(0, MAX_OUTPUT - stderr.length);
+        spool.write(stderrTail);
+      }
       const spooled = spool.finalize();
+      const isTruncated = stdoutBytes > MAX_OUTPUT || stderrBytes > MAX_OUTPUT || Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES || Buffer.byteLength(stderr, "utf8") > COMMAND_OUTPUT_MAX_BYTES;
       finish({
         command: cmd,
         args,
         stdout: normalizeCommandOutput(stdout) + (spooled ? spoolNote(spooled) : ""),
         stderr: normalizeCommandOutput(stderr),
         exitCode,
-        truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES || Buffer.byteLength(stderr, "utf8") > COMMAND_OUTPUT_MAX_BYTES,
+        truncated: isTruncated,
         allowed: true,
         danger
       });
@@ -1730,4 +1819,4 @@ export {
   getExecAllowlist,
   execTool
 };
-//# sourceMappingURL=chunk-WI3VDXHD.js.map
+//# sourceMappingURL=chunk-BSJSNVGA.js.map

package/dist/{chunk-UKGMDCXT.js → chunk-C2DQKVLO.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-NBDZMMG2.js";
 import {
   truncateMiddle
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/fetch.ts
 import { FetchError, ToolError, ToolValidationError } from "@wrongstack/core/types";
@@ -79,13 +79,29 @@ var fetchTool = {
     return final;
   },
   async *executeStream(input, ctx, opts) {
-    if (!input?.url) {
+    if (!input?.url || typeof input.url !== "string" || !input.url.trim()) {
       throw new ToolValidationError({
-        message: "fetch: url is required",
+        message: "fetch: url is required and cannot be empty",
         field: "url"
       });
     }
-    const u = new URL(input.url);
+    const trimmedUrl = input.url.trim();
+    let u;
+    try {
+      u = new URL(trimmedUrl);
+    } catch {
+      throw new ToolValidationError({
+        message: `fetch: invalid URL "${input.url}"`,
+        field: "url"
+      });
+    }
+    const ALLOWED_FORMATS = /* @__PURE__ */ new Set(["markdown", "text", "raw"]);
+    if (input.format !== void 0 && !ALLOWED_FORMATS.has(input.format)) {
+      throw new ToolValidationError({
+        message: `fetch: unsupported format "${input.format}". Allowed formats: markdown, text, raw`,
+        field: "format"
+      });
+    }
     if (u.username || u.password) {
       throw new ToolValidationError({
         message: "fetch: URLs with embedded credentials (user:pass@host) are not allowed",
@@ -105,8 +121,9 @@ var fetchTool = {
       });
     }
     await assertNotPrivate(u.hostname);
-    yield { type: "log", text: `GET ${input.url}` };
+    yield { type: "log", text: `GET ${trimmedUrl}` };
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    signal.throwIfAborted();
     const ctrl = new AbortController();
     const timer = setTimeout(
       () => ctrl.abort(
@@ -122,10 +139,10 @@ var fetchTool = {
     try {
       let res;
       try {
-        res = await guardedFetch(input.url, 5, combined);
+        res = await guardedFetch(trimmedUrl, 5, combined);
       } catch (err) {
         if (signal.aborted) throw err;
-        throw describeFetchError(err, input.url, ctrl.signal.aborted);
+        throw describeFetchError(err, trimmedUrl, ctrl.signal.aborted);
       }
       const ct = res.headers.get("content-type") ?? "application/octet-stream";
       if (/^image\/|^audio\/|^video\/|application\/octet-stream/.test(ct)) {
@@ -146,31 +163,46 @@ var fetchTool = {
       let pendingBytes = 0;
       const FLUSH_AT = 4 * 1024;
       if (reader) {
-        for (; ; ) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          if (!value) continue;
-          received += value.byteLength;
-          pendingBytes += value.byteLength;
-          chunks.push(value);
-          if (pendingBytes >= FLUSH_AT) {
-            const recent = Buffer.from(value).toString("utf-8");
-            yield {
-              type: "partial_output",
-              text: recent,
-              data: { received }
-            };
-            pendingBytes = 0;
+        try {
+          for (; ; ) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            if (!value) continue;
+            received += value.byteLength;
+            pendingBytes += value.byteLength;
+            chunks.push(value);
+            if (pendingBytes >= FLUSH_AT) {
+              const recent = Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString(
+                "utf8"
+              );
+              yield {
+                type: "partial_output",
+                text: recent,
+                data: { received }
+              };
+              pendingBytes = 0;
+            }
+            if (received > MAX_BYTES) {
+              await reader.cancel().catch(() => {
+              });
+              break;
+            }
           }
-          if (received > MAX_BYTES) break;
+        } finally {
+          reader.releaseLock();
         }
       }
-      const text = Buffer.concat(chunks.map((c) => Buffer.from(c))).toString("utf8");
-      const format = input.format ?? (ct.includes("text/html") ? "markdown" : "text");
+      const text = Buffer.concat(chunks).toString("utf8");
+      const isHtml = ct.includes("text/html");
+      const isJson = /[\/+]json(;|$)/i.test(ct);
+      const format = input.format ?? (isHtml ? "markdown" : "text");
       let content;
       if (format === "raw") content = text;
-      else if (format === "markdown" && ct.includes("text/html")) content = TD.turndown(text);
-      else if (ct.includes("application/json")) content = prettyJson(text);
+      else if (format === "markdown" && isHtml) content = TD.turndown(text);
+      else if (format === "markdown" && isJson) content = `\`\`\`json
+${prettyJson(text)}
+\`\`\``;
+      else if (isJson) content = prettyJson(text);
       else content = text;
       yield {
         type: "final",
@@ -226,6 +258,7 @@ function describeFetchError(err, url, timedOut) {
   });
 }
 function prettyJson(s) {
+  if (!s || s.length > 5e5) return s;
   try {
     return JSON.stringify(JSON.parse(s), null, 2);
   } catch {
@@ -236,4 +269,4 @@ function prettyJson(s) {
 export {
   fetchTool
 };
-//# sourceMappingURL=chunk-UKGMDCXT.js.map
+//# sourceMappingURL=chunk-C2DQKVLO.js.map

package/dist/{chunk-CIFAIIHI.js → chunk-CFLJFDYV.js}

@@ -3,12 +3,12 @@ import {
 } from "./chunk-FQZOHLG3.js";
 import {
   enqueueReindex
-} from "./chunk-VZLX2JZG.js";
+} from "./chunk-DP6CXMJZ.js";
 import {
   safeResolveReal,
   sha256hex,
   truncateDiffPayload
-} from "./chunk-D33S4RQG.js";
+} from "./chunk-ZUFHAHTE.js";
 
 // src/edit.ts
 import * as fs from "node:fs/promises";
@@ -41,43 +41,50 @@ var FUZZY_MAX_INTERIOR_CHARS = 2e3;
 function findLadderMatches(fileLf, oldLf) {
   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 +95,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 +117,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 +163,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 +193,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 +212,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 +230,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 +515,4 @@ Compare this against your old_string and retry with the file's actual text.` : "
 export {
   editTool
 };
-//# sourceMappingURL=chunk-CIFAIIHI.js.map
+//# sourceMappingURL=chunk-CFLJFDYV.js.map