token-goat 2.9.14 → 2.9.15

package/README.md

@@ -138,6 +138,11 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | Large MCP tool result (≥2 KB) doesn't table-ify (an object-rooted config dump, a single-resource response, a nested settings tree) but most of its bytes are `null`/`""`/`[]`/`{}` | Deterministic empty-value pruning: recursively drops those four empty shapes to a fixed point (a container left empty by its own dropped children is dropped too) and renders the remainder as compact JSON with a trailing `dropped N empty value(s) (null, "", [], {})` summary line; `0` and `false` are never dropped; only applied when it saves ≥15%. Same full-recovery-by-id guarantee and `TOKEN_GOAT_MCP_COMPRESS=0` opt-out as the table pass |
 | GitHub MCP tool result (`list_pull_requests`, `list_issues`, `search_code`, `get_file_contents`, `pull_request_read`, …) carries dozens of boilerplate fields per object | GitHub compression pack strips `_links`, `node_id`, `gravatar_id`, `site_admin`, and every `*_url` field (`avatar_url`, `html_url`, `events_url`, `gists_url`, `followers_url`, …) except `download_url`/`git_url`/`clone_url`/`ssh_url`, before handing the shrunk JSON to the same table-ifying pass — same `TOKEN_GOAT_MCP_COMPRESS=0` opt-out and full-recovery-by-id guarantee |
 | Browser-automation MCP tool result (claude-in-chrome's `read_console_messages`/`read_network_requests`, chrome-devtools-mcp's `list_console_messages`/`list_network_requests`) carries verbose CDP plumbing per entry | Browser compression pack strips console `stackTrace` frames and network `requestHeaders`/`responseHeaders`/`timing`/`initiator`/`securityDetails`/cookie fields, keeping `url`/`method`/`status`/`resourceType`/`mimeType`/`reqid` and the actual log text, before the same table-ifying pass runs — same opt-out and full-recovery-by-id guarantee |
+| Atlassian MCP tool result (Jira issues, Confluence pages, search results) carries repetitive UI chrome and schemas | Atlassian compression pack strips boilerplate fields (`avatarUrls`, `iconUrl`, `self`, `expand`, `schema`, `operations`, `editmeta`, `names`, `_links`, `timeZone`), reducing payloads by 60–80% before table compression |
+| Oversized MCP tool result (≥25 KB) or dumped JSON tool spill file (e.g. `content.json`) re-read whole into context | Oversized MCP results return an elision preview and recovery ID; pre-read hooks intercept tool spill files, redirecting models to `token-goat mcp-output --json-query '<path>'` or `--file <path>` (~90–98% smaller) |
+| Large XML package (.dtsx, .ampkg, .xaml) read in full or paged with sequential line ranges | Pre-read hook intercepts package reads (20KB threshold) with package-specific hierarchy advice; sequential 3+ range paging is actively denied and redirected to `xml-outline` and `xml-query` |
+| Scratch terminal script or shell command used to inspect XML (`Select-Xml`, `[xml]`, `inspect_*.ps1`, Python `xml.etree`, `xmllint`) | Pre-bash hook intercepts terminal XML parsing commands, recommending `token-goat xml-query --xpath <expr>` or `xml-outline` instead of multi-step script generation (~85–95% smaller) |
+| XML document with deep element hierarchies or entity-encoded XML/AML payloads | `token-goat xml-query <file> --xpath <expr>` extracts targeted elements with exact line ranges (`--with-lines`), and `--decode-embedded-xml` pretty-prints and bounds nested AML payloads (~80–95% smaller) |
 | `curl -v` dumps TLS handshake + all request/response headers | Verbose lines stripped; request line, HTTP status, content-type, and body kept — typically 70–90% smaller |
 | `jest --verbose` / `vitest --verbose` emits one `✓` line per passing test | Consecutive passing-test lines collapsed to a count per file; failures kept verbatim, ~95% smaller on passing suites |
 | `go test -v` emits `--- PASS: TestName (Ns)` for every passing test | PASS lines collapsed to a count per package; FAIL lines and panic output kept, ~90% smaller on clean runs |
