@wrongstack/tools 1.0.0 → 1.0.2

package/dist/codebase-index/embedding-pass.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The semantic embedding pass.
+ *
+ * Embeds one vector per file so the index can answer questions phrased in the
+ * problem's vocabulary rather than the code's — "where do we back off after a
+ * 429" instead of `retryAfterMsFromHeaders`.
+ *
+ * ## What gets embedded, and why it is the file
+ *
+ * A bare declaration is poor material for an embedding: `function resolve(id:
+ * string): Widget` carries almost nothing a lexical index does not already
+ * have, and BM25 over FTS5 already matches it better. What carries meaning is
+ * the concept layer's description of what a file is *for*, so that is the text
+ * this pass embeds, falling back to the file's declaration names when no
+ * summary exists yet.
+ *
+ * That also makes it eight times cheaper than a symbol-level pass on this
+ * repository — eight thousand files against sixty-six thousand symbols.
+ *
+ * ## Why it is a pass and not part of indexing
+ *
+ * Model inference is asynchronous and batched. The indexer's write path is a
+ * synchronous SQLite transaction; running inference inside it would hold a
+ * write lock open across thousands of inferences. The older char-trigram
+ * embedding could live there precisely because it was neither of those things
+ * — and it was also not semantic, which is why it is being superseded rather
+ * than extended.
+ *
+ * ## Why the vectors never silently mix
+ *
+ * Two models produce incomparable spaces. The provider id is stored with every
+ * row and checked before a pass; a change wipes the table and re-embeds rather
+ * than leaving half the index in one space and half in another.
+ */
+import { type IndexStore } from './writer.js';
+/**
+ * The host-supplied embedding model.
+ *
+ * Structurally identical to the `EmbeddingProvider` that
+ * `packages/vector-memory` already defines, so its transformers-backed
+ * implementation satisfies this without an adapter. Injected rather than
+ * imported for the same reason the summariser is: `packages/tools` must not
+ * depend on an optional native model runtime.
+ */
+export interface EmbeddingPort {
+    /** Stable id including the model and quantisation. Changing it re-embeds. */
+    readonly id: string;
+    /** Vector length. Must not change for a given `id`. */
+    readonly dimensions: number;
+    /** Embed a batch. Must return exactly one vector per input, in order. */
+    embed(texts: string[]): Promise<Float32Array[]>;
+}
+/** Texts sent per inference call. */
+export declare const DEFAULT_BATCH_SIZE = 16;
+/** Ceiling on embedded text. Beyond this a summary is not a summary. */
+export declare const MAX_EMBED_CHARS = 2000;
+export interface EmbedOptions {
+    /** Stop after this many files. */
+    maxFiles?: number | undefined;
+    batchSize?: number | undefined;
+    /** Re-embed even when the stored text hash still matches. */
+    force?: boolean | undefined;
+    signal?: AbortSignal | undefined;
+    onProgress?: ((done: number, total: number) => void) | undefined;
+}
+export interface EmbedResult {
+    embedded: number;
+    /** Files whose embedded text was unchanged. */
+    cached: number;
+    /** Vectors dropped because their file left the index. */
+    pruned: number;
+    /** True when a provider change forced a full re-embed. */
+    providerChanged: boolean;
+    /** Files with no summary, embedded from their declaration names instead. */
+    fromDeclarations: number;
+    durationMs: number;
+    errors: string[];
+}
+/**
+ * Run one embedding pass. Never throws: an inference failure costs that batch
+ * its vectors, is recorded in `errors`, and the walk continues.
+ */
+export declare function embedFiles(store: IndexStore, port: EmbeddingPort, relativeOf: (file: string) => string, options?: EmbedOptions): Promise<EmbedResult>;
+/** Reported when a project has no index to embed. */
+export type EmbedIndexMissing = {
+    indexed: false;
+};
+/**
+ * Embed a project's files, owning the store lifetime so callers outside this
+ * package never touch `indexStorePool`. Refuses to run without an index.
+ */
+export declare function embedProjectFiles(projectRoot: string, port: EmbeddingPort, options?: EmbedOptions & {
+    indexDir?: string | undefined;
+}): Promise<EmbedResult | EmbedIndexMissing>;
+//# sourceMappingURL=embedding-pass.d.ts.map

