token-goat 2.9.30 → 2.9.31

package/dist/{token-goat-chunk-APGZXSPS.mjs → token-goat-chunk-DGS2LVNA.mjs}

@@ -1,34 +1,40 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
-  commandPathIsTouchable,
-  docSectionHint,
-  grepLinesHint,
-  leadWithCommand
-} from "./token-goat-chunk-ATCPY7EQ.mjs";
+  commandPathIsTouchable
+} from "./token-goat-chunk-P6VGNTQT.mjs";
 import {
+  dropFileLineRangesIfChanged,
   getFileLineRanges
-} from "./token-goat-chunk-C63JQV5K.mjs";
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import {
+  hasBareBackgroundOrNewline,
+  hasUnquotedOperator,
+  isRedirectAmpersand
+} from "./token-goat-chunk-4GILLLWY.mjs";
 import {
   isUnderSystemTemp
-} from "./token-goat-chunk-7IN2MKDS.mjs";
+} from "./token-goat-chunk-4GBVPH3D.mjs";
 import {
   FALSY_ENV_VALUES
 } from "./token-goat-chunk-IVE6U7KV.mjs";
 import {
   escapeRegExp
-} from "./token-goat-chunk-GOLEOXZP.mjs";
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  configGetCommand,
+  docSectionHint,
+  grepLinesHint,
+  leadWithCommand,
+  quotedArg,
+  quotedArgs
+} from "./token-goat-chunk-GGGG7RWB.mjs";
 import {
   TOOL_RESULTS_ID_CHARS,
   hostPathOfIndexKey,
   normalizePath,
   resolveIndexPath
 } from "./token-goat-chunk-FNFBKLRD.mjs";
