token-goat 2.9.13 → 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
 
@@ -298,6 +310,15 @@ Built-in output compression covers 150+ dev tool CLIs: `pytest`, `jest` / `vites
 
 A failing `pytest` / `jest` / `vitest` / `go test` / `cargo test` run (including bare `npm test`/`npm run test`/`yarn test`/`pnpm test`) also gets a one-line advisory naming the exact `token-goat bash-output <id> | token-goat failures` command to run instead of re-reading the raw dump. Silent on a passing run, a non-test command, or output too small to be worth reducing.
 
+Give the command three ways: as positional arguments (`token-goat compress pytest -v tests/`), as one string with `-c` / `--cmd`, or base64-encoded with `--cmd-b64`. The base64 form preserves quotes, backslashes, and dollar signs that a harness or an intermediate shell would otherwise mangle; it takes precedence when more than one form is supplied. `--native` runs the command through the platform's own shell (`cmd.exe` on Windows) instead of bash, which keeps Windows path backslashes intact for tools that reject the forward-slash form.
+
+`-q` / `--quiet-success` trades a clean run's output for one line. On exit code 0 the full output is stored for recall and only the summary prints; on any other exit code the compressed output is delivered as usual.
+
+```
+$ token-goat compress -q --cmd "npm run lint"
+[tg: ok] npm run lint (22.2s, recall: token-goat bash-output 326d9800e732eb9d)
+```
+
 ### 6. Context pressure
 
 Token-goat tracks how close a session is to the autocompact trigger and tightens its hints as the window fills. Surgical-read suggestions kick in on progressively smaller files as pressure builds (500 lines at cool, down to 50 at critical), so large reads get flagged before they tip the session over. The PreCompact manifest also shrinks: capped at 500 tokens once the window runs hot, 300 once critical, so it stops contributing to the pressure it measures. The denominator is always the fixed 660,000-token autocompact trigger budget, not the model's raw context window, so the same thresholds apply across models. Run `token-goat doctor --context` to see the current footprint.
@@ -478,6 +499,8 @@ The file-by-file table for each harness, and the path that file sits at: **[What
 
 Hooks fire automatically on every tool call once installed — nothing to start or restart there. The background worker is a separate, manual step: `token-goat worker start` launches it as a detached process, `token-goat worker status` checks it, `token-goat worker stop` kills it. It restarts itself automatically if it crashes or gets killed while the machine is running — an edit hook checks its liveness and respawns it, rate-limited to about once every 5 minutes. It does not survive a reboot or logout, though; re-run `worker start` after either. `token-goat uninstall` removes the hook entries, `CLAUDE.md` block, and skill directory, but does not touch a running worker — stop it separately with `token-goat worker stop` if you no longer want it running.
 
+To move to a newer release, `token-goat upgrade` installs it from npm and then re-runs `token-goat install`, so your hooks and integration manifests point at the build that just landed. `token-goat upgrade --check` reports whether one is available without installing anything, and `--json` gives the same answer for a script. Both go quiet when `network.offline` is set, and `token-goat doctor` mentions an available update at the end of its report.
+
 ## Verify
 
 ```
@@ -701,12 +724,16 @@ Bug reports go to the same place. The most useful ones include:
 - The matching log line from `%LOCALAPPDATA%\dfk-helper\token-goat\logs\` on Windows or `~/.local/share/token-goat/logs/` on Linux/WSL
 - What you expected and what actually happened
 
+To audit an existing AI session for missed savings, hook friction, or optimization opportunities before opening an issue, see the [Session Mining Prompt](docs/PROMPT_SESSION_MINING.md).
+
 For private questions, commercial licensing, or anything you'd rather not post publicly, contact me at token-goat@dfkhelper.com.
 
 ## Disclaimer
 
 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
+};