package/dist/codebase-index/graph-adjacency-cache.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Process-local cache of the wiring graph.
+ *
+ * Building the graph means pulling ~180k resolved refs, ~66k symbol→file
+ * pairs, the homonym counts and the import-visibility map, then laying the
+ * whole thing out as CSR — around half a second on this repo. That is fine
+ * once per index generation and unacceptable once per query, and the
+ * personalised retrieval walk is a per-query operation.
+ *
+ * The cache holds one graph. In the detached project server that is exactly
+ * right: one daemon serves one project. A caller for a different project (or
+ * a different index directory) simply replaces the entry rather than growing
+ * a map that would keep tens of megabytes alive for a project nobody is
+ * querying any more.
+ *
+ * Freshness is decided by the index's own `last_indexed` stamp plus the row
+ * counts, read fresh on every request. That costs three trivial queries and
+ * makes the cache self-invalidating from any path — daemon, worker, or
+ * inline — without having to be wired into the server's generation plumbing.
+ */
+import { type WiringGraph } from './graph-rank.js';
+import type { IndexStore } from './writer.js';
+/** Everything the walk needs, built together and invalidated together. */
+export interface WiringSnapshot {
+    graph: WiringGraph;
+    /** Declaring file per symbol id — the walk reports files, not just nodes. */
+    fileOf: ReadonlyMap<number, string>;
+}
+/**
+ * Return the wiring graph for this store, building it only when the index has
+ * changed since the last call.
+ */
+export declare function getWiringSnapshot(store: IndexStore, projectRoot: string, indexDir: string | undefined): WiringSnapshot;
+/** Drop the cached graph. Tests and shutdown paths only. */
+export declare function clearWiringSnapshot(): void;
+//# sourceMappingURL=graph-adjacency-cache.d.ts.map

package/dist/codebase-index/graph-rank-pass.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The index-time centrality pass.
+ *
+ * Runs inside the indexer's atomic update, immediately after ref resolution
+ * and module resolution have settled: `refs.to_id` is only final at that
+ * point, and a rank computed from half-resolved refs would describe a graph
+ * that never existed.
+ *
+ * Rank is a property of the whole graph, so this recomputes everything or
+ * nothing. That is affordable on a full run and wasteful on a one-file
+ * watcher run, which is what {@link shouldRefreshRanks} arbitrates.
+ */
+import type { IndexStore } from './writer.js';
+/**
+ * Data-version marker for the rank layer, in the same spirit as
+ * `relation_graph_version`: bumping it forces every index to recompute ranks
+ * once without a `SCHEMA_VERSION` bump (which would drop and rebuild the
+ * entire database). Older processes sharing the DB cannot downgrade it.
+ */
+export declare const RANK_VERSION = "1";
+export declare const RANK_VERSION_KEY = "rank_version";
+/**
+ * Above this many files in a targeted run, recompute. A watcher run that
+ * touches one file barely moves any score, so leaving ranks one generation
+ * stale is the cheaper trade; a bulk targeted run is effectively a full run
+ * and should not be served stale ranks.
+ */
+export declare const RANK_REFRESH_FILE_THRESHOLD = 25;
+export interface RankPassResult {
+    /** False when the pass decided the existing ranks were good enough. */
+    computed: boolean;
+    symbols: number;
+    files: number;
+    durationMs: number;
+}
+export declare function shouldRefreshRanks(store: IndexStore, opts: {
+    files?: readonly string[] | undefined;
+    force?: boolean | undefined;
+}): boolean;
+/**
+ * Recompute and persist both rank tables. Never throws: a failed rank pass
+ * leaves the previous (or empty) ranks in place and must not take the index
+ * run down with it — every consumer treats a missing rank as "unranked".
+ */
+export declare function runGraphRankPass(store: IndexStore, errors: string[]): RankPassResult;
+//# sourceMappingURL=graph-rank-pass.d.ts.map

