@omfalos/mokosh 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1135 @@
+/** Tag applier strategy interface — one implementation per testing framework. */
+type TagFramework = "vitest" | "playwright" | "cypress" | "jest";
+
+/**
+ * @description Top-level configuration for mokosh. All fields are optional; unset fields
+ *   fall back to built-in defaults. Load this object via `loadMokoshConfig`, then activate
+ *   it with `applyConfig` before calling `createImportMap`.
+ */
+interface MokoshConfig {
+    /** Additional directories to skip when scanning (merged with built-in defaults). */
+    ignoreDirs?: string[];
+    /** Additional file extensions to scan (merged with built-in defaults). */
+    extensions?: string[];
+    /** Override the default cache path (`mokosh-cache/graph.json`). */
+    cachePath?: string;
+    /** Default entry points used when none are provided on the CLI. */
+    entryPoints?: string[];
+    /** Additional basename substrings that mark a file as `"config"` category. */
+    configMatchers?: string[];
+    /** Additional basename substrings that mark a file as `"test"` category (e.g. `".unit."`). */
+    testPatterns?: string[];
+    /** Additional import specifiers that indicate a test file (e.g. `"@my-org/test-utils"`). */
+    testLibraries?: string[];
+    /** Ratio of export-statements to total statements required for `"barrel"` classification. Default: `0.8`. */
+    barrelThreshold?: number;
+    /** When true, enriches each node with `commitCount90d` and `lastAuthor` via git log. Only fetched for new/modified files. */
+    gitStats?: boolean;
+    /**
+     * Tag-applier configuration for `--apply-tags`. Controls which format is written into
+     * test files. Defaults to `{ framework: "vitest" }` when unset.
+     */
+    tagApplier?: {
+        /**
+         * Fallback test framework whose tag format to use for TS/JS files. Each file's actual
+         * framework is auto-detected from its imports (`@playwright/test`, `cypress`,
+         * `@jest/globals`, `vitest`), so a single repo can mix frameworks and each file is tagged
+         * in its own native format. This value is only used when a file has no detectable
+         * framework import (e.g. `globals: true` configs with no explicit import).
+         * - `"vitest"` — injects `{ tags: [...] }` in describe/test/it options (default)
+         * - `"playwright"` — injects `{ tag: ["@name"] }` with `@` prefix convention
+         * - `"cypress"` — injects `{ tags: ["@name"] }` for use with `@cypress/grep`
+         * - `"jest"` — writes a `/** @group name *\/` docblock for use with `jest-runner-groups`
+         */
+        framework?: TagFramework;
+        /**
+         * Path-glob pattern (project-relative, e.g. `"tests/e2e/**"`) to fallback framework. Checked
+         * in object key order, first match wins, before falling back further to `framework`. Only
+         * consulted when a file's own imports don't reveal a framework — lets different directories
+         * default to different frameworks (e.g. e2e tests using Playwright globals, unit tests using
+         * Jest globals) instead of sharing one project-wide default.
+         */
+        frameworkOverrides?: Record<string, TagFramework>;
+    };
+    /** Path to the Istanbul/v8 `coverage-summary.json` file, relative to the project root. When set, `coveragePct` is populated on each node after the graph is built. */
+    coverageReportPath?: string;
+    /** Default line-coverage threshold (0–100) used by `find_uncovered`. Defaults to `80` when not specified. */
+    coverageThreshold?: number;
+}
+/**
+ * @description Loads a mokosh config file, probing standard filenames in `rootDirOrPath` or reading an explicit path when `isExplicitPath` is true.
+ *   JS/CJS configs may export a plain object or a factory function; the MCP server passes `allowJs: false` to prevent arbitrary code execution.
+ * @param {string} rootDirOrPath - Directory to probe for standard config filenames, or absolute path to the config file when `isExplicitPath` is true.
+ * @param {{ allowJs?: boolean; isExplicitPath?: boolean }} options - `allowJs` (default `true`) controls whether `.js`/`.cjs` files are loaded; `isExplicitPath` treats the first arg as a direct file path.
+ * @returns {MokoshConfig} The parsed config, or an empty object when no config file is found.
+ */
+declare function loadMokoshConfig(rootDirOrPath: string, { allowJs, isExplicitPath }?: {
+    allowJs?: boolean;
+    isExplicitPath?: boolean;
+}): MokoshConfig;
+/**
+ * @description Applies a `MokoshConfig` to the global registries that control classification and scanning.
+ *   Call this after `loadMokoshConfig` and before `createImportMap`.
+ * @param {MokoshConfig} config - The loaded config whose matchers, patterns, libraries, and thresholds are registered.
+ */
+declare function applyConfig(config: MokoshConfig): void;
+
+declare const DEFAULT_IGNORE_DIRS: readonly string[];
+declare const DEFAULT_EXTENSIONS: readonly string[];
+interface ScanOptions {
+    /** Replaces the default ignore-dir list. Use `additionalIgnoreDirs` to extend instead. */
+    ignoreDirs?: string[];
+    /** Replaces the default extension list. Use `additionalExtensions` to extend instead. */
+    extensions?: string[];
+    /** Merged with `DEFAULT_IGNORE_DIRS` (additive). */
+    additionalIgnoreDirs?: string[];
+    /** Merged with `DEFAULT_EXTENSIONS` (additive). */
+    additionalExtensions?: string[];
+}
+
+/**
+ * @description Reads an Istanbul/v8 `coverage-summary.json` file and returns a map of
+ *   project-relative file paths to their line-coverage percentage (0–100).
+ *   Returns an empty map when the file is missing, unreadable, or malformed — the
+ *   caller can always proceed safely with no coverage data.
+ * @param rootDir - Absolute path to the project root; used to make paths relative.
+ * @param reportPath - Path to the coverage summary JSON, relative to `rootDir`.
+ * @returns A map of `relativePath → lineCoveragePct`.
+ */
+declare function loadCoverageMap(rootDir: string, reportPath: string): Map<string, number>;
+
+type FileType = "javascript" | "typescript" | "css" | "scss" | "less" | "stylus" | "coffeescript" | "livescript" | "lua" | "gherkin" | "python" | "go" | "unknown";
+type ImportType = "static" | "dynamic" | "require" | "re-export" | "side-effect";
+type NodeCategory = "logic" | "ui" | "type-only" | "config" | "test" | "barrel" | "other";
+type TagKind = "function" | "class" | "variable" | "type" | "import" | "library" | "comment-marker";
+
+interface StructuredTag {
+    name: string;
+    kind: TagKind;
+}
+interface ExportedSymbol {
+    name: string;
+    doc?: string;
+    flags?: string[];
+    signature?: string;
+}
+interface ImportEdge {
+    fromPath: string;
+    toPath: string;
+    isStyle: boolean;
+    rawSpecifier: string;
+    type: ImportType;
+    symbols?: string[] | undefined;
+    isExternal?: boolean | undefined;
+    version?: string | undefined;
+    /** True when this import resolves to a sibling workspace package rather than an external npm dep. */
+    isWorkspace?: boolean | undefined;
+    /** The workspace package name (e.g. `"@myorg/shared"`) when `isWorkspace` is true. */
+    workspacePackage?: string | undefined;
+    /** Fraction of the target's exports consumed by this import (0–1). Only present for internal non-side-effect imports where the target has at least one export. */
+    exportUsageRatio?: number;
+}
+interface CallEdge {
+    from: string;
+    to: string;
+    toFile: string;
+}
+interface FunctionComplexity {
+    name: string;
+    line: number;
+    complexity: number;
+    cognitiveComplexity: number;
+}
+interface GraphNode {
+    path: string;
+    type: FileType;
+    category: NodeCategory;
+    imports: ImportEdge[];
+    exports: ExportedSymbol[];
+    tags: StructuredTag[];
+}
+interface FileNode extends GraphNode {
+    mtime: number;
+    size: number;
+    description?: string;
+    testedBy?: string[];
+    commitCount90d?: number;
+    lastAuthor?: string;
+    callEdges?: CallEdge[];
+    /** Line coverage percentage (0–100) from the last coverage report. Undefined when no report was loaded. */
+    coveragePct?: number;
+    /** Average exportUsageRatio across all outgoing internal import edges that have a computable ratio. */
+    avgExportUsage?: number;
+    /** Highest single-edge exportUsageRatio for this file — identifies the dependency whose API surface is most consumed. */
+    maxExportUsage?: number;
+    /** McCabe cyclomatic complexity (base 1). Counts independent decision paths through the file. Only present for TypeScript/JavaScript files. */
+    complexity?: number;
+    /** Cognitive complexity — nesting-penalised difficulty score. Higher values indicate harder-to-read code. Only present for TypeScript/JavaScript files. */
+    cognitiveComplexity?: number;
+    /** Per-function complexity breakdown. Covers named function declarations, const-assigned arrow/function expressions, and class methods/constructors/accessors — anonymous inline callbacks are not included. Only present for TypeScript/JavaScript files. */
+    functions?: FunctionComplexity[];
+}
+
+interface SerializedGraph {
+    nodes: FileNode[];
+    cycles?: string[][] | undefined;
+}
+interface DependencyGraph {
+    nodes: Map<string, FileNode>;
+}
+type TraversalVisitor = (node: FileNode, depth: number, parentPath: string | null) => undefined | boolean;
+interface TraversalOptions {
+    maxDepth?: number;
+    direction?: "outgoing" | "incoming";
+}
+
+/** Graph class wrapping the raw node map with DFS traversal, cycle detection, serialization, and reverse-edge helpers. */
+
+/**
+ * @description Represents the dependency graph of the project.
+ *   Wraps the raw node map with traversal, cycle detection, serialization, and
+ *   reverse-index helpers. All node paths are project-relative strings.
+ */
+declare class Graph {
+    nodes: Map<string, FileNode>;
+    private _incomingEdgesCache;
+    private _callIncomingCache;
+    /**
+     * @param {Map<string, FileNode>} nodes - All parsed file nodes, keyed by project-relative path.
+     */
+    constructor(nodes: Map<string, FileNode>);
+    /**
+     * @description Serializes the graph into a plain JSON-compatible object
+     *   that can be written to disk and later restored via `deserialize`.
+     * @returns {SerializedGraph} A flat representation of all nodes in the graph.
+     */
+    serialize(): SerializedGraph;
+    /**
+     * @description Reconstructs a Graph from a serialized snapshot, rebuilding
+     *   the internal node map keyed by file path.
+     * @param {SerializedGraph} serialized - The plain object produced by `serialize`.
+     * @returns {Graph} A fully functional Graph instance.
+     */
+    static deserialize(serialized: SerializedGraph): Graph;
+    /**
+     * @description Lazily builds and caches a reverse index mapping each file path
+     *   to the list of files that import it. Used internally for incoming traversal.
+     * @returns {Map<string, string[]>} Map from target file path to list of importer file paths.
+     */
+    private getIncomingEdgesMap;
+    /**
+     * @description Core DFS engine. Visits each reachable node once, calling visitor at each step.
+     *   The caller provides a getNeighbors function so the same loop works for any edge type.
+     * @param startPath - Project-relative path of the node to start from.
+     * @param visitor - Called for each visited node; return `false` to prune the branch.
+     * @param options - `maxDepth` and `direction` (direction is interpreted by the caller's getNeighbors).
+     * @param getNeighbors - Returns the next paths to visit from a given path.
+     */
+    private dfs;
+    /**
+     * @description Performs a DFS on the import dependency graph.
+     *   Supports both outgoing and incoming (reverse) traversal.
+     * @param startPath - Project-relative path of the node to start from.
+     * @param visitor - Callback executed for each node; return `false` to stop traversing a branch.
+     * @param options - Configuration for `maxDepth` and `direction`.
+     */
+    traverse(startPath: string, visitor: TraversalVisitor, options?: TraversalOptions): void;
+    /**
+     * @description Builds and caches a reverse index of call edges: target file path → list of
+     *   source file paths whose exported functions call into it. Computed lazily on first access
+     *   and reused for the lifetime of this Graph instance.
+     * @returns {Map<string, string[]>} Map from target file path to list of source file paths that call into it.
+     */
+    private getCallIncomingCache;
+    /**
+     * @description Performs a DFS over call edges (exported-function → imported-symbol).
+     *   Outgoing follows callEdges forward; incoming follows the reverse call index.
+     * @param startPath - Project-relative path of the node to start from.
+     * @param visitor - Callback executed for each node; return `false` to stop traversing a branch.
+     * @param options - Configuration for `maxDepth` and `direction`.
+     */
+    traverseCalls(startPath: string, visitor: TraversalVisitor, options?: TraversalOptions): void;
+    /**
+     * @description Returns files whose exported functions call into the given file (one hop).
+     * @param filePath - Project-relative path of the target file.
+     * @returns Project-relative paths of all direct callers.
+     */
+    getCallers(filePath: string): string[];
+    /**
+     * @description Returns all call edges originating from a file.
+     * @param filePath - Project-relative path of the source file.
+     * @returns The file's call edges, or an empty array if none exist.
+     */
+    getCallEdgesFor(filePath: string): CallEdge[];
+    /**
+     * @description Returns the FileNodes that a given file directly imports —
+     *   the first-hop outgoing neighbours in the import graph.
+     * @param path - Project-relative path of the node to look up.
+     * @returns Array of FileNodes imported by the given file; empty if the path is unknown.
+     */
+    getNeighbors(path: string): FileNode[];
+    /**
+     * @description Identifies files that are not reachable from any entry point
+     *   by walking the full import graph forward from each node.
+     * @param allFiles - Complete list of project-relative file paths to test.
+     * @returns Subset of `allFiles` that nothing imports, directly or transitively.
+     */
+    findUnusedFiles(allFiles: string[]): string[];
+    /**
+     * @description Detects all circular import chains in the graph using DFS
+     *   with a back-edge check. Each returned array is one cycle as an ordered path.
+     * @returns Array of cycles; each cycle is a list of file paths forming a loop.
+     */
+    findCycles(): string[][];
+}
+
+/**
+ * Coarse kind of a public export derived from its type signature prefix.
+ * Used to distinguish runtime values from type-only exports without parsing the full signature.
+ */
+type ExportKind = "function" | "class" | "interface" | "type" | "enum" | "const" | "namespace" | "unknown";
+/** A single named export surfaced by an entry point, resolved to its original defining file. */
+interface PublicExport {
+    /** Exported symbol name. */
+    name: string;
+    /** Project-relative path of the file that originally defines this symbol. */
+    definedIn: string;
+    /** Coarse kind derived from the signature prefix. */
+    kind: ExportKind;
+    /** JSDoc summary when present on the defining export. */
+    doc?: string;
+    /** Type signature string when present (e.g. `"interface FileNode"`, `"class Graph"`). */
+    signature?: string;
+}
+/** The complete API surface report for one or more entry points. */
+interface ApiSurface {
+    /** Project-relative paths used as public entry points for this report. */
+    entryPoints: string[];
+    /** All symbols accessible from any entry point via direct declaration or `export *` chains. */
+    publicExports: PublicExport[];
+    /**
+     * All non-test files transitively reachable from any entry point (excluding the entry points
+     * themselves). These form the implementation surface backing the public API.
+     */
+    internalFiles: string[];
+    /**
+     * Non-test files NOT reachable from any entry point — separate consumers (CLI, MCP server),
+     * config, or truly unused files. Not automatically dead code.
+     */
+    unreachableFromEntry: string[];
+    /**
+     * Test files in the graph that are not reachable from any entry point.
+     * Shown separately so they don't inflate the `unreachableFromEntry` signal.
+     */
+    testFiles: string[];
+}
+/**
+ * Attempts to auto-detect the primary public entry point by reading `package.json` from `root`.
+ * Handles modern conditional-exports objects as well as plain `main`/`module` fields.
+ * Converts `dist/index.js` → `src/index.ts` before checking the graph.
+ * Falls back to common candidates when `package.json` is absent or unparseable.
+ *
+ * @param {Graph} graph - The built dependency graph.
+ * @param {string} root - Absolute path to the project root.
+ * @returns {string | null} Project-relative path of the detected entry point, or `null` if none found.
+ */
+declare function detectEntryPoint(graph: Graph, root: string): string | null;
+/**
+ * Detects all public entry points for a project by reading the `package.json exports` map.
+ * Each sub-path (`.`, `./utils`, etc.) is resolved to a project-relative graph path.
+ * Falls back to `main`/`module` fields, then to common `src/index.ts` candidates.
+ *
+ * @param {Graph} graph - The built dependency graph.
+ * @param {string} root - Absolute path to the project root.
+ * @returns {string[]} Ordered list of project-relative paths for all detected entry points.
+ */
+declare function detectAllEntryPoints(graph: Graph, root: string): string[];
+declare function buildApiSurface(graph: Graph, entryPoints: string[]): ApiSurface;
+
+/** Public types for the call-graph subsystem. */
+/** A file and function name that calls the target function. */
+interface CallerEntry {
+    /** Project-relative path of the file containing the caller. */
+    file: string;
+    /** Name of the function that makes the call. */
+    callerFunction: string;
+}
+/** A file and function name that the target function calls. */
+interface CalleeEntry {
+    /** Project-relative path of the file containing the callee. */
+    file: string;
+    /** Name of the function being called. */
+    calleeFunction: string;
+}
+/**
+ * Function-level call relationships for a single named function.
+ * A token-efficient answer to "who calls X?" and "what does X call?"
+ * without sending the full graph to the AI.
+ */
+interface FunctionCallInfo {
+    /** The function name that was queried. */
+    functionName: string;
+    /**
+     * Project-relative path of the file that exports or defines this function.
+     * `null` when no file in the graph exports a symbol with this name.
+     */
+    definedIn: string | null;
+    /** Files and functions that call this function. */
+    callers: CallerEntry[];
+    /** Files and functions that this function calls. */
+    callees: CalleeEntry[];
+}
+
+/** Queries the call-edge graph to find callers and callees at the function level. */
+
+/**
+ * Queries the call graph for a named function, returning its callers and callees.
+ *
+ * Callers are found by scanning every node's `callEdges` for edges whose `to`
+ * field matches `functionName`. Callees are found by looking at the defining
+ * file's `callEdges` for edges whose `from` field matches `functionName`.
+ *
+ * Call edges are populated only for TypeScript/JavaScript files. Functions in
+ * other language files will return empty `callers` and `callees` arrays.
+ *
+ * @param {Graph} graph - The import graph that carries `callEdges` on each node.
+ * @param {string} functionName - Exact name of the function to look up.
+ * @returns {FunctionCallInfo} Caller/callee lists; `definedIn` is `null` if the function is not exported.
+ */
+declare function queryCallGraph(graph: Graph, functionName: string): FunctionCallInfo;
+
+/**
+ * Pre-computed blast-radius map for every file in the graph.
+ *
+ * At small scales (< ~500 nodes) the live `graph.traverse` approach used by
+ * `get_affected` is fast enough (< 1ms per query). The cache pays off when:
+ *   - The same file is queried many times in one session (O(1) vs O(n) per call)
+ *   - The codebase exceeds ~1000 nodes and traversal cost becomes noticeable
+ *   - The cache is persisted to disk and reused across MCP restarts
+ */
+interface ChangeImpactCache {
+    /**
+     * Map from project-relative file path to the list of all files that are
+     * transitively affected if that file changes (incoming traversal).
+     */
+    impact: Map<string, string[]>;
+    /**
+     * Fingerprint of the graph this cache was built from.
+     * Used to detect stale caches without re-traversing the graph.
+     */
+    graphHash: string;
+}
+/**
+ * Computes a lightweight fingerprint of the graph by hashing the sorted list of
+ * `path:mtime:size` tuples for every node. Any file addition, deletion, or
+ * modification will produce a different hash.
+ *
+ * @param graph - The graph to fingerprint.
+ * @returns A hex string hash.
+ */
+declare function computeGraphHash(graph: Graph): string;
+/**
+ * Pre-computes the incoming blast-radius for every node in the graph.
+ *
+ * Runs one incoming traversal per node — O(n²) worst case but performed once.
+ * Results are stored in a `Map` for O(1) subsequent lookups.
+ *
+ * @param graph - The import graph to pre-compute.
+ * @returns A `ChangeImpactCache` ready for `queryChangeImpact`.
+ */
+declare function buildChangeImpactCache(graph: Graph): ChangeImpactCache;
+/**
+ * Returns the list of files transitively affected by a change in `filePath`.
+ * Falls back to an empty array when the file is not in the cache.
+ *
+ * @param cache - A previously built `ChangeImpactCache`.
+ * @param filePath - Project-relative path of the changed file.
+ * @returns Sorted list of affected file paths.
+ */
+declare function queryChangeImpact(cache: ChangeImpactCache, filePath: string): string[];
+/**
+ * Returns `true` when `cache` was built from the same graph as `graph`.
+ * Use this before trusting a deserialized cache loaded from disk.
+ *
+ * @param cache - The cache to validate.
+ * @param graph - The current graph to compare against.
+ * @returns `true` if the cache is still valid for this graph.
+ */
+declare function isChangeImpactCacheValid(cache: ChangeImpactCache, graph: Graph): boolean;
+/**
+ * Serializes a `ChangeImpactCache` to JSON and writes it to `cachePath`,
+ * creating parent directories as needed.
+ *
+ * @param cache - The cache to persist.
+ * @param cachePath - Absolute path to write the JSON file.
+ */
+declare function saveChangeImpactCache(cache: ChangeImpactCache, cachePath: string): void;
+/**
+ * Reads and deserializes a `ChangeImpactCache` from disk.
+ * Returns `null` when the file does not exist or cannot be parsed.
+ *
+ * @param cachePath - Absolute path to the JSON file written by `saveChangeImpactCache`.
+ * @returns The deserialized cache, or `null` on failure.
+ */
+declare function loadChangeImpactCache(cachePath: string): ChangeImpactCache | null;
+
+/** Controls how aggressively `detectFeatures` promotes files to features. */
+interface FeatureDetectionOptions {
+    /**
+     * Minimum number of internal imports a file must have before it is
+     * considered a feature. Lower values surface more candidates;
+     * higher values keep the list focused on true feature aggregators.
+     * @default 5
+     */
+    minOutDegree?: number;
+}
+/**
+ * A file identified as a feature hub — a non-test file with high out-degree
+ * (imports many internal modules), acting as an orchestrator or aggregator.
+ */
+interface FeatureInfo {
+    /** Absolute (or project-relative) path of the feature file. */
+    path: string;
+    /** How many internal files this file imports (its out-degree in the dep graph). */
+    outDegree: number;
+    /** Auto-generated tag of the form `feature:<basename>`, used for queries and reports. */
+    tag: string;
+}
+/**
+ * @description Scans the dependency graph and promotes non-test, non-barrel files with many
+ *   imports to "feature hubs". Uses a two-pass approach: first count out-degrees, then filter
+ *   and annotate. The result maps file path → `FeatureInfo` for tag generation or graph annotation.
+ * @param {Map<string, FileNode>} nodes - All file nodes in the dependency graph, keyed by file path.
+ * @param {FeatureDetectionOptions} [options] - Tuning knobs; currently just `minOutDegree` (default 5).
+ * @returns {Map<string, FeatureInfo>} Map of detected feature files; empty if none qualify.
+ */
+declare function detectFeatures(nodes: Map<string, FileNode>, options?: FeatureDetectionOptions): Map<string, FeatureInfo>;
+
+/** Builds a FeatureGraph grouping graph nodes into feature domains under their respective hub files. */
+
+/**
+ * A group of files that a single feature hub transitively imports.
+ * The hub itself is the high-out-degree orchestrator; `files` are its dependencies.
+ */
+interface FeatureDomain {
+    /** Project-relative path of the feature hub file. */
+    hub: string;
+    /** Number of internal imports the hub has (its out-degree). */
+    outDegree: number;
+    /** All files transitively imported by the hub, excluding the hub itself. */
+    files: string[];
+}
+/**
+ * Domain-clustered view of the import graph.
+ * Provides a token-efficient way to answer "what files are in domain X?"
+ * without traversing the full graph.
+ */
+interface FeatureGraph {
+    /** Map from feature name (e.g. `"parser"`) to its domain info. */
+    features: Map<string, FeatureDomain>;
+    /**
+     * Files not reachable from any feature hub — shared utilities, top-level
+     * entry points, or files below the out-degree threshold.
+     */
+    unassigned: string[];
+}
+/**
+ * Options for `buildFeatureGraph`. Extends `FeatureDetectionOptions` so callers
+ * can pass `{ minOutDegree }` without needing to know this type explicitly.
+ */
+interface FeatureGraphOptions extends FeatureDetectionOptions {
+    /**
+     * Comparator used to pick the "best" hub when a file is reachable from
+     * multiple hubs. Return a negative number when `left` should win over `right`.
+     * @default ascending out-degree (most-specific hub wins)
+     */
+    hubComparator?: (left: FeatureInfo, right: FeatureInfo) => number;
+    /**
+     * Override the hub-detection function. Defaults to `detectFeatures`.
+     * Inject a custom implementation for testing or alternative hub strategies.
+     */
+    detectFn?: (nodes: Map<string, FileNode>, options?: FeatureDetectionOptions) => Map<string, FeatureInfo>;
+}
+/**
+ * Builds a domain-clustered view of the import graph by grouping files under
+ * the most specific feature hub that can reach them.
+ *
+ * Assignment rule: each file is assigned to the hub with the lowest out-degree
+ * that can transitively reach it (overridable via `options.hubComparator`).
+ *
+ * @param graph - The import graph to cluster.
+ * @param options - Controls hub detection threshold, assignment comparator, and detectFn override.
+ * @returns A `FeatureGraph` with one domain per hub and an `unassigned` list.
+ */
+declare function buildFeatureGraph(graph: Graph, options?: FeatureGraphOptions): FeatureGraph;
+
+/** Public types for the responsibility-graph subsystem. Kept separate to avoid circular imports between infer-role.ts and index.ts. */
+/**
+ * Semantic role of a module derived from its file path and category.
+ * Roles are intentionally generic so they apply across any project layout.
+ */
+type ModuleRole = "test" | "config" | "types" | "model" | "service" | "controller" | "middleware" | "router" | "component" | "store" | "util" | "handler" | "cli" | "api" | "parser" | "builder" | "resolver" | "adapter" | "plugin" | "other";
+/**
+ * What a single module is responsible for, derived purely from graph data.
+ * No inference or hallucination — only data already present in the `FileNode`.
+ */
+interface ModuleResponsibility {
+    /** Project-relative file path. */
+    path: string;
+    /** Coarse semantic role inferred from file path and category. */
+    role: ModuleRole;
+    /**
+     * Human-readable description extracted from the file's leading JSDoc comment.
+     * `undefined` when the file has no file-level JSDoc.
+     */
+    description?: string;
+    /** Names of all exported symbols (functions, types, classes). */
+    exports: string[];
+    /**
+     * Name of the feature hub this file belongs to, if any.
+     * Derived from `buildFeatureGraph` with default threshold.
+     */
+    featureHub?: string;
+}
+/**
+ * Map from project-relative path to its responsibility record.
+ * A token-efficient answer to "what does module X do?" across many files at once.
+ */
+type ResponsibilityGraph = Map<string, ModuleResponsibility>;
+
+/**
+ * Builds a responsibility map for every file in the graph.
+ *
+ * Each entry is derived entirely from data already present in the `FileNode`:
+ * - `description` comes from the file's leading JSDoc (`FileNode.description`)
+ * - `exports` are the exported symbol names
+ * - `role` is inferred from file path and category via `inferRole`
+ * - `featureHub` is resolved via `buildFeatureGraph` with default options
+ *
+ * Test files are included with `role: "test"` so callers can filter them if needed.
+ *
+ * @param {Graph} graph - The import graph to derive responsibilities from.
+ * @param {FeatureDetectionOptions} [featureOptions] - Options forwarded to `buildFeatureGraph` (e.g. `minOutDegree`).
+ * @returns {ResponsibilityGraph} A map from each file path to its `ModuleResponsibility`.
+ */
+declare function buildResponsibilityGraph(graph: Graph, featureOptions?: FeatureDetectionOptions): ResponsibilityGraph;
+
+/**
+ * @description Tracks which exported symbols of each visited node are "affected" by a change.
+ *
+ * Enables symbol-level pruning during graph traversal: if a node only imports `foo` and `foo`
+ * was not among the changed symbols, that node is not considered affected and traversal stops there.
+ */
+declare class SymbolTraversalContext {
+    private affectedSymbols;
+    /**
+     * @param {string} startPath - Relative path of the changed file; seeded with the given affected symbols.
+     * @param {string[]} affectedSymbols - Symbol names that are considered changed. Pass `["*"]` to treat the whole file as changed.
+     */
+    constructor(startPath: string, affectedSymbols: string[]);
+    /**
+     * @description Checks whether `visitedNode` imports any affected symbol from `childPath` and,
+     * if so, propagates the affected symbol set to `visitedNode` for the next traversal step.
+     *
+     * Both roles live in one method to avoid a second pass over the import edges — the check
+     * and the update read the same edge, so splitting them would duplicate work.
+     * @param {{ path: string; imports: ImportEdge[] }} visitedNode - The node currently being evaluated; its imports are inspected.
+     * @param {string} childPath - The path it was reached from; used to look up the current affected symbols.
+     * @returns {boolean} `true` if at least one imported symbol is affected and traversal should continue; `false` to prune.
+     */
+    updateAffectedSymbols(visitedNode: {
+        path: string;
+        imports: ImportEdge[];
+    }, childPath: string): boolean;
+}
+
+/** Structural kind of a type export. */
+type TypeKind = "interface" | "class" | "enum" | "type";
+/**
+ * A single type-like export extracted from a TypeScript source file.
+ * Only interfaces, classes, enums, and type aliases are included —
+ * plain functions and values are excluded.
+ */
+interface TypeNode {
+    /** Exported symbol name (e.g. `"FileNode"`). */
+    name: string;
+    /** Project-relative path of the file that exports this type. */
+    file: string;
+    /** Structural kind inferred from the export signature. */
+    kind: TypeKind;
+    /** JSDoc description attached to the export, if present. */
+    doc?: string;
+}
+/**
+ * A directed edge representing that one file imports a specific type from another file.
+ */
+interface TypeEdge {
+    /** Project-relative path of the importing file. */
+    fromFile: string;
+    /** Name of the imported type. */
+    toType: string;
+    /** Project-relative path of the file that defines the type. */
+    toFile: string;
+}
+/**
+ * Type-level view of the import graph.
+ * Answers "what types depend on X?" and "what does type X depend on?"
+ * at a fraction of the cost of sending the full graph.
+ */
+interface TypeGraph {
+    /**
+     * All type-like exports in the graph.
+     * Key format: `"<file>::<typeName>"` (e.g. `"src/types/node.ts::FileNode"`).
+     */
+    types: Map<string, TypeNode>;
+    /** All import edges where the imported symbol is a known type. */
+    edges: TypeEdge[];
+}
+/**
+ * Result of a focused query for one named type.
+ * A token-efficient answer to "what types depend on X?" and "what does X use?"
+ */
+interface TypeQueryResult {
+    /** The type that was queried. */
+    type: TypeNode | null;
+    /** Project-relative paths of files that import this type. */
+    usedByFiles: string[];
+    /** Types that the defining file imports from other files. */
+    uses: TypeNode[];
+}
+/**
+ * Builds a type-level view of the import graph by extracting all type-like exports
+ * and the import edges that connect them.
+ *
+ * Only TypeScript and JavaScript files are considered — other file types carry no
+ * type information usable for this graph.
+ *
+ * @param graph - The import graph to derive the type graph from.
+ * @returns A `TypeGraph` with all type nodes and their dependency edges.
+ */
+declare function buildTypeGraph(graph: Graph): TypeGraph;
+/**
+ * Queries the type graph for a specific named type, returning its direct dependents
+ * (files that import it) and its direct dependencies (types it imports).
+ *
+ * When `typeName` is not found in the graph, `type` is `null` and both lists are empty.
+ *
+ * @param typeGraph - A previously built `TypeGraph`.
+ * @param typeName - Exact exported name of the type to look up (e.g. `"FileNode"`).
+ * @returns `TypeQueryResult` with the type node and its one-hop neighbours.
+ */
+declare function queryTypeGraph(typeGraph: TypeGraph, typeName: string): TypeQueryResult;
+
+/** @description Metadata for a single package inside a monorepo workspace. */
+interface WorkspacePackage {
+    /** Package name from `package.json`. */
+    name: string;
+    /** Absolute path to the package directory. */
+    root: string;
+    /** Path relative to the monorepo root (used as a stable key in node paths). */
+    relativeRoot: string;
+    /** Resolved entry point absolute paths, in priority order. */
+    entryPoints: string[];
+}
+/** @description Result returned by `detectMonorepo` describing the workspace layout. */
+interface MonorepoLayout {
+    root: string;
+    /** Primary detected tool (first detector that fired), or `"none"`. */
+    type: string;
+    /** All tools detected in this repo (e.g. `["turborepo", "pnpm"]` for a Turborepo+pnpm repo). */
+    types: string[];
+    packages: WorkspacePackage[];
+    packageMap: Map<string, WorkspacePackage>;
+}
+
+/** Registry for MonorepoDetector plugins, allowing custom detectors to be added alongside the built-in ones. */
+
+/**
+ * @description Contract for a tool-specific monorepo detector.
+ *   Each detector knows how to recognise one package manager or build orchestrator
+ *   and enumerate the packages it manages.
+ */
+interface MonorepoDetector {
+    /**
+     * Identifier for this tool (e.g. `"pnpm"`, `"nx"`).
+     * Included in `MonorepoLayout.types` when this detector fires.
+     */
+    readonly type: string;
+    /**
+     * @description Inspects `rootDir` and returns the workspace packages it manages.
+     *   Return `null` to signal "this tool is not present here" (detector does not fire).
+     *   Return an empty array to signal "tool is present but manages no packages" (detector fires, contributes its type).
+     * @param {string} rootDir - Absolute path to the repository root to inspect.
+     * @returns {WorkspacePackage[] | null} Discovered packages, an empty array if the tool is present but empty, or `null` if the tool is absent.
+     */
+    detect(rootDir: string): WorkspacePackage[] | null;
+}
+/**
+ * @description Registers a monorepo detector. Detectors are run in registration order;
+ *   register higher-priority tools first (e.g. Turborepo before pnpm).
+ * @param {MonorepoDetector} detector - The detector implementation to add to the registry.
+ */
+declare function registerMonorepoDetector(detector: MonorepoDetector): void;
+
+/**
+ * @description Runs all registered monorepo detectors against `rootDir` and merges
+ *   their results into a single `MonorepoLayout`. All matching detectors contribute
+ *   their `type` string and packages — so a Turborepo + pnpm repo will have
+ *   `types: ["turborepo", "pnpm"]` and packages from the pnpm detector.
+ *
+ *   Packages are deduplicated by name: the first detector to emit a package name wins.
+ *   Returns `type: "none"` when no detector fires.
+ */
+declare function detectMonorepo(rootDir: string, detectors?: readonly MonorepoDetector[]): MonorepoLayout;
+
+/** WorkspaceGraph holds one per-package Graph for a monorepo and exposes cross-package blast-radius queries. */
+
+/** @description JSON-safe snapshot of a `WorkspaceGraph`, suitable for writing to disk and restoring via `WorkspaceGraph.deserialize`. */
+interface SerializedWorkspaceGraph {
+    monorepoRoot: string;
+    type: string;
+    packages: Array<{
+        pkg: Omit<WorkspacePackage, "root">;
+        nodes: FileNode[];
+    }>;
+}
+/**
+ * @description Holds one per-package `Graph` for each workspace package in a monorepo.
+ *   Cross-package import edges are preserved inside each graph via `ImportEdge.isWorkspace`.
+ *   The workspace graph does not merge all nodes into one flat namespace — each package graph
+ *   is queried independently, with cross-package traversal handled by `getAffectedAcrossPackages`.
+ */
+declare class WorkspaceGraph {
+    readonly monorepoRoot: string;
+    readonly type: string;
+    readonly packages: Map<string, {
+        graph: Graph;
+        pkg: WorkspacePackage;
+    }>;
+    /**
+     * @param {string} monorepoRoot - Absolute path to the monorepo root directory.
+     * @param {string} type - Primary detected monorepo tool (e.g. `"turborepo"`, `"pnpm"`), or `"none"`.
+     */
+    constructor(monorepoRoot: string, type: string);
+    /**
+     * @description Registers a package and its pre-built graph into this workspace.
+     * @param {WorkspacePackage} pkg - Package metadata including name, root, and entry points.
+     * @param {Graph} graph - The fully-built dependency graph for this package.
+     */
+    addPackage(pkg: WorkspacePackage, graph: Graph): void;
+    /**
+     * @description Returns the workspace package whose `relativeRoot` is a path prefix of `relPath`.
+     * @param {string} relPath - A monorepo-root-relative file path to look up.
+     * @returns {WorkspacePackage | undefined} The owning package, or `undefined` if none matches.
+     */
+    getPackageForFile(relPath: string): WorkspacePackage | undefined;
+    /**
+     * @description Returns a map of package-level dependencies derived from workspace import edges.
+     *   Key: package name. Value: list of workspace package names it imports from.
+     * @returns {Map<string, string[]>} Map from package name to the list of workspace packages it depends on.
+     */
+    getPackageDependencies(): Map<string, string[]>;
+    /**
+     * @description Cross-package blast-radius analysis. Returns every file (with its package name)
+     *   that could be affected if the given monorepo-root-relative path changes.
+     *   Step 1: traverses incoming edges within the owning package graph for intra-package dependents.
+     *   Step 2: surfaces files in other packages that hold workspace import edges pointing at the owner.
+     * @param {string} relPath - Monorepo-root-relative path of the changed file.
+     * @returns {Array<{ file: string; package: string }>} Each affected file paired with its package name.
+     */
+    getAffectedAcrossPackages(relPath: string): Array<{
+        file: string;
+        package: string;
+    }>;
+    /**
+     * @description Serializes the workspace graph to a plain JSON-safe object.
+     *   `root` is omitted from package entries as it is not needed after build time.
+     * @returns {SerializedWorkspaceGraph} A JSON-serializable snapshot of the workspace graph.
+     */
+    serialize(): SerializedWorkspaceGraph;
+    /**
+     * @description Reconstructs a `WorkspaceGraph` from a serialized snapshot.
+     *   The `root` field on each package is set to an empty string — it is not persisted and not needed for graph traversal.
+     * @param {SerializedWorkspaceGraph} data - The plain object produced by `serialize`.
+     * @returns {WorkspaceGraph} A fully functional `WorkspaceGraph` instance.
+     */
+    static deserialize(data: SerializedWorkspaceGraph): WorkspaceGraph;
+}
+
+/**
+ * @description Contract for graph serializers. Implement this to add a new export format
+ *   (e.g. Graphviz DOT, JSON, SVG) without touching the core graph model.
+ */
+interface GraphExporter {
+    /**
+     * @description Converts a dependency graph into a serialized string in the exporter's target format.
+     * @param graph - The fully-built dependency graph to serialize.
+     * @returns A string representation of the graph in the target format (e.g. Mermaid, DOT).
+     */
+    serialize(graph: Graph): string;
+}
+
+/** GraphExporter implementation that renders dependency graphs as Mermaid flowchart diagrams. */
+
+/**
+ * @description GraphExporter implementation that renders dependency graphs as Mermaid diagrams.
+ *   Use this directly or pass it anywhere a GraphExporter is accepted.
+ */
+declare const MermaidExporter: GraphExporter;
+/**
+ * @description Convenience wrapper around MermaidExporter.serialize.
+ * @param graph - The dependency graph to render.
+ * @returns A Mermaid `graph TD` diagram string.
+ */
+declare function toMermaid(graph: Graph): string;
+
+/** A config matcher: substring, regex, or predicate tested against the lowercase basename. */
+type ConfigMatcher = string | RegExp | ((baseName: string) => boolean);
+/**
+ * @description Registers a custom config-file matcher used when categorising nodes.
+ * Accepts a substring, regex, or predicate tested against the lowercase basename.
+ * Call this before running `createImportMap` — e.g. in a `mokosh.config.ts`.
+ * @param matcher - A substring, `RegExp`, or predicate function tested against the lowercase file basename.
+ * @example
+ * // Match any file whose basename contains ".myconfig."
+ * registerConfigMatcher(".myconfig.");
+ *
+ * // Match via regex
+ * registerConfigMatcher(/^vite\.config\./);
+ *
+ * // Match via predicate
+ * registerConfigMatcher((name) => name.startsWith("jest.config"));
+ */
+declare function registerConfigMatcher(matcher: ConfigMatcher): void;
+/**
+ * @description Registers an additional basename substring that marks a file as a test.
+ * @param pattern - A substring matched against the file basename, e.g. `".unit."`.
+ */
+declare function registerTestPattern(pattern: string): void;
+/**
+ * @description Registers an additional import specifier that indicates a test file.
+ * @param lib - An import specifier substring, e.g. `"@my-org/test-utils"`.
+ */
+declare function registerTestLibrary(lib: string): void;
+
+interface RawCallEdge {
+    from: string;
+    to: string;
+    toSpecifier: string;
+}
+interface ParseResult {
+    imports: ImportEdge[];
+    exports: ExportedSymbol[];
+    tags: StructuredTag[];
+    category: NodeCategory;
+    rawCallEdges?: RawCallEdge[];
+    description?: string;
+    /** McCabe cyclomatic complexity of the file (base 1, undefined for non-TS/JS files). */
+    complexity?: number;
+    /** Cognitive complexity — nesting-aware difficulty score (undefined for non-TS/JS files). */
+    cognitiveComplexity?: number;
+    /** Per-function complexity breakdown (undefined for non-TS/JS files). */
+    functions?: FunctionComplexity[];
+}
+
+/** Parser registry: maps FileType values to parser functions and provides lookup by file type. */
+
+type ParserFunction = (filePath: string, content: string) => ParseResult | Promise<ParseResult>;
+/**
+ * @description Registers a parser function for a given file type, overwriting any
+ *   previously registered parser for that type.
+ * @param type - The `FileType` key this parser should handle.
+ * @param parser - The parsing function that extracts imports and tags from file content.
+ */
+declare function registerParser(type: FileType, parser: ParserFunction): void;
+
+/**
+ * Criteria for filtering nodes in a serialized graph.
+ *
+ * String fields support a `"!"` prefix for negation (e.g. `category: "!test"`).
+ * `tags` uses OR logic across positive entries; negated entries (`"!auth"`) act
+ * as mandatory exclusions and are evaluated independently.
+ */
+interface NodeQuery {
+    category?: string;
+    type?: string;
+    /** OR match across entries. Prefix with `"!"` to exclude that tag. */
+    tags?: string[];
+    /** AND match — all entries must be present (use `tag:a+b` syntax in query strings). */
+    allTags?: string[];
+    path?: string;
+    isExternal?: boolean;
+    /** Substring match on `imp.toPath` — node must import a file whose path contains this string. */
+    importsFile?: string;
+    /** Substring match on importer paths — node must be imported by a file whose path contains this string. */
+    importedBy?: string;
+    minImports?: number;
+    maxImports?: number;
+    minSize?: number;
+    maxSize?: number;
+    sort?: "size" | "imports" | "commitCount90d" | "exportUsage";
+    limit?: number;
+    hasDocstring?: boolean;
+    /** Minimum line-coverage percentage; nodes below this value are excluded. Nodes with no coverage data are excluded. */
+    minCoverage?: number;
+    /** Maximum line-coverage percentage; nodes above this value are excluded. Nodes with no coverage data are treated as 0%. */
+    maxCoverage?: number;
+    /** Minimum avgExportUsage (0–1); nodes below this value are excluded. Nodes with no data are excluded. */
+    minExportUsage?: number;
+    /** Maximum avgExportUsage (0–1); nodes above this value are excluded. Nodes with no data are treated as 0. */
+    maxExportUsage?: number;
+}
+
+/** Filters a graph by applying NodeQuery predicates: category, type, tag, path, imports, coverage, and more. */
+
+/**
+ * @description Filters a serialized graph to only nodes matching all criteria in `query`,
+ *   then trims each node's import list to edges whose target is also in the result set.
+ *   Optionally sorts the result and applies a `limit`.
+ * @param {SerializedGraph} graph - The serialized graph to filter.
+ * @param {NodeQuery} query - Filter criteria; omitted fields are treated as wildcards.
+ * @returns {SerializedGraph} A new `SerializedGraph` containing only the matching subgraph.
+ */
+declare function filterGraph(graph: SerializedGraph, query: NodeQuery): SerializedGraph;
+
+/** Parses a key:value query string into a structured NodeQuery for use with filterGraph. */
+
+/**
+ * @description Parses a `"key:value,key:value"` query string into a structured `NodeQuery`.
+ *   String values support `"!"` prefix for negation. The `tag`/`tags` key may appear multiple
+ *   times; values are OR-matched (negated entries act as exclusions). `tag:a+b` maps to `allTags`.
+ * @param {string} queryString - Comma-separated `key:value` pairs, e.g. `"category:logic,tag:auth"`.
+ * @returns {NodeQuery} The structured query object ready for use with `filterGraph` or `matchNode`.
+ */
+declare function parseQuery(queryString: string): NodeQuery;
+
+/**
+ * @description Result for a single file processed by {@link applyTagsToFile}.
+ */
+interface ApplyTagsFileResult {
+    /** Project-relative path of the test file. */
+    path: string;
+    /** `"updated"` when the file was rewritten, `"unchanged"` when tags already matched, `"error"` on I/O failure. */
+    status: "updated" | "unchanged" | "error";
+    /** Present only when status is `"error"`. */
+    error?: string;
+}
+/**
+ * @description Aggregate result returned by {@link applyTags} after processing all test nodes.
+ */
+interface ApplyTagsResult {
+    /** Number of files that were written (or would have been written in dry-run mode). */
+    updated: number;
+    /** Number of files where the existing tags already matched the computed tags. */
+    unchanged: number;
+    /** Number of files that could not be read or written. */
+    errors: number;
+    /** Per-file breakdown. */
+    files: ApplyTagsFileResult[];
+}
+/**
+ * @description Iterates every test node in the graph, extracts `"import"` kind tags that pass
+ *   a name validity check and generic-name blocklist, then delegates writing to the strategy
+ *   selected by `mokosh.config.*` (`tagApplier.framework`, default `"vitest"`). Non-test nodes
+ *   are skipped.
+ * @param {Graph} graph - The fully-enriched dependency graph.
+ * @param {string} rootDir - Absolute path to the project root.
+ * @param {{ dryRun: boolean }} options - Pass `dryRun: true` to preview changes without disk writes.
+ * @returns {Promise<ApplyTagsResult>} Aggregate result with per-file status breakdown.
+ */
+declare function applyTags(graph: Graph, rootDir: string, options: {
+    dryRun: boolean;
+}): Promise<ApplyTagsResult>;
+
+/** Strategy interface and default implementation for identifying test nodes in the graph. */
+
+/**
+ * @description Strategy interface for determining whether a graph node represents a test file.
+ */
+interface TestNodeIdentifier {
+    /**
+     * @description Returns whether the given node should be treated as a test node.
+     * @param {{ category: string; tags: StructuredTag[] }} node - A minimal node descriptor containing its category and structured tags.
+     * @returns {boolean} `true` if the node is a test file.
+     */
+    isTestNode(node: {
+        category: string;
+        tags: StructuredTag[];
+    }): boolean;
+}
+
+/** Proposes semantic test tags and affected test files from git diff and the dependency graph. */
+
+/** @description Options for `proposeTags` and `proposeAffectedTests`, allowing callers to override the test-node identifier and feature-detection behaviour. */
+interface ProposeTagsOptions {
+    identifier?: TestNodeIdentifier;
+    featureDetection?: FeatureDetectionOptions | false;
+}
+/**
+ * @description Proposes Vitest tags to run based on which files changed.
+ *
+ * Traverses the incoming dependency graph from each changed file. Test nodes
+ * that can reach the changed file contribute their tags. Feature hubs act as
+ * boundaries: the hub's tag is emitted and traversal stops there, preventing
+ * combinatorial blowup in large graphs.
+ * @param {Graph} graph - The full project dependency graph.
+ * @param {string[]} changedFiles - Relative paths of files that were modified (e.g. from git diff).
+ * @param {ProposeTagsOptions} [options] - Optional: custom test identifier and feature-detection settings.
+ * @returns {string[]} Deduplicated list of tag strings to pass to `vitest --grep`.
+ */
+declare function proposeTags(graph: Graph, changedFiles: string[], options?: ProposeTagsOptions): string[];
+/**
+ * @description Returns the file paths of test files affected by the changed files.
+ *
+ * Traverses the incoming dependency graph from each changed file and collects
+ * paths of reachable test nodes. Feature hubs act as traversal boundaries —
+ * tests beyond a hub are excluded because the hub's own tag already covers
+ * them when using `proposeTags`.
+ *
+ * The output is a plain list of relative paths suitable for piping directly
+ * into Vitest: `vitest $(mokosh --affected-tests)`.
+ * @param {Graph} graph - The full project dependency graph.
+ * @param {string[]} changedFiles - Relative paths of files that were modified (e.g. from git diff).
+ * @param {ProposeTagsOptions} [options] - Optional: custom test identifier and feature-detection settings.
+ * @returns {string[]} Deduplicated list of relative test file paths.
+ */
+declare function proposeAffectedTests(graph: Graph, changedFiles: string[], options?: ProposeTagsOptions): string[];
+
+/** Public library API: createImportMap, createWorkspaceGraph, and getAllProjectFiles. */
+
+/**
+ * @description Builds a dependency graph from the given entry points, optionally reusing a
+ *   previously built graph for incremental updates.
+ * @param rootDir - Absolute or relative path to the project root; resolved internally.
+ * @param entryPoints - File paths (relative to `rootDir`) that seed the graph walk.
+ * @param previousGraph - An earlier graph to diff against for incremental builds; pass `null` for a full build.
+ * @param options - `silent` suppresses progress output; `gitStats` attaches git churn data; `coverageMap` maps file paths to line-coverage percentages.
+ * @returns The fully-built Graph with all reachable nodes and import edges populated.
+ */
+declare function createImportMap(rootDir: string, entryPoints: string[], previousGraph?: Graph | null, options?: {
+    silent?: boolean;
+    gitStats?: boolean;
+    coverageMap?: Map<string, number>;
+}): Promise<Graph>;
+/**
+ * @description Auto-detects the monorepo layout under `rootDir` and builds a per-package
+ *   dependency graph, stitching them together into a single WorkspaceGraph.
+ * @param rootDir - Absolute path to the monorepo root.
+ * @param options - `packages` filters to a named subset of packages; `silent` suppresses progress; `gitStats` attaches git churn data per file.
+ * @returns A WorkspaceGraph where each package has its own Graph and cross-package edges are resolved.
+ */
+declare function createWorkspaceGraph(rootDir: string, options?: {
+    packages?: string[];
+    silent?: boolean;
+    gitStats?: boolean;
+}): Promise<WorkspaceGraph>;
+/**
+ * @description Recursively walks `rootDir` and returns paths of every file whose extension
+ *   is in the allowed set, skipping ignored directories. Silently skips unreadable entries.
+ * @param rootDir - Root directory to scan; returned paths are relative to this.
+ * @param options - Override or extend the default ignore-dir and extension lists via ScanOptions.
+ * @returns Relative file paths for all matching source files found under `rootDir`.
+ */
+declare function getAllProjectFiles(rootDir: string, options?: ScanOptions): string[];
+
+export { type ApiSurface, type ApplyTagsFileResult, type ApplyTagsResult, type CallEdge, type CalleeEntry, type CallerEntry, type ChangeImpactCache, DEFAULT_EXTENSIONS, DEFAULT_IGNORE_DIRS, type DependencyGraph, type ExportKind, type ExportedSymbol, type FeatureDetectionOptions, type FeatureDomain, type FeatureGraph, type FeatureGraphOptions, type FeatureInfo, type FileNode, type FileType, type FunctionCallInfo, Graph, type GraphExporter, type ImportEdge, type ImportType, MermaidExporter, type ModuleResponsibility, type ModuleRole, type MokoshConfig, type MonorepoDetector, type MonorepoLayout, type NodeCategory, type NodeQuery, type ProposeTagsOptions, type PublicExport, type ResponsibilityGraph, type ScanOptions, type SerializedGraph, type SerializedWorkspaceGraph, type StructuredTag, SymbolTraversalContext, type TagKind, type TestNodeIdentifier, type TraversalOptions, type TraversalVisitor, type TypeEdge, type TypeGraph, type TypeKind, type TypeNode, type TypeQueryResult, WorkspaceGraph, type WorkspacePackage, applyConfig, applyTags, buildApiSurface, buildChangeImpactCache, buildFeatureGraph, buildResponsibilityGraph, buildTypeGraph, computeGraphHash, createImportMap, createWorkspaceGraph, detectAllEntryPoints, detectEntryPoint, detectFeatures, detectMonorepo, filterGraph, getAllProjectFiles, isChangeImpactCacheValid, loadChangeImpactCache, loadCoverageMap, loadMokoshConfig, parseQuery, proposeAffectedTests, proposeTags, queryCallGraph, queryChangeImpact, queryTypeGraph, registerConfigMatcher, registerMonorepoDetector, registerParser, registerTestLibrary, registerTestPattern, saveChangeImpactCache, toMermaid };