@colbymchenry/codegraph 0.9.7 → 0.9.9

package/dist/mcp/tools.d.ts

@@ -0,0 +1,413 @@
+/**
+ * MCP Tool Definitions
+ *
+ * Defines the tools exposed by the CodeGraph MCP server.
+ */
+import type CodeGraph from '../index';
+import type { PendingFile } from '../sync';
+/**
+ * Calculate the recommended number of codegraph_explore calls based on project size.
+ * Larger codebases need more exploration calls to cover their surface area,
+ * but smaller ones should use fewer to avoid unnecessary overhead.
+ */
+export declare function getExploreBudget(fileCount: number): number;
+/**
+ * Adaptive output budget for `codegraph_explore`, scaled to project size.
+ *
+ * Smaller codebases get a tighter total cap, fewer default files, smaller
+ * per-file cap, and tighter clustering — so a focused query on a 100-file
+ * project doesn't dump a whole file's worth of source into the agent's
+ * context. Larger codebases keep the generous defaults because the
+ * agent's native discovery cost (grep + find + many Reads) genuinely
+ * dwarfs a fat explore call at that scale.
+ *
+ * Meta-text (relationships map, "additional relevant files" list,
+ * completeness signal, budget note) is gated off for tiny projects
+ * where one rich call is the whole story and the extra prose is just
+ * overhead.
+ *
+ * Tier breakpoints mirror `getExploreBudget` so a project sits in the
+ * same tier across both knobs.
+ */
+export interface ExploreOutputBudget {
+    /** Hard cap on total output characters. */
+    maxOutputChars: number;
+    /** Default `maxFiles` when the caller didn't specify one. */
+    defaultMaxFiles: number;
+    /** Cap on contiguous source returned per file (across all its clusters). */
+    maxCharsPerFile: number;
+    /** Cluster gap threshold in lines — tighter clustering on small projects. */
+    gapThreshold: number;
+    /** Max symbols listed in the per-file header (`#### path — sym(kind), ...`). */
+    maxSymbolsInFileHeader: number;
+    /** Max edges shown per relationship kind in the Relationships section. */
+    maxEdgesPerRelationshipKind: number;
+    /** Include the "Relationships" section. */
+    includeRelationships: boolean;
+    /** Include the "Additional relevant files (not shown)" trailing list. */
+    includeAdditionalFiles: boolean;
+    /** Include the "Complete source code is included above…" reminder. */
+    includeCompletenessSignal: boolean;
+    /** Include the explore-budget reminder at the end. */
+    includeBudgetNote: boolean;
+    /**
+     * Hard-drop test/spec/icon/i18n files from the relevant-file set unless
+     * the query itself mentions tests. Today they're only deprioritized in
+     * the sort, which on tiny repos still lets one slip into the top N (e.g.
+     * cobra's `command_test.go` displaced `args.go` and contributed ~10KB of
+     * pure noise to "How does cobra parse commands?"). Off by default; on
+     * for the very-tiny tier where one slip dominates the budget.
+     */
+    excludeLowValueFiles: boolean;
+}
+export declare function getExploreOutputBudget(fileCount: number): ExploreOutputBudget;
+/**
+ * Per-file staleness banner emitted at the top of a tool response when the
+ * file watcher has pending events for files referenced by the response.
+ * The agent uses this to fall back to Read for those specific files
+ * without waiting for the debounced sync (issue #403).
+ */
+export declare function formatStaleBanner(stale: PendingFile[]): string;
+/**
+ * Compact footer listing pending files that are NOT referenced in this
+ * response. Gives the agent a complete project-wide freshness picture
+ * without bloating the main banner.
+ */
+export declare function formatStaleFooter(stale: PendingFile[]): string;
+/**
+ * MCP Tool definition
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, PropertySchema>;
+        required?: string[];
+    };
+}
+interface PropertySchema {
+    type: string;
+    description: string;
+    enum?: string[];
+    default?: unknown;
+}
+/**
+ * Tool execution result
+ */
+export interface ToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+/**
+ * All CodeGraph MCP tools
+ *
+ * Designed for minimal context usage - use codegraph_explore as the primary tool
+ * (one call usually answers the whole question), and only use other tools for
+ * targeted follow-up queries.
+ *
+ * All tools support cross-project queries via the optional `projectPath` parameter.
+ */
+export declare const tools: ToolDefinition[];
+/**
+ * Allowlist-filtered tool definitions WITHOUT an engine — the static surface the
+ * proxy answers `tools/list` with before any project is open. Mirrors
+ * `ToolHandler.getTools()` in the no-CodeGraph case (the dynamic per-repo budget
+ * note in a description only adds once `cg` is loaded; the schemas are static).
+ */
+export declare function getStaticTools(): ToolDefinition[];
+/**
+ * Tool handler that executes tools against a CodeGraph instance
+ *
+ * Supports cross-project queries via the projectPath parameter.
+ * Other projects are opened on-demand and cached for performance.
+ */
+export declare class ToolHandler {
+    private cg;
+    private projectCache;
+    private defaultProjectHint;
+    private worktreeMismatchCache;
+    private catchUpGate;
+    constructor(cg: CodeGraph | null);
+    /**
+     * Update the default CodeGraph instance (e.g. after lazy initialization)
+     */
+    setDefaultCodeGraph(cg: CodeGraph): void;
+    /**
+     * Engine-only: register the catch-up sync promise so the next `execute()`
+     * call awaits it before serving. The handler swallows rejections (the
+     * engine logs them) so a sync failure never propagates as a tool error;
+     * we still want to serve a best-effort result over the same potentially-
+     * stale data, which is what would have happened without the gate.
+     */
+    setCatchUpGate(p: Promise<void> | null): void;
+    /**
+     * Record the directory the server tried to resolve the default project from.
+     * Used only to make the "no default project" error actionable.
+     */
+    setDefaultProjectHint(searchedPath: string): void;
+    /**
+     * Whether a default CodeGraph instance is available
+     */
+    hasDefaultCodeGraph(): boolean;
+    /**
+     * Optional allowlist of exposed tools, parsed from the CODEGRAPH_MCP_TOOLS
+     * env var (comma-separated short names, e.g. "trace,search,node,context").
+     * Unset/empty → every tool is exposed. Lets an operator (or an A/B harness)
+     * trim the tool surface without rebuilding the client config; the ablated
+     * tool is then truly absent from ListTools rather than merely denied on call.
+     * Matching is on the short form, so "node" and "codegraph_node" both work.
+     */
+    private toolAllowlist;
+    /** Whether a tool name passes the CODEGRAPH_MCP_TOOLS allowlist (if any). */
+    private isToolAllowed;
+    /**
+     * Get tool definitions with dynamic descriptions based on project size.
+     * The codegraph_explore tool description includes a budget recommendation
+     * scaled to the number of indexed files. Honors the CODEGRAPH_MCP_TOOLS
+     * allowlist so a trimmed surface is reflected in ListTools.
+     */
+    getTools(): ToolDefinition[];
+    /**
+     * Get CodeGraph instance for a project
+     *
+     * If projectPath is provided, opens that project's CodeGraph (cached).
+     * Otherwise returns the default CodeGraph instance.
+     *
+     * Walks up parent directories to find the nearest .codegraph/ folder,
+     * similar to how git finds .git/ directories.
+     */
+    private getCodeGraph;
+    /**
+     * Close all cached project connections
+     */
+    closeAll(): void;
+    /**
+     * Validate that a value is a non-empty string within length bounds.
+     *
+     * The `maxLength` cap protects against MCP clients that ship huge
+     * payloads (10MB+ query strings either by accident or maliciously).
+     * Without this, a single oversized input can pin the FTS5 index or
+     * exhaust memory before any real work runs.
+     */
+    private validateString;
+    /**
+     * Validate an optional path-like string input. Returns the value if
+     * valid (or undefined), or a ToolResult with the error.
+     */
+    private validateOptionalPath;
+    /**
+     * Cached git worktree/index mismatch for a tool call's effective project.
+     *
+     * The "effective project" is what the request targets: an explicit
+     * `projectPath` arg, else the directory the server resolved its default
+     * project from (`defaultProjectHint`), else cwd. Memoized per start path —
+     * see `worktreeMismatchCache`. Best-effort: if the project can't be resolved
+     * (e.g. nothing initialized yet), it reports "no mismatch" so a tool is never
+     * broken by this check.
+     */
+    private worktreeMismatchFor;
+    /**
+     * Prefix a successful read-tool result with a compact worktree-mismatch
+     * notice when the resolved index belongs to a different git working tree than
+     * the caller's (issue #155). Without this, an agent in a nested worktree
+     * silently trusts main-branch results. No-op on error results and when there
+     * is no mismatch. `codegraph_status` is excluded — it embeds its own verbose
+     * warning — so it stays out of this path.
+     */
+    private withWorktreeNotice;
+    /**
+     * Annotate a successful read-tool result with per-file staleness — the
+     * non-blocking answer to issue #403. The file watcher tracks every event
+     * it sees per path; here we intersect "files referenced in this response"
+     * against that pending set and prepend a compact banner so the agent can
+     * fall back to Read for those *specific* files without waiting for the
+     * debounced sync to fire. Other pending files in the project (not
+     * referenced by this response) get a small footer so the agent has a
+     * complete picture without bloating the banner.
+     *
+     * Cost when nothing is pending — the common case — is one boolean check.
+     * No I/O, no parsing of markdown beyond a per-pending-file substring scan.
+     */
+    private withStalenessNotice;
+    /**
+     * Execute a tool by name
+     */
+    execute(toolName: string, args: Record<string, unknown>): Promise<ToolResult>;
+    /**
+     * Handle codegraph_search
+     */
+    private handleSearch;
+    /**
+     * Handle codegraph_callers
+     */
+    private handleCallers;
+    /**
+     * Handle codegraph_callees
+     */
+    private handleCallees;
+    /**
+     * Handle codegraph_impact
+     */
+    private handleImpact;
+    /**
+     * Describe a synthesized (dynamic-dispatch) edge for human output: how the
+     * callback was wired up — the bridge static parsing can't see. Returns null
+     * for ordinary static edges. Used by trace + the node trail so a synthesized
+     * hop reads as "registered via onUpdate at App.tsx:3148", not a bare arrow.
+     */
+    private synthEdgeNote;
+    /**
+     * Flow-from-named-symbols: an agent's codegraph_explore query is a bag of
+     * symbol names that usually spans the flow it's investigating (e.g.
+     * "PmsProductController getList PmsProductService list PmsProductServiceImpl").
+     * Surface the longest call chain AMONG those named symbols — scoped to what the
+     * agent explicitly named, so (unlike a fuzzy relevance set) there's no
+     * wrong-feature wandering. Rides synthesized edges, so controller→service-
+     * interface→impl shows up. Returns '' if no chain of >=3 nodes exists.
+     *
+     * Ambiguous tokens (Java `list` → dozens of nodes) are disambiguated by
+     * CO-NAMING: the agent names the class too, so we keep only `list` candidates
+     * whose qualifiedName contains another named token (`PmsProductServiceImpl::list`),
+     * dropping unrelated `OmsOrderService::list`.
+     */
+    private buildFlowFromNamedSymbols;
+    /**
+     * Compact "blast radius" for the entry symbols of an explore result: who
+     * depends on each (callers) and which test files cover it — LOCATIONS ONLY,
+     * no source, so the agent knows what to update / re-verify before editing
+     * without reaching for a separate impact call. Always-on, but skips symbols
+     * that have no dependents (nothing to warn about), and returns '' when none
+     * qualify so a leaf-only exploration stays clean.
+     */
+    private buildBlastRadiusSection;
+    /**
+     * Graph-connectivity relevance via Random-Walk-with-Restart (personalized
+     * PageRank) from the query's matched SEED nodes over the call/reference graph.
+     *
+     * This is the ranking signal text search (FTS/bm25) CANNOT provide, and it's
+     * codegraph's home turf: relevance by STRUCTURE, not words. A file whose
+     * symbols are call-connected to the matched cluster accrues walk mass and
+     * ranks high; a lone TEXT match — e.g. `LensSwitcher.swift` matched the word
+     * "switch" from `switchOrganization`, but calls none of `setUser`/`fetchUser`
+     * — gets only its own restart probability and ranks ~0. Immune to the
+     * tokenization trap that fools term matching, deterministic, no embeddings.
+     *
+     * Undirected adjacency (reachability both ways), restart α=0.25 to the seeds,
+     * power iteration to convergence. Bounded to the already-relevant subgraph, so
+     * it's a few hundred nodes × ~25 iterations — negligible cost.
+     */
+    private computeGraphRelevance;
+    /**
+     * Handle codegraph_explore — deep exploration in a single call
+     *
+     * Strategy: find relevant symbols via graph traversal, group by file,
+     * then read contiguous file sections covering all symbols per file.
+     * This replaces multiple codegraph_node + Read calls.
+     *
+     * Output size is adaptive to project file count via
+     * `getExploreOutputBudget` — see #185 for why a fixed 35k cap was a
+     * tax on small projects while earning its keep on large ones.
+     */
+    private handleExplore;
+    /**
+     * Handle codegraph_node
+     */
+    private handleNode;
+    /** Render one symbol: details + (optional) body/outline + its caller/callee trail. */
+    private renderNodeSection;
+    /**
+     * Build the "trail" for a symbol: its direct callees (what it calls) and
+     * callers (what calls it), each with file:line — so codegraph_node doubles as
+     * the structural Grep→Read→expand primitive: a spot PLUS where to go next.
+     * Capped to stay cheap. Walk the graph by calling codegraph_node on a trail
+     * entry; no Read needed for covered hops. Empty edges on a non-leaf often mean
+     * dynamic dispatch the static graph couldn't resolve — that absence is itself
+     * a signal (read that one hop) rather than a dead end.
+     */
+    private formatTrail;
+    /**
+     * Handle codegraph_status
+     */
+    private handleStatus;
+    /**
+     * Handle codegraph_files - get project file structure from the index
+     */
+    private handleFiles;
+    /**
+     * Convert glob pattern to regex
+     */
+    private globToRegex;
+    /**
+     * Format files as a flat list
+     */
+    private formatFilesFlat;
+    /**
+     * Format files grouped by language
+     */
+    private formatFilesGrouped;
+    /**
+     * Format files as a tree structure
+     */
+    private formatFilesTree;
+    /**
+     * Find a symbol by name, handling disambiguation when multiple matches exist.
+     * Returns the best match and a note about alternatives if any.
+     */
+    /**
+     * Check if a node matches a symbol query.
+     *
+     * Accepts simple names (`run`) and three flavors of qualifier:
+     *   - dotted     `Session.request`         (TS/JS/Python)
+     *   - colon-pair `stage_apply::run`        (Rust, C++, Ruby)
+     *   - slash      `configurator/stage_apply` (path-ish)
+     *
+     * Multi-level qualifiers compose: `crate::configurator::stage_apply::run`
+     * works. Rust path prefixes (`crate`, `super`, `self`) are stripped so
+     * the canonical `crate::module::symbol` form resolves.
+     *
+     * Resolution order, last part must always equal `node.name`:
+     *   1. Suffix-match against `qualifiedName` (handles class-scoped methods
+     *      where the extractor builds the qualified name from the AST stack)
+     *   2. File-path containment (handles file-derived modules in Rust/
+     *      Python — `stage_apply::run` matches a `run` in `stage_apply.rs`)
+     */
+    private matchesSymbol;
+    /**
+     * Find ALL definitions matching a name, ranked, so codegraph_node can return
+     * every overload instead of guessing one (the wrong guess → a Read). Keepers
+     * rank before generated stubs (.pb.go etc.); stable within a group preserves
+     * FTS order. Returns [] when nothing matches; a qualified lookup that finds no
+     * exact match returns [] rather than a misleading fuzzy file hit (#173); a
+     * bare name with no exact match falls back to the single top fuzzy result.
+     */
+    private findSymbolMatches;
+    /**
+     * Find ALL symbols matching a name. Used by callers/callees/impact to aggregate
+     * results across all matching symbols (e.g., multiple classes with an `execute` method).
+     */
+    private findAllSymbols;
+    /**
+     * Truncate output if it exceeds the maximum length
+     */
+    private truncateOutput;
+    private formatSearchResults;
+    private formatNodeList;
+    private formatImpact;
+    /**
+     * Build a compact structural outline of a container symbol from its
+     * indexed children (methods, fields, properties, …) — name, kind,
+     * line number, and signature — so the agent gets the shape of a class
+     * without the full source of every method. Returns '' when the container
+     * has no indexed children, so the caller can fall back to full source.
+     */
+    private buildContainerOutline;
+    private formatNodeDetails;
+    private textResult;
+    private errorResult;
+}
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/mcp/transport.d.ts

