@aroman22/codegraph-vba 1.3.3

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/project-config.d.ts

@@ -0,0 +1,56 @@
+import { Language } from './types';
+/** Filename of the project-scoped config, resolved relative to the project root. */
+export declare const PROJECT_CONFIG_FILENAME = "codegraph.json";
+export interface ProjectConfig {
+    /** Map of custom file extension (`.foo`) to a supported language id. */
+    extensions?: Record<string, string>;
+    /**
+     * Gitignore-style patterns naming gitignored directories whose embedded git
+     * repositories should be indexed anyway — the explicit opt-in to override
+     * `.gitignore` for nested-repo discovery (#622, #699). Absent/empty (the
+     * default) means `.gitignore` is fully respected: gitignored embedded repos
+     * are never discovered or indexed (#970, #976).
+     */
+    includeIgnored?: string[];
+    /**
+     * Gitignore-style patterns for paths to keep OUT of the index — even when
+     * they are git-TRACKED, which `.gitignore` cannot do (#999). The escape hatch
+     * for a committed vendor/theme/SDK directory (e.g. a checked-in Metronic theme
+     * under `static/`) that bloats the graph and slows indexing but isn't really
+     * your code. Matched against project-root-relative paths, so a directory like
+     * `"static/"`, a double-star vendor glob, or `"assets/theme"` all work.
+     * Absent/empty (the default) excludes nothing beyond the built-in defaults
+     * and your `.gitignore`.
+     */
+    exclude?: string[];
+}
+/**
+ * Load the validated extension overrides for a project, mtime-cached.
+ *
+ * Returns a map of `.ext` → supported language id. The result merges on top of
+ * the built-in extension map at the point of use (see `detectLanguage` /
+ * `isSourceFile`), with these user mappings taking precedence. Returns an empty
+ * map when there is no `codegraph.json` (the zero-config default).
+ */
+export declare function loadExtensionOverrides(rootDir: string): Record<string, Language>;
+/**
+ * Load the validated `includeIgnored` patterns for a project, mtime-cached.
+ *
+ * These name gitignored directories whose embedded git repositories should be
+ * indexed despite `.gitignore` (#622, #699). An empty result — the zero-config
+ * default — means `.gitignore` is fully respected: gitignored embedded repos
+ * are never discovered or indexed (#970, #976).
+ */
+export declare function loadIncludeIgnoredPatterns(rootDir: string): string[];
+/**
+ * Load the validated `exclude` patterns for a project, mtime-cached.
+ *
+ * These name paths to keep OUT of the index even when git-tracked — the escape
+ * hatch for a committed vendor/theme/SDK directory `.gitignore` can't drop
+ * (#999). An empty result — the zero-config default — excludes nothing beyond
+ * the built-in defaults and the project's `.gitignore`.
+ */
+export declare function loadExcludePatterns(rootDir: string): string[];
+/** Test/maintenance hook: forget cached config (e.g. after rewriting it in a test). */
+export declare function clearProjectConfigCache(): void;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/reasoning/config.d.ts

@@ -0,0 +1,45 @@
+/** Managed tier ("CodeGraph AI") — the metered gateway used when logged in. */
+export declare const MANAGED_DEFAULT_URL = "https://ai.getcodegraph.com/v1";
+/** The gateway's public model id (it translates this to the upstream provider id). */
+export declare const MANAGED_DEFAULT_MODEL = "openai/gpt-oss-120b";
+export interface OffloadConfig {
+    /** Managed tier: route through CodeGraph AI (metered) with the logged-in org token. */
+    managed?: boolean;
+    /** OpenAI-compatible base URL ending in `/v1` (e.g. https://api.cerebras.ai/v1). */
+    url?: string;
+    /** Model id to request (default `gpt-oss-120b` BYO, `openai/gpt-oss-120b` managed). */
+    model?: string;
+    /** Name of the env var holding the provider API key (never persisted). BYO only. */
+    keyEnv?: string;
+    /** reasoning_effort: low | medium | high (default `low`). */
+    effort?: string;
+    /** Output style: plain | report (default `plain`). */
+    style?: string;
+}
+export interface ResolvedOffload {
+    /** True when the offload is usable (endpoint present; for managed, a token too). */
+    enabled: boolean;
+    /** Managed tier (CodeGraph AI, metered) vs BYO endpoint. */
+    managed: boolean;
+    url?: string;
+    model: string;
+    /** Resolved API key / org token (from env, the configured `keyEnv`, or login), if any. */
+    apiKey?: string;
+    /** Where the key/token came from (for `status` display) — never the secret itself. */
+    keySource?: string;
+    effort: string;
+    style: string;
+    timeoutMs: number;
+    maxTokens: number;
+    strip: boolean;
+    debug: boolean;
+    /** Where the endpoint came from — drives `codegraph offload status`. */
+    origin: 'env' | 'config' | 'none';
+}
+/** The persisted offload block (empty object if none). */
+export declare function readOffloadConfig(): OffloadConfig;
+/** Persist (or, with `null`, clear) the offload block, leaving other config keys intact. */
+export declare function writeOffloadConfig(offload: OffloadConfig | null): void;
+/** Merge the persisted config with `CODEGRAPH_OFFLOAD_*` env overrides (env wins). */
+export declare function resolveOffload(env?: NodeJS.ProcessEnv): ResolvedOffload;
+//# sourceMappingURL=config.d.ts.map

