@mduenas/codegraph 0.4.0

package/dist/index.js

@@ -0,0 +1,818 @@
+"use strict";
+/**
+ * CodeGraph
+ *
+ * A local-first code intelligence system that builds a semantic
+ * knowledge graph from any codebase.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGraph = exports.MCPServer = exports.MemoryMonitor = exports.throttle = exports.debounce = exports.processInBatches = exports.Mutex = exports.defaultLogger = exports.silentLogger = exports.getLogger = exports.setLogger = exports.ConfigError = exports.VectorError = exports.SearchError = exports.DatabaseError = exports.ParseError = exports.FileError = exports.CodeGraphError = exports.getSupportedLanguages = exports.isLanguageSupported = exports.detectLanguage = exports.isInitialized = exports.getCodeGraphDir = exports.getConfigPath = exports.getDatabasePath = void 0;
+const path = __importStar(require("path"));
+const db_1 = require("./db");
+const queries_1 = require("./db/queries");
+const config_1 = require("./config");
+const directory_1 = require("./directory");
+const extraction_1 = require("./extraction");
+const resolution_1 = require("./resolution");
+const graph_1 = require("./graph");
+const vectors_1 = require("./vectors");
+const context_1 = require("./context");
+const sync_1 = require("./sync");
+const utils_1 = require("./utils");
+// Re-export types for consumers
+__exportStar(require("./types"), exports);
+var db_2 = require("./db");
+Object.defineProperty(exports, "getDatabasePath", { enumerable: true, get: function () { return db_2.getDatabasePath; } });
+var config_2 = require("./config");
+Object.defineProperty(exports, "getConfigPath", { enumerable: true, get: function () { return config_2.getConfigPath; } });
+var directory_2 = require("./directory");
+Object.defineProperty(exports, "getCodeGraphDir", { enumerable: true, get: function () { return directory_2.getCodeGraphDir; } });
+Object.defineProperty(exports, "isInitialized", { enumerable: true, get: function () { return directory_2.isInitialized; } });
+var extraction_2 = require("./extraction");
+Object.defineProperty(exports, "detectLanguage", { enumerable: true, get: function () { return extraction_2.detectLanguage; } });
+Object.defineProperty(exports, "isLanguageSupported", { enumerable: true, get: function () { return extraction_2.isLanguageSupported; } });
+Object.defineProperty(exports, "getSupportedLanguages", { enumerable: true, get: function () { return extraction_2.getSupportedLanguages; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "CodeGraphError", { enumerable: true, get: function () { return errors_1.CodeGraphError; } });
+Object.defineProperty(exports, "FileError", { enumerable: true, get: function () { return errors_1.FileError; } });
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
+Object.defineProperty(exports, "DatabaseError", { enumerable: true, get: function () { return errors_1.DatabaseError; } });
+Object.defineProperty(exports, "SearchError", { enumerable: true, get: function () { return errors_1.SearchError; } });
+Object.defineProperty(exports, "VectorError", { enumerable: true, get: function () { return errors_1.VectorError; } });
+Object.defineProperty(exports, "ConfigError", { enumerable: true, get: function () { return errors_1.ConfigError; } });
+Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return errors_1.setLogger; } });
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return errors_1.getLogger; } });
+Object.defineProperty(exports, "silentLogger", { enumerable: true, get: function () { return errors_1.silentLogger; } });
+Object.defineProperty(exports, "defaultLogger", { enumerable: true, get: function () { return errors_1.defaultLogger; } });
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "Mutex", { enumerable: true, get: function () { return utils_2.Mutex; } });
+Object.defineProperty(exports, "processInBatches", { enumerable: true, get: function () { return utils_2.processInBatches; } });
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return utils_2.debounce; } });
+Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return utils_2.throttle; } });
+Object.defineProperty(exports, "MemoryMonitor", { enumerable: true, get: function () { return utils_2.MemoryMonitor; } });
+var mcp_1 = require("./mcp");
+Object.defineProperty(exports, "MCPServer", { enumerable: true, get: function () { return mcp_1.MCPServer; } });
+/**
+ * Main CodeGraph class
+ *
+ * Provides the primary interface for interacting with the code knowledge graph.
+ */
+class CodeGraph {
+    db;
+    queries;
+    config;
+    projectRoot;
+    orchestrator;
+    resolver;
+    graphManager;
+    traverser;
+    vectorManager = null;
+    contextBuilder;
+    gitHooksManager;
+    // Mutex for preventing concurrent indexing operations
+    indexMutex = new utils_1.Mutex();
+    constructor(db, queries, config, projectRoot) {
+        this.db = db;
+        this.queries = queries;
+        this.config = config;
+        this.projectRoot = projectRoot;
+        this.orchestrator = new extraction_1.ExtractionOrchestrator(projectRoot, config, queries);
+        this.resolver = (0, resolution_1.createResolver)(projectRoot, queries);
+        this.graphManager = new graph_1.GraphQueryManager(queries);
+        this.traverser = new graph_1.GraphTraverser(queries);
+        // Vector manager is created lazily when embeddings are enabled
+        if (config.enableEmbeddings) {
+            this.vectorManager = (0, vectors_1.createVectorManager)(db.getDb(), queries, {
+                embedder: {
+                    cacheDir: path.join(projectRoot, '.codegraph', 'models'),
+                },
+            });
+        }
+        // Context builder (uses vector manager if available)
+        this.contextBuilder = (0, context_1.createContextBuilder)(projectRoot, queries, this.traverser, this.vectorManager);
+        // Git hooks manager
+        this.gitHooksManager = (0, sync_1.createGitHooksManager)(projectRoot);
+    }
+    // ===========================================================================
+    // Lifecycle Methods
+    // ===========================================================================
+    /**
+     * Initialize a new CodeGraph project
+     *
+     * Creates the .codegraph directory, database, and configuration.
+     *
+     * @param projectRoot - Path to the project root directory
+     * @param options - Initialization options
+     * @returns A new CodeGraph instance
+     */
+    static async init(projectRoot, options = {}) {
+        const resolvedRoot = path.resolve(projectRoot);
+        // Check if already initialized
+        if ((0, directory_1.isInitialized)(resolvedRoot)) {
+            throw new Error(`CodeGraph already initialized in ${resolvedRoot}`);
+        }
+        // Create directory structure
+        (0, directory_1.createDirectory)(resolvedRoot);
+        // Create and save configuration
+        const config = (0, config_1.createDefaultConfig)(resolvedRoot);
+        if (options.config) {
+            Object.assign(config, options.config);
+        }
+        (0, config_1.saveConfig)(resolvedRoot, config);
+        // Initialize database
+        const dbPath = (0, db_1.getDatabasePath)(resolvedRoot);
+        const db = db_1.DatabaseConnection.initialize(dbPath);
+        const queries = new queries_1.QueryBuilder(db.getDb());
+        const instance = new CodeGraph(db, queries, config, resolvedRoot);
+        // Run initial indexing if requested
+        if (options.index) {
+            await instance.indexAll({ onProgress: options.onProgress });
+        }
+        return instance;
+    }
+    /**
+     * Initialize synchronously (without indexing)
+     */
+    static initSync(projectRoot, options = {}) {
+        const resolvedRoot = path.resolve(projectRoot);
+        // Check if already initialized
+        if ((0, directory_1.isInitialized)(resolvedRoot)) {
+            throw new Error(`CodeGraph already initialized in ${resolvedRoot}`);
+        }
+        // Create directory structure
+        (0, directory_1.createDirectory)(resolvedRoot);
+        // Create and save configuration
+        const config = (0, config_1.createDefaultConfig)(resolvedRoot);
+        if (options.config) {
+            Object.assign(config, options.config);
+        }
+        (0, config_1.saveConfig)(resolvedRoot, config);
+        // Initialize database
+        const dbPath = (0, db_1.getDatabasePath)(resolvedRoot);
+        const db = db_1.DatabaseConnection.initialize(dbPath);
+        const queries = new queries_1.QueryBuilder(db.getDb());
+        return new CodeGraph(db, queries, config, resolvedRoot);
+    }
+    /**
+     * Open an existing CodeGraph project
+     *
+     * @param projectRoot - Path to the project root directory
+     * @param options - Open options
+     * @returns A CodeGraph instance
+     */
+    static async open(projectRoot, options = {}) {
+        const resolvedRoot = path.resolve(projectRoot);
+        // Check if initialized
+        if (!(0, directory_1.isInitialized)(resolvedRoot)) {
+            throw new Error(`CodeGraph not initialized in ${resolvedRoot}. Run init() first.`);
+        }
+        // Validate directory structure
+        const validation = (0, directory_1.validateDirectory)(resolvedRoot);
+        if (!validation.valid) {
+            throw new Error(`Invalid CodeGraph directory: ${validation.errors.join(', ')}`);
+        }
+        // Load configuration
+        const config = (0, config_1.loadConfig)(resolvedRoot);
+        // Open database
+        const dbPath = (0, db_1.getDatabasePath)(resolvedRoot);
+        const db = db_1.DatabaseConnection.open(dbPath);
+        const queries = new queries_1.QueryBuilder(db.getDb());
+        const instance = new CodeGraph(db, queries, config, resolvedRoot);
+        // Sync if requested
+        if (options.sync) {
+            await instance.sync();
+        }
+        return instance;
+    }
+    /**
+     * Open synchronously (without sync)
+     */
+    static openSync(projectRoot) {
+        const resolvedRoot = path.resolve(projectRoot);
+        // Check if initialized
+        if (!(0, directory_1.isInitialized)(resolvedRoot)) {
+            throw new Error(`CodeGraph not initialized in ${resolvedRoot}. Run init() first.`);
+        }
+        // Validate directory structure
+        const validation = (0, directory_1.validateDirectory)(resolvedRoot);
+        if (!validation.valid) {
+            throw new Error(`Invalid CodeGraph directory: ${validation.errors.join(', ')}`);
+        }
+        // Load configuration
+        const config = (0, config_1.loadConfig)(resolvedRoot);
+        // Open database
+        const dbPath = (0, db_1.getDatabasePath)(resolvedRoot);
+        const db = db_1.DatabaseConnection.open(dbPath);
+        const queries = new queries_1.QueryBuilder(db.getDb());
+        return new CodeGraph(db, queries, config, resolvedRoot);
+    }
+    /**
+     * Check if a directory has been initialized as a CodeGraph project
+     */
+    static isInitialized(projectRoot) {
+        return (0, directory_1.isInitialized)(path.resolve(projectRoot));
+    }
+    /**
+     * Close the CodeGraph instance and release resources
+     */
+    close() {
+        this.db.close();
+    }
+    // ===========================================================================
+    // Configuration
+    // ===========================================================================
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        Object.assign(this.config, updates);
+        (0, config_1.saveConfig)(this.projectRoot, this.config);
+        // Recreate orchestrator and resolver with new config
+        this.orchestrator = new extraction_1.ExtractionOrchestrator(this.projectRoot, this.config, this.queries);
+        this.resolver = (0, resolution_1.createResolver)(this.projectRoot, this.queries);
+    }
+    /**
+     * Get the project root directory
+     */
+    getProjectRoot() {
+        return this.projectRoot;
+    }
+    // ===========================================================================
+    // Indexing
+    // ===========================================================================
+    /**
+     * Index all files in the project
+     *
+     * Uses a mutex to prevent concurrent indexing operations.
+     */
+    async indexAll(options = {}) {
+        return this.indexMutex.withLock(async () => {
+            const result = await this.orchestrator.indexAll(options.onProgress, options.signal);
+            // Resolve references to create call/import/extends edges
+            if (result.success && result.filesIndexed > 0) {
+                options.onProgress?.({
+                    phase: 'resolving',
+                    current: 0,
+                    total: 1,
+                });
+                this.resolveReferences();
+            }
+            return result;
+        });
+    }
+    /**
+     * Index specific files
+     *
+     * Uses a mutex to prevent concurrent indexing operations.
+     */
+    async indexFiles(filePaths) {
+        return this.indexMutex.withLock(async () => {
+            return this.orchestrator.indexFiles(filePaths);
+        });
+    }
+    /**
+     * Sync with current file state (incremental update)
+     *
+     * Uses a mutex to prevent concurrent indexing operations.
+     */
+    async sync(options = {}) {
+        return this.indexMutex.withLock(async () => {
+            const result = await this.orchestrator.sync(options.onProgress);
+            // Resolve references if files were updated
+            if (result.filesAdded > 0 || result.filesModified > 0) {
+                this.resolveReferences();
+            }
+            return result;
+        });
+    }
+    /**
+     * Check if an indexing operation is currently in progress
+     */
+    isIndexing() {
+        return this.indexMutex.isLocked();
+    }
+    /**
+     * Get files that have changed since last index
+     */
+    getChangedFiles() {
+        return this.orchestrator.getChangedFiles();
+    }
+    /**
+     * Extract nodes and edges from source code (without storing)
+     */
+    extractFromSource(filePath, source) {
+        return (0, extraction_1.extractFromSource)(filePath, source);
+    }
+    // ===========================================================================
+    // Reference Resolution
+    // ===========================================================================
+    /**
+     * 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() {
+        // Get all unresolved references from the database
+        const unresolvedRefs = this.queries.getUnresolvedReferences();
+        return this.resolver.resolveAndPersist(unresolvedRefs);
+    }
+    /**
+     * Get detected frameworks in the project
+     */
+    getDetectedFrameworks() {
+        return this.resolver.getDetectedFrameworks();
+    }
+    /**
+     * Re-initialize the resolver (useful after adding new files)
+     */
+    reinitializeResolver() {
+        this.resolver.initialize();
+    }
+    // ===========================================================================
+    // Graph Statistics
+    // ===========================================================================
+    /**
+     * Get statistics about the knowledge graph
+     */
+    getStats() {
+        const stats = this.queries.getStats();
+        stats.dbSizeBytes = this.db.getSize();
+        return stats;
+    }
+    // ===========================================================================
+    // Node Operations
+    // ===========================================================================
+    /**
+     * Get a node by ID
+     */
+    getNode(id) {
+        return this.queries.getNodeById(id);
+    }
+    /**
+     * Get all nodes in a file
+     */
+    getNodesInFile(filePath) {
+        return this.queries.getNodesByFile(filePath);
+    }
+    /**
+     * Get all nodes of a specific kind
+     */
+    getNodesByKind(kind) {
+        return this.queries.getNodesByKind(kind);
+    }
+    /**
+     * Search nodes by text
+     */
+    searchNodes(query, options) {
+        return this.queries.searchNodes(query, options);
+    }
+    // ===========================================================================
+    // Edge Operations
+    // ===========================================================================
+    /**
+     * Get outgoing edges from a node
+     */
+    getOutgoingEdges(nodeId) {
+        return this.queries.getOutgoingEdges(nodeId);
+    }
+    /**
+     * Get incoming edges to a node
+     */
+    getIncomingEdges(nodeId) {
+        return this.queries.getIncomingEdges(nodeId);
+    }
+    // ===========================================================================
+    // File Operations
+    // ===========================================================================
+    /**
+     * Get a file record by path
+     */
+    getFile(filePath) {
+        return this.queries.getFileByPath(filePath);
+    }
+    /**
+     * Get all tracked files
+     */
+    getFiles() {
+        return this.queries.getAllFiles();
+    }
+    // ===========================================================================
+    // Graph Query Methods
+    // ===========================================================================
+    /**
+     * 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) {
+        return this.graphManager.getContext(nodeId);
+    }
+    /**
+     * 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, options) {
+        return this.traverser.traverseBFS(startId, options);
+    }
+    /**
+     * 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, depth = 2) {
+        return this.traverser.getCallGraph(nodeId, depth);
+    }
+    /**
+     * 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) {
+        return this.traverser.getTypeHierarchy(nodeId);
+    }
+    /**
+     * 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) {
+        return this.traverser.findUsages(nodeId);
+    }
+    /**
+     * 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, maxDepth = 1) {
+        return this.traverser.getCallers(nodeId, maxDepth);
+    }
+    /**
+     * 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, maxDepth = 1) {
+        return this.traverser.getCallees(nodeId, maxDepth);
+    }
+    /**
+     * 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, maxDepth = 3) {
+        return this.traverser.getImpactRadius(nodeId, maxDepth);
+    }
+    /**
+     * 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, toId, edgeKinds) {
+        return this.traverser.findPath(fromId, toId, edgeKinds);
+    }
+    /**
+     * 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) {
+        return this.traverser.getAncestors(nodeId);
+    }
+    /**
+     * Get immediate children of a node
+     *
+     * @param nodeId - ID of the node
+     * @returns Array of child nodes
+     */
+    getChildren(nodeId) {
+        return this.traverser.getChildren(nodeId);
+    }
+    /**
+     * Get dependencies of a file
+     *
+     * @param filePath - Path to the file
+     * @returns Array of file paths this file depends on
+     */
+    getFileDependencies(filePath) {
+        return this.graphManager.getFileDependencies(filePath);
+    }
+    /**
+     * Get dependents of a file
+     *
+     * @param filePath - Path to the file
+     * @returns Array of file paths that depend on this file
+     */
+    getFileDependents(filePath) {
+        return this.graphManager.getFileDependents(filePath);
+    }
+    /**
+     * Find circular dependencies in the codebase
+     *
+     * @returns Array of cycles, each cycle is an array of file paths
+     */
+    findCircularDependencies() {
+        return this.graphManager.findCircularDependencies();
+    }
+    /**
+     * Find dead code (unreferenced symbols)
+     *
+     * @param kinds - Node kinds to check (default: functions, methods, classes)
+     * @returns Array of unreferenced nodes
+     */
+    findDeadCode(kinds) {
+        return this.graphManager.findDeadCode(kinds);
+    }
+    /**
+     * Get complexity metrics for a node
+     *
+     * @param nodeId - ID of the node
+     * @returns Object containing various complexity metrics
+     */
+    getNodeMetrics(nodeId) {
+        return this.graphManager.getNodeMetrics(nodeId);
+    }
+    // ===========================================================================
+    // Semantic Search (Vector Embeddings)
+    // ===========================================================================
+    /**
+     * Initialize the embedding system
+     *
+     * This downloads the embedding model on first use and initializes
+     * the vector search system. Must be called before using semantic search.
+     */
+    async initializeEmbeddings() {
+        if (!this.vectorManager) {
+            this.vectorManager = (0, vectors_1.createVectorManager)(this.db.getDb(), this.queries, {
+                embedder: {
+                    showProgress: true,
+                },
+            });
+        }
+        await this.vectorManager.initialize();
+    }
+    /**
+     * Check if embeddings are initialized
+     */
+    isEmbeddingsInitialized() {
+        return this.vectorManager?.isInitialized() ?? false;
+    }
+    /**
+     * Generate embeddings for all eligible nodes
+     *
+     * @param onProgress - Optional progress callback
+     * @returns Number of nodes embedded
+     */
+    async generateEmbeddings(onProgress) {
+        if (!this.vectorManager) {
+            await this.initializeEmbeddings();
+        }
+        return this.vectorManager.embedAllNodes(onProgress);
+    }
+    /**
+     * Semantic search using embeddings
+     *
+     * Searches for code nodes semantically similar to the query.
+     * Requires embeddings to be initialized first.
+     *
+     * @param query - Natural language search query
+     * @param limit - Maximum number of results (default: 10)
+     * @returns Array of search results with similarity scores
+     */
+    async semanticSearch(query, limit = 10) {
+        if (!this.vectorManager || !this.vectorManager.isInitialized()) {
+            throw new Error('Embeddings not initialized. Call initializeEmbeddings() first.');
+        }
+        return this.vectorManager.search(query, { limit });
+    }
+    /**
+     * Find similar code blocks
+     *
+     * Finds nodes semantically similar to a given node.
+     * Requires embeddings to be initialized first.
+     *
+     * @param nodeId - ID of the node to find similar nodes for
+     * @param limit - Maximum number of results (default: 10)
+     * @returns Array of similar nodes with similarity scores
+     */
+    async findSimilar(nodeId, limit = 10) {
+        if (!this.vectorManager || !this.vectorManager.isInitialized()) {
+            throw new Error('Embeddings not initialized. Call initializeEmbeddings() first.');
+        }
+        return this.vectorManager.findSimilar(nodeId, { limit });
+    }
+    /**
+     * Get vector embedding statistics
+     */
+    getEmbeddingStats() {
+        if (!this.vectorManager) {
+            return null;
+        }
+        return this.vectorManager.getStats();
+    }
+    // ===========================================================================
+    // Context Building
+    // ===========================================================================
+    /**
+     * 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
+     */
+    async getCode(nodeId) {
+        return this.contextBuilder.getCode(nodeId);
+    }
+    /**
+     * 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
+     */
+    async findRelevantContext(query, options) {
+        // Update context builder with current vector manager
+        this.contextBuilder = (0, context_1.createContextBuilder)(this.projectRoot, this.queries, this.traverser, this.vectorManager);
+        return this.contextBuilder.findRelevantContext(query, options);
+    }
+    /**
+     * Build context for a task
+     *
+     * Creates comprehensive context by:
+     * 1. Running semantic 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)
+     */
+    async buildContext(input, options) {
+        // Update context builder with current vector manager
+        this.contextBuilder = (0, context_1.createContextBuilder)(this.projectRoot, this.queries, this.traverser, this.vectorManager);
+        return this.contextBuilder.buildContext(input, options);
+    }
+    // ===========================================================================
+    // Git Integration
+    // ===========================================================================
+    /**
+     * Check if the project is a git repository
+     */
+    isGitRepository() {
+        return this.gitHooksManager.isGitRepository();
+    }
+    /**
+     * Check if the CodeGraph git hook is installed
+     */
+    isGitHookInstalled() {
+        return this.gitHooksManager.isHookInstalled();
+    }
+    /**
+     * Install git hooks for automatic incremental indexing
+     *
+     * Installs a post-commit hook that automatically runs `codegraph sync`
+     * after each commit to keep the graph up-to-date.
+     *
+     * If a post-commit hook already exists:
+     * - If it's a CodeGraph hook, it will be updated
+     * - If it's a user hook, it will be backed up before installing
+     *
+     * @returns Result indicating success/failure and any messages
+     */
+    installGitHooks() {
+        return this.gitHooksManager.installHook();
+    }
+    /**
+     * Remove CodeGraph git hooks
+     *
+     * Removes the CodeGraph post-commit hook. If a backup of a previous
+     * user hook exists, it will be restored.
+     *
+     * @returns Result indicating success/failure and any messages
+     */
+    removeGitHooks() {
+        return this.gitHooksManager.removeHook();
+    }
+    // ===========================================================================
+    // Database Management
+    // ===========================================================================
+    /**
+     * Optimize the database (vacuum and analyze)
+     */
+    optimize() {
+        this.db.optimize();
+    }
+    /**
+     * Clear all data from the graph
+     */
+    clear() {
+        this.queries.clear();
+    }
+    /**
+     * Alias for close() for backwards compatibility.
+     * @deprecated Use close() instead
+     */
+    destroy() {
+        this.close();
+    }
+    /**
+     * Completely remove CodeGraph from the project.
+     * This closes the database and deletes the .codegraph directory.
+     *
+     * WARNING: This permanently deletes all CodeGraph data for the project.
+     */
+    uninitialize() {
+        this.db.close();
+        (0, directory_1.removeDirectory)(this.projectRoot);
+    }
+}
+exports.CodeGraph = CodeGraph;
+// Default export
+exports.default = CodeGraph;
+//# sourceMappingURL=index.js.map