@saluzi/codegraph 0.1.0 → 0.2.0

package/dist/graph/queries.js

@@ -1,366 +0,0 @@
-"use strict";
-/**
- * Graph Query Functions
- *
- * Higher-level query functions built on top of traversal algorithms.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphQueryManager = void 0;
-const traversal_1 = require("./traversal");
-/**
- * Graph query manager for complex queries
- */
-class GraphQueryManager {
-    queries;
-    traverser;
-    constructor(queries) {
-        this.queries = queries;
-        this.traverser = new traversal_1.GraphTraverser(queries);
-    }
-    /**
-     * Get full context for a node
-     *
-     * Returns the focal node along with its ancestors, children,
-     * and both incoming and outgoing references.
-     *
-     * @param nodeId - ID of the focal node
-     * @returns Context object with all related information
-     */
-    getContext(nodeId) {
-        const focal = this.queries.getNodeById(nodeId);
-        if (!focal) {
-            throw new Error(`Node not found: ${nodeId}`);
-        }
-        // Get ancestors (containment hierarchy)
-        const ancestors = this.traverser.getAncestors(nodeId);
-        // Get children
-        const children = this.traverser.getChildren(nodeId);
-        // Get incoming references (things that reference this node)
-        const incomingEdges = this.queries.getIncomingEdges(nodeId);
-        const incomingRefs = [];
-        for (const edge of incomingEdges) {
-            // Skip containment edges (already in ancestors)
-            if (edge.kind === 'contains') {
-                continue;
-            }
-            const node = this.queries.getNodeById(edge.source);
-            if (node) {
-                incomingRefs.push({ node, edge });
-            }
-        }
-        // Get outgoing references (things this node references)
-        const outgoingEdges = this.queries.getOutgoingEdges(nodeId);
-        const outgoingRefs = [];
-        for (const edge of outgoingEdges) {
-            // Skip containment edges (already in children)
-            if (edge.kind === 'contains') {
-                continue;
-            }
-            const node = this.queries.getNodeById(edge.target);
-            if (node) {
-                outgoingRefs.push({ node, edge });
-            }
-        }
-        // Get type information (type_of, returns edges)
-        const types = [];
-        const typeEdgeKinds = ['type_of', 'returns'];
-        for (const kind of typeEdgeKinds) {
-            const typeEdges = this.queries.getOutgoingEdges(nodeId, [kind]);
-            for (const edge of typeEdges) {
-                const typeNode = this.queries.getNodeById(edge.target);
-                if (typeNode && !types.some((t) => t.id === typeNode.id)) {
-                    types.push(typeNode);
-                }
-            }
-        }
-        // Get relevant imports
-        const imports = [];
-        const fileNode = ancestors.find((a) => a.kind === 'file');
-        if (fileNode) {
-            const importEdges = this.queries.getOutgoingEdges(fileNode.id, ['imports']);
-            for (const edge of importEdges) {
-                const importNode = this.queries.getNodeById(edge.target);
-                if (importNode) {
-                    imports.push(importNode);
-                }
-            }
-        }
-        return {
-            focal,
-            ancestors,
-            children,
-            incomingRefs,
-            outgoingRefs,
-            types,
-            imports,
-        };
-    }
-    /**
-     * Get dependencies of a file
-     *
-     * Returns all files that this file imports from.
-     *
-     * @param filePath - Path to the file
-     * @returns Array of file paths this file depends on
-     */
-    getFileDependencies(filePath) {
-        const nodes = this.queries.getNodesByFile(filePath);
-        const fileNode = nodes.find((n) => n.kind === 'file');
-        if (!fileNode) {
-            return [];
-        }
-        const dependencies = new Set();
-        const importEdges = this.queries.getOutgoingEdges(fileNode.id, ['imports']);
-        for (const edge of importEdges) {
-            const targetNode = this.queries.getNodeById(edge.target);
-            if (targetNode && targetNode.filePath !== filePath) {
-                dependencies.add(targetNode.filePath);
-            }
-        }
-        return Array.from(dependencies);
-    }
-    /**
-     * Get dependents of a file
-     *
-     * Returns all files that import from this file.
-     *
-     * @param filePath - Path to the file
-     * @returns Array of file paths that depend on this file
-     */
-    getFileDependents(filePath) {
-        const nodes = this.queries.getNodesByFile(filePath);
-        const dependents = new Set();
-        // Check file-level incoming import edges (file:X imports file:Y)
-        const fileNode = nodes.find((n) => n.kind === 'file');
-        if (fileNode) {
-            const incomingFileEdges = this.queries.getIncomingEdges(fileNode.id, ['imports']);
-            for (const edge of incomingFileEdges) {
-                const sourceNode = this.queries.getNodeById(edge.source);
-                if (sourceNode && sourceNode.filePath !== filePath) {
-                    dependents.add(sourceNode.filePath);
-                }
-            }
-        }
-        // Also check node-level imports of exported symbols
-        for (const node of nodes) {
-            if (node.isExported) {
-                const incomingEdges = this.queries.getIncomingEdges(node.id, ['imports']);
-                for (const edge of incomingEdges) {
-                    const sourceNode = this.queries.getNodeById(edge.source);
-                    if (sourceNode && sourceNode.filePath !== filePath) {
-                        dependents.add(sourceNode.filePath);
-                    }
-                }
-            }
-        }
-        return Array.from(dependents);
-    }
-    /**
-     * Get all symbols exported by a file
-     *
-     * @param filePath - Path to the file
-     * @returns Array of exported nodes
-     */
-    getExportedSymbols(filePath) {
-        const nodes = this.queries.getNodesByFile(filePath);
-        return nodes.filter((n) => n.isExported);
-    }
-    /**
-     * Find symbols by qualified name pattern
-     *
-     * @param pattern - Pattern to match (supports * wildcard)
-     * @returns Array of matching nodes
-     */
-    findByQualifiedName(pattern) {
-        // Convert glob pattern to regex
-        const regexPattern = pattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        const regex = new RegExp(`^${regexPattern}$`);
-        // This is inefficient for large graphs - would need FTS index on qualified_name
-        // For now, use kind-based filtering if possible
-        const allNodes = [];
-        const kinds = [
-            'class',
-            'function',
-            'method',
-            'interface',
-            'type_alias',
-            'variable',
-            'constant',
-        ];
-        for (const kind of kinds) {
-            const nodes = this.queries.getNodesByKind(kind);
-            for (const node of nodes) {
-                if (regex.test(node.qualifiedName)) {
-                    allNodes.push(node);
-                }
-            }
-        }
-        return allNodes;
-    }
-    /**
-     * Get the module/package structure
-     *
-     * Returns a tree structure of files organized by directory.
-     *
-     * @returns Map of directory paths to contained files
-     */
-    getModuleStructure() {
-        const files = this.queries.getAllFiles();
-        const structure = new Map();
-        for (const file of files) {
-            const parts = file.path.split('/');
-            const dir = parts.slice(0, -1).join('/') || '.';
-            if (!structure.has(dir)) {
-                structure.set(dir, []);
-            }
-            structure.get(dir).push(file.path);
-        }
-        return structure;
-    }
-    /**
-     * Find circular dependencies in the graph
-     *
-     * @returns Array of cycles, each cycle is an array of node IDs
-     */
-    findCircularDependencies() {
-        const files = this.queries.getAllFiles();
-        const cycles = [];
-        const visited = new Set();
-        const recursionStack = new Set();
-        const dfs = (filePath, path) => {
-            if (recursionStack.has(filePath)) {
-                // Found a cycle
-                const cycleStart = path.indexOf(filePath);
-                if (cycleStart !== -1) {
-                    cycles.push(path.slice(cycleStart));
-                }
-                return;
-            }
-            if (visited.has(filePath)) {
-                return;
-            }
-            visited.add(filePath);
-            recursionStack.add(filePath);
-            const dependencies = this.getFileDependencies(filePath);
-            for (const dep of dependencies) {
-                dfs(dep, [...path, filePath]);
-            }
-            recursionStack.delete(filePath);
-        };
-        for (const file of files) {
-            if (!visited.has(file.path)) {
-                dfs(file.path, []);
-            }
-        }
-        return cycles;
-    }
-    /**
-     * Get complexity metrics for a node
-     *
-     * @param nodeId - ID of the node
-     * @returns Object containing various complexity metrics
-     */
-    getNodeMetrics(nodeId) {
-        const incomingEdges = this.queries.getIncomingEdges(nodeId);
-        const outgoingEdges = this.queries.getOutgoingEdges(nodeId);
-        const callEdges = outgoingEdges.filter((e) => e.kind === 'calls');
-        const callerEdges = incomingEdges.filter((e) => e.kind === 'calls');
-        const containsEdges = outgoingEdges.filter((e) => e.kind === 'contains');
-        const ancestors = this.traverser.getAncestors(nodeId);
-        return {
-            incomingEdgeCount: incomingEdges.length,
-            outgoingEdgeCount: outgoingEdges.length,
-            callCount: callEdges.length,
-            callerCount: callerEdges.length,
-            childCount: containsEdges.length,
-            depth: ancestors.length,
-        };
-    }
-    /**
-     * Find dead code (nodes with no incoming references)
-     *
-     * @param kinds - Node kinds to check (default: functions, methods, classes)
-     * @returns Array of unreferenced nodes
-     */
-    findDeadCode(kinds) {
-        const targetKinds = kinds || ['function', 'method', 'class'];
-        const deadCode = [];
-        for (const kind of targetKinds) {
-            const nodes = this.queries.getNodesByKind(kind);
-            for (const node of nodes) {
-                // Skip exported symbols (they may be used externally)
-                if (node.isExported) {
-                    continue;
-                }
-                const incomingEdges = this.queries.getIncomingEdges(node.id);
-                // Filter out containment edges
-                const references = incomingEdges.filter((e) => e.kind !== 'contains');
-                if (references.length === 0) {
-                    deadCode.push(node);
-                }
-            }
-        }
-        return deadCode;
-    }
-    /**
-     * Get subgraph containing nodes matching a filter
-     *
-     * @param filter - Filter function to select nodes
-     * @param includeEdges - Whether to include edges between matching nodes
-     * @returns Subgraph containing matching nodes
-     */
-    getFilteredSubgraph(filter, includeEdges = true) {
-        const nodes = new Map();
-        const edges = [];
-        // Get all nodes of common kinds
-        const kinds = [
-            'file',
-            'module',
-            'class',
-            'struct',
-            'interface',
-            'trait',
-            'function',
-            'method',
-            'variable',
-            'constant',
-            'enum',
-            'type_alias',
-        ];
-        for (const kind of kinds) {
-            const kindNodes = this.queries.getNodesByKind(kind);
-            for (const node of kindNodes) {
-                if (filter(node)) {
-                    nodes.set(node.id, node);
-                }
-            }
-        }
-        // Include edges between matching nodes
-        if (includeEdges) {
-            for (const nodeId of nodes.keys()) {
-                const outgoing = this.queries.getOutgoingEdges(nodeId);
-                for (const edge of outgoing) {
-                    if (nodes.has(edge.target)) {
-                        edges.push(edge);
-                    }
-                }
-            }
-        }
-        return {
-            nodes,
-            edges,
-            roots: [],
-        };
-    }
-    /**
-     * Access the underlying traverser for direct traversal operations
-     */
-    getTraverser() {
-        return this.traverser;
-    }
-}
-exports.GraphQueryManager = GraphQueryManager;
-//# sourceMappingURL=queries.js.map