@@ -175,6 +180,7 @@ The fastest way to reduce AI token costs is fixing these five, not writing short
 | Reading poetry.lock or package-lock.json to find a pinned version | `token-goat lockdeps` returns a name/version table of direct dependencies; optional packages and transitive entries excluded |
 | Large SVG / diagram file (≥8 KB) read in full | Coordinate path flooding blocked; extracted layer/group IDs and title shown; redirects to `token-goat xml-outline` and `xml-query` |
 | Broad recursive Glob sweep (`*`, `**/*`) on root directory | Pre-Glob hook warns against tree-dumping and points at `token-goat map --compact` for fast, lightweight structure inspection |
+| Guessing database column names in `session_store_sql` / `sql` and falling back to `SELECT *` | `token-goat session-schema [table]` and `describe <target>` provide instant schema discovery; `post_tool_use_failure` hook intercepts unknown columns and guides the query — ~85–95% smaller than trial-and-error `SELECT *` dumps |
 | Compound test/build pipeline (`npm run build && npm run typecheck && npm test`) | Post-Bash hook routes chained build/test/lint commands to `generic-ci` compression, dropping verbose passing steps and compiler noise |
 
 On a per-token API plan, 100K wasted tokens per session runs about $0.30. Five sessions a week is ~$450/year. AI coding cost reduction at that scale comes from fixing the waste, not from using the product less. Token-goat is free. And on subscription plans, it can result in limits feeling 10x higher.
@@ -186,6 +192,7 @@ On a per-token API plan, 100K wasted tokens per session runs about $0.30. Five s
 ```bash
 cd ~/notes                  # or any plain folder of .md files, no .git required
 token-goat index . --walk   # non-git folders need --walk (git repos: plain `token-goat index .`)
+token-goat semantic --preflight   # verify runtime, model weights & project coverage
 token-goat semantic "how long to steep cold brew"
 ```
 
@@ -204,10 +211,15 @@ Numbers below come from synthetic-fixture benchmarks in the test suite, except t
 | DB reindex | Batched single transaction + composite indexes on `(file_id, kind)` | 100 files / 10K rows: 84 s → 1 s (~80× faster) | `src/parser.ts`, `src/db.ts` (index migration) |
 | Hook cold-start | Lazy import of heavy modules; unknown events short-circuit | 86 ms → 30 ms (~65% faster); unknown-event dispatch <1 ms | `src/hooks_cli.ts` |
 | Symbol start_line | TypeScript decorators captured in symbol span | One `token-goat read` returns the decorator + signature + body; no re-read | `src/parser.ts` (TypeScript adapter) |
-| Section extraction | Setext headings, h5/h6, anchor IDs, and `__frontmatter__` | `token-goat section` resolves more headings without falling back to a full file read | `src/parser.ts` (Markdown adapter) |
+| Section extraction | Setext headings, h5/h6, anchor IDs, shell comment banners (`##`, `# ---`, `# ===`, `# [...]`, `# REGION:`), and `__frontmatter__` | `token-goat section` resolves more headings and procedural shell checks without falling back to a full file read | `src/parser.ts` (Markdown & Shell adapters) |
 | Image cache | Repeat Read of an unchanged image serves the stored re-encode, keyed on path + size + mtime, instead of re-encoding it again | Skips the re-encode entirely on a hit; the same bytes reach the model, so the reported saving is identical either way | `src/image_shrink.ts` (`findCachedShrink`) |
 | Monorepo defaults | Reindex batch 500 → 2000; compact `min_events` 5 → 3 | Fewer worker wakeups; compact manifests fire on shorter sessions | `src/config.ts` defaults |
 | Miss suggestions | `read` / `section` print "Did you mean…?" on a miss; `section` also auto-redirects on an unambiguous heading-prefix match | Keeps agents on the surgical-read path instead of falling back to full-file `Read` | `src/read_commands.ts` |
