token-goat 2.9.29 → 2.9.31

package/dist/{token-goat-chunk-DNSPXQXQ.mjs → token-goat-chunk-CJLS3CDL.mjs}

@@ -4,29 +4,62 @@ import {
   parse
 } from "./token-goat-chunk-3BTK54F3.mjs";
 import {
-  filtersFilteredToEmptyNotice
-} from "./token-goat-chunk-XYWPOSCN.mjs";
+  compileGuardedRegexCached,
+  countNoun
+} from "./token-goat-chunk-HU4TORC5.mjs";
 import {
-  displaySafeText
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+  echoedValue
+} from "./token-goat-chunk-GGGG7RWB.mjs";
 import {
-  compileGuardedRegexCached
-} from "./token-goat-chunk-JTKCQMQA.mjs";
+  displaySafeText
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
 
 // src/csv_query.ts
 init_define_import_meta_env();
+
+// src/query_notices.ts
+init_define_import_meta_env();
+function headElidedNotice(hidden, noun) {
+  return `...(${countNoun(hidden, `more ${noun}`)} elided; use --head to see more)`;
+}
+function traversalLimitNotice(matched) {
+  if (matched === 0) return "...(no matches: the search stopped at this tool's traversal limit before finding any, so the part of the document it did not reach may still hold some. Narrow the path to search less of the document.)";
+  return "...(the search stopped early at this tool's traversal limit; these are not necessarily all the matches. Narrow the path to search less of the document.)";
+}
+
+// src/filter_notice.ts
+init_define_import_meta_env();
+function allOfCount(count, singular, plural = `${singular}s`) {
+  return count === 1 ? `the only ${singular}` : `all ${count} ${plural}`;
+}
+function filteredSubject(count, singular, plural) {
+  const one = count === 1;
+  return { subject: `${allOfCount(count, singular, plural)} ${one ? "was" : "were"}`, pronoun: one ? "it" : "them" };
+}
+function grepFilteredToEmptyNotice(preFilterCount, grep, nounSingular, nounPlural) {
+  const { subject, pronoun } = filteredSubject(preFilterCount, nounSingular, nounPlural);
+  return `  (${subject} filtered out by --grep ${displaySafeText(grep)} -- widen or drop the filter to see ${pronoun})`;
+}
+function filtersFilteredToEmptyNotice(preFilterCount, activeFilters, nounSingular, nounPlural, reassurance) {
+  const { subject, pronoun } = filteredSubject(preFilterCount, nounSingular, nounPlural);
+  const cause = activeFilters.length === 0 ? "the active filter" : activeFilters.map(displaySafeText).join(" + ");
+  const knob = activeFilters.length > 1 ? "filters" : "filter";
+  const tail = reassurance === void 0 ? "" : `; ${reassurance}`;
+  return `  (${subject} filtered out by ${cause}${tail} -- widen or drop the ${knob} to see ${pronoun})`;
+}
+
+// src/csv_query.ts
 var DELIMITER_CANDIDATES = [",", "	", ";", "|"];
 var DELIMITER_SAMPLE_ROWS = 5;
 function detectDelimiter(content) {
-  const slice = content.slice(0, 1e4);
-  if (slice.trim() === "") return ",";
+  if (content.trim() === "") return ",";
   for (const cand of DELIMITER_CANDIDATES) {
     let rows;
     try {
-      rows = parse(slice, { columns: false, skip_empty_lines: true, trim: true, delimiter: cand, bom: true, relax_quotes: true, to: DELIMITER_SAMPLE_ROWS });
+      rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter: cand, bom: true, relax_quotes: true, to: DELIMITER_SAMPLE_ROWS });
     } catch {
       continue;
     }
@@ -39,7 +72,9 @@ function parseRecords(content, opts) {
   const delimiter = opts.delimiter ?? detectDelimiter(content);
   if (opts.noHeader === true) {
     const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true, relax_quotes: true });
