token-goat 2.9.29 → 2.9.31

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"
     );
   }