@@ -0,0 +1,188 @@
+/**
+ * MCP JSON-RPC Transports
+ *
+ * Two flavors share the same wire format (newline-delimited JSON-RPC 2.0):
+ *
+ * - `StdioTransport` — original transport; reads/writes the process's
+ *   stdin/stdout. Used by direct-mode MCP servers.
+ * - `SocketTransport` — wraps a single `net.Socket`. Used by the shared-daemon
+ *   architecture (see {@link ./daemon}) to multiplex multiple MCP clients onto
+ *   one CodeGraph instance via per-connection sessions.
+ *
+ * Both implement {@link JsonRpcTransport} so the session-level protocol logic
+ * (initialize / tools/list / tools/call, plus server-initiated `roots/list`)
+ * is identical regardless of where the bytes come from.
+ */
+import type { Socket } from 'net';
+/**
+ * JSON-RPC 2.0 Request
+ */
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params?: unknown;
+}
+/**
+ * JSON-RPC 2.0 Response
+ */
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+/**
+ * JSON-RPC 2.0 Error
+ */
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/**
+ * JSON-RPC 2.0 Notification (no id, no response expected)
+ */
+export interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+export declare const ErrorCodes: {
+    readonly ParseError: -32700;
+    readonly InvalidRequest: -32600;
+    readonly MethodNotFound: -32601;
+    readonly InvalidParams: -32602;
+    readonly InternalError: -32603;
+};
+export type MessageHandler = (message: JsonRpcRequest | JsonRpcNotification) => Promise<void>;
+/**
+ * Generic JSON-RPC transport interface — common surface for stdio and socket
+ * carriers. Anything below the session layer (initialize, tool dispatch, etc.)
+ * talks to this, not to a concrete transport class.
+ */
+export interface JsonRpcTransport {
+    start(handler: MessageHandler): void;
+    stop(): void;
+    send(response: JsonRpcResponse): void;
+    notify(method: string, params?: unknown): void;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    sendResult(id: string | number, result: unknown): void;
+    sendError(id: string | number | null, code: number, message: string, data?: unknown): void;
+}
+/**
+ * Shared implementation of newline-delimited JSON-RPC 2.0 over any
+ * `Readable`/`Writable` stream pair. Stdio and socket transports both wrap
+ * this — the only difference between them is which streams get plugged in
+ * and how a "close" propagates back to the owning code.
+ */
+declare abstract class LineBasedJsonRpcTransport implements JsonRpcTransport {
+    protected messageHandler: MessageHandler | null;
+    protected pending: Map<string | number, {
+        resolve: (value: unknown) => void;
+        reject: (error: Error) => void;
+    }>;
+    protected nextRequestId: number;
+    protected stopped: boolean;
+    abstract start(handler: MessageHandler): void;
+    protected abstract write(line: string): void;
+    protected abstract idPrefix(): string;
+    abstract stop(): void;
+    /**
+     * Send a server-initiated request to the client and await its response.
+     *
+     * MCP is bidirectional: the server can ask the client questions too. We use
+     * this for `roots/list` — the spec-blessed way to learn the workspace root
+     * when the client didn't pass one in `initialize` (see issue #196). Rejects
+     * on timeout so callers can fall back rather than hang forever.
+     */
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    send(response: JsonRpcResponse): void;
+    notify(method: string, params?: unknown): void;
+    sendResult(id: string | number, result: unknown): void;
+    sendError(id: string | number | null, code: number, message: string, data?: unknown): void;
+    /**
+     * Fail any in-flight server-initiated requests so their awaiters don't hang.
+     * Called from `stop()` in subclasses.
+     */
+    protected rejectPending(reason: string): void;
+    /**
+     * Handle an incoming line of JSON. Both transports feed lines here.
+     */
+    protected handleLine(line: string): Promise<void>;
+    /**
+     * Resolve (or reject) the pending server-initiated request matching this
+     * response's id. Unknown ids are ignored — the client may echo something we
+     * never sent, or a request may have already timed out.
+     */
+    private handleResponse;
+    /**
+     * Check if message is a valid JSON-RPC 2.0 message
+     */
+    private isValidMessage;
+}
+export interface StdioTransportOptions {
+    /**
+     * If true, the transport calls `process.exit(0)` when stdin closes. Set to
+     * `false` in shared-daemon mode where the stdio "session" is just *one* of
+     * many clients — losing it shouldn't drag the daemon down. The default
+     * (true) matches the original single-process behavior callers rely on.
+     */
+    exitOnClose?: boolean;
+    /**
+     * Optional callback fired when the stdin stream closes. The daemon uses
+     * this to decrement its connected-clients refcount.
+     */
+    onClose?: () => void;
+}
+/**
+ * Stdio Transport for MCP
+ *
+ * Reads JSON-RPC messages from stdin and writes responses to stdout. Used by
+ * the direct (single-process) MCP server path, where the MCP host launches
+ * one server per session and talks to it over the child's stdio. Also used by
+ * shared-daemon mode for the launcher's session (with `exitOnClose: false`)
+ * so the daemon outlives its launcher.
+ */
+export declare class StdioTransport extends LineBasedJsonRpcTransport {
+    private rl;
+    private opts;
+    constructor(opts?: StdioTransportOptions);
+    start(handler: MessageHandler): void;
+    stop(): void;
+    protected write(line: string): void;
+    protected idPrefix(): string;
+}
+/**
+ * Socket Transport for MCP daemon sessions.
+ *
+ * Wraps a single `net.Socket` (Unix domain socket on POSIX, named pipe on
+ * Windows). One instance per connected MCP client. Unlike {@link StdioTransport},
+ * `stop()` and stream-close *don't* call `process.exit` — a daemon-side session
+ * ending must not bring down the whole daemon.
+ */
+export declare class SocketTransport extends LineBasedJsonRpcTransport {
+    private socket;
+    private prefix;
+    private buffer;
+    private closeHandlers;
+    constructor(socket: Socket, prefix?: string);
+    /**
+     * Register a callback fired exactly once when the socket closes (from either
+     * side). Used by the daemon to decrement its connected-clients refcount.
+     */
+    onClose(handler: () => void): void;
+    start(handler: MessageHandler): void;
+    stop(): void;
+    /**
+     * Write a one-shot line directly to the socket (no JSON-RPC framing applied
+     * by this class — caller produces the line). The daemon uses this for the
+     * hello/handshake line that precedes the JSON-RPC stream.
+     */
+    writeRaw(line: string): void;
+    protected write(line: string): void;
+    protected idPrefix(): string;
+    private handleSocketClose;
+}
+export {};
+//# sourceMappingURL=transport.d.ts.map

