@maxgfr/codeindex 2.17.1 → 2.18.0

package/README.md

@@ -16,7 +16,10 @@ engine as a single file instead of taking an npm dependency.
 - **Walk** a repo deterministically: ignore lists, binary/lockfile skips, size
   and count caps (`capped` flag, never silent truncation), symlink-cycle guard.
 - **Scan** every file into a `FileRecord`: classification, language, symbols,
-  imports, headings, hashes — with an incremental cache fastpath.
+  imports, headings, hashes — with an incremental cache fastpath. Extraction
+  runs across worker threads by default (`--workers`, `CODEINDEX_WORKERS`);
+  artifacts are byte-identical either way, and anything that would make a
+  worker's result differ falls back to the single-threaded path.
 - **Extract symbols** via tree-sitter (13 languages, when the wasm sidecar is
   present) or per-language regex rules (15 languages, always available).
 - **Resolve imports** across languages: tsconfig paths, package `exports`,
@@ -228,7 +231,27 @@ about another checkout. `--server-name <name>` overrides the announced
 **Prime the index first** and activation becomes a load, not a rebuild:
 `codeindex index --repo <dir> --out <dir>/.codeindex`. The first tool call
 deserializes those artifacts when the engine version, commit and artifact
-hashes all match.
+hashes all match. The same index also makes every CLI read command
+(`search`, `symbols`, `graph`, `repomap`, …) a lookup instead of a rebuild.
+
+### Protocol, and what it costs an agent
+
+The server negotiates its protocol version: it answers with whatever revision
+the client asked for among `2024-11-05`, `2025-03-26`, `2025-06-18` and
+`2025-11-25`, and otherwise with the newest. Fields a later revision
+introduced are only sent to clients that asked for it, so an older client sees
+exactly what it saw before.
+
+From `2025-03-26` every tool carries behaviour annotations — `readOnlyHint` on
+the 21 read tools, `destructiveHint`/`idempotentHint` on the five that write —
+which is what lets a host auto-approve reads and confirm only writes.
+
+Responses are capped (`--max-response-bytes`, default 1 MB). Under the cap
+nothing changes. Over it — where a whole-repo `graph` on a large monorepo runs
+to millions of tokens and no client can accept it — the response is replaced by
+a short notice naming the size, the artifact already on disk, and the narrower
+tool that answers the question. Most tools also take a `limit`/`maxResults`/
+`top`/`maxEdges` argument to stay well under it.
 
 `engine.mjs` is a pure side-effect-free library (safe for consumers to inline
 into their own CLIs); `cli.mjs` is the thin standalone CLI/MCP wrapper.
@@ -264,7 +287,7 @@ a consumer can stamp its own identity into artifacts it persists.
 
 ## Benchmarks
 
-Measured against 01x-in/codeindex, universal-ctags and scip-typescript with a
+Measured against universal-ctags, Serena (LSP over MCP) and Graphify with a
 reproducible harness (`scripts/bench/`); full methodology, fairness notes and
 all scenarios in [BENCHMARKS.md](./BENCHMARKS.md).
 

package/docs/MIGRATION.md

@@ -272,6 +272,113 @@ with no `.codeindex/` behaves exactly as before.
   sidecar keeps its own memoization path (the graph/symbols shas are all the
   guard checks).
 