package/dist/reasoning/credentials.d.ts

@@ -0,0 +1,5 @@
+/** The stored managed-offload org token, if the machine is logged in. */
+export declare function readOffloadToken(): string | undefined;
+/** Persist (or, with `null`, clear) the managed-offload org token at `0600`. */
+export declare function writeOffloadToken(token: string | null): void;
+//# sourceMappingURL=credentials.d.ts.map

package/dist/reasoning/login.d.ts

@@ -0,0 +1,21 @@
+/** Dashboard base for the device-login endpoints; override for testing via CODEGRAPH_LOGIN_URL. */
+export declare function loginBaseUrl(): string;
+/** The dashboard's response to a device-authorization start request. */
+export interface DeviceStart {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    /** Same URL with the code prefilled, for one-click open. */
+    verification_uri_complete?: string;
+    /** Seconds the CLI should wait between polls. */
+    interval?: number;
+    /** Seconds until the request expires. */
+    expires_in?: number;
+}
+/** Begin a device-authorization request. */
+export declare function startDeviceLogin(): Promise<DeviceStart>;
+/** Poll until the user approves in the browser; resolves with the org token. */
+export declare function pollForToken(deviceCode: string, intervalSec: number, expiresInSec: number): Promise<string>;
+/** Best-effort: open a URL in the default browser. Never throws — the URL is also printed. */
+export declare function openBrowser(url: string): Promise<void>;
+//# sourceMappingURL=login.d.ts.map

package/dist/reasoning/reasoner.d.ts

@@ -0,0 +1,43 @@
+interface SynthArgs {
+    query: string;
+    context: string;
+}
+/** True when a reasoning offload endpoint is configured (env or `~/.codegraph/config.json`). */
+export declare function isOffloadEnabled(): boolean;
+export interface OffloadUsage {
+    plan?: string;
+    allowance?: number;
+    used?: number;
+    overage?: number;
+    remaining?: number;
+    periodEnd?: number;
+    unlimited?: boolean;
+    banned?: boolean;
+    tokensLast30?: number;
+    callsLast30?: number;
+    creditsLast30?: number;
+    models?: string[];
+}
+/**
+ * GET `/v1/usage` from the configured (managed) endpoint → the org's credit
+ * balance/usage, or null on any failure. Drives `codegraph offload status`.
+ */
+export declare function fetchUsage(): Promise<OffloadUsage | null>;
+/**
+ * Strip sections of the explore output addressed to the AGENT (not useful to a
+ * reasoning model): the "Not shown above" pointer list, the completeness signal,
+ * the explore-budget note, the trimmed/truncation notices, and the redundant
+ * "## Exploration:/Found N symbols" header (the query is sent separately). Left
+ * in, some models regurgitate them ("We have 2 explore calls. Let's explore…")
+ * and they add noise. Source code, blast radius, relationships, and flow stay.
+ * Opt-in (`CODEGRAPH_OFFLOAD_STRIP=1`) — default off (it also removes the "Not
+ * shown above" pointers, which can be useful navigation).
+ */
+export declare function stripAgentDirectives(context: string): string;
+/**
+ * Offload reasoning over the retrieved `context` to the configured model and
+ * return its synthesized answer, or null to signal "fall back to local source".
+ */
+export declare function synthesizeOffload({ query, context }: SynthArgs): Promise<string | null>;
+export {};
+//# sourceMappingURL=reasoner.d.ts.map

package/dist/resolution/c-fnptr-synthesizer.d.ts

@@ -0,0 +1,5 @@
+import type { Edge } from '../types';
+import type { QueryBuilder } from '../db/queries';
+import type { ResolutionContext } from './types';
+export declare function cFnPointerDispatchEdges(queries: QueryBuilder, ctx: ResolutionContext): Edge[];
+//# sourceMappingURL=c-fnptr-synthesizer.d.ts.map

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