-import {
-  hasBareBackgroundOrNewline,
-  hasUnquotedOperator,
-  isRedirectAmpersand
-} from "./token-goat-chunk-KWPNJBDH.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -37,14 +43,14 @@ import {
 init_define_import_meta_env();
 import { statSync, openSync, readSync, closeSync } from "node:fs";
 function outlineCommand(shown) {
-  return 'token-goat outline "' + shown + '"';
+  return "token-goat outline " + quotedArg(shown);
 }
 function structuredDataHint(hintPath, target, reason = "") {
   const ext = /\.(json|ya?ml)$/i.exec(hintPath)?.[1];
   if (ext === void 0) return null;
   const fmt = ext.toLowerCase() === "json" ? "json" : "yaml";
-  const outline = "token-goat " + fmt + '-outline "' + hintPath + '"';
-  const query = (path2) => "token-goat " + fmt + '-query "' + hintPath + '" "' + path2 + '"';
+  const outline = "token-goat " + fmt + "-outline " + quotedArg(hintPath);
+  const query = (path2) => "token-goat " + fmt + "-query " + quotedArgs(hintPath, path2).join(" ");
   if (target === null || /["'`$\\]/.test(target)) {
     return leadWithCommand(outline, "to list the top-level keys with their type and size (`--filter TEXT` narrows a large one), then `" + query("KEY") + "` to read one value (`\"['a.b']\"` for a key holding a dot)", reason);
   }
@@ -52,27 +58,27 @@ function structuredDataHint(hintPath, target, reason = "") {
   return leadWithCommand(query(path), "to read that value, or `" + outline + "` for every top-level key with its type and size", reason);
 }
 function sqlTableHint(hintPath, target, reason = "") {
-  return leadWithCommand('token-goat read "' + hintPath + "::" + target.name + '"', "to pull one CREATE TABLE / CREATE TYPE block", reason);
+  return leadWithCommand("token-goat read " + quotedArg(hintPath + "::" + target.name), "to pull one CREATE TABLE / CREATE TYPE block", reason);
 }
 function surgicalHintFor(hintPath, isEnv, isConfig, isDoc, isXml, target, reason = "") {
   const outline = outlineCommand(hintPath);
-  if (isXml) return leadWithCommand('token-goat xml-outline "' + hintPath + '"', 'to inspect structure, or `token-goat xml-query "' + hintPath + '" "<selector>"` to query specific nodes', reason);
-  if (isEnv) return leadWithCommand('token-goat config-get "' + hintPath + '" ' + target.name, "to read a specific variable", reason);
+  if (isXml) return leadWithCommand("token-goat xml-outline " + quotedArg(hintPath), "to inspect structure, or `token-goat xml-query " + quotedArgs(hintPath, "<selector>").join(" ") + "` to query specific nodes", reason);
+  if (isEnv) return leadWithCommand(configGetCommand(hintPath, target.name), "to read a specific variable", reason);
   if (isConfig && /\.properties$/i.test(hintPath)) {
-    return target.real ? leadWithCommand('token-goat config-get "' + hintPath + '" ' + target.name, "to read a specific value", reason) : grepLinesHint("<key>", hintPath, reason);
+    return target.real ? leadWithCommand(configGetCommand(hintPath, target.name), "to read a specific value", reason) : grepLinesHint("<key>", hintPath, reason);
   }
   if (isConfig) {
     const structured = structuredDataHint(hintPath, target.real ? target.name : null, reason);
     if (structured !== null) return structured;
-    return target.slice === "key" ? leadWithCommand('token-goat config-get "' + hintPath + '" ' + target.name, "to read a specific value, or `" + outline + "` for every key with line ranges", reason) : leadWithCommand('token-goat section "' + hintPath + "::" + target.name + '"', "to read one table, or `" + outline + "` for every key with line ranges", reason);
+    return target.slice === "key" ? leadWithCommand(configGetCommand(hintPath, target.name), "to read a specific value, or `" + outline + "` for every key with line ranges", reason) : leadWithCommand("token-goat section " + quotedArg(hintPath + "::" + target.name), "to read one table, or `" + outline + "` for every key with line ranges", reason);
   }
   if (isDoc) return docSectionHint(hintPath, target.name, reason);
-  return target.real ? leadWithCommand('token-goat read "' + hintPath + "::" + target.name + '"', "to read one function or class, or `" + outline + "` for all of them", reason) : leadWithCommand(outline, "to list every function and class with its line range", reason);
+  return target.real ? leadWithCommand("token-goat read " + quotedArg(hintPath + "::" + target.name), "to read one function or class, or `" + outline + "` for all of them", reason) : leadWithCommand(outline, "to list every function and class with its line range", reason);
 }
 function surgicalHintForConfigDoc(filePath, isConfig, isDoc, isSql, isXml, target, reason = "") {
   if (isXml || isConfig || isDoc) return surgicalHintFor(filePath, false, isConfig, isDoc, isXml, target, reason);
   if (isSql) return sqlTableHint(filePath, target, reason);
-  return leadWithCommand(outlineCommand(filePath), 'or `token-goat skeleton "' + filePath + '"` to see the file structure', reason);
+  return leadWithCommand(outlineCommand(filePath), "or `token-goat skeleton " + quotedArg(filePath) + "` to see the file structure", reason);
 }
 function splitShellSegments(cmd) {
   const segments = [];
@@ -624,8 +630,9 @@ function substituteSentence(filePath, ranges, sub) {
   const allReads = reads.length === 2 ? reads.join(" and ") : reads.length >= 3 ? reads.slice(0, -1).join(", ") + ", and " + reads[reads.length - 1] : reads[0];
   return "Lines " + spans + " of " + filePath + " cost " + sub.requestedBytes + " bytes; " + allReads + " returns the same content as " + sub.replacementBytes + " bytes, resolved to whole regions and robust to line shifts.";
 }
-function leadingLinesHint(lead, hintPath, start, end, preHookCwd, substitute) {
+function leadingLinesHint(lead, hintPath, start, end, preHookCwd, substitute, event) {
   const key = resolveIndexPath(hintPath, preHookCwd ?? process.cwd());
+  if (commandPathIsTouchable(hintPath, event)) dropFileLineRangesIfChanged(key);
   const prior = findRangeOverlap(getFileLineRanges(key), start, end);
   if (prior !== null) return sedOverlapHint(hintPath, prior, start, end);
   if (substitute === null) return null;
@@ -651,7 +658,7 @@ function sedOverlapHint(filePath, prior, start, end) {
   if (segments.length === 0) {
     return base + "These lines were already served - recall them from your earlier output instead of re-reading.";
   }
-  const reads = segments.map(([s, e]) => '`token-goat read "' + filePath + "@" + s + "-" + e + '"`').join(" and ");
+  const reads = segments.map(([s, e]) => "`token-goat read " + quotedArg(filePath + "@" + s + "-" + e) + "`").join(" and ");
   return base + "For only the new lines, " + reads + ".";
 }
 function extractNodeFileRead(cmd) {
@@ -926,16 +933,18 @@ function stripHeredocBodies(cmd) {
 }
 var ASSIGNMENT_PREFIX_WORDS = /* @__PURE__ */ new Set(["env", "export", "time", "command", "nohup", "exec", "!", "{", "do", "then", "else"]);
 var ENV_VALUE_FLAGS = /* @__PURE__ */ new Set(["-u", "--unset", "-C", "--chdir"]);
+var ENV_CHDIR_FLAG = /^(?:--c|-[A-BD-Za-z]*C)/;
 var ENV_PREFIX_WORDS = /* @__PURE__ */ new Set(["env"]);
 function walkCommandPrefix(words, prefixWords) {
   const assignments = [];
   let prefixed = false;
+  let chdir = false;
   for (let i = 0; i < words.length; i++) {
     const word = words[i];
     const pwsh = /^\$env:([A-Za-z_]\w*)(?:=(.*))?$/i.exec(word);
     if (pwsh !== null) {
       assignments.push({ name: pwsh[1].toUpperCase(), value: pwsh[2] ?? (words[i + 1] === "=" ? words[i + 2] : void 0) });
-      return { command: i, assignments };
+      return { command: i, assignments, chdir };
     }
     const posix = /^([A-Za-z_]\w*)=(.*)$/.exec(word);
     if (posix !== null) {
@@ -947,17 +956,24 @@ function walkCommandPrefix(words, prefixWords) {
       continue;
     }
     if (prefixed && word.startsWith("-")) {
-      if (ENV_VALUE_FLAGS.has(word)) i++;
+      if (ENV_CHDIR_FLAG.test(word)) chdir = true;
+      if (ENV_VALUE_FLAGS.has(word) || /^-[A-Za-z]+C$/.test(word)) i++;
       continue;
     }
-    return { command: i, assignments };
+    return { command: i, assignments, chdir };
   }
-  return { command: words.length, assignments };
+  return { command: words.length, assignments, chdir };
 }
+var caseless = (literal) => literal.replace(/[A-Za-z]/g, (c) => `[${c.toUpperCase()}${c.toLowerCase()}]`);
+var CHANGES_WHAT_RUNS_NAMES = ["PATH", "BASH_ENV", "ENV", "CDPATH", "HOME", "SHELL", "IFS", "PROMPT_COMMAND", "USERPROFILE", "APPDATA", "LOCALAPPDATA"].map(caseless).join("|") + `|(?:${caseless("LD_")}|${caseless("DYLD_")}|${caseless("XDG_")}|${caseless("GIT_")}|${caseless("NPM_CONFIG_")}|${caseless("PIP_")}|${caseless("UV_")}|${caseless("PERL")}|${caseless("RUBY")})\\w*|${caseless("NODE_")}(?!${caseless("ENV")}\\b)\\w*|${caseless("PYTHON")}(?!${["IOENCODING", "UTF8", "UNBUFFERED", "DONTWRITEBYTECODE"].map(caseless).join("|")}\\b)\\w*|${caseless("TOKEN_GOAT_")}(?!${caseless("BASH_COMPRESS")}\\b)\\w*`;
+var CHANGES_WHAT_RUNS = new RegExp(`^(?:${CHANGES_WHAT_RUNS_NAMES})$`);
 function stripLeadingAssignments(cmd) {
   const { words, starts } = splitCommandWordsAt(cmd);
-  const at = starts[walkCommandPrefix(words, ENV_PREFIX_WORDS).command];
+  const { command, assignments, chdir } = walkCommandPrefix(words, ENV_PREFIX_WORDS);
+  const at = starts[command];
   if (at === void 0 || at === 0) return cmd;
+  if (chdir) return cmd;
+  if (assignments.some(({ name }) => CHANGES_WHAT_RUNS.test(name))) return cmd;
   return isCompressibleSingleCommand(cmd.slice(0, at + 1)) ? cmd.slice(at) : cmd;
 }
 function commandOptsOutOfCompression(cmd) {
@@ -1257,6 +1273,7 @@ export {
   extractMarkdownHeadingGrep,
   extractRgStructuralSearch,
   extractGrepPipeChain,
+  CHANGES_WHAT_RUNS_NAMES,
   stripLeadingAssignments,
   compressionOptedOut,
   extractCurlUrl,

package/dist/{token-goat-chunk-54K3EUV3.mjs → token-goat-chunk-DOWRSMWO.mjs}

@@ -2,7 +2,7 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   detectHarness
-} from "./token-goat-chunk-U4N3BN2W.mjs";
+} from "./token-goat-chunk-QYHO5CPH.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";

package/dist/token-goat-chunk-E45INMY3.mjs

@@ -0,0 +1,71 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/languages/markup_scan.ts
+init_define_import_meta_env();
+function charFinder(text, ch) {
+  let cached = -2;
+  return (from) => {
+    if (cached === -1) return -1;
+    if (cached >= from) return cached;
+    cached = text.indexOf(ch, from);
+    return cached;
+  };
+}
+function gtFinder(text) {
+  return charFinder(text, ">");
+}
+function findOpenTags(text, open) {
+  const out = [];
+  open.lastIndex = 0;
+  let m;
+  while ((m = open.exec(text)) !== null) {
+    const nameEnd = m.index + m[0].length;
+    const gt = text.indexOf(">", nameEnd);
+    if (gt < 0) break;
+    out.push({ start: m.index, nameEnd, end: gt + 1 });
+    open.lastIndex = gt + 1;
+  }
+  return out;
+}
+function findElements(text, open, close, limit = Infinity) {
+  const out = [];
+  const next = elementCursor(text, open, close);
+  let el;
+  while (out.length < limit && (el = next()) !== null) out.push(el);
+  return out;
+}
+function elementCursor(text, open, close) {
+  open.lastIndex = 0;
+  let done = false;
+  return () => {
+    if (done) return null;
+    const m = open.exec(text);
+    if (m !== null) {
+      const nameEnd = m.index + m[0].length;
+      const gt = text.indexOf(">", nameEnd);
+      if (gt >= 0) {
+        close.lastIndex = gt + 1;
+        const c = close.exec(text);
+        if (c !== null) {
+          const end = c.index + c[0].length;
+          open.lastIndex = end;
+          return { start: m.index, nameEnd, end, attrs: text.slice(nameEnd, gt), body: text.slice(gt + 1, c.index), bodyEnd: c.index };
+        }
+      }
+    }
+    done = true;
+    return null;
+  };
+}
+
+export {
+  charFinder,
+  gtFinder,
+  findOpenTags,
+  findElements,
+  elementCursor
+};

package/dist/token-goat-chunk-EC5F37F4.mjs

@@ -0,0 +1,244 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  isIgnoredIndexPath
+} from "./token-goat-chunk-ZNMNUPAZ.mjs";
+import {
+  isSecretFileName
+} from "./token-goat-chunk-32ZOY4N5.mjs";
+import {
+  hasSkipSegmentBelowRoot
+} from "./token-goat-chunk-NISNMD7T.mjs";
+import {
+  getOwnProjectFileEntries
+} from "./token-goat-chunk-IK2DRMFX.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  fileIsAbsent,
+  findProject
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  isUnderBlockedRoot
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  foldPath,
+  isInsideRoot
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/path_suggest.ts
+init_define_import_meta_env();
+import { existsSync, opendirSync, realpathSync } from "node:fs";
+import * as path from "node:path";
+
+// src/indexed_file_names.ts
+init_define_import_meta_env();
+function indexedFileList(rootDir) {
+  const out = [];
+  for (const [folded, indexed] of getOwnProjectFileEntries(rootDir)) {
+    if (isIgnoredIndexPath(folded, rootDir)) continue;
+    out.push({ filePath: indexed.filePath, base: folded.slice(Math.max(folded.lastIndexOf("/"), folded.lastIndexOf("\\")) + 1) });
+  }
+  return out;
+}
+function filesNamed(list, name) {
+  const want = foldPath(name);
+  const matches = [];
+  for (const { filePath, base } of list) {
+    const dot = base.lastIndexOf(".");
+    if (base === want || dot > 0 && base.slice(0, dot) === want) matches.push(filePath);
+  }
+  return [...new Set(matches)].sort();
+}
+function indexedFilesNamed(name, rootDir) {
+  return filesNamed(indexedFileList(rootDir), name);
+}
+
+// src/util_suggest.ts
+init_define_import_meta_env();
+function levenshteinDistance(a, b, cap = 3) {
+  if (Math.abs(a.length - b.length) > cap) return cap + 1;
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr.push(Math.min((curr[j - 1] ?? 0) + 1, (prev[j] ?? 0) + 1, (prev[j - 1] ?? 0) + cost));
+    }
+    prev.splice(0, prev.length, ...curr);
+  }
+  return prev[b.length] ?? cap + 1;
+}
+function suggestPackageNames(query, names) {
+  return [...new Set(names)].map((n) => ({ n, d: levenshteinDistance(query.toLowerCase(), n.toLowerCase()) })).filter((x) => x.d <= 3).sort((a, b) => a.d - b.d).slice(0, 5).map((x) => x.n);
+}
+
+// src/path_suggest.ts
+var MAX_PATH_SUGGESTIONS = 3;
+var MAX_PATH_CHARS = 1024;
+var MAX_DIR_ENTRIES = 5e3;
+var UNICODE_SPACES = /[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
+var TRAILING_LOCATION = /(?::\d+(?:-\d+)?|#L\d+(?:-L?\d+)?)$/;
+var SPELLING_REWRITES = [
+  (name) => name.replace(UNICODE_SPACES, " "),
+  (name) => name.replace(/ (AM|PM)\b/g, "\u202F$1"),
+  (name) => name.replace(/ (AM|PM)\b/g, "\xA0$1"),
+  (name) => name.normalize("NFC"),
+  (name) => name.normalize("NFD"),
+  (name) => name.replace(/'/g, "\u2019"),
+  (name) => name.replace(/[\u2018\u2019]/g, "'")
+];
+function withoutDecoration(missing) {
+  const trimmed = missing.trim();
+  const unmentioned = trimmed.startsWith("@") && trimmed.length > 1 ? trimmed.slice(1) : trimmed;
+  return unmentioned.replace(TRAILING_LOCATION, "");
+}
+function spellingVariants(missing) {
+  const seen = /* @__PURE__ */ new Set([withoutDecoration(missing)]);
+  for (const rewrite of SPELLING_REWRITES) {
+    for (const spelling of [...seen]) seen.add(rewrite(spelling));
+  }
+  seen.delete(missing);
+  return [...seen].filter((spelling) => spelling !== "");
+}
+function scopeFor(cwd, rootDir) {
+  const cfg = loadConfig();
+  const project = rootDir !== null ? findProject(rootDir) : null;
+  const indexed = rootDir !== null && project !== null && samePath(project.root, rootDir);
+  return { root: indexed && rootDir !== null ? rootDir : cwd, indexed, skipDirs: cfg.indexing.skip_dirs, blockedRoots: cfg.worker.blocked_roots };
+}
+function permitted(abs, scope) {
+  if (isSecretFileName(abs)) return false;
+  if (isIgnoredIndexPath(abs, scope.root) || hasSkipSegmentBelowRoot(abs, scope.root, (segment) => scope.skipDirs.includes(segment))) return false;
+  if (isUnderBlockedRoot(abs, scope.blockedRoots)) return false;
+  return isInsideRoot(abs, scope.root);
+}
+function entriesOf(dir, scope) {
+  if (!isInsideRoot(dir, scope.root)) return [];
+  const names = [];
+  try {
+    const handle = opendirSync(dir);
+    try {
+      while (names.length < MAX_DIR_ENTRIES) {
+        const entry = handle.readSync();
+        if (entry === null) break;
+        names.push(entry.name);
+      }
+    } finally {
+      handle.closeSync();
+    }
+  } catch {
+  }
+  return names;
+}
+function displayPath(abs, cwd) {
+  const full = path.resolve(abs);
+  for (const base of [path.resolve(cwd), realCwd(path.resolve(cwd))]) {
+    const rel = path.relative(foldPath(base), foldPath(full));
+    if (rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)) return full.split(/[\\/]/).slice(-rel.split(/[\\/]/).length).join("/");
+  }
+  return abs.replace(/\\/g, "/");
+}
+function realCwd(cwd) {
+  try {
+    return realpathSync.native(cwd);
+  } catch {
+    return cwd;
+  }
+}
+function sharedParents(a, b) {
+  const left = path.dirname(a).split(/[\\/]/).reverse();
+  const right = path.dirname(b).split(/[\\/]/).reverse();
+  let shared = 0;
+  while (shared < left.length && shared < right.length && left[shared].toLowerCase() === right[shared].toLowerCase()) shared++;
+  return shared;
+}
+function samePath(a, b) {
+  return foldPath(path.resolve(a)) === foldPath(path.resolve(b));
+}
+function resolveIndexed(file, rootDir) {
+  return path.resolve(rootDir, file);
+}
+function sameNameFiles(missingAbs, rootDir, files, scope) {
+  const base = path.basename(missingAbs);
+  const dot = base.lastIndexOf(".");
+  const names = dot > 0 ? [base, base.slice(0, dot)] : [base];
+  const found = [...new Set(names.flatMap((name) => filesNamed(files, name)))].map((file) => resolveIndexed(file, rootDir)).filter((abs) => !samePath(abs, missingAbs) && !fileIsAbsent(abs) && permitted(abs, scope));
+  const ranked = found.sort((a, b) => sharedParents(b, missingAbs) - sharedParents(a, missingAbs) || a.localeCompare(b));
+  return ranked.length <= MAX_PATH_SUGGESTIONS ? ranked : ranked.filter((abs) => sharedParents(abs, missingAbs) > 0);
+}
+function typoBudget(base) {
+  const dot = base.lastIndexOf(".");
+  if ((dot > 0 ? dot : base.length) < 3) return 0;
+  return base.length >= 8 ? 2 : 1;
+}
+function nearNameFiles(missingAbs, rootDir, files, scope) {
+  const base = path.basename(missingAbs);
+  const budget = typoBudget(base);
+  if (budget === 0) return [];
+  const dir = path.dirname(missingAbs);
+  const lower = base.toLowerCase();
+  const scored = [];
+  const consider = (abs, sameDir) => {
+    const name = path.basename(abs);
+    if (name === base) return;
+    const distance = levenshteinDistance(name.toLowerCase(), lower, budget);
+    if (distance > budget) return;
+    scored.push({ abs, rank: sameDir ? 0 : 1, distance });
+  };
+  for (const name of entriesOf(dir, scope)) consider(path.join(dir, name), true);
+  for (const file of files ?? []) consider(resolveIndexed(file.filePath, rootDir), false);
+  return scored.sort((a, b) => a.rank - b.rank || a.distance - b.distance || a.abs.localeCompare(b.abs)).map((entry) => entry.abs).filter((abs) => !samePath(abs, missingAbs) && !fileIsAbsent(abs) && permitted(abs, scope));
+}
+function caseCorrected(abs, scope) {
+  const root = path.parse(abs).root;
+  let current = root;
+  let changed = false;
+  for (const segment of abs.slice(root.length).split(/[\\/]/).filter((s) => s !== "")) {
+    const next = path.join(current, segment);
+    if (existsSync(next)) {
+      current = next;
+      continue;
+    }
+    const matches = entriesOf(current, scope).filter((entry) => entry.toLowerCase() === segment.toLowerCase());
+    if (matches.length !== 1) return null;
+    current = path.join(current, matches[0]);
+    changed = true;
+  }
+  return changed && permitted(current, scope) ? current : null;
+}
+function suggestPaths(missing, cwd, rootDir) {
+  if (missing === "" || missing.length > MAX_PATH_CHARS || /[\r\n\0]/.test(missing)) return [];
+  const scope = scopeFor(cwd, rootDir);
+  const missingAbs = path.resolve(cwd, missing);
+  const variants = spellingVariants(missing).map((spelling) => path.resolve(cwd, spelling)).filter((abs) => !samePath(abs, missingAbs) && permitted(abs, scope) && existsSync(abs));
+  if (variants.length > 0) return [...new Set(variants)].slice(0, MAX_PATH_SUGGESTIONS).map((abs) => displayPath(abs, cwd));
+  const stripped = path.resolve(cwd, withoutDecoration(missing));
+  const found = [];
+  const add = (list) => {
+    for (const abs of list) if (!samePath(abs, missingAbs) && !found.some((seen) => samePath(seen, abs))) found.push(abs);
+  };
+  let files = null;
+  if (scope.indexed) {
+    try {
+      files = indexedFileList(scope.root);
+      add(sameNameFiles(stripped, scope.root, files, scope));
+    } catch {
+    }
+  }
+  const corrected = caseCorrected(stripped, scope);
+  add(nearNameFiles(stripped, scope.root, files, scope));
+  if (corrected !== null) add([corrected]);
+  return found.slice(0, MAX_PATH_SUGGESTIONS).map((abs) => displayPath(abs, cwd));
+}
+
+export {
+  levenshteinDistance,
+  suggestPackageNames,
+  indexedFilesNamed,
+  suggestPaths
+};

package/dist/{token-goat-chunk-XTQAOTSO.mjs → token-goat-chunk-EDBDRVH5.mjs}

@@ -3,6 +3,9 @@ const require = __cjsRequire(import.meta.url);
 import {
   DocumentRefusedError
 } from "./token-goat-chunk-Y4AFKTHK.mjs";
+import {
+  echoedValue
+} from "./token-goat-chunk-GGGG7RWB.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -15,7 +18,7 @@ var STREAM_CHUNK_BYTES = 64 * 1024;
 var ZipOutputTooLargeError = class extends DocumentRefusedError {
   constructor(entryName, limitBytes, decompressedSoFarBytes) {
     super(
-      `zip entry '${entryName}' is over the ${Math.round(limitBytes / (1024 * 1024))}MB decompressed-size limit (over ${Math.round(decompressedSoFarBytes / (1024 * 1024))}MB decompressed so far)`,
+      `zip entry ${echoedValue(entryName)} is over the ${Math.round(limitBytes / (1024 * 1024))}MB decompressed-size limit (over ${Math.round(decompressedSoFarBytes / (1024 * 1024))}MB decompressed so far)`,
       "ZipOutputTooLargeError"
     );
   }

package/dist/{token-goat-chunk-5BCIJXMO.mjs → token-goat-chunk-EELTBKDM.mjs}

@@ -2,27 +2,27 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   resolveBashCall
-} from "./token-goat-chunk-JTQQGXZH.mjs";
-import {
-  copilotCliUserRoot,
-  readCopilotMcpTools
-} from "./token-goat-chunk-VPBBTSJR.mjs";
+} from "./token-goat-chunk-ODBT2USM.mjs";
 import {
   accumulateResidentLine,
   createResidentContextStats,
   summarizeResidentContext
-} from "./token-goat-chunk-SJHWVNDQ.mjs";
+} from "./token-goat-chunk-WDH44VAU.mjs";
+import {
+  projectTranscriptsDir
+} from "./token-goat-chunk-BPGCUMR7.mjs";
 import {
   commandHash,
   getBashOutput,
   normalizeCommandForCacheKey
-} from "./token-goat-chunk-AFLYLHDH.mjs";
+} from "./token-goat-chunk-KQBLRPBN.mjs";
 import {
-  projectTranscriptsDir
-} from "./token-goat-chunk-BPGCUMR7.mjs";
+  copilotCliUserRoot,
+  readCopilotMcpTools
+} from "./token-goat-chunk-76FGDLRO.mjs";
 import {
   estimateTokens
-} from "./token-goat-chunk-JB6QN6VF.mjs";
+} from "./token-goat-chunk-BFCWY73P.mjs";
 import {
   canonicalize
 } from "./token-goat-chunk-AM5V6GSX.mjs";
@@ -462,6 +462,9 @@ function ownClaudeTranscript(projectRoot) {
     return null;
   }
 }