+## v2.18.0 — parallel extraction, persisted-index reads, MCP protocol negotiation
+
+Large release, all **additive**: `SCHEMA_VERSION` / `EMBED_VERSION` /
+`EXTRACTOR_VERSION` are untouched, `graph.json` / `symbols.json` / `index.scip`
+stay **byte-identical**, and every existing export keeps its signature. **No
+re-pin is required.** New capabilities are opt-in by calling the new functions
+or passing the new options.
+
+### Extraction is faster and its records are unchanged
+
+`extractAst` folded its four full-tree traversals into one and reads children
+via `namedChildren` instead of per-index `namedChild(i)`. Results are identical;
+this is purely fewer wasm boundary crossings.
+
+One signature grew: `extractAst(rel, ext, content, opts)` accepts
+`opts.imports` (**default `true`**), which computes `refs` and `pkg`. The
+default preserves today's contract, so a consumer reading `ast.refs` needs no
+change. `extractCode` passes `false` because it recomputes both with regex and
+discarded the AST's versions — that dead work is now skipped.
+
+### `scanSummary` — a file count without parsing the repo
+
+`scanSummary(root, opts)` returns `{root, commit, fileCount, languages, capped,
+excluded}` from the walk plus the path classifiers, with **no read, hash or
+parse**. It shares the kept-file loop with `scanRepo`, so the two cannot report
+different numbers. Use it wherever you only need the histogram — the CLI `scan`
+command went from 6.7s to 0.17s on a 7k-file repo. `scanRepo` is unchanged.
+
+### `scanRepoParallel` — worker_threads extraction (opt-in, degrades silently)
+
+`scanRepoParallel(root, opts)` is **async** and returns the same `RepoScan`
+`scanRepo` would, byte for byte. Code files are read/hashed/extracted across
+`min(cores-1, 8)` workers; docs and everything else stay on the main thread.
+`opts.workers` (or `CODEINDEX_WORKERS`) sets the count; `0` or `1` is the
+sequential path.
+
+`scanRepo` stays **synchronous and sequential** — the pipeline never becomes
+async, and consumers calling it are unaffected.
+
+Two things to know before switching:
+
+- **It degrades to sequential rather than risk a different result.** Workers
+  report the grammar keys they actually readied; any disagreement with the main
+  thread discards the whole parallel run. So does a failure to resolve the
+  engine URL, spawn, or complete. `extractInParallel` never throws.
+- **The worker imports the engine BY URL, so it must be a real file.** The URL
+  is resolved the way grammars are: the running module when it is
+  `engine.mjs`, else an adjacent `engine.mjs`. **If you re-bundle the engine
+  into your own entry, neither resolves and you get the sequential path** — by
+  design, since importing your bundle in a worker would run your top-level code.
+  Vendoring `scripts/engine.mjs` as a file (the documented layout) works.
+
+Memory is the trade: each worker carries its own tree-sitter wasm arena. On a
+7k-file repo, 1.63s / 1424 MB parallel versus 5.03s / 1019 MB sequential.
+
+New exports: `scanRepoParallel`, `extractInParallel`, `runExtractWorker`,
+`workerCount`, `keptCodeFiles`, `buildCodeRecord`, type `ExtractedRecord`, and
+`ScanOptions.extracted` (populated by `scanRepoParallel` — never set it by hand).
+
+`runExtractWorker` must stay exported from any re-export of the barrel: the
+worker bootstrap imports it by name, and a missing export is indistinguishable
+from "this is not the engine".
+
+### The persisted-index preload is public and no longer MCP-only
+
+v2.15.0 said these helpers were "entirely internal to `mcp.ts`". They now live
+in `src/preload.ts` and are exported: `preloadSession`, `preloadArtifacts`,
+`readPersistedIndex`, `toCacheMap`, `INDEX_DIR`, plus types `PersistedMeta`,
+`PersistedCacheEntry`, `PersistedCacheMap`. `toCacheMap` is still re-exported
+from `mcp.ts`, so existing imports keep working.
+
+The freshness guard is unchanged — same T4 oracle, same "never throws, always
+degrades to a cold build" contract. Every CLI read command now goes through it,
+which is where the 5s → 0.3s figures come from.
+
+### MCP: protocol negotiation, response cap, and closed CLI gaps
+
+- **Protocol is negotiated.** The server reads `params.protocolVersion` and
+  answers with it when it speaks it (`2024-11-05`, `2025-03-26`, `2025-06-18`,
+  `2025-11-25`), else with the newest. **A client that asks for `2024-11-05`
+  receives exactly the bytes it received before** — `title` and `annotations`
+  are gated on the negotiated version. Clients that never send `initialize` are
+  treated as `2024-11-05`.
+- **Responses are capped, not paginated.** Under `maxResponseBytes` (default
+  1e6, `--max-response-bytes`) a response is byte-identical to before. Over it —
+  where no MCP client could consume the payload anyway — it is replaced by a
+  parseable notice naming the size, the on-disk artifact, and the narrower tool.
+  New exports: `capResponse`, `DEFAULT_MAX_RESPONSE_BYTES`, `resourceLinkFor`,
+  `negotiateProtocol`, `validateArgs`.
+- **Arguments are type-checked** against the declared `inputSchema`, returning
+  a Tool Execution Error (`isError`). Previously a wrong-typed argument was
+  silently ignored. If you drive this server programmatically with loosely
+  typed arguments, a call that used to fall back to a default now errors —
+  numeric strings (`"50"`) are still accepted.
+- **New optional tool arguments**, all defaulting to today's behaviour:
+  `find_symbol.maxResults`, `complexity.top`, `complexity.since` (risk mode
+  previously dropped it), `mermaid.maxEdges`, `dead_code.limit`, `grep.scope`
+  (was CLI-only), `callers.recall` (was CLI-only), `check_rules.configPath`.
+  `check_rules` no longer requires `rules` when `configPath` is given.
+- **Session cache is a 4-entry LRU**, not one entry, so alternating repos or
+  scopes no longer forces a cold rebuild each call.
+
+### New CLI flags
+
+`--workers <n>` (index), `--index <dir>` and `--no-index-cache` (read commands),
+`--max-response-bytes <n>` (mcp).
+
 ## Typical mapping (what to replace with what)
 
 What a consumer usually deletes from its own codebase, and the engine export

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxgfr/codeindex",
-  "version": "2.17.1",
+  "version": "2.18.0",
   "description": "Self-contained, deterministic repo-indexing engine: walk + language detection + symbol/import extraction (tree-sitter AST with regex fallback) + import resolution + typed cross-file link-graph + analytics. Ships as a single zero-dependency engine.mjs that consumer tools vendor.",
   "type": "module",
   "packageManager": "pnpm@10.33.0",