package/dist/graph/traversal.d.ts

@@ -1,137 +0,0 @@
-/**
- * Graph Traversal Algorithms
- *
- * BFS and DFS traversal for the code knowledge graph.
- */
-import { Node, Edge, Subgraph, TraversalOptions, EdgeKind } from '../types'
-import { QueryBuilder } from '../db/queries'
-/**
- * Graph traverser for BFS and DFS traversal
- */
-export declare class GraphTraverser {
-  private queries
-  constructor(queries: QueryBuilder)
-  /**
-   * Traverse the graph using breadth-first search
-   *
-   * @param startId - Starting node ID
-   * @param options - Traversal options
-   * @returns Subgraph containing traversed nodes and edges
-   */
-  traverseBFS(startId: string, options?: TraversalOptions): Subgraph
-  /**
-   * Traverse the graph using depth-first search
-   *
-   * @param startId - Starting node ID
-   * @param options - Traversal options
-   * @returns Subgraph containing traversed nodes and edges
-   */
-  traverseDFS(startId: string, options?: TraversalOptions): Subgraph
-  /**
-   * Recursive DFS helper
-   */
-  private dfsRecursive
-  /**
-   * Get adjacent edges based on direction
-   */
-  private getAdjacentEdges
-  /**
-   * Find all 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
-  }>
-  private getCallersRecursive
-  /**
-   * Find all functions/methods called by a function
-   *
-   * @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
-  }>
-  private getCalleesRecursive
-  /**
-   * Get the call graph for a function (both callers and callees)
-   *
-   * @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
-   *
-   * @param nodeId - ID of the class/interface node
-   * @returns Subgraph containing the type hierarchy
-   */
-  getTypeHierarchy(nodeId: string): Subgraph
-  private getTypeAncestors
-  private getTypeDescendants
-  /**
-   * Find all usages of a symbol
-   *
-   * @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
-  }>
-  /**
-   * 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
-  private getImpactRecursive
-  /**
-   * 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?: EdgeKind[],
-  ): Array<{
-    node: Node
-    edge: Edge | null
-  }> | null
-  /**
-   * Get the containment hierarchy for a node (ancestors)
-   *
-   * @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[]
-}
-//# sourceMappingURL=traversal.d.ts.map