+function noSessionTranscriptMessage(projectRoot) {
+  return [`no session transcript found for ${projectRoot}`, "Pass --transcript <path> to specify one explicitly."];
+}
 function findProjectSession(projectRoot) {
   const copilotSession = findActiveCopilotSession(projectRoot) ?? findLatestCopilotSession(projectRoot);
   const claudeTranscript = findLatestTranscript(projectRoot);
@@ -602,6 +605,7 @@ export {
   buildWasteReport,
   isCopilotTranscript,
   findLatestCopilotSession,
+  noSessionTranscriptMessage,
   findProjectSession,
   unusedMcpServers,
   MCP_DISABLE_NOTE,

package/dist/{token-goat-chunk-W3QCJS6G.mjs → token-goat-chunk-F4HYL64R.mjs}

@@ -27,18 +27,20 @@ import {
   reconstructLayout,
   resolveDestPage,
   withPdfDocument
-} from "./token-goat-chunk-QSBRTGM2.mjs";
-import "./token-goat-chunk-4FVIAHSI.mjs";
-import "./token-goat-chunk-7IN2MKDS.mjs";
-import "./token-goat-chunk-U4N3BN2W.mjs";
+} from "./token-goat-chunk-25TRAWET.mjs";
+import "./token-goat-chunk-T5P5ACNQ.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
 import "./token-goat-chunk-YZAAZU2S.mjs";
 import "./token-goat-chunk-IVE6U7KV.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-GOLEOXZP.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
 import "./token-goat-chunk-AM5V6GSX.mjs";
 import "./token-goat-chunk-FNFBKLRD.mjs";
-import "./token-goat-chunk-VES7EL7O.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
   MAX_LOCATE_CONTEXT_CHARS,