package/dist/mcp/version.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Resolved package version, computed once at module load.
+ *
+ * The version string is the rendezvous datum between cooperating daemon and
+ * proxy processes: the daemon advertises its version in the hello line, and
+ * the proxy refuses to share IPC across a mismatch (falls back to direct
+ * mode). Keeping the resolution in one place avoids drift between the CLI
+ * `--version` output (which reads `package.json` directly) and the daemon
+ * handshake.
+ *
+ * Resolution strategy: read the bundled `package.json` two levels up from
+ * this file — same relative position whether we're loaded from `src/mcp/` or
+ * the `dist/mcp/` output, since `tsc` preserves the layout. If reading fails
+ * (e.g. the package was unpacked oddly), fall back to "0.0.0-unknown" — a
+ * sentinel that will never match a real version, so the proxy harmlessly
+ * falls back to direct mode.
+ */
+export declare const CodeGraphPackageVersion: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/resolution/callback-synthesizer.d.ts

@@ -0,0 +1,10 @@
+import type { QueryBuilder } from '../db/queries';
+import type { ResolutionContext } from './types';
+/**
+ * Synthesize dispatcher→callback edges (field observers + EventEmitters +
+ * React re-render + JSX children + Vue templates + RN event channel +
+ * Fabric native-impl + MyBatis Java↔XML + Gin middleware chain). Returns the
+ * count added. Never throws into indexing — callers wrap in try/catch.
+ */
+export declare function synthesizeCallbackEdges(queries: QueryBuilder, ctx: ResolutionContext): number;
+//# sourceMappingURL=callback-synthesizer.d.ts.map

package/dist/resolution/frameworks/cargo-workspace.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cargo Workspace Resolver Helper
+ *
+ * Parses a project's root Cargo.toml and member crate manifests to
+ * build a crate-name -> member-directory map. Used by the Rust
+ * resolver to resolve `use crate_name::...` references that point
+ * into workspace member crates.
+ */
+import { ResolutionContext } from '../types';
+/**
+ * Build a map from crate-name aliases to workspace member directory paths.
+ * Example: "mytool-core" and "mytool_core" -> "crates/mytool-core"
+ *
+ * Supports glob members (e.g. `members = ["crates/*"]`) via picomatch
+ * when the context exposes `listDirectories`.
+ */
+export declare function getCargoWorkspaceCrateMap(context: ResolutionContext): Map<string, string>;
+//# sourceMappingURL=cargo-workspace.d.ts.map

package/dist/resolution/frameworks/csharp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * C# Framework Resolver
+ *
+ * Handles ASP.NET Core, ASP.NET MVC, and common C# patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const aspnetResolver: FrameworkResolver;
+//# sourceMappingURL=csharp.d.ts.map