-    return rows.map((row) => Object.fromEntries(row.map((cell, i) => [`col${i + 1}`, cell])));
+    const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
+    const columns = Array.from({ length: width }, (_, i) => `col${i + 1}`);
+    return { records: rows.map((row) => Object.fromEntries(columns.map((name, i) => [name, row[i] ?? ""]))), columns };
   }
   const header = csvHeader(content, { ...opts, delimiter });
   const dupes = header.filter((name, i) => name !== "" && header.indexOf(name) !== i);
@@ -49,14 +84,25 @@ function parseRecords(content, opts) {
       `duplicate column ${unique.length === 1 ? "name" : "names"} in header: ${unique.join(", ")} \u2014 rename the duplicates or pass --no-header to address columns positionally as col1, col2, \u2026`
     );
   }
-  return parse(content, { columns: true, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true, relax_quotes: true });
+  const records = parse(content, { columns: () => header, skip_empty_lines: true, trim: true, delimiter, bom: true, relax_column_count: true, relax_quotes: true });
+  return { records, columns: header };
+}
+function nameBlankHeaders(raw) {
+  const taken = new Set(raw.filter((name) => name !== ""));
+  return raw.map((name, i) => {
+    if (name !== "") return name;
+    let synth = `col${i + 1}`;
+    while (taken.has(synth)) synth += "_";
+    taken.add(synth);
+    return synth;
+  });
 }
 function csvHeader(content, opts) {
   if (opts.noHeader === true) return [];
   const delimiter = opts.delimiter ?? detectDelimiter(content);
   try {
     const rows = parse(content, { columns: false, skip_empty_lines: true, trim: true, delimiter, bom: true, to: 1, relax_quotes: true });
-    return rows[0] ?? [];
+    return nameBlankHeaders(rows[0] ?? []);
   } catch {
     return [];
   }
@@ -70,7 +116,7 @@ function parseWhereSpecs(specs) {
     const op = m[2];
     const value = m[3];
     if ((op === ">" || op === "<" || op === ">=" || op === "<=") && value.trim() === "") {
-      throw new Error(`invalid --where spec: ${spec} (missing comparison value after '${op}')`);
+      throw new Error(`invalid --where spec: ${spec} (missing comparison value after ${echoedValue(op)})`);
     }
     if (op === "~=") {
       const guarded = compileGuardedRegexCached(value);
@@ -128,8 +174,8 @@ function matchesWhere(row, where) {
   }
 }
 function queryCsv(content, opts) {
-  const records = parseRecords(content, opts);
-  const allColumns = records.length > 0 ? Object.keys(records[0]) : [];
+  const { records, columns: allHeader } = parseRecords(content, opts);
+  const allColumns = records.length > 0 ? allHeader : [];
   const realHeader = records.length > 0 ? allColumns : csvHeader(content, opts);
   const columns = opts.columns && opts.columns.length > 0 ? opts.columns : allColumns;
   for (const c of columns) {
@@ -164,7 +210,7 @@ function formatCsvTable(result, activeFilters = []) {
     ...result.rows.map((r) => r.map(quoteCsvCell).join(","))
   ];
   if (result.totalRows > result.rows.length) {
-    lines.push(`...(${result.totalRows - result.rows.length} more rows elided; use --head to see more)`);
+    lines.push(headElidedNotice(result.totalRows - result.rows.length, "row"));
   }
   if (result.totalRows === 0 && result.preFilterRows > 0) {
     lines.push(filtersFilteredToEmptyNotice(result.preFilterRows, activeFilters, "data row", "data rows"));
@@ -172,8 +218,8 @@ function formatCsvTable(result, activeFilters = []) {
   return lines.join("\n");
 }
 function profileCsv(content, opts = {}) {
-  const records = parseRecords(content, opts);
-  const columns = records.length > 0 ? Object.keys(records[0]) : [];
+  const { records, columns: allHeader } = parseRecords(content, opts);
+  const columns = records.length > 0 ? allHeader : [];
   return columns.map((col) => {
     const values = records.map((r) => r[col] ?? "");
     const nullCount = values.filter((v) => v.trim() === "").length;
@@ -219,6 +265,12 @@ function formatCsvProfile(profiles) {
 }
 
 export {
+  headElidedNotice,
+  traversalLimitNotice,
+  allOfCount,
+  filteredSubject,
+  grepFilteredToEmptyNotice,
+  filtersFilteredToEmptyNotice,
   parseWhereSpecs,
   queryCsv,
   quoteCsvCell,

package/dist/{token-goat-chunk-MELOKFDJ.mjs → token-goat-chunk-CO3UYX6G.mjs}

@@ -8,7 +8,7 @@ import {
 init_define_import_meta_env();
 import { createRequire } from "node:module";
 function readManifest() {
-  if (true) return JSON.parse('{"version":"2.9.29","name":"token-goat","bugs":{"url":"https://github.com/DFKHelper/token-goat/issues"}}');
+  if (true) return JSON.parse('{"version":"2.9.31","name":"token-goat","bugs":{"url":"https://github.com/DFKHelper/token-goat/issues"}}');
   try {
     return createRequire(import.meta.url)("../package.json");
   } catch {
@@ -132,6 +132,11 @@ function ensureStorageRootPrivate(dir) {
   if (isUnderRoot(dir, DATA_DIR)) ensureDataDirPrivate();
   if (isUnderRoot(dir, tokenGoatHome())) ensureHomeDirPrivate();
 }
+function _resetDataDirCacheForTesting() {
+  DATA_DIR = defaultDataDir();
+  dataDirHardened = false;
+  hardenedHomes.clear();
+}
 function globalDbPath() {
   return path.join(DATA_DIR, "global.db");
 }
@@ -190,6 +195,7 @@ export {
   tokenGoatHome,
   isTokenGoatStorage,
   ensureStorageRootPrivate,
+  _resetDataDirCacheForTesting,
   globalDbPath,
   configPath,
   projectConfigPath,

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

@@ -0,0 +1,154 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  FIND_SCAN_LIMIT,
+  findParentName,
+  findSymbolCandidates
+} from "./token-goat-chunk-4SC7UJYV.mjs";
+import {
+  indexedSourceText
+} from "./token-goat-chunk-QH7YVYOY.mjs";
+import {
+  querySymbols
+} from "./token-goat-chunk-IK2DRMFX.mjs";
+import {
+  getDb,
+  pathEqClause
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  fingerprintContent
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  globalDbPath
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/notes.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+var WHOLE_FILE_NOTE_SYMBOL = "";
+function toNoteRow(row) {
+  return {
+    id: row.id,
+    filePath: row.file_path,
+    symbol: row.symbol,
+    content: row.content,
+    fingerprint: row.fingerprint,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function declarationGroups(rows, dbPath) {
+  const fileSymbols = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let siblings = fileSymbols.get(row.filePath);
+    if (siblings === void 0) {
+      siblings = querySymbols({ filePath: row.filePath, limit: FIND_SCAN_LIMIT }, dbPath);
+      fileSymbols.set(row.filePath, siblings);
+    }
+    const parent = findParentName(row, siblings);
+    const key = JSON.stringify([row.filePath, parent]);
+    const group = groups.get(key);
+    if (group === void 0) groups.set(key, { parent, rows: [row] });
+    else group.rows.push(row);
+  }
+  return [...groups.values()];
+}
+function groupEntry(group) {
+  const rows = [...group].sort((x, y) => x.lineStart - y.lineStart);
+  const first = rows[0];
+  if (rows.length === 1 && first.body !== "") return first;
+  const body = rows.map((r) => r.body !== "" ? r.body : bodyFromSource(r)).join("\n");
+  return { ...first, lineEnd: Math.max(...rows.map((r) => r.lineEnd)), body };
+}
+function resolveSymbolMatch(filePath, symbolName, dbPath = globalDbPath()) {
+  const { candidates, displaySymbol } = findSymbolCandidates(filePath, filePath, symbolName, void 0, dbPath);
+  const seen = /* @__PURE__ */ new Set();
+  const distinct = candidates.filter((c) => {
+    const key = `${c.filePath}|${c.lineStart}|${c.lineEnd}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  if (distinct.length === 0) return { kind: "none" };
+  if (distinct.length === 1) return { kind: "ok", entry: groupEntry(distinct) };
+  const groups = declarationGroups(distinct, dbPath);
+  if (groups.length === 1) return { kind: "ok", entry: groupEntry(groups[0].rows) };
+  const fileLevel = groups.find((g) => g.parent === null);
+  if (fileLevel !== void 0 && !symbolName.includes(".")) return { kind: "ok", entry: groupEntry(fileLevel.rows) };
+  const declarations = groups.map((g) => ({ entry: groupEntry(g.rows), qualifiedName: g.parent === null ? displaySymbol : `${g.parent}.${displaySymbol}` })).sort((x, y) => x.entry.lineStart - y.entry.lineStart);
+  return { kind: "ambiguous", symbol: displaySymbol, candidates: declarations };
+}
+function bodyFromSource(entry) {
+  try {
+    return indexedSourceText(entry.filePath, fs.readFileSync(entry.filePath, "utf8")).split(/\r?\n/).slice(Math.max(0, entry.lineStart - 1), entry.lineEnd).join("\n");
+  } catch {
+    return "";
+  }
+}
+function symbolNamesInFile(filePath, dbPath = globalDbPath()) {
+  const symbols = querySymbols({ filePath, limit: -1 }, dbPath);
+  return [...new Set(symbols.map((s) => s.name))].sort();
+}
+function computeFileFingerprint(filePath, dbPath = globalDbPath()) {
+  const symbols = querySymbols({ filePath, limit: -1 }, dbPath);
+  const manifest = symbols.map((s) => `${s.name}:${s.kind}:${s.lineStart}-${s.lineEnd}`).sort().join("\n");
+  return fingerprintContent(manifest);
+}
+function computeSymbolFingerprints(filePath, symbolName, dbPath = globalDbPath()) {
+  const match = resolveSymbolMatch(filePath, symbolName, dbPath);
+  if (match.kind === "none") return [];
+  return (match.kind === "ok" ? [match.entry] : match.candidates.map((c) => c.entry)).map((e) => fingerprintContent(e.body));
+}
+function upsertNote(filePath, symbol, content, fingerprint, dbPath = globalDbPath()) {
+  const db = getDb(dbPath);
+  const now = Date.now() / 1e3;
+  db.transaction(() => {
+    const updated = db.prepare(`UPDATE notes SET content = ?, fingerprint = ?, updated_at = ? WHERE ${pathEqClause("file_path")} AND symbol = ?`).run(content, fingerprint, now, foldPath(filePath), symbol);
+    if (updated.changes > 0) return;
+    db.prepare("INSERT INTO notes (file_path, symbol, content, fingerprint, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(
+      filePath,
+      symbol,
+      content,
+      fingerprint,
+      now,
+      now
+    );
+  }).immediate();
+}
+function getNote(filePath, symbol, dbPath = globalDbPath()) {
+  const db = getDb(dbPath);
+  const row = db.prepare(
+    `SELECT id, file_path, symbol, content, fingerprint, created_at, updated_at FROM notes WHERE ${pathEqClause("file_path")} AND symbol = ?`
+  ).get(foldPath(filePath), symbol);
+  return row === void 0 ? null : toNoteRow(row);
+}
+function listNotes(dbPath = globalDbPath()) {
+  const db = getDb(dbPath);
+  const rows = db.prepare(
+    "SELECT id, file_path, symbol, content, fingerprint, created_at, updated_at FROM notes ORDER BY file_path, symbol"
+  ).all();
+  return rows.map(toNoteRow);
+}
+function isNoteStale(note, dbPath = globalDbPath()) {
+  if (note.symbol !== WHOLE_FILE_NOTE_SYMBOL) return !computeSymbolFingerprints(note.filePath, note.symbol, dbPath).includes(note.fingerprint);
+  return computeFileFingerprint(note.filePath, dbPath) !== note.fingerprint;
+}
+
+export {
+  WHOLE_FILE_NOTE_SYMBOL,
+  resolveSymbolMatch,
+  symbolNamesInFile,
+  computeFileFingerprint,
+  computeSymbolFingerprints,
+  upsertNote,
+  getNote,
+  listNotes,
+  isNoteStale
+};