+| Atlassian MCP compression | Strips UI chrome, avatars, operations, and schema links from Jira and Confluence tool responses | 60–80% smaller before generic table compression | `src/mcp_atlassian_compress.ts` |
+| MCP tool spill slicing | Narrow-slice queries on cached MCP tool outputs or dumped JSON files with `mcp-output --json-query` | 90–98% smaller than whole-file JSON re-reads | `src/mcp_json_query.ts` |
+| XML package & terminal script interception | Pre-read nudges on `.dtsx`/`.ampkg`/`.xaml` and pre-bash interception of `Select-Xml`/`[xml]`/scratch scripts | 85–95% smaller than scratch script creation and chunk paging | `src/bash_extractors.ts`, `src/hooks_read.ts` |
+| Enhanced XML XPath & embedded AML | Granular XPath expressions, element source line ranges, and decoded embedded XML/AML payloads | 80–95% smaller than reading whole XML packages | `src/xml_query.ts` |
+| Session Store Schema & SQL Error Intercept | Authoritative schema discovery via `session-schema` / `describe`, paired with runtime unknown-column diagnosis in `postToolUseFailureHandler` | 85–95% smaller than trial-and-error `SELECT *` dumps | `src/session_store_schema.ts`, `src/hooks_tool_failure.ts` |
 
 ## Token-savings examples
 
@@ -720,6 +732,8 @@ For private questions, commercial licensing, or anything you'd rather not post p
 
 Token-Goat runs on your machine and touches your files. The software is provided as-is, without warranty of any kind. DFK Helper LLC is not liable for any damages arising from use. Full terms, including the No Liability clause, are in the LICENSE file.
 
+All product names, logos, brands, trademarks, and registered trademarks mentioned are property of their respective owners. All company, product, and service names used in this project are for identification and compatibility purposes only; their use does not imply any affiliation, sponsorship, or endorsement.
+
 ## License
 
 Token-Goat is licensed under the PolyForm Noncommercial License 1.0.0. See the LICENSE file for the full terms.

package/dist/token-goat-chunk-2X2EBBC6.mjs