package/scripts/engine.d.mts

@@ -1,4 +1,4 @@
-declare const ENGINE_VERSION = "2.17.1";
+declare const ENGINE_VERSION = "2.18.0";
 declare const SCHEMA_VERSION = 4;
 declare const EXTRACTOR_VERSION = 10;
 type FileKind = "code" | "doc" | "config" | "asset" | "other";
@@ -169,9 +169,100 @@ interface ScanOptions {
     }>;
     fullHash?: boolean;
     precomputedWalk?: WalkResult;
+    extracted?: Map<string, ExtractedRecord>;
 }
+interface ExtractedRecord {
+    size: number;
+    mtimeMs: number;
+    record: FileRecord;
+}
+declare function buildCodeRecord(rel: string, ext: string, size: number, content: string, hash: string, lang: string, opts?: {
+    maxCallsPerFile?: number;
+}): FileRecord;
+declare function keptCodeFiles(root: string, opts?: ScanOptions): {
+    f: WalkedFile;
+    lang: string;
+}[];
+interface ScanSummary {
+    root: string;
+    commit?: string;
+    fileCount: number;
+    languages: Record<string, number>;
+    capped: boolean;
+    excluded: number;
+}
+declare function scanSummary(root: string, opts?: ScanOptions): ScanSummary;
 declare function scanRepo(root: string, opts?: ScanOptions): RepoScan;
 