package/dist/codebase-index/graph-rank.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Graph centrality over the symbol wiring graph.
+ *
+ * Two modes share one implementation:
+ *
+ *  - **Global** — computed once per index run with a uniform restart
+ *    distribution, persisted to `symbol_rank` / `file_rank`. Answers "what is
+ *    architecturally central in this repo", and drives the repo map, the
+ *    CodeMap node sizing and the atlas projection.
+ *  - **Personalised** — computed per query with the lexical (BM25) hit scores
+ *    as the restart distribution. Answers "what is central *to this query*".
+ *    Lexical search proposes the seeds; the graph decides the ordering.
+ *
+ * The walk runs over an **undirected** view of the graph: a caller and its
+ * callee are mutually relevant when you are trying to understand either one,
+ * and a directed walk starves leaf utilities that everything depends on.
+ * Directed in/out degrees are still reported separately, because they are
+ * what a human reads as "blast radius" vs "coupling".
+ *
+ * Only refs that resolved to a real symbol id participate. At the time of
+ * writing roughly a third of this repo's refs stay unresolved (stdlib and
+ * third-party targets that were never indexed); including them would mean
+ * walking to nodes that carry no code.
+ *
+ * Edge multiplicity is deliberately preserved. Five calls from A to B produce
+ * five edges, so B receives five shares of A's mass: repeated coupling is
+ * stronger coupling. Self-references are dropped — recursion should not make
+ * a symbol important on its own account.
+ *
+ * ## Why edges carry a confidence weight
+ *
+ * The index resolves a ref by matching `to_name` to the lowest symbol id in
+ * the same language family — it is not file- or import-aware, which
+ * `findIncomingCallsByName` already documents as an ambiguity source. For a
+ * per-query answer that is a caveat; for a global ranking it is fatal. On this
+ * repo roughly half of all resolved refs point at a name that several symbols
+ * declare, and the worst offenders are test globals and single-letter locals:
+ * every `it(...)` in the suite lands on whichever `it` happens to hold the
+ * lowest id, handing that one symbol thousands of incoming edges it never had.
+ *
+ * So an edge into a name that `n` symbols declare carries weight `1 / n`: the
+ * resolver guessed one of `n` equally plausible targets, and the walk spreads
+ * exactly that much belief. Unique names — the half we can actually trust —
+ * keep full weight.
+ *
+ * Homonym counting alone is not enough, because the worst misresolutions are
+ * to names that really are unique. Every `it(...)` in the test suite resolves
+ * to the one `const it: Catalog` in the desktop app's i18n file — the Italian
+ * locale — handing a translation table 5,500 incoming edges. Nothing declares
+ * a competing `it`, so no homonym penalty applies.
+ *
+ * The second weight is therefore visibility, in three tiers. An edge is fully
+ * trusted when the two symbols share a file, or when the source file actually
+ * imports the target's file — the module resolver already recorded those pairs
+ * in `refs.to_file`. Otherwise the question is whether we can believe the
+ * absence of that import:
+ *
+ *  - The source file has resolved imports, and the target's file is not among
+ *    them. The resolver worked here and still did not connect these two files,
+ *    so the reference almost certainly is not to this symbol
+ *    ({@link CONTRADICTED_VISIBILITY_WEIGHT}).
+ *  - The source file has no resolved imports at all. Resolution failed
+ *    wholesale for it, so its silence is not evidence either way, and the edge
+ *    keeps a reduced but meaningful weight
+ *    ({@link UNVERIFIED_VISIBILITY_WEIGHT}).
+ *
+ * These stay penalties rather than filters: module resolution only resolves
+ * about three fifths of this repo's import specifiers, and dropping the rest
+ * outright would gut the graph.
+ *
+ * Both of these are ranking-quality fixes, not resolver fixes; making ref
+ * resolution import-aware would remove the need for either.
+ */
+/** Ref shape as returned by `IndexStore.getAllResolvedRefs()`. */
+export interface ResolvedRefEdge {
+    fromId: number;
+    toId: number;
+    callType: string;
+}
+/**
+ * Compressed sparse row adjacency over a dense node numbering.
+ *
+ * `neighbours[offsets[u] .. offsets[u + 1]]` are the dense indices adjacent to
+ * dense node `u`. `ids[u]` maps back to the original symbol id.
+ */
+export interface WiringGraph {
+    /** Number of nodes. */
+    size: number;
+    /** Original symbol id for each dense index. */
+    ids: Int32Array;
+    /** Dense index for each original symbol id. */
+    index: Map<number, number>;
+    /** CSR row offsets, length `size + 1`. */
+    offsets: Int32Array;
+    /** CSR adjacency entries, length `offsets[size]`. */
+    neighbours: Int32Array;
+    /**
+     * Confidence per adjacency entry, parallel to `neighbours`, in `(0, 1]`.
+     *
+     * This attenuates rather than redistributes: an edge with confidence `c`
+     * carries `c` of the mass it would otherwise carry, and the remaining
+     * `1 - c` returns to the restart distribution as belief the walk declined
+     * to place. Normalising these away — dividing each node's split by the sum
+     * of its weights — would make them inert, because a node with a single
+     * low-confidence edge would still hand over all of its mass.
+     */
+    weights: Float64Array;
+    /** Directed in-degree per dense node (how many symbols reference it). */
+    inDegree: Int32Array;
+    /** Directed out-degree per dense node (how many symbols it references). */
+    outDegree: Int32Array;
+}
+export interface PageRankOptions {
+    /**
+     * Restart (teleport) probability — the share of mass that returns to the
+     * restart distribution each iteration. Higher keeps the walk closer to its
+     * seeds. 0.25 is the value Graft settled on for code graphs; the classic
+     * web-PageRank 0.15 wanders too far for personalised queries.
+     */
+    restart?: number;
+    /** Power iterations. 25 converges comfortably at this graph size. */
+    iterations?: number;
+    /**
+     * Seed weights by **dense index**, for a personalised walk. Weights need not
+     * be normalised. Omitted (or empty) means a uniform restart distribution.
+     */
+    seeds?: ReadonlyMap<number, number> | undefined;
+}
+export declare const DEFAULT_RESTART = 0.25;
+export declare const DEFAULT_ITERATIONS = 25;
+/**
+ * Weight for a cross-file edge from a file whose imports never resolved. We
+ * cannot corroborate the edge, but we cannot contradict it either.
+ */
+export declare const UNVERIFIED_VISIBILITY_WEIGHT = 0.25;
+/**
+ * Weight for a cross-file edge from a file whose imports DID resolve, to a
+ * file it does not import. Near-zero rather than zero so a single resolver
+ * miss degrades one edge instead of erasing it.
+ */
+export declare const CONTRADICTED_VISIBILITY_WEIGHT = 0.02;
+/**
+ * Build the undirected CSR wiring graph from the resolved ref list.
+ *
+ * Two passes over the edge list (count, then fill) so the adjacency lands in
+ * flat typed arrays with no intermediate per-node arrays — at 180k edges the
+ * array-of-arrays shape costs more in allocation than the walk itself.
+ */
+export interface WiringGraphOptions {
+    /**
+     * How many symbols declare the name each target symbol carries, keyed by
+     * target symbol id. Absent ids are treated as unambiguous (weight 1).
+     */
+    candidates?: ReadonlyMap<number, number> | undefined;
+    /** Declaring file per symbol id, used for the visibility check. */
+    fileOf?: ReadonlyMap<number, string> | undefined;
+    /** Files each source file imports, as resolved by the module resolver. */
+    importsOf?: ReadonlyMap<string, ReadonlySet<string>> | undefined;
+}
+export declare function buildWiringGraph(refs: readonly ResolvedRefEdge[], options?: WiringGraphOptions): WiringGraph;
+/**
+ * Power-iterate PageRank over `graph`, returning scores normalised so the
+ * highest is exactly 1.0. Nodes the walk never reaches score 0.
+ *
+ * Mass is conserved exactly: every node hands `restart` of its mass back to
+ * the restart distribution, spreads the rest over its neighbours, and a node
+ * with no neighbours hands everything back. Low-confidence edges return their
+ * unspent share to the same pool. Without it the total would leak downwards
+ * and the final normalisation would hide the leak.
+ */
+export declare function pageRank(graph: WiringGraph, options?: PageRankOptions): Float64Array;
+/** One persisted `symbol_rank` row. */
+export interface SymbolRankRow {
+    symbolId: number;
+    rank: number;
+    inDeg: number;
+    outDeg: number;
+}
+/** One persisted `file_rank` row. */
+export interface FileRankRow {
+    file: string;
+    rank: number;
+    inDeg: number;
+    outDeg: number;
+}
+/** Materialise the score vector as persistable symbol rows. */
+export declare function toSymbolRankRows(graph: WiringGraph, scores: Float64Array): SymbolRankRow[];
+/**
+ * Roll symbol scores up to files.
+ *
+ * A file's rank is the **sum** of its symbols' ranks, not the mean: a module
+ * that exports twenty things everyone uses is more central than one that
+ * exports a single equally-used thing, and averaging erases exactly that.
+ * Degrees roll up the same way. The result is re-normalised to max 1.0 so
+ * file and symbol ranks share a scale.
+ */
+export declare function aggregateFileRank(rows: readonly SymbolRankRow[], fileOf: ReadonlyMap<number, string>): FileRankRow[];
+//# sourceMappingURL=graph-rank.d.ts.map