@@ -0,0 +1,277 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  getDb
+} from "./token-goat-chunk-K7F2BFIK.mjs";
+import {
+  foldPath,
+  globalDbPath,
+  isCaseInsensitiveFs
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/index_reader.ts
+init_define_import_meta_env();
+
+// src/sql_path.ts
+init_define_import_meta_env();
+function pathEqClause(column) {
+  return isCaseInsensitiveFs() ? `TG_LOWER(${column}) = ?` : `${column} = ?`;
+}
+function pathSuffixClause(column) {
+  const col = isCaseInsensitiveFs() ? `TG_LOWER(${column})` : column;
+  return {
+    // Both separators are accepted because not every writer into `symbols` stores a normalizePath'd (forward-slash) file_path, and the JS-side path-boundary test this narrowing feeds treats `/` and `\` alike.
+    clause: `(${col} = ? OR substr(${col}, -length(?)) = ? OR substr(${col}, -length(?)) = ?)`,
+    params: (baseName) => {
+      const folded = foldPath(baseName);
+      return [folded, `/${folded}`, `/${folded}`, `\\${folded}`, `\\${folded}`];
+    }
+  };
+}
+function projectScopeClause(column) {
+  const caseInsensitive = isCaseInsensitiveFs();
+  const col = caseInsensitive ? `TG_LOWER(${column})` : column;
+  return {
+    // Parenthesised so an OR anywhere in the surrounding WHERE cannot bind tighter than the pair.
+    clause: `(${col} >= ? AND ${col} < ?)`,
+    params: (root) => {
+      const folded = caseInsensitive ? foldPath(normalizePath(root)) : normalizePath(root);
+      const lower = folded.endsWith("/") ? folded : `${folded}/`;
+      const upper = `${lower.slice(0, -1)}0`;
+      return [lower, upper];
+    }
+  };
+}
+
+// src/index_reader.ts
+function toSymbolEntry(row) {
+  return {
+    filePath: row.file_path,
+    name: row.name,
+    kind: row.kind,
+    lineStart: row.line_start,
+    lineEnd: row.line_end,
+    body: row.body ?? "",
+    docstring: row.docstring ?? "",
+    parent: row.parent ?? ""
+  };
+}
+function toRefEntry(row) {
+  return {
+    filePath: row.file_path,
+    name: row.name,
+    line: row.line,
+    col: row.col,
+    context: row.context ?? ""
+  };
+}
+function applyRootDirScope(rootDir, column, where, params) {
+  if (rootDir === void 0) return;
+  const { clause, params: bounds } = projectScopeClause(column);
+  where.push(clause);
+  params.push(...bounds(rootDir));
+}
+function buildSymbolWhere(opts) {
+  const where = [];
+  const params = [];
+  if (opts.name !== void 0) {
+    where.push("name = ?");
+    params.push(opts.name);
+  }
+  if (opts.filePath !== void 0) {
+    if (opts.filePath.includes("/") || opts.filePath.includes("\\")) {
+      const alt = opts.filePath.includes("/") ? opts.filePath.replace(/\//g, "\\") : opts.filePath.replace(/\\/g, "/");
+      where.push(`(${pathEqClause("file_path")} OR ${pathEqClause("file_path")})`);
+      params.push(foldPath(opts.filePath), foldPath(alt));
+    } else {
+      where.push(pathEqClause("file_path"));
+      params.push(foldPath(opts.filePath));
+    }
+  }
+  if (opts.kind !== void 0) {
+    where.push("kind = ?");
+    params.push(opts.kind);
+  }
+  if (opts.fileBaseName !== void 0) {
+    const { clause: suffixClause, params: suffixParams } = pathSuffixClause("file_path");
+    where.push(suffixClause);
+    params.push(...suffixParams(opts.fileBaseName));
+  }
+  if (opts.enclosingLine !== void 0) {
+    where.push("line_start <= ? AND ? <= line_end");
+    params.push(opts.enclosingLine, opts.enclosingLine);
+  }
+  applyRootDirScope(opts.rootDir, "file_path", where, params);
+  return { clause: where.length > 0 ? `WHERE ${where.join(" AND ")}` : "", params };
+}
+var DEFAULT_QUERY_LIMIT = 100;
+function querySymbols(opts = {}, dbPath = globalDbPath()) {
+  const { clause, params } = buildSymbolWhere(opts);
+  const limit = opts.limit ?? DEFAULT_QUERY_LIMIT;
+  const offset = opts.offset ?? 0;
+  const sql = `SELECT file_path, name, kind, line_start, line_end, body, docstring, parent FROM symbols ${clause} ORDER BY file_path, line_start, rowid LIMIT ? OFFSET ?`;
+  const db = getDb(dbPath);
+  const rows = db.prepare(sql).all(...params, limit, offset);
+  return rows.map(toSymbolEntry);
+}
+function distinctSymbolKinds(rootDir, dbPath = globalDbPath()) {
+  const where = [];
+  const params = [];
+  applyRootDirScope(rootDir, "file_path", where, params);
+  const clause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+  const db = getDb(dbPath);
+  const rows = db.prepare(`SELECT DISTINCT kind FROM symbols ${clause} ORDER BY kind`).all(...params);
+  return rows.map((r) => r.kind);
+}
+function countSymbols(opts = {}, dbPath = globalDbPath()) {
+  const { clause, params } = buildSymbolWhere(opts);
+  const sql = `SELECT COUNT(*) as cnt FROM symbols ${clause}`;
+  const db = getDb(dbPath);
+  const row = db.prepare(sql).get(...params);
+  return row.cnt;
+}
+function buildRefsWhere(opts) {
+  const where = ["name = ?"];
+  const params = [opts.name];
+  if (opts.filePath !== void 0) {
+    where.push(pathEqClause("file_path"));
+    params.push(foldPath(opts.filePath));
+  }
+  applyRootDirScope(opts.rootDir, "file_path", where, params);
+  return { clause: `WHERE ${where.join(" AND ")}`, params };
+}
+function queryRefs(opts, dbPath = globalDbPath()) {
+  const { clause, params } = buildRefsWhere(opts);
+  const limit = opts.limit ?? DEFAULT_QUERY_LIMIT;
+  const sql = `SELECT file_path, name, line, col, context FROM refs ${clause} ORDER BY file_path, line LIMIT ?`;
+  const db = getDb(dbPath);
+  const rows = db.prepare(sql).all(...params, limit);
+  return rows.map(toRefEntry);
+}
+function countRefs(opts, dbPath = globalDbPath()) {
+  const { clause, params } = buildRefsWhere(opts);
+  const sql = `SELECT COUNT(*) as cnt FROM refs ${clause}`;
+  const db = getDb(dbPath);
+  const row = db.prepare(sql).get(...params);
+  return row.cnt;
+}
+function queryRefsByContext(context, filePath, dbPath = globalDbPath()) {
+  const sql = `SELECT file_path, name, line, col, context FROM refs WHERE context = ? AND ${pathEqClause("file_path")} ORDER BY line LIMIT 20`;
+  const db = getDb(dbPath);
+  const rows = db.prepare(sql).all(context, foldPath(filePath));
+  return rows.map(toRefEntry);
+}
+var REF_COUNT_BATCH = 900;
+function queryRefCounts(names, dbPath = globalDbPath(), rootDir) {
+  const counts = /* @__PURE__ */ new Map();
+  if (names.length === 0) return counts;
+  const db = getDb(dbPath);
+  const scopeWhere = [];
+  const scopeParams = [];
+  applyRootDirScope(rootDir, "file_path", scopeWhere, scopeParams);
+  const scopeSql = scopeWhere.length > 0 ? ` AND ${scopeWhere.join(" AND ")}` : "";
+  const sqlFor = (width) => `SELECT name, COUNT(*) as c FROM refs WHERE name IN (${Array.from({ length: width }, () => "?").join(", ")})${scopeSql} GROUP BY name`;
+  const full = names.length >= REF_COUNT_BATCH ? db.prepare(sqlFor(REF_COUNT_BATCH)) : void 0;
+  db.transaction(() => {
+    for (let start = 0; start < names.length; start += REF_COUNT_BATCH) {
+      const batch = names.slice(start, start + REF_COUNT_BATCH);
+      const stmt = batch.length === REF_COUNT_BATCH && full !== void 0 ? full : db.prepare(sqlFor(batch.length));
+      for (const row of stmt.all(...batch, ...scopeParams)) {
+        counts.set(row.name, row.c);
+      }
+    }
+  })();
+  return counts;
+}
+function getProjectFileEntries(rootDir, dbPath = globalDbPath()) {
+  const db = getDb(dbPath);
+  const { clause, params } = projectScopeClause("path");
+  const rows = db.prepare(`SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${clause}`).all(...params(rootDir));
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    out.set(foldPath(row.path), {
+      filePath: row.path,
+      sha: row.sha ?? "",
+      mtime: row.mtime ?? 0,
+      language: row.language ?? "unknown",
+      indexedAt: row.indexed_at ?? 0,
+      embedSha: row.embed_sha ?? "",
+      parserSha: row.parser_sha ?? ""
+    });
+  }
+  return out;
+}
+function getFileEntry(filePath, dbPath = globalDbPath()) {
+  const db = getDb(dbPath);
+  let row = db.prepare(
+    `SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${pathEqClause("path")}`
+  ).get(foldPath(filePath));
+  if (row === void 0 && (filePath.includes("/") || filePath.includes("\\"))) {
+    const altPath = filePath.includes("/") ? filePath.replace(/\//g, "\\") : filePath.replace(/\\/g, "/");
+    row = db.prepare(
+      `SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${pathEqClause("path")}`
+    ).get(foldPath(altPath));
+  }
+  if (row === void 0) return null;
+  return {
+    filePath: row.path,
+    sha: row.sha ?? "",
+    mtime: row.mtime ?? 0,
+    language: row.language ?? "unknown",
+    indexedAt: row.indexed_at ?? 0,
+    embedSha: row.embed_sha ?? "",
+    parserSha: row.parser_sha ?? ""
+  };
+}
+function sanitizeFtsQuery(query, join = "AND") {
+  const terms = query.split(/\s+/).filter((t) => t.length > 0).map((t) => '"' + t.replace(/"/g, '""') + '"');
+  return terms.join(join === "OR" ? " OR " : " ");
+}
+function runFtsQuery(db, match, limit, scope, rootDir) {
+  const sql = `SELECT s.file_path, s.name, s.kind, s.line_start, s.line_end, s.body, s.docstring, s.parent FROM symbols_fts JOIN symbols s ON s.id = symbols_fts.rowid WHERE symbols_fts MATCH ?${scope !== void 0 ? ` AND ${scope.clause}` : ""} ORDER BY bm25(symbols_fts) LIMIT ?`;
+  const params = [match];
+  if (scope !== void 0 && rootDir !== void 0) {
+    params.push(...scope.params(rootDir));
+  }
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(toSymbolEntry);
+}
+function searchSymbolsFts(query, limit = 50, dbPath = globalDbPath(), rootDir) {
+  const andMatch = sanitizeFtsQuery(query, "AND");
+  if (andMatch === "") return [];
+  const db = getDb(dbPath);
+  const scope = rootDir !== void 0 ? projectScopeClause("s.file_path") : void 0;
+  try {
+    const andResults = runFtsQuery(db, andMatch, limit, scope, rootDir);
+    if (andResults.length > 0) return andResults;
+    const orMatch = sanitizeFtsQuery(query, "OR");
+    if (orMatch === andMatch) return andResults;
+    return runFtsQuery(db, orMatch, limit, scope, rootDir);
+  } catch {
+    return [];
+  }
+}
+
+export {
+  pathEqClause,
+  projectScopeClause,
+  DEFAULT_QUERY_LIMIT,
+  querySymbols,
+  distinctSymbolKinds,
+  countSymbols,
+  queryRefs,
+  countRefs,
+  queryRefsByContext,
+  queryRefCounts,
+  getProjectFileEntries,
+  getFileEntry,
+  sanitizeFtsQuery,
+  searchSymbolsFts
+};

package/dist/{token-goat-chunk-XQF5J25J.mjs → token-goat-chunk-3NSDDTGL.mjs}

@@ -10,14 +10,15 @@ import {
   querySheet,
   rangeSheet,
   xlsxColumns
-} from "./token-goat-chunk-ZFM4PWXL.mjs";
-import "./token-goat-chunk-EG3663UT.mjs";
+} from "./token-goat-chunk-NU7TLMQK.mjs";
+import "./token-goat-chunk-YKG35VHC.mjs";
 import "./token-goat-chunk-3BTK54F3.mjs";
-import "./token-goat-chunk-YHGTGG6K.mjs";
+import "./token-goat-chunk-MZDIJJ3R.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-AMYCQJX4.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
 import "./token-goat-chunk-GMOUBOX4.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {

package/dist/token-goat-chunk-4EXFN2AW.mjs

@@ -0,0 +1,29 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  SQLITE_QUERY_ROW_CAP,
+  formatSqliteQueryTable,
+  formatSqliteSchema,
+  formatSqliteTables,
+  getSqliteSchema,
+  getSqliteTables,
+  isSqliteFile,
+  openReadonlySqlite,
+  runReadOnlySqliteQuery,
+  validateReadOnlySelect
+} from "./token-goat-chunk-LMFO66YD.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  SQLITE_QUERY_ROW_CAP,
+  formatSqliteQueryTable,
+  formatSqliteSchema,
+  formatSqliteTables,
+  getSqliteSchema,
+  getSqliteTables,
+  isSqliteFile,
+  openReadonlySqlite,
+  runReadOnlySqliteQuery,
+  validateReadOnlySelect
+};

package/dist/{token-goat-chunk-4SDX3QP3.mjs → token-goat-chunk-5V7DAC7V.mjs}

@@ -3,15 +3,16 @@ const require = __cjsRequire(import.meta.url);
 import {
   NotAnOfficeDocumentError,
   collectElements,
+  collectParagraphTexts,
   collectTextRuns,
   decodeZipEntry,
   ooxmlPartBudget,
   parseOoxmlPart,
   readOoxmlZip
-} from "./token-goat-chunk-YHGTGG6K.mjs";
+} from "./token-goat-chunk-MZDIJJ3R.mjs";
 import {
   displaySafeText
-} from "./token-goat-chunk-AMYCQJX4.mjs";
+} from "./token-goat-chunk-ERTXEKB6.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -53,7 +54,7 @@ async function docxText(filePath) {
 }
 async function docxTables(filePath) {
   const parsed = await loadDocumentBody(filePath);
-  const tbls = collectElements(parsed, "w:tbl");
+  const tbls = collectElements(parsed, "w:tbl", { includeNested: true });
   const out = [];
   for (let i = 0; i < tbls.length; i++) {
     const tbl = tbls[i];
@@ -64,7 +65,7 @@ async function docxTables(filePath) {
       const tcElements = collectElements(tr, "w:tc");
       const rowCells = [];
       for (const tc of tcElements) {
-        const cellText = collectTextRuns(tc, "w:t").join("").replace(/\r?\n/g, " ").trim();
+        const cellText = collectParagraphTexts(tc, "w:p", "w:t", ["w:tbl"], "w:br").map((t) => t.replace(/\r?\n/g, " ").trim()).filter((t) => t.length > 0).join(" ");
         rowCells.push(cellText);
       }
       if (rowCells.length > maxCols) maxCols = rowCells.length;

package/dist/token-goat-chunk-6DLVZDB6.mjs

@@ -0,0 +1,34 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildEvent,
+  relay,
+  relayInProcess
+} from "./token-goat-chunk-SZWYESBS.mjs";
+import "./token-goat-chunk-YZX7EFG4.mjs";
+import {
+  MAX_STDIN_BYTES,
+  readStdinJson
+} from "./token-goat-chunk-OUGNPMDA.mjs";
+import "./token-goat-chunk-BL5LNGBG.mjs";
+import "./token-goat-chunk-YQ7WI2CO.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-NDRP4KJQ.mjs";
+import "./token-goat-chunk-2X2EBBC6.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-IVUQLQWN.mjs";
+import "./token-goat-chunk-K7F2BFIK.mjs";
+import "./token-goat-chunk-S4XRY446.mjs";
+import "./token-goat-chunk-EEIDFMEM.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  MAX_STDIN_BYTES,
+  buildEvent,
+  readStdinJson,
+  relay,
+  relayInProcess
+};

package/dist/{token-goat-chunk-XEH6KBWW.mjs → token-goat-chunk-7ZYK25AO.mjs}

@@ -6,12 +6,13 @@ import {
   pptxOutline,
   pptxSlideText,
   pptxTextGrep
-} from "./token-goat-chunk-2ESBO4IN.mjs";
-import "./token-goat-chunk-YHGTGG6K.mjs";
+} from "./token-goat-chunk-ASYEPR3S.mjs";
+import "./token-goat-chunk-MZDIJJ3R.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-AMYCQJX4.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
 import "./token-goat-chunk-GMOUBOX4.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {

package/dist/{token-goat-chunk-7OGKZ7AP.mjs → token-goat-chunk-A4JYKD5H.mjs}

@@ -2,12 +2,14 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   loadConfig
-} from "./token-goat-chunk-SAQ5PG4L.mjs";
+} from "./token-goat-chunk-S4XRY446.mjs";
 import "./token-goat-chunk-EEIDFMEM.mjs";
 import {
-  VERSION,
+  VERSION
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
   displaySafeJson
-} from "./token-goat-chunk-AMYCQJX4.mjs";
+} from "./token-goat-chunk-ERTXEKB6.mjs";
 import "./token-goat-chunk-GMOUBOX4.mjs";
 import {
   init_define_import_meta_env

package/dist/{token-goat-chunk-2ESBO4IN.mjs → token-goat-chunk-ASYEPR3S.mjs}

@@ -4,14 +4,14 @@ import {
   NotAnOfficeDocumentError,
   assertOoxmlWithinDeadline,
   collectElements,
-  collectTextRuns,
+  collectParagraphTexts,
   decodeZipEntry,
   ooxmlPartBudget,
   ooxmlWorkDeadline,
   parseOoxmlPart,
   readOoxmlZip,
   sortNumberedParts
-} from "./token-goat-chunk-YHGTGG6K.mjs";
+} from "./token-goat-chunk-MZDIJJ3R.mjs";
 import {
   compileGuardedRegex
 } from "./token-goat-chunk-GMOUBOX4.mjs";