@@ -0,0 +1,15 @@
+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 + SvelteKit load + RN event
+ * channel + Fabric native-impl + MyBatis Java↔XML + Gin middleware chain +
+ * Redux-thunk dispatch chain + object-literal registry dispatch + RTK Query
+ * generated-hook → endpoint + Pinia useStore().action() + Vuex string dispatch +
+ * Celery task .delay()/.apply_async() → task body + Spring publishEvent → @EventListener +
+ * MediatR Send/Publish → IRequestHandler/INotificationHandler +
+ * Sidekiq Worker.perform_async → #perform + Laravel event(new X) → listener handle).
+ * 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/astro.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Astro Framework Resolver
+ *
+ * Handles Astro component references, the `Astro` global, `astro:*` virtual
+ * module imports, and Astro's `src/pages/` file-based routing.
+ */
+import { FrameworkResolver } from '../types';
+export declare const astroResolver: FrameworkResolver;
+//# sourceMappingURL=astro.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

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

@@ -0,0 +1,51 @@
+/**
+ * Drupal Framework Resolver
+ *
+ * Supports Drupal 8/9/10/11 (Composer-based projects). Drupal 7 is not supported.
+ *
+ * ## What this resolver does
+ *
+ * 1. **Detection** — reads composer.json and checks for any `drupal/*` dependency in
+ *    `require` or `require-dev`.
+ *
+ * 2. **Route extraction** — parses `*.routing.yml` files and emits `route` nodes for each
+ *    Drupal route, with `references` edges to the `_controller`, `_form`, or entity handler
+ *    class/method.
+ *
+ * 3. **Hook detection** — scans `.module`, `.install`, `.theme`, and `.inc` files for Drupal
+ *    hook implementations. Two strategies are used:
+ *      a. Docblock: `@Implements hook_X()` → precise, no false positives.
+ *      b. Name pattern: function `{moduleName}_{hookSuffix}()` → catches hooks without
+ *         docblocks but may produce false positives on helper functions.
+ *    Detected hooks emit an `UnresolvedRef` from the implementing function node to the
+ *    canonical `hook_X` name, linking implementations to the hook when `codegraph_callers`
+ *    is invoked.
+ *
+ * ## Design decisions (review in future iterations)
+ *
+ * - Hook graph resolution (v1): hook references are stored as UnresolvedRef pointing to the
+ *   canonical `hook_X` name. If Drupal core is indexed, these will resolve to core hook
+ *   definitions. Without core, they remain unresolved but are still searchable via
+ *   `codegraph_search("form_alter")`. Full hook-node creation (virtual nodes for every hook)
+ *   is deferred to a future iteration.
+ *
+ * - Services / plugins (out of scope for v1): `*.services.yml` service definitions and plugin
+ *   annotations (`@Block`, `@FormElement`, etc.) are not extracted. Add a TODO below when
+ *   ready to implement.
+ *
+ * - Twig templates (out of scope for v1): `.twig` files are tracked as file nodes but no
+ *   symbol extraction is performed (no tree-sitter Twig grammar). Implement when a Twig
+ *   grammar WASM is available.
+ *
+ * ## TODOs for future iterations
+ *
+ * - TODO: Extract service definitions from `*.services.yml` files (class → service-id edges).
+ * - TODO: Extract plugin annotations (`@Block`, `@FormElement`, `@Field`, etc.) from PHP
+ *   docblocks and emit plugin nodes with references to the annotated class.
+ * - TODO: Add Twig symbol extraction when a tree-sitter Twig grammar becomes available.
+ * - TODO: Improve hook resolution: create virtual `hook_*` nodes so `codegraph_callers`
+ *   returns all implementations even when Drupal core is not indexed.
+ */
+import { FrameworkResolver } from '../types';
+export declare const drupalResolver: FrameworkResolver;
+//# sourceMappingURL=drupal.d.ts.map

package/dist/resolution/frameworks/expo-modules.d.ts

@@ -0,0 +1,3 @@
+import { FrameworkResolver } from '../types';
+export declare const expoModulesResolver: FrameworkResolver;
+//# sourceMappingURL=expo-modules.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Express/Node.js Framework Resolver
+ *
+ * Handles Express and general Node.js patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const expressResolver: FrameworkResolver;
+//# sourceMappingURL=express.d.ts.map

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

@@ -0,0 +1,3 @@
+import { FrameworkResolver } from '../types';
+export declare const fabricViewResolver: FrameworkResolver;
+//# sourceMappingURL=fabric.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Go Framework Resolver
+ *
+ * Handles Gin, Echo, Fiber, Chi, and standard library patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const goResolver: FrameworkResolver;
+//# sourceMappingURL=go.d.ts.map

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