package/dist/codebase-index/index-service.d.ts

@@ -11,8 +11,9 @@
  * run on one event loop, so a pooled connection is both safe and substantially
  * cheaper than re-running schema/FTS drift checks for every edited file.
  */
+import type { ContextResult } from './context-retrieval.js';
 import type { CodeMapGraph, IndexResult, IndexStats } from './schema.js';
-import type { CallRefsOpArgs, IndexOpArgs, SearchOpArgs, SearchOpResult, StatsOpArgs } from './worker-protocol.js';
+import type { CallRefsOpArgs, ContextOpArgs, IndexOpArgs, SearchOpArgs, SearchOpResult, StatsOpArgs, VectorSearchOpArgs, VectorSearchOpResult } from './worker-protocol.js';
 interface ServiceHooks {
     signal?: AbortSignal | undefined;
     onProgress?: ((current: number, total: number) => void) | undefined;
@@ -21,6 +22,19 @@ interface ServiceHooks {
 export declare function indexService(args: IndexOpArgs, hooks?: ServiceHooks): Promise<IndexResult>;
 /** Ranked symbol search (FTS5 inside SQLite; BM25 fallback without FTS5). */
 export declare function searchService(args: SearchOpArgs): SearchOpResult;
+/**
+ * Personalised retrieval: lexical seeds walked through the wiring graph.
+ *
+ * Path relativisation happens here rather than in the retriever so the pure
+ * algorithm stays free of `node:path`, and so the daemon — which knows the
+ * project root it was started for — is the one that decides what "relative"
+ * means.
+ */
+export declare function contextService(args: ContextOpArgs): ContextResult;
+/**
+ * Nearest files to a query vector. The caller embeds; this only compares.
+ */
+export declare function vectorSearchService(args: VectorSearchOpArgs): VectorSearchOpResult;
 /** Index health and statistics. */
 export declare function statsService(args: StatsOpArgs): IndexStats;
 /** Package-level dependency graph. */

package/dist/codebase-index/index.d.ts

@@ -13,36 +13,51 @@
  *          fallback so every mapped language always enters the index
  * Ranking: Okapi BM25 / FTS5 (k1=1.5, b=0.75)
  */
-export { resolveProjectIndexDaemonAvailability, type ProjectIndexDaemonAvailability, } from './project-server-client.js';
+export { type InvariantEvaluationResult, type InvariantRuleId, type InvariantViolation, type ModuleContract, PolyglotInvariantEngine, polyglotInvariantEngine, } from './ast-invariant-engine.js';
+export { type MutateSymbolOptions, type MutateSymbolResult, replaceSymbolInFile, } from './ast-symbol-mutator.js';
 export { cancelPendingReindexes, checkCodebaseIndexServerHealth, codebaseIndexStats, enqueueReindex, ensureCodebaseIndexServer, fileGraphService, getIndexState, incomingCallsService, isIndexableFile, isIndexing, isIndexReady, onIndexStateChange, outgoingCallsService, packageGraphService, runStartupIndex, searchCodebaseIndex, shutdownCodebaseIndexHost, shutdownCodebaseIndexServer, symbolGraphService, } from './background-indexer.js';
 export { buildBm25Index, buildIndexableText, tokenise, } from './bm25.js';
+export { getCodebaseIndexPerfSnapshot, resetCodebaseIndexPerfMetrics, type CodebaseIndexPerfSnapshot, } from './perf-metrics.js';
 export type { CircuitSnapshot, CircuitState } from './circuit-breaker.js';
 export { CircuitOpenError, IndexCircuitBreaker, IndexTimeoutError, indexCircuitBreaker, resetIndexCircuitBreaker, } from './circuit-breaker.js';
-export { codebaseAstReplaceTool, type CodebaseAstReplaceInput, type CodebaseAstReplaceOutput, } from './codebase-ast-replace-tool.js';
-export { codebaseInvariantCheckTool, type CodebaseInvariantCheckInput, type CodebaseInvariantCheckOutput, } from './codebase-invariant-check-tool.js';
-export { replaceSymbolInFile, type MutateSymbolOptions, type MutateSymbolResult, } from './ast-symbol-mutator.js';
-export { codebaseImpactAnalysisTool, type CodebaseImpactAnalysisInput, type CodebaseImpactAnalysisOutput, type ImpactAnalysisInput, type ImpactAnalysisOutput, type ImpactCallSite, } from './codebase-impact-analysis-tool.js';
-export { codebaseIncomingCallsTool, type CodebaseIncomingCallsInput, type CodebaseIncomingCallsOutput, type IncomingCallsInput, type IncomingCallsOutput, } from './codebase-incoming-calls-tool.js';
-export { codebaseIndexTool, type CodebaseIndexInput, type CodebaseIndexOutput, } from './codebase-index-tool.js';
-export { codebaseOutgoingCallsTool, type CodebaseOutgoingCallsInput, type CodebaseOutgoingCallsOutput, type OutgoingCallsInput, type OutgoingCallsOutput, } from './codebase-outgoing-calls-tool.js';
-export { codebaseRepoMapTool, type CodebaseRepoMapInput, type CodebaseRepoMapOutput, } from './codebase-repo-map-tool.js';
-export { codebaseSearchTool, type CodebaseSearchInput, type CodebaseSearchOutput, } from './codebase-search-tool.js';
-export { codebaseSkeletonTool, type CodebaseSkeletonInput, type CodebaseSkeletonOutput, } from './codebase-skeleton-tool.js';
-export { codebaseStatsTool, type CodebaseStatsInput, type CodebaseStatsOutput, } from './codebase-stats-tool.js';
-export { codebaseTargetedTestTool, type CodebaseTargetedTestInput, type CodebaseTargetedTestOutput, type TargetedTestInput, type TargetedTestOutput, } from './codebase-targeted-test-tool.js';
-export { generateRepoMap, type RepoMapOptions, type RepoMapResult, } from './repo-map.js';
-export { extractDirectorySkeleton, extractFileSkeleton, type FileSkeletonResult, type SkeletonOptions, type SkeletonSymbolRange, } from './skeleton-extractor.js';
-export { deadCodeScanTool, runDeadCodeScan } from './dead-code-scan.js';
+export { type CodebaseAstReplaceInput, type CodebaseAstReplaceOutput, codebaseAstReplaceTool, } from './codebase-ast-replace-tool.js';
+export { type CodebaseImpactAnalysisInput, type CodebaseImpactAnalysisOutput, codebaseImpactAnalysisTool, type ImpactAnalysisInput, type ImpactAnalysisOutput, type ImpactCallSite, } from './codebase-impact-analysis-tool.js';
+export { type CodebaseIncomingCallsInput, type CodebaseIncomingCallsOutput, codebaseIncomingCallsTool, type IncomingCallsInput, type IncomingCallsOutput, } from './codebase-incoming-calls-tool.js';
+export { type CodebaseIndexInput, type CodebaseIndexOutput, codebaseIndexTool, } from './codebase-index-tool.js';
+export { type CodebaseInvariantCheckInput, type CodebaseInvariantCheckOutput, codebaseInvariantCheckTool, } from './codebase-invariant-check-tool.js';
+export { type CodebaseOutgoingCallsInput, type CodebaseOutgoingCallsOutput, codebaseOutgoingCallsTool, type OutgoingCallsInput, type OutgoingCallsOutput, } from './codebase-outgoing-calls-tool.js';
+export { type CodebaseRepoMapInput, type CodebaseRepoMapOutput, codebaseRepoMapTool, } from './codebase-repo-map-tool.js';
+export { type CodebaseSearchInput, type CodebaseSearchOutput, codebaseSearchTool, } from './codebase-search-tool.js';
+export { type CodebaseSkeletonInput, type CodebaseSkeletonOutput, codebaseSkeletonTool, } from './codebase-skeleton-tool.js';
+export { type CodebaseStatsInput, type CodebaseStatsOutput, codebaseStatsTool, } from './codebase-stats-tool.js';
+export { type CodebaseTargetedTestInput, type CodebaseTargetedTestOutput, codebaseTargetedTestTool, type TargetedTestInput, type TargetedTestOutput, } from './codebase-targeted-test-tool.js';
 export type { DeadCodeScanInput, DeadCodeScanOutput, DeadFile, DeadPackage, DeadSymbol, } from './dead-code-scan.js';
+export { deadCodeScanTool, runDeadCodeScan } from './dead-code-scan.js';
+export { compileGitignore, type IgnoreMatcher, loadGitignoreMatcher, } from './gitignore.js';
 export { runIndexer } from './indexer.js';
-export { compileGitignore, loadGitignoreMatcher, type IgnoreMatcher, } from './gitignore.js';
 export { detectLang, INDEXABLE_EXTENSIONS, isIndexablePath } from './languages.js';
 export { internalKindToLspKind, lspKindToInternalKind, } from './lsp-kind.js';
 export type { ProjectIndexServerClientHealth, ProjectIndexServerConnectionState, ProjectIndexServerConnectionStatus, } from './project-server-client.js';
+export { type ProjectIndexDaemonAvailability, resolveProjectIndexDaemonAvailability, } from './project-server-client.js';
+export { projectIndexServerEndpoint, projectIndexServerMetadataPath, } from './project-server-endpoint.js';
 export type { ProjectIndexServerActivity, ProjectIndexServerHealth, } from './project-server-protocol.js';
+export { generateRepoMap, type RepoMapOptions, type RepoMapResult, } from './repo-map.js';
 export type { CallSite, CodeMapGraph, FileMeta, FileSymbols, GraphEdge, GraphNode, IndexResult, IndexStats, SearchResult, Symbol, SymbolKind, SymbolLang, } from './schema.js';
-export { projectIndexServerEndpoint, projectIndexServerMetadataPath, } from './project-server-endpoint.js';
 export { SCHEMA_VERSION } from './schema.js';
+export { extractDirectorySkeleton, extractFileSkeleton, type FileSkeletonResult, type SkeletonOptions, type SkeletonSymbolRange, } from './skeleton-extractor.js';
 export { codebaseIndexDirOverride, IndexStore, resolveIndexDir } from './writer.js';
-export { PolyglotInvariantEngine, polyglotInvariantEngine, type InvariantEvaluationResult, type InvariantRuleId, type InvariantViolation, type ModuleContract, } from './ast-invariant-engine.js';
+export { type AtlasBrief, type AtlasBriefHub, type AtlasBriefIndexMissing, type AtlasBriefPackage, type AtlasBriefSubsystem, BRIEF_HUB_LIMIT, BRIEF_PACKAGE_LIMIT, BRIEF_SUBSYSTEM_LIMIT, buildAtlasBrief, buildProjectAtlasBrief, } from './atlas-brief.js';
+export { type AtlasExportOptions, EXPORT_FILE_LIMIT, EXPORT_PACKAGE_LIMIT, renderAtlasHtml, } from './atlas-export.js';
+export { ATLAS_DIR, ATLAS_FILE_LIMIT, ATLAS_JSON, ATLAS_MANIFEST, ATLAS_MARKDOWN, ATLAS_SCHEMA, type AtlasDocument, type AtlasEdge, type AtlasFile, type AtlasFreshness, type AtlasIndexMissing, type AtlasManifest, type AtlasPackage, type AtlasProjection, type AtlasSymbol, buildAtlas, checkAtlasFreshness, checkProjectAtlasFreshness, exportProjectAtlasHtml, MAX_REPORTED_DRIFT, type WrittenAtlas, writeAtlas, writeProjectAtlas, } from './atlas-projection.js';
+export { type CodebaseContextInput, type CodebaseContextOutput, codebaseContextTool, setContextQueryEmbedder, } from './codebase-context-tool.js';
+export { type ConceptIndexMissing, DEFAULT_CONCURRENCY, type EnrichOptions, type EnrichResult, enrichConcepts, enrichProjectConcepts, MAX_CRUX_LINES, MAX_SOURCE_CHARS, MAX_SUMMARY_CHARS, type SummarizeFileInput, type SummarizeFileResult, type SummarizerPort, type SummarizeSubsystemInput, type SummarizeSubsystemResult, } from './concept-enrichment.js';
+export { type ContextEntry, type ContextOptions, type ContextResult, type ContextSymbol, DEFAULT_LIMIT, DEFAULT_SYMBOLS_PER_FILE, retrieveContext, SEED_LIMIT, } from './context-retrieval.js';
+export { DEFAULT_BATCH_SIZE, type EmbeddingPort, type EmbedIndexMissing, type EmbedOptions, type EmbedResult, embedFiles, embedProjectFiles, MAX_EMBED_CHARS, } from './embedding-pass.js';
+export { clearWiringSnapshot, getWiringSnapshot, type WiringSnapshot, } from './graph-adjacency-cache.js';
+export { aggregateFileRank, buildWiringGraph, CONTRADICTED_VISIBILITY_WEIGHT, DEFAULT_ITERATIONS, DEFAULT_RESTART, type FileRankRow, type PageRankOptions, pageRank, type ResolvedRefEdge, type SymbolRankRow, toSymbolRankRows, UNVERIFIED_VISIBILITY_WEIGHT, type WiringGraph, type WiringGraphOptions, } from './graph-rank.js';
+export { RANK_REFRESH_FILE_THRESHOLD, RANK_VERSION, RANK_VERSION_KEY, type RankPassResult, runGraphRankPass, shouldRefreshRanks, } from './graph-rank-pass.js';
+export { CONCEPT_RELATIONS, type ConceptCoverage, type ConceptEdge, type ConceptRelation, type ConceptState, type FileConcept, isConceptRelation, type Subsystem, } from './writer-concepts.js';
+export { decorateGraphNodes } from './writer-graph-decorate.js';
+export type { RankedFileRow } from './writer-rank.js';
+export { FILE_VECTOR_PROVIDER_KEY, type FileVectorRow, type FileVectorState, type VectorHit, } from './writer-vectors.js';
 //# sourceMappingURL=index.d.ts.map