@specship/specship 0.11.0

package/dist/index.d.ts

@@ -0,0 +1,674 @@
+/**
+ * SpecShip
+ *
+ * A local-first code intelligence system that builds a semantic
+ * knowledge graph from any codebase.
+ */
+import { Node, Edge, FileRecord, ExtractionResult, Subgraph, TraversalOptions, SearchOptions, SearchResult, Context, GraphStats, TaskInput, TaskContext, BuildContextOptions, FindRelevantContextOptions } from './types';
+import { IndexProgress, IndexResult, SyncResult } from './extraction';
+import { ResolutionResult } from './resolution';
+import { SpecLinkResolver, SpecLinkResolverStats } from './resolution/spec-link-resolver';
+import { SpecFunnel } from './resolution/brief-link-resolver';
+import { DomainGapSeed } from './resolution/domain-gap-seed';
+import { SpecQueries } from './db/spec-queries';
+import { AnalyzeResult, SweepResult, Proposal, ProposalState, PreviewResult, ApplyOutcome, UndoOutcome } from './reflect';
+import { MaintainabilityReport, MaintainabilityThresholds } from './graph/maintainability';
+import { FitnessReport, FitnessRule } from './fitness/fitness';
+import { EnforceConfig, EnforceReport } from './enforce/enforce';
+import { BehaviourSurface } from './behaviour/behaviour-surface';
+import { WatchOptions, PendingFile } from './sync';
+export * from './types';
+export { getDatabasePath, DatabaseConnection } from './db';
+export { QueryBuilder } from './db/queries';
+export { getSpecShipDir, isInitialized, findNearestSpecShipRoot, SPECSHIP_DIR, } from './directory';
+export { IndexProgress, IndexResult, SyncResult } from './extraction';
+export { detectLanguage, isLanguageSupported, isGrammarLoaded, getSupportedLanguages, initGrammars, loadGrammarsForLanguages, loadAllGrammars } from './extraction';
+export { ResolutionResult } from './resolution';
+export { computeSpecFunnel, resolveBriefLink, summarizeBriefFunnel, findBriefsForSpec, } from './resolution/brief-link-resolver';
+export type { SpecFunnel, SpecFunnelSummary, SpecFunnelDoc, BriefLink, BriefLinkState, BriefRollup, BriefFunnelEntry, } from './resolution/brief-link-resolver';
+export { computeDomainGapSeed } from './resolution/domain-gap-seed';
+export type { DomainGapSeed, GapSeedEntity, GapSeedSpec, DomainCoverage, } from './resolution/domain-gap-seed';
+export { analyze as reflectAnalyze, sweep as reflectSweep, ReflectStore, previewProposal, applyProposal, undoProposal, } from './reflect';
+export type { Proposal, ProposalType, ProposalSeverity, ProposalState, TargetKind, ProposalEvidence, ProposalPayload, PreviewResult, ApplyOutcome, UndoOutcome, ReflectContext, AnalyzeResult, SweepResult, } from './reflect';
+export { computeMaintainability, resolveThresholds, resolveExclude, DEFAULT_THRESHOLDS, DEFAULT_EXCLUDE, CONFIG_FILE_NAME, HIGH_PRECISION_CLASSES, LOW_CONFIDENCE_CLASSES, highPrecisionClean } from './graph/maintainability';
+export { evaluateFitness, loadFitnessRules, FITNESS_CONFIG_FILE } from './fitness/fitness';
+export { evaluateEnforcement, loadEnforceConfig, ENFORCE_CONFIG_FILE } from './enforce/enforce';
+export { computeBehaviourSurface, renderBehaviourSurface, isUiNode } from './behaviour/behaviour-surface';
+export type { BehaviourSurface, BehaviourFlowElement, BehaviourSurfaceDeps } from './behaviour/behaviour-surface';
+export type { EnforceConfig, GateConfig, EnforceReport, EnforceDeps, CheckOutcome, CheckName, RequirementVerification, } from './enforce/enforce';
+export type { FitnessRule, ForbiddenRule, LayersRule, IsolationRule, FitnessReport, FitnessViolation, FitnessConfigError, Selector, } from './fitness/fitness';
+export type { MaintainabilityReport, MaintainabilityThresholds, CouplingFinding, OversizedFinding, GodFileFinding, CycleFinding, DeadCodeFinding, } from './graph/maintainability';
+export { SpecShipError, FileError, ParseError, DatabaseError, SearchError, VectorError, ConfigError, Logger, setLogger, getLogger, silentLogger, defaultLogger, } from './errors';
+export { Mutex, FileLock, processInBatches, debounce, throttle, MemoryMonitor } from './utils';
+export { FileWatcher, WatchOptions, PendingFile, LockUnavailableError } from './sync';
+export { MCPServer } from './mcp';
+/**
+ * Options for initializing a new SpecShip project
+ */
+export interface InitOptions {
+    /** Whether to run initial indexing after init */
+    index?: boolean;
+    /** Progress callback for indexing */
+    onProgress?: (progress: IndexProgress) => void;
+}
+/**
+ * Options for opening an existing SpecShip project
+ */
+export interface OpenOptions {
+    /** Whether to run sync if files have changed */
+    sync?: boolean;
+    /** Whether to run in read-only mode */
+    readOnly?: boolean;
+}
+/**
+ * Options for indexing
+ */
+export interface IndexOptions {
+    /** Progress callback */
+    onProgress?: (progress: IndexProgress) => void;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Enable verbose logging (worker lifecycle, memory, timeouts) */
+    verbose?: boolean;
+}
+/**
+ * Main SpecShip class
+ *
+ * Provides the primary interface for interacting with the code knowledge graph.
+ */
+export declare class SpecShip {
+    private db;
+    private queries;
+    private specQueries;
+    private projectRoot;
+    private orchestrator;
+    private resolver;
+    private specLinkResolver;
+    private graphManager;
+    private traverser;
+    private contextBuilder;
+    private indexMutex;
+    private fileLock;
+    private watcher;
+    private constructor();
+    /** Access to the spec queries (for MCP tools, CLI commands, embedded SDK users). */
+    getSpecQueries(): SpecQueries;
+    /** Access to the spec link resolver. */
+    getSpecLinkResolver(): SpecLinkResolver;
+    /**
+     * The project-wide spec lifecycle funnel: brainstormed ideas → specs →
+     * implemented, with per-document rollups (REQ-FUNNEL-006). Exposed on the
+     * instance so the desktop server can serve it without runtime-importing the
+     * package (it calls this on the dynamically-loaded SpecShip).
+     */
+    getSpecFunnel(): SpecFunnel;
+    /**
+     * The domain gap-seed (REQ-DOMAIN-003): the structural code entities and
+     * non-domain specs that no domain fact yet covers, plus a coverage tally.
+     * Read-only — computed from live state, writes nothing. Exposed on the
+     * instance so the `/ss-spec domain` command and the desktop server can drive it
+     * without runtime-importing the package.
+     */
+    getDomainGapSeed(): DomainGapSeed;
+    /**
+     * The maintainability harness (REQ-MAINT-001): coupling, size hotspots,
+     * dependency cycles, and dead-code candidates, derived from the graph with no
+     * additional parse. Read-only and deterministic. Exposed on the instance so
+     * the CLI / MCP / desktop server can drive it without runtime-importing the
+     * package.
+     */
+    getMaintainability(thresholds?: Partial<MaintainabilityThresholds>): MaintainabilityReport;
+    /**
+     * The architecture-fitness harness (REQ-FITNESS-001/002): evaluate declarative
+     * architecture rules (from specship.config.json `fitness.rules`, or an explicit
+     * override) against the graph. Read-only, deterministic. Exposed on the
+     * instance so the CLI / MCP / server drive it without runtime-importing the
+     * package.
+     */
+    getFitness(rules?: FitnessRule[]): FitnessReport;
+    /**
+     * Enforcement mode (REQ-ENFORCE-001/002/003): compose drift + fitness +
+     * maintainability + the spec→test→verify behaviour chain into one gate. Which
+     * checks gate vs advise comes from specship.config.json `enforce` (or an
+     * explicit override); with no config every check is advisory and the run
+     * passes. The behaviour chain reads `tests`-kind spec-links on each requirement
+     * and its acceptance criteria (verified = passing, broken = ran-and-failed).
+     */
+    getEnforce(config?: EnforceConfig): EnforceReport;
+    /**
+     * The behaviour surface for a requirement (REQ-BEHAVIOUR-001): its linked code
+     * plus the 1-hop route / component / handler neighbourhood, grouped UI vs
+     * backend, so the `/ss-behaviour` skill can author end-to-end tests from one
+     * call. Lives here as an instance method so the CLI / MCP / server drive it
+     * without runtime-importing the package. A requirement (or its acceptance
+     * children) supplies the linked nodes; their callers + callees supply the
+     * neighbourhood.
+     */
+    getBehaviourSurface(specId: string): BehaviourSurface;
+    private reflectContext;
+    /** Run a reflection pass, persist the batch, return the open proposals. */
+    reflectAnalyze(): AnalyzeResult;
+    /** Run a sweep: analyze + return new high-severity proposals to notify on. */
+    reflectSweep(): SweepResult;
+    /** List persisted proposals, optionally filtered by state. */
+    reflectList(state?: ProposalState): Proposal[];
+    /** Fetch one proposal by its content hash. */
+    reflectGet(hash: string): Proposal | null;
+    /** Non-mutating preview of the change a proposal would make (REQ-REFLECT-003). */
+    reflectPreview(hash: string): PreviewResult | null;
+    /** Apply a proposal — write idempotently + reversibly, then record state. */
+    reflectApply(hash: string): ApplyOutcome | null;
+    /** Undo a previously applied proposal — remove exactly what apply added. */
+    reflectUndo(hash: string): UndoOutcome | null;
+    /** Dismiss a proposal so it does not resurface on later sweeps (REQ-REFLECT-007.A2). */
+    reflectDismiss(hash: string): boolean;
+    /**
+     * Initialize a new SpecShip project
+     *
+     * Creates the .SpecShip directory, database, and configuration.
+     *
+     * @param projectRoot - Path to the project root directory
+     * @param options - Initialization options
+     * @returns A new SpecShip instance
+     */
+    static init(projectRoot: string, options?: InitOptions): Promise<SpecShip>;
+    /**
+     * Initialize synchronously (without indexing)
+     */
+    static initSync(projectRoot: string): SpecShip;
+    /**
+     * Open an existing SpecShip project
+     *
+     * @param projectRoot - Path to the project root directory
+     * @param options - Open options
+     * @returns A SpecShip instance
+     */
+    static open(projectRoot: string, options?: OpenOptions): Promise<SpecShip>;
+    /**
+     * Open synchronously (without sync)
+     */
+    static openSync(projectRoot: string): SpecShip;
+    /**
+     * Check if a directory has been initialized as a SpecShip project
+     */
+    static isInitialized(projectRoot: string): boolean;
+    /**
+     * Close the SpecShip instance and release resources
+     */
+    close(): void;
+    /**
+     * Get the project root directory
+     */
+    getProjectRoot(): string;
+    /**
+     * Index all files in the project
+     *
+     * Uses a mutex to prevent concurrent indexing operations.
+     */
+    indexAll(options?: IndexOptions): Promise<IndexResult>;
+    /**
+     * Refresh `.specship/statusline.json` so the `specship statusline` segment
+     * has current Tier-A data without ever opening the DB itself
+     * (REQ-STATUSLINE-003). Best-effort: a failure here must never break the
+     * index/sync operation that triggered it, so the producer swallows its own
+     * errors and this wrapper guards the data-gathering too.
+     */
+    private refreshStatuslineCache;
+    /**
+     * Internal spec indexing — does NOT take the indexMutex (caller already holds it)
+     * and does NOT take the fileLock. Used by indexAll which manages locks itself.
+     */
+    private indexSpecsInternal;
+    /**
+     * Index spec files (Markdown only in v1).
+     *
+     * Default spec roots: `<projectRoot>/specs/` if it exists. Callers can
+     * pass explicit roots/files for non-default layouts.
+     *
+     * Pipeline per file:
+     *   1. Hash file content; skip if `spec_files.content_hash` matches.
+     *   2. Delete prior specs for this file (cascade-deletes children, links).
+     *   3. Run MarkdownSpecExtractor → insert specs + virtual node projections.
+     *   4. Apply `spec-declaration` link candidates from `implementations:`.
+     *   5. Mark previously-linked specs as drifted (drift_axis='spec') when
+     *      their content_hash has changed.
+     *
+     * Returns extraction stats including spec link resolver effects.
+     */
+    indexSpecs(roots?: string[]): Promise<{
+        filesProcessed: number;
+        filesSkipped: number;
+        specsExtracted: number;
+        linkCandidates: number;
+        resolverStats: SpecLinkResolverStats;
+        errors: number;
+        durationMs: number;
+    }>;
+    /**
+     * Default spec roots: `<projectRoot>/specs/` if it exists. Future
+     * iterations can read from `.specship/config.json`.
+     */
+    private defaultSpecRoots;
+    /**
+     * Recursively collect `.md` files from a directory.
+     */
+    private collectSpecFiles;
+    /**
+     * Index specific files
+     *
+     * Uses a mutex to prevent concurrent indexing operations.
+     */
+    indexFiles(filePaths: string[]): Promise<IndexResult>;
+    /**
+     * Sync with current file state (incremental update)
+     *
+     * Uses a mutex to prevent concurrent indexing operations.
+     */
+    sync(options?: IndexOptions): Promise<SyncResult>;
+    /**
+     * Check if an indexing operation is currently in progress
+     */
+    isIndexing(): boolean;
+    /**
+     * Start watching for file changes and auto-syncing.
+     *
+     * Uses native OS file events (FSEvents on macOS, inotify on Linux 19+,
+     * ReadDirectoryChangesW on Windows) with debouncing to avoid thrashing.
+     *
+     * @param options - Watch options (debounce delay, callbacks)
+     * @returns true if watching started successfully
+     */
+    watch(options?: WatchOptions): boolean;
+    /**
+     * Stop watching for file changes.
+     */
+    unwatch(): void;
+    /**
+     * Check if the file watcher is active.
+     */
+    isWatching(): boolean;
+    /**
+     * Files seen by the file watcher since the last successful sync —
+     * the per-file "stale" signal MCP tools attach to responses so an agent
+     * can fall back to {@link Read} for just the affected file without
+     * waiting for a debounced sync to complete (issue #403).
+     *
+     * Returns an empty list when the watcher isn't active, or no events have
+     * arrived. Each entry includes `firstSeenMs` and `lastSeenMs` (wall-clock
+     * `Date.now()` values) so callers can render "edited Nms ago", plus an
+     * `indexing` flag indicating whether the in-flight sync (if any) will
+     * absorb that file.
+     */
+    getPendingFiles(): PendingFile[];
+    /**
+     * Resolves once the file watcher has installed its watch set. Useful for
+     * tests that need a deterministic boundary before asserting on
+     * `getPendingFiles()`. Resolves immediately when no watcher is active.
+     */
+    waitUntilWatcherReady(timeoutMs?: number): Promise<void>;
+    /**
+     * Get files that have changed since last index
+     */
+    getChangedFiles(): {
+        added: string[];
+        modified: string[];
+        removed: string[];
+    };
+    /**
+     * Most recent index timestamp (ms since epoch) across all tracked files, or
+     * null when nothing is indexed yet. Lets library consumers check index
+     * freshness without shelling out to `specship status --json`. (#329)
+     */
+    getLastIndexedAt(): number | null;
+    /**
+     * Extract nodes and edges from source code (without storing)
+     */
+    extractFromSource(filePath: string, source: string): ExtractionResult;
+    /**
+     * Resolve unresolved references and create edges
+     *
+     * This method takes unresolved references from extraction and attempts
+     * to resolve them using multiple strategies:
+     * - Framework-specific patterns (React, Express, Laravel)
+     * - Import-based resolution
+     * - Name-based symbol matching
+     */
+    resolveReferences(onProgress?: (current: number, total: number) => void): ResolutionResult;
+    /**
+     * Resolve references in batches to keep memory bounded on large codebases.
+     * Processes chunks of unresolved refs, persisting results after each batch.
+     */
+    resolveReferencesBatched(onProgress?: (current: number, total: number) => void): Promise<ResolutionResult>;
+    /**
+     * Get detected frameworks in the project
+     */
+    getDetectedFrameworks(): string[];
+    /**
+     * Re-initialize the resolver (useful after adding new files)
+     */
+    reinitializeResolver(): void;
+    /**
+     * Get statistics about the knowledge graph
+     */
+    getStats(): GraphStats;
+    /**
+     * Active SQLite backend for this project's connection (`node-sqlite` — Node's
+     * built-in real-SQLite module). Surfaced via `specship status` and the
+     * `specship_status` MCP tool alongside the effective journal mode.
+     */
+    getBackend(): import('./db').SqliteBackend;
+    /**
+     * The journal mode actually in effect ('wal', 'delete', …). 'wal' means
+     * readers never block on a concurrent writer; anything else means they can,
+     * which is the precondition for the "database is locked" failures in issue
+     * #238. Surfaced via `specship status` and the `specship_status` MCP tool.
+     */
+    getJournalMode(): string;
+    /**
+     * Get a node by ID
+     */
+    getNode(id: string): Node | null;
+    /**
+     * Get all nodes in a file
+     */
+    getNodesInFile(filePath: string): Node[];
+    /**
+     * Get all nodes of a specific kind
+     */
+    getNodesByKind(kind: Node['kind']): Node[];
+    /**
+     * Get ALL nodes with an exact name (direct index lookup, not FTS-ranked/capped).
+     * Used to enumerate every overload of a heavily-overloaded name so the specific
+     * definition the caller wants is never dropped below a search cut.
+     */
+    getNodesByName(name: string): Node[];
+    /**
+     * Search nodes by text
+     */
+    searchNodes(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Find the project's "primary route file" — the file with the densest
+     * concentration of framework-emitted `route` nodes (≥3 routes, ≥30%
+     * of all non-test routes). Used to inline the routing config in
+     * `specship_explore` responses on small realworld template repos
+     * (rails-realworld, laravel-realworld, drupal-admintoolbar, …) where
+     * Glob+Read of `routes.rb`/`urls.py`/etc. otherwise beats specship.
+     */
+    getTopRouteFile(): {
+        filePath: string;
+        routeCount: number;
+        totalRoutes: number;
+    } | null;
+    /**
+     * Build a URL → handler routing manifest from the index. Each entry
+     * pairs a route node (URL + method) with its handler function/method
+     * via the `references` edge that framework resolvers emit. Returns
+     * null when fewer than 3 valid (non-test) routes exist.
+     */
+    getRoutingManifest(limit?: number): {
+        entries: Array<{
+            url: string;
+            handler: string;
+            handlerFile: string;
+            handlerLine: number;
+            handlerKind: string;
+        }>;
+        topHandlerFile: string | null;
+        topHandlerFileCount: number;
+        totalRoutes: number;
+    } | null;
+    /**
+     * Get outgoing edges from a node
+     */
+    getOutgoingEdges(nodeId: string): Edge[];
+    /**
+     * Get incoming edges to a node
+     */
+    getIncomingEdges(nodeId: string): Edge[];
+    /**
+     * Get a file record by path
+     */
+    getFile(filePath: string): FileRecord | null;
+    /**
+     * Get all tracked files
+     */
+    getFiles(): FileRecord[];
+    /**
+     * Estimate the set of files an agent would have needed to Read if it had
+     * NOT used the SpecShip graph to answer a query involving `symbols`.
+     *
+     * For each symbol name in `symbols`, `getNodesByName` is called (exact-match,
+     * no FTS) and the distinct project-relative file paths of the returned nodes
+     * are collected, capped at 5 files per symbol to avoid god-name blowup (a
+     * single overly-common name like `handle` should not pull in the whole repo).
+     * File paths are then deduped across all symbols and each path's byte size is
+     * looked up via `getFile(path)`.
+     *
+     * Returns:
+     *   - `files`: array of `{ path: string; size: number }` with project-relative
+     *     paths (matching `Node.filePath` / `FileRecord.path`). Callers can dedup
+     *     across multiple calls before summing.
+     *   - `resolved`: `true` when at least one file was found; `false` is the
+     *     safe "we couldn't estimate, claim nothing" sentinel.
+     *
+     * Synchronous — the graph is already open in memory like other query methods.
+     */
+    estimateReadEquivalent(symbols: string[]): {
+        files: {
+            path: string;
+            size: number;
+        }[];
+        resolved: boolean;
+    };
+    /**
+     * Get the context for a node (ancestors, children, references)
+     *
+     * Returns comprehensive context about a node including its containment
+     * hierarchy, children, incoming/outgoing references, type information,
+     * and relevant imports.
+     *
+     * @param nodeId - ID of the focal node
+     * @returns Context object with all related information
+     */
+    getContext(nodeId: string): Context;
+    /**
+     * Traverse the graph from a starting node
+     *
+     * Uses breadth-first search by default. Supports filtering by edge types,
+     * node types, and traversal direction.
+     *
+     * @param startId - Starting node ID
+     * @param options - Traversal options
+     * @returns Subgraph containing traversed nodes and edges
+     */
+    traverse(startId: string, options?: TraversalOptions): Subgraph;
+    /**
+     * Get the call graph for a function
+     *
+     * Returns both callers (functions that call this function) and
+     * callees (functions called by this function) up to the specified depth.
+     *
+     * @param nodeId - ID of the function/method node
+     * @param depth - Maximum depth in each direction (default: 2)
+     * @returns Subgraph containing the call graph
+     */
+    getCallGraph(nodeId: string, depth?: number): Subgraph;
+    /**
+     * Get the type hierarchy for a class/interface
+     *
+     * Returns both ancestors (types this extends/implements) and
+     * descendants (types that extend/implement this).
+     *
+     * @param nodeId - ID of the class/interface node
+     * @returns Subgraph containing the type hierarchy
+     */
+    getTypeHierarchy(nodeId: string): Subgraph;
+    /**
+     * Find all usages of a symbol
+     *
+     * Returns all nodes that reference the specified symbol through
+     * any edge type (calls, references, type_of, etc.).
+     *
+     * @param nodeId - ID of the symbol node
+     * @returns Array of nodes and edges that reference this symbol
+     */
+    findUsages(nodeId: string): Array<{
+        node: Node;
+        edge: Edge;
+    }>;
+    /**
+     * Get callers of a function/method
+     *
+     * @param nodeId - ID of the function/method node
+     * @param maxDepth - Maximum depth to traverse (default: 1)
+     * @returns Array of nodes that call this function
+     */
+    getCallers(nodeId: string, maxDepth?: number): Array<{
+        node: Node;
+        edge: Edge;
+    }>;
+    /**
+     * Get callees of a function/method
+     *
+     * @param nodeId - ID of the function/method node
+     * @param maxDepth - Maximum depth to traverse (default: 1)
+     * @returns Array of nodes called by this function
+     */
+    getCallees(nodeId: string, maxDepth?: number): Array<{
+        node: Node;
+        edge: Edge;
+    }>;
+    /**
+     * Calculate the impact radius of a node
+     *
+     * Returns all nodes that could be affected by changes to this node.
+     *
+     * @param nodeId - ID of the node
+     * @param maxDepth - Maximum depth to traverse (default: 3)
+     * @returns Subgraph containing potentially impacted nodes
+     */
+    getImpactRadius(nodeId: string, maxDepth?: number): Subgraph;
+    /**
+     * Find the shortest path between two nodes
+     *
+     * @param fromId - Starting node ID
+     * @param toId - Target node ID
+     * @param edgeKinds - Edge types to consider (all if empty)
+     * @returns Array of nodes and edges forming the path, or null if no path exists
+     */
+    findPath(fromId: string, toId: string, edgeKinds?: Edge['kind'][]): Array<{
+        node: Node;
+        edge: Edge | null;
+    }> | null;
+    /**
+     * Get ancestors of a node in the containment hierarchy
+     *
+     * @param nodeId - ID of the node
+     * @returns Array of ancestor nodes from immediate parent to root
+     */
+    getAncestors(nodeId: string): Node[];
+    /**
+     * Get immediate children of a node
+     *
+     * @param nodeId - ID of the node
+     * @returns Array of child nodes
+     */
+    getChildren(nodeId: string): Node[];
+    /**
+     * Get dependencies of a file
+     *
+     * @param filePath - Path to the file
+     * @returns Array of file paths this file depends on
+     */
+    getFileDependencies(filePath: string): string[];
+    /**
+     * Get dependents of a file
+     *
+     * @param filePath - Path to the file
+     * @returns Array of file paths that depend on this file
+     */
+    getFileDependents(filePath: string): string[];
+    /**
+     * Find circular dependencies in the codebase
+     *
+     * @returns Array of cycles, each cycle is an array of file paths
+     */
+    findCircularDependencies(): string[][];
+    /**
+     * Find dead code (unreferenced symbols)
+     *
+     * @param kinds - Node kinds to check (default: functions, methods, classes)
+     * @returns Array of unreferenced nodes
+     */
+    findDeadCode(kinds?: Node['kind'][]): Node[];
+    /**
+     * Get complexity metrics for a node
+     *
+     * @param nodeId - ID of the node
+     * @returns Object containing various complexity metrics
+     */
+    getNodeMetrics(nodeId: string): {
+        incomingEdgeCount: number;
+        outgoingEdgeCount: number;
+        callCount: number;
+        callerCount: number;
+        childCount: number;
+        depth: number;
+    };
+    /**
+     * Get the source code for a node
+     *
+     * Reads the file and extracts the code between startLine and endLine.
+     *
+     * @param nodeId - ID of the node
+     * @returns Code string or null if not found
+     */
+    getCode(nodeId: string): Promise<string | null>;
+    /**
+     * Find relevant subgraph for a query
+     *
+     * Combines semantic search with graph traversal to find the most
+     * relevant nodes and their relationships for a given query.
+     *
+     * @param query - Natural language query describing the task
+     * @param options - Search and traversal options
+     * @returns Subgraph of relevant nodes and edges
+     */
+    findRelevantContext(query: string, options?: FindRelevantContextOptions): Promise<Subgraph>;
+    /**
+     * Build context for a task
+     *
+     * Creates comprehensive context by:
+     * 1. Running FTS search to find entry points
+     * 2. Expanding the graph around entry points
+     * 3. Extracting code blocks for key nodes
+     * 4. Formatting output for Claude
+     *
+     * @param input - Task description (string or {title, description})
+     * @param options - Build options (maxNodes, includeCode, format, etc.)
+     * @returns TaskContext object or formatted string (markdown/JSON)
+     */
+    buildContext(input: TaskInput, options?: BuildContextOptions): Promise<TaskContext | string>;
+    /**
+     * Optimize the database (vacuum and analyze)
+     */
+    optimize(): void;
+    /**
+     * Clear all data from the graph
+     */
+    clear(): void;
+    /**
+     * Alias for close() for backwards compatibility.
+     * @deprecated Use close() instead
+     */
+    destroy(): void;
+    /**
+     * Completely remove SpecShip from the project.
+     * This closes the database and deletes the .SpecShip directory.
+     *
+     * WARNING: This permanently deletes all SpecShip data for the project.
+     */
+    uninitialize(): void;
+}
+export default SpecShip;
+//# sourceMappingURL=index.d.ts.map