@@ -0,0 +1,41 @@
+/**
+ * GoFrame Framework Resolver (route metadata) — issue #747.
+ *
+ * GoFrame's "standard router" binds routes reflectively, so there is no literal
+ * path string at a `.GET("/x", handler)` call site and no static edge from a
+ * route to the controller method that serves it. The structural facts live in
+ * two places, joined only at runtime by GoFrame:
+ *
+ *   // api/user/v1/user_sign_in.go — the route lives in a struct tag on the request type
+ *   type SignInReq struct {
+ *       g.Meta `path:"/user/sign-in" method:"post" tags:"UserService" summary:"…"`
+ *       …
+ *   }
+ *   // internal/controller/user/user_v1_sign_in.go — the handler takes *that* request type
+ *   func (c *ControllerV1) SignIn(ctx context.Context, req *v1.SignInReq) (res *v1.SignInRes, err error)
+ *   // internal/cmd/cmd.go — reflective binding (no path, no handler name)
+ *   group.Bind(user.NewV1())
+ *
+ * This resolver handles the FIRST half: it reads the `g.Meta` struct tag on a
+ * request type into a `route` node (`POST /user/sign-in`). The route → handler
+ * EDGE is the genuinely reflective part — the method name is NOT derivable from
+ * the request type (`DeptSearchReq` is served by `List`, `DeptAddReq` by `Add`),
+ * so the only reliable join is the request type appearing in the method's
+ * parameter signature. That whole-graph join is done by the companion
+ * `goframeRouteEdges` synthesizer, which reads the request type back out of the
+ * route node's qualifiedName.
+ *
+ * Honesty note: the route node carries the `g.Meta` path verbatim. The group
+ * prefix from `s.Group("/api", …)` / nested `group.Group("/v1", …)` is applied
+ * by reflective `Bind` at runtime and is deliberately NOT reconstructed here —
+ * the discriminating, structural part is the per-route path + method.
+ */
+import { FrameworkResolver } from '../types';
+/** Marker embedded in a route node's qualifiedName so the synthesizer can read
+ *  back the request type to join on. The value after it is the package-qualified
+ *  request type (`cash.ListReq`) — the package disambiguates the many identical
+ *  bare names (`ListReq`, `GetReq`) a large app defines, one per module. Falls
+ *  back to the bare type when no `package` declaration is found. */
+export declare const GOFRAME_ROUTE_MARKER = "::goframe-route:";
+export declare const goframeResolver: FrameworkResolver;
+//# sourceMappingURL=goframe.d.ts.map

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

@@ -0,0 +1,50 @@
+/**
+ * Framework Resolver Registry
+ *
+ * Manages framework-specific resolvers.
+ */
+import { FrameworkResolver, ResolutionContext } from '../types';
+import type { Language } from '../../types';
+/**
+ * Get all framework resolvers
+ */
+export declare function getAllFrameworkResolvers(): FrameworkResolver[];
+/**
+ * Get a resolver by name
+ */
+export declare function getFrameworkResolver(name: string): FrameworkResolver | undefined;
+/**
+ * Detect which frameworks are used in a project
+ */
+export declare function detectFrameworks(context: ResolutionContext): FrameworkResolver[];
+/**
+ * Filter a list of detected frameworks down to ones that apply to a given language.
+ * Frameworks without an explicit `languages` list are treated as universal.
+ */
+export declare function getApplicableFrameworks(detected: FrameworkResolver[], language: Language): FrameworkResolver[];
+/**
+ * Register a custom framework resolver
+ */
+export declare function registerFrameworkResolver(resolver: FrameworkResolver): void;
+export { drupalResolver } from './drupal';
+export { laravelResolver, FACADE_MAPPINGS } from './laravel';
+export { expressResolver } from './express';
+export { nestjsResolver } from './nestjs';
+export { reactResolver } from './react';
+export { svelteResolver } from './svelte';
+export { vueResolver } from './vue';
+export { astroResolver } from './astro';
+export { djangoResolver, flaskResolver, fastapiResolver } from './python';
+export { railsResolver } from './ruby';
+export { springResolver } from './java';
+export { playResolver } from './play';
+export { goResolver } from './go';
+export { goframeResolver } from './goframe';
+export { rustResolver } from './rust';
+export { aspnetResolver } from './csharp';
+export { swiftUIResolver, uikitResolver, vaporResolver } from './swift';
+export { swiftObjcBridgeResolver } from './swift-objc';
+export { reactNativeBridgeResolver } from './react-native';
+export { expoModulesResolver } from './expo-modules';
+export { fabricViewResolver } from './fabric';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * Java Framework Resolver
+ *
+ * Handles Spring Boot and general Java patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const springResolver: FrameworkResolver;
+//# sourceMappingURL=java.d.ts.map

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

@@ -0,0 +1,13 @@
+/**
+ * Laravel Framework Resolver
+ *
+ * Handles Laravel-specific patterns for reference resolution.
+ */
+import { FrameworkResolver } from '../types';
+/**
+ * Laravel facade mappings to underlying classes
+ * Exported for potential use in facade resolution
+ */
+export declare const FACADE_MAPPINGS: Record<string, string>;
+export declare const laravelResolver: FrameworkResolver;
+//# sourceMappingURL=laravel.d.ts.map