@@ -28,14 +28,17 @@ function shapePlaceholderType(shape) {
 function slideShapes(parsedSlide) {
   return collectElements(parsedSlide, "p:sp");
 }
+function flatSlideText(node) {
+  return collectParagraphTexts(node, "a:p", "a:t", [], "a:br").map((t) => t.trim()).filter((t) => t.length > 0).join(" ");
+}
 function shapeText(shape) {
-  return collectTextRuns(shape, "a:t").join(" ").trim();
+  return flatSlideText(shape);
 }
 function tableRowBlocks(parsedSlide) {
   const blocks = [];
   for (const tbl of collectElements(parsedSlide, "a:tbl")) {
     for (const row of collectElements(tbl, "a:tr")) {
-      const cellTexts = collectElements(row, "a:tc").map((cell) => collectTextRuns(cell, "a:t").join(" ").trim());
+      const cellTexts = collectElements(row, "a:tc").map((cell) => flatSlideText(cell));
       const rowText = cellTexts.join(" | ").trim();
       if (rowText.length > 0) blocks.push(rowText);
     }
@@ -116,7 +119,7 @@ async function notesTextFor(entries, notesPath, budget) {
   const parsed = await parseOoxmlPart(xml);
   const shapes = collectElements(parsed, "p:sp");
   const bodyShape = shapes.find((s) => shapePlaceholderType(s) === "body");
-  return bodyShape !== void 0 ? shapeText(bodyShape) : collectTextRuns(parsed, "a:t").join(" ").trim();
+  return bodyShape !== void 0 ? shapeText(bodyShape) : flatSlideText(parsed);
 }
 async function pptxOutline(filePath, deadline = ooxmlWorkDeadline()) {
   const { entries, slidePaths, budget } = await listSlideParts(filePath);
@@ -131,7 +134,7 @@ async function pptxOutline(filePath, deadline = ooxmlWorkDeadline()) {
       return t === "title" || t === "ctrTitle";
     });
     const title = titleShape !== void 0 ? shapeText(titleShape) : "";
-    const allText = collectTextRuns(parsed, "a:t").join(" ");
+    const allText = flatSlideText(parsed);
     const bodyChars = Math.max(0, allText.length - title.length);
     const hasNotes = (await notesTextFor(entries, await notesPathFor(entries, path, budget), budget)).length > 0;
     out.push({ slide: i + 1, title, bodyChars, hasNotes });
@@ -190,7 +193,7 @@ async function pptxTextGrep(filePath, pattern, deadline = ooxmlWorkDeadline()) {
   for (let i = 0; i < slidePaths.length; i++) {
     assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
     const parsed = await parseSlide(entries, slidePaths[i], budget);
-    const text = collectTextRuns(parsed, "a:t").join(" ");
+    const text = flatSlideText(parsed);
     if (re.test(text)) {
       const idx = text.search(re);
       const snippet = text.slice(Math.max(0, idx - 40), idx + 80).trim();

package/dist/{token-goat-chunk-PGGDW7DZ.mjs → token-goat-chunk-ATIFTMRC.mjs}

@@ -3,7 +3,7 @@ const require = __cjsRequire(import.meta.url);
 import {
   deliveredOutputBytes,
   wrappedShell
-} from "./token-goat-chunk-3XQPEJMV.mjs";
+} from "./token-goat-chunk-YZX7EFG4.mjs";
 import {
   ToolFilter,
   capTokens,
@@ -14,16 +14,19 @@ import {
   selectFilter,
   shlexSplit,
   storeBashOutputSync
-} from "./token-goat-chunk-VZYD4OZB.mjs";
+} from "./token-goat-chunk-YQ7WI2CO.mjs";
+import "./token-goat-chunk-2X2EBBC6.mjs";
 import {
   recordStat
-} from "./token-goat-chunk-T2IWWTHB.mjs";
+} from "./token-goat-chunk-IVUQLQWN.mjs";
+import "./token-goat-chunk-K7F2BFIK.mjs";
 import {
   loadConfig
-} from "./token-goat-chunk-SAQ5PG4L.mjs";
+} from "./token-goat-chunk-S4XRY446.mjs";
 import "./token-goat-chunk-EEIDFMEM.mjs";
-import "./token-goat-chunk-POBYR64E.mjs";
-import "./token-goat-chunk-AMYCQJX4.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
 import "./token-goat-chunk-GMOUBOX4.mjs";
 import {
   init_define_import_meta_env