+interface BuildIndexOptions extends ScanOptions {
+    meta?: {
+        version?: string;
+        schemaVersion?: number;
+    };
+    previousCommunities?: Record<string, string[]>;
+}
+interface IndexArtifacts {
+    scan: RepoScan;
+    graph: Graph;
+    symbols: SymbolIndex;
+}
+declare function buildIndexArtifacts(repo: string, opts?: BuildIndexOptions): IndexArtifacts;
+declare function buildArtifactsFromScan(scan: RepoScan, opts?: BuildIndexOptions): IndexArtifacts;
+
+declare const INDEX_DIR = ".codeindex";
+type PersistedCacheEntry = {
+    hash: string;
+    record: FileRecord;
+    size?: number;
+    mtimeMs?: number;
+};
+type PersistedCacheMap = Map<string, PersistedCacheEntry>;
+interface PersistedMeta {
+    engineVersion?: string;
+    commit?: string;
+    graphSha1?: string;
+    symbolsSha1?: string;
+}
+declare function toCacheMap(scan: RepoScan): PersistedCacheMap;
+declare function readPersistedIndex(repo: string, indexDir?: string): {
+    cacheMap: PersistedCacheMap;
+    meta: PersistedMeta;
+} | undefined;
+declare function preloadArtifacts(repo: string, scan: RepoScan, meta: PersistedMeta, indexDir?: string): IndexArtifacts | undefined;
+declare function preloadSession(repo: string, opts: Omit<ScanOptions, "cache">, indexDir?: string): {
+    scan: RepoScan;
+    cacheMap: PersistedCacheMap;
+    arts?: IndexArtifacts;
+} | undefined;
+
+interface Job {
+    abs: string;
+    rel: string;
+    ext: string;
+}
+interface WorkerInput {
+    jobs: Job[];
+    grammarKeys: string[];
+    maxCallsPerFile?: number;
+}
+interface WorkerOutput {
+    ready: string[];
+    records: {
+        rel: string;
+        size: number;
+        mtimeMs: number;
+        record: FileRecord;
+    }[];
+}
+declare function workerCount(requested?: number): number;
+declare function runExtractWorker(input: WorkerInput, post: (out: WorkerOutput) => void): Promise<void>;
+declare function extractInParallel(jobs: Job[], grammarKeys: string[], count: number, opts?: {
+    maxCallsPerFile?: number;
+}): Promise<Map<string, ExtractedRecord> | undefined>;
+declare function scanRepoParallel(root: string, opts?: ScanOptions & {
+    workers?: number;
+}): Promise<RepoScan>;
+
 declare function compileGlobs(globs: string[] | undefined): ((rel: string) => boolean) | null;
 
 interface IgnoreRule {
@@ -253,9 +344,10 @@ interface AstResult {
 }
 declare function extractAst(rel: string, ext: string, content: string, opts?: {
     maxCalls?: number;
+    imports?: boolean;
 }): AstResult | undefined;
 
-declare const DEFAULT_GRAMMARS_URL = "https://github.com/maxgfr/codeindex/releases/download/v2.17.1/grammars-2.17.1.tar.gz";
+declare const DEFAULT_GRAMMARS_URL = "https://github.com/maxgfr/codeindex/releases/download/v2.18.0/grammars-2.18.0.tar.gz";
 interface GrammarsPullTarget {
     url: string;
     sha256Url?: string;
@@ -496,21 +588,6 @@ interface RenderScipOptions {
 }
 declare function renderScip(scan: RepoScan, opts?: RenderScipOptions): Uint8Array;
 
-interface BuildIndexOptions extends ScanOptions {
-    meta?: {
-        version?: string;
-        schemaVersion?: number;
-    };
-    previousCommunities?: Record<string, string[]>;
-}
-interface IndexArtifacts {
-    scan: RepoScan;
-    graph: Graph;
-    symbols: SymbolIndex;
-}
-declare function buildIndexArtifacts(repo: string, opts?: BuildIndexOptions): IndexArtifacts;
-declare function buildArtifactsFromScan(scan: RepoScan, opts?: BuildIndexOptions): IndexArtifacts;
-
 declare function headCommit(dir: string): string | undefined;
 interface DiffFile {
     path: string;
@@ -739,6 +816,152 @@ interface MermaidOptions {
     maxEdges?: number;
 }
 declare function renderMermaid(graph: Graph, opts?: MermaidOptions): string;
+interface ClusteredMermaidResult {
+    content: string;
+    shownModules: number;
+    totalModules: number;
+    shownEdges: number;
+    totalEdges: number;
+}
+interface ClusteredMermaidOptions {
+    maxModules?: number;
+    maxEdges?: number;
+    title?: string;
+}
+declare function renderMermaidClustered(graph: Graph, opts?: ClusteredMermaidOptions): ClusteredMermaidResult;
+
+declare function hubThreshold(degrees: number[]): number;
+interface ImpactedFile {
+    rel: string;
+    module: string;
+    depth: number;
+}
+interface ImpactResult {
+    target: string;
+    scope: "module" | "file";
+    seeds: string[];
+    files: ImpactedFile[];
+    modules: string[];
+}
+declare function reverseClosure(edges: Edge[], seeds: string[], depth?: number): Map<string, number>;
+declare function impactOf(graph: Graph, target: string, depth?: number): ImpactResult | undefined;
+interface NeighborLink {
+    node: string;
+    direction: "out" | "in";
+    kind: string;
+    weight: number;
+    depth: number;
+    confidence?: "extracted" | "inferred";
+}
+interface NeighborResult {
+    target: string;
+    scope: "module" | "file";
+    links: NeighborLink[];
+    members?: string[];
+}
+declare function neighborsOf(graph: Graph, target: string, depth?: number, kinds?: Set<string>): NeighborResult | undefined;
+
+interface DeltaOptions {
+    base?: string;
+    staged?: boolean;
+    depth?: number;
+}
+interface ChangedSymbol {
+    name: string;
+    kind: string;
+    exported: boolean;
+    line: number;
+    endLine?: number;
+    parent?: string;
+    approx?: boolean;
+}
+interface DeltaChange {
+    path: string;
+    status: DiffFile["status"];
+    oldPath?: string;
+    binary?: boolean;
+    linesAdded?: number;
+    linesDeleted?: number;
+    module?: string;
+    hunks: {
+        start: number;
+        end: number;
+    }[];
+    symbols: ChangedSymbol[];
+}
+interface DeltaModule {
+    slug: string;
+    path: string;
+    score: number;
+    bucket: "HIGH" | "MEDIUM" | "LOW";
+    reasons: string[];
+    changedFiles: string[];
+    changedSymbols: {
+        total: number;
+        exported: number;
+    };
+    impact: {
+        directFiles: number;
+        transitiveFiles: number;
+        modules: string[];
+    };
+    tests: {
+        status: "covered" | "gap" | "n/a";
+        files: string[];
+    };
+    open: string[];
+}
+interface DeltaResult {
+    base: {
+        ref: string;
+        mergeBase: string;
+        staged: boolean;
+    };
+    indexCommit?: string;
+    depth: number;
+    changes: DeltaChange[];
+    modules: DeltaModule[];
+    dangling: {
+        from: string;
+        spec: string;
+        reason: string;
+    }[];
+    deleted: string[];
+    unindexed: string[];
+    notes: string[];
+}
+type DeltaError = {
+    error: string;
+};
+declare const RISK_WEIGHTS: {
+    readonly exportedChange: 25;
+    readonly hubHigh: 20;
+    readonly hubMed: 10;
+    readonly blastHigh: 20;
+    readonly blastMed: 10;
+    readonly testGap: 20;
+    readonly surprise: 10;
+    readonly dangling: 15;
+};
+declare const DEFAULT_DELTA_DEPTH = 2;
+interface NamedDef {
+    name: string;
+    file: string;
+    line: number;
+    endLine?: number;
+    kind: string;
+    exported: boolean;
+    parent?: string;
+}
+declare function symbolsInHunks(defs: NamedDef[], hunks: Hunk[]): ChangedSymbol[];
+declare function computeDelta(graph: Graph, symbols: SymbolIndex | undefined, diff: {
+    files: DiffFile[];
+    hunks: Map<string, Hunk[]>;
+    base: DeltaResult["base"];
+    notes?: string[];
+}, depth?: number): DeltaResult;
+declare function deltaFor(repo: string, graph: Graph, symbols: SymbolIndex | undefined, opts?: DeltaOptions): DeltaResult | DeltaError;
+declare function formatDeltaPanel(res: DeltaResult): string;
 
 interface McpServerOptions {
     serverInfo?: {
@@ -746,6 +969,7 @@ interface McpServerOptions {
         version?: string;
     };
     defaultRepo?: string;
+    maxResponseBytes?: number;
 }
 declare function runMcpServer(opts?: McpServerOptions): Promise<void>;
 
@@ -782,4 +1006,4 @@ declare function rrf<T>(lists: T[][], keyOf: (item: T) => string, k?: number): M
 
 declare function runCli(rawArgv: string[]): Promise<void>;
 
-export { type ArchRule, type BuildIndexOptions, type BuiltinRule, type CallerEntry, type CallerIndex, type CallerIndexOptions, type CallerSite, type ChangeCoupling, type CodeInfo, type CodeSymbol, type CouplingOptions, DEFAULT_GRAMMARS_URL, DEFAULT_MAX_FILES, type DeadSymbol, type DiffFile, type DiffSpec, EMBED_VERSION, ENGINE_VERSION, EXTRACTOR_VERSION, type Edge, type EdgeKind, type EditResult, type EmbedEndpointOptions, type EmbedPullTarget, type EmbeddingIndex, type EmbeddingRecord, type EmbeddingUnit, type FileCategory, type FileKind, type FileNode, type FileRecord, type FindSymbolOptions, type ForbiddenEdgeRule, type GrammarsPullResult, type GrammarsPullTarget, type GrammarsTier, type GrammarsTierName, type Graph, type GrepOptions, type Hotspot, type Hunk, type IgnoreRule, type IndexArtifacts, MARKDOWN_EXT, type MarkdownInfo, type McpServerOptions, type MermaidOptions, type ModuleInfo, type ModuleNode, type RawCallerIndex, type RawCallerSite, type RawRef, type RenderScipOptions, type RepoMapOptions, type RepoScan, type Resolution, type ResolveContext, type RiskHotspot, type RuleSeverity, type RuleViolation, SCHEMA_VERSION, type ScanOptions, type SearchHit, type SearchOptions, type SearchResult, type SemanticSearchOptions, type SemanticSearchResult, type ShResult, type StaticEmbedModel, type SurpriseEdge, type SymbolComplexity, type SymbolIndex, type SymbolMatch, type SymbolReferences, type TestMap, type Tier, type WalkOptions, type WalkResult, type WalkedFile, type WarmGrammarsOptions, type WarmGrammarsResult, type WorkspaceInfo, type WorkspaceKind, type WorkspacePackage, allGrammarKeys, applyCentrality, basicTokenize, betweennessOf, buildArtifactsFromScan, buildCallerIndex, buildEmbeddingIndex, buildEndpointIndex, buildGraph, buildIndexArtifacts, buildModules, buildRawCallerIndex, buildResolveContext, buildSymbolIndex, byKey, byStr, categorize, changeCoupling, changedSince, checkRules, classify, clip, clipInline, communityOf, compileGlobs, complexityOfSource, computeImportPairs, computeSurprises, computeSymbolRefs, computeTestMap, deleteMemory, deserializeEmbeddings, detectCommunities, detectWorkspaces, diffFiles, diffHunks, embedEndpointUrl, embedViaEndpoint, embeddingUnits, enclosingSymbol, encode, encodeQueryViaEndpoint, ensureGrammars, escapeRegExp, extToLang, extractAst, extractCode, extractGrammarsTarball, extractMarkdown, extractSymbols, extractTarInto, fetchExpectedSha256, fetchGrammarsTarball, findDeadCode, findReferences, findSymbol, foldText, gitChurn, grammarKeyForExt, grammarKeysForExts, grammarReady, grepRepo, hasEmbedModel, have, headCommit, healthzUrl, insertAfterSymbol, insertBeforeSymbol, intDot, isCode, isDoc, isGitWorktree, isIgnored, isSurprising, isTestFile, isTestPath, keywords, languageOf, listMemories, loadEmbedModel, pagerankOf, parseGitignore, parseRules, probeEndpoint, pullGrammars, quantize, rankHotspots, rankedKeywords, readMemory, readText, renderGraphJson, renderMermaid, renderRepoMap, renderScip, renderSymbolsJson, replaceSymbolBody, resolveBaseRef, resolveCallEdges, resolveDocLink, resolveEmbedEndpoint, resolveEmbedModelDir, resolveEmbedPullUrl, resolveGrammarsDir, resolveGrammarsPullTarget, resolveGrammarsTier, resolveImport, resolveUniqueSymbol, rewriteCommand, riskHotspots, roundHalfToEven, rrf, runCli, runMcpServer, scanRepo, searchIndex, searchSemantic, serializeEmbeddings, sh, sha1, sharedGrammarsCacheDir, shortHash, slugify, subtokens, symbolComplexity, symbolsOverview, testsForModule, tierForPath, tokenize, uniqueSymbolDefs, untestedModules, untrackedFiles, walk, warmGrammars, wordpiece, writeMemory };
+export { type ArchRule, type BuildIndexOptions, type BuiltinRule, type CallerEntry, type CallerIndex, type CallerIndexOptions, type CallerSite, type ChangeCoupling, type ChangedSymbol, type ClusteredMermaidOptions, type ClusteredMermaidResult, type CodeInfo, type CodeSymbol, type CouplingOptions, DEFAULT_DELTA_DEPTH, DEFAULT_GRAMMARS_URL, DEFAULT_MAX_FILES, type DeadSymbol, type DeltaChange, type DeltaError, type DeltaModule, type DeltaOptions, type DeltaResult, type DiffFile, type DiffSpec, EMBED_VERSION, ENGINE_VERSION, EXTRACTOR_VERSION, type Edge, type EdgeKind, type EditResult, type EmbedEndpointOptions, type EmbedPullTarget, type EmbeddingIndex, type EmbeddingRecord, type EmbeddingUnit, type ExtractedRecord, type FileCategory, type FileKind, type FileNode, type FileRecord, type FindSymbolOptions, type ForbiddenEdgeRule, type GrammarsPullResult, type GrammarsPullTarget, type GrammarsTier, type GrammarsTierName, type Graph, type GrepOptions, type Hotspot, type Hunk, INDEX_DIR, type IgnoreRule, type ImpactResult, type ImpactedFile, type IndexArtifacts, MARKDOWN_EXT, type MarkdownInfo, type McpServerOptions, type MermaidOptions, type ModuleInfo, type ModuleNode, type NeighborLink, type NeighborResult, type PersistedCacheEntry, type PersistedCacheMap, type PersistedMeta, RISK_WEIGHTS, type RawCallerIndex, type RawCallerSite, type RawRef, type RenderScipOptions, type RepoMapOptions, type RepoScan, type Resolution, type ResolveContext, type RiskHotspot, type RuleSeverity, type RuleViolation, SCHEMA_VERSION, type ScanOptions, type ScanSummary, type SearchHit, type SearchOptions, type SearchResult, type SemanticSearchOptions, type SemanticSearchResult, type ShResult, type StaticEmbedModel, type SurpriseEdge, type SymbolComplexity, type SymbolIndex, type SymbolMatch, type SymbolReferences, type TestMap, type Tier, type WalkOptions, type WalkResult, type WalkedFile, type WarmGrammarsOptions, type WarmGrammarsResult, type WorkspaceInfo, type WorkspaceKind, type WorkspacePackage, allGrammarKeys, applyCentrality, basicTokenize, betweennessOf, buildArtifactsFromScan, buildCallerIndex, buildCodeRecord, buildEmbeddingIndex, buildEndpointIndex, buildGraph, buildIndexArtifacts, buildModules, buildRawCallerIndex, buildResolveContext, buildSymbolIndex, byKey, byStr, categorize, changeCoupling, changedSince, checkRules, classify, clip, clipInline, communityOf, compileGlobs, complexityOfSource, computeDelta, computeImportPairs, computeSurprises, computeSymbolRefs, computeTestMap, deleteMemory, deltaFor, deserializeEmbeddings, detectCommunities, detectWorkspaces, diffFiles, diffHunks, embedEndpointUrl, embedViaEndpoint, embeddingUnits, enclosingSymbol, encode, encodeQueryViaEndpoint, ensureGrammars, escapeRegExp, extToLang, extractAst, extractCode, extractGrammarsTarball, extractInParallel, extractMarkdown, extractSymbols, extractTarInto, fetchExpectedSha256, fetchGrammarsTarball, findDeadCode, findReferences, findSymbol, foldText, formatDeltaPanel, gitChurn, grammarKeyForExt, grammarKeysForExts, grammarReady, grepRepo, hasEmbedModel, have, headCommit, healthzUrl, hubThreshold, impactOf, insertAfterSymbol, insertBeforeSymbol, intDot, isCode, isDoc, isGitWorktree, isIgnored, isSurprising, isTestFile, isTestPath, keptCodeFiles, keywords, languageOf, listMemories, loadEmbedModel, neighborsOf, pagerankOf, parseGitignore, parseRules, preloadArtifacts, preloadSession, probeEndpoint, pullGrammars, quantize, rankHotspots, rankedKeywords, readMemory, readPersistedIndex, readText, renderGraphJson, renderMermaid, renderMermaidClustered, renderRepoMap, renderScip, renderSymbolsJson, replaceSymbolBody, resolveBaseRef, resolveCallEdges, resolveDocLink, resolveEmbedEndpoint, resolveEmbedModelDir, resolveEmbedPullUrl, resolveGrammarsDir, resolveGrammarsPullTarget, resolveGrammarsTier, resolveImport, resolveUniqueSymbol, reverseClosure, rewriteCommand, riskHotspots, roundHalfToEven, rrf, runCli, runExtractWorker, runMcpServer, scanRepo, scanRepoParallel, scanSummary, searchIndex, searchSemantic, serializeEmbeddings, sh, sha1, sharedGrammarsCacheDir, shortHash, slugify, subtokens, symbolComplexity, symbolsInHunks, symbolsOverview, testsForModule, tierForPath, toCacheMap, tokenize, uniqueSymbolDefs, untestedModules, untrackedFiles, walk, warmGrammars, wordpiece, workerCount, writeMemory };