@ltm-alpha/alpha-cs 1.6.0

package/dist/graph/symbol-lookup.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Symbol Lookup — the single "what did the user mean by this name?" path.
+ *
+ * Every verb that takes a symbol NAME from a human (or an agent) has to turn
+ * that string into node(s). `codegraph_node` and `codegraph_explore` went
+ * through the matcher below; the `callers` / `callees` / `impact` CLI verbs
+ * carried their own ad-hoc filter instead:
+ *
+ *     node.name === symbol || node.name.endsWith('.' + symbol)
+ *
+ * which compares the query against the BARE name only. That produced two
+ * opposite failures in the same repository:
+ *
+ *   - a bare name over-reported: `callers group` silently merged the callers of
+ *     every distinct symbol named `group` — in any language — into one list
+ *     headed "Callers of group", with nothing saying they were different
+ *     symbols;
+ *   - a qualified name under-reported: `Foo.Bar.baz` can never equal a bare
+ *     `baz`, so every candidate failed the filter and the code fell through to
+ *     an arbitrary top-of-FTS hit — or reported "not found" for a symbol that
+ *     plainly exists.
+ *
+ * Both are fixed by routing all of them through one resolver, which this module
+ * owns so the CLI and the MCP tools cannot drift apart again.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUST_PATH_PREFIXES = void 0;
+exports.isQualifiedSymbol = isQualifiedSymbol;
+exports.lastQualifierPart = lastQualifierPart;
+exports.matchesSymbol = matchesSymbol;
+exports.groupDefinitions = groupDefinitions;
+exports.lookupSymbolNodes = lookupSymbolNodes;
+exports.describeSymbolNode = describeSymbolNode;
+/** Rust path prefixes that name no directory (`crate::x`, `super::y`). */
+exports.RUST_PATH_PREFIXES = new Set(['crate', 'super', 'self']);
+/** Does this query carry any scope qualifier at all? */
+function isQualifiedSymbol(symbol) {
+    return /[.\/]|::/.test(symbol);
+}
+/** The bare identifier at the end of a qualified query (arity spelling stripped). */
+function lastQualifierPart(symbol) {
+    const noArity = symbol.replace(/\/\d{1,3}$/, '') || symbol;
+    const parts = noArity.split(/::|[./]/).filter((p) => p.length > 0);
+    return parts[parts.length - 1] ?? symbol;
+}
+/**
+ * Rewrite every scope separator to `.` so a query and a stored qualifiedName
+ * written in different conventions can be compared directly. The extractors
+ * join hierarchy with `::` while users type the language's own spelling
+ * (`Session.request`, `stage_apply::run`, `pkg/mod.Fn`).
+ */
+function canonicalScope(text) {
+    return text.replace(/::/g, '.').replace(/\//g, '.');
+}
+/**
+ * Does `node` satisfy the user's symbol query?
+ *
+ * Bare queries match the name. Qualified queries are checked against the
+ * qualifiedName under both separator conventions, then — for languages whose
+ * hierarchy lives in the file path rather than the name (Rust modules, Python
+ * packages) — against the path.
+ */
+function matchesSymbol(node, symbol) {
+    // Erlang arity spelling (`fn/3`, `mod:fn/3`): when the node's qualifiedName
+    // carries an arity (#1610) the written arity must match exactly, and the rest
+    // of the comparison runs on the arity-less spelling. A node with no arity
+    // keeps the original symbol (a `/` there means a path-ish name instead).
+    const aritySpelling = /^(.+)\/(\d{1,3})$/.exec(symbol);
+    if (aritySpelling) {
+        const nodeArity = /\/(\d{1,3})$/.exec(node.qualifiedName ?? '')?.[1];
+        if (nodeArity !== undefined) {
+            if (nodeArity !== aritySpelling[2])
+                return false;
+            symbol = aritySpelling[1];
+        }
+    }
+    if (node.name === symbol)
+        return true;
+    // File basename match ("product-card" matches "product-card.liquid").
+    if (node.kind === 'file' && node.name.replace(/\.[^.]+$/, '') === symbol)
+        return true;
+    if (!isQualifiedSymbol(symbol))
+        return false;
+    const parts = symbol.split(/::|[./]/).filter((p) => p.length > 0);
+    if (parts.length < 2)
+        return false;
+    const lastPart = parts[parts.length - 1];
+    if (node.name !== lastPart)
+        return false;
+    // Stage 1: qualified-name containment under the extractor's `::` convention.
+    if (node.qualifiedName.includes(parts.join('::')))
+        return true;
+    // Stage 1b: boundary-aligned suffix under a canonical separator.
+    //
+    // Splitting on EVERY separator assumes no scope component contains one —
+    // false for any language whose module names are themselves dotted (Elixir
+    // `AppWeb.Format`, a Java/C# package, a Python dotted module). There the
+    // stored qualifiedName is `AppWeb.Format::group`, so the stage-1 spelling
+    // `AppWeb::Format::group` cannot match and a perfectly precise query
+    // resolved to nothing. Canonicalising both sides and requiring the match to
+    // land on a separator boundary handles both conventions with one rule, and
+    // is strictly tighter than the `includes` above.
+    const canonicalQuery = canonicalScope(symbol);
+    const canonicalNode = canonicalScope(node.qualifiedName);
+    if (canonicalNode === canonicalQuery || canonicalNode.endsWith(`.${canonicalQuery}`)) {
+        return true;
+    }
+    // Stage 2: file-path containment. Rust modules and Python packages are not in
+    // qualifiedName — they are encoded in the path — so `stage_apply::run`
+    // matches a `run` in any file with a `stage_apply` path segment.
+    const containerHints = parts.slice(0, -1).filter((p) => !exports.RUST_PATH_PREFIXES.has(p));
+    if (containerHints.length === 0)
+        return false;
+    const segments = node.filePath.split('/').filter((s) => s.length > 0);
+    return containerHints.every((hint) => segments.some((seg) => seg === hint || seg.replace(/\.[^.]+$/, '') === hint));
+}
+/**
+ * One group per (filePath, qualifiedName): same-file overloads stay together,
+ * while unrelated definitions keep their own edges. Shared by CLI and MCP.
+ * A non-matching file hint keeps all definitions and must be disclosed.
+ */
+function groupDefinitions(nodes, fileFilter) {
+    let pool = nodes;
+    let filteredOut = false;
+    if (fileFilter) {
+        const wanted = fileFilter.replace(/^\.\//, '');
+        const narrowed = pool.filter((n) => n.filePath === wanted || n.filePath.endsWith(wanted) || n.filePath.endsWith(`/${wanted}`));
+        if (narrowed.length > 0)
+            pool = narrowed;
+        else
+            filteredOut = true;
+    }
+    const byDef = new Map();
+    for (const n of pool) {
+        const key = `${n.filePath}|${n.qualifiedName}`;
+        const group = byDef.get(key);
+        if (group)
+            group.push(n);
+        else
+            byDef.set(key, [n]);
+    }
+    return { groups: [...byDef.values()], filteredOut };
+}
+/**
+ * Resolve a user-supplied symbol name to the definitions it names.
+ *
+ * The exact-name index is consulted FIRST and is authoritative: it is complete
+ * and uncapped, whereas FTS ranks and truncates, and tokenises away `::` — so
+ * a qualified query could miss a symbol that exists, or land on whatever
+ * happened to rank first. FTS candidates still have to satisfy the matcher;
+ * partial or mistyped names must never select the top fuzzy hit (#1473).
+ */
+function lookupSymbolNodes(cg, symbol) {
+    const qualified = isQualifiedSymbol(symbol);
+    // Exact-name index, then filter by the qualifier the user actually wrote.
+    const tail = qualified ? lastQualifierPart(symbol) : symbol;
+    let nodes = tail ? cg.getNodesByName(tail) : [];
+    if (qualified)
+        nodes = nodes.filter((n) => matchesSymbol(n, symbol));
+    if (nodes.length === 0) {
+        const hits = cg.searchNodes(symbol, { limit: 50 }).map((h) => h.node);
+        const exact = hits.filter((n) => matchesSymbol(n, symbol));
+        if (exact.length > 0) {
+            nodes = exact;
+        }
+        // Any query with no exact match resolves to NOTHING rather than a
+        // misleading fuzzy hit (#1473; qualified lookups already did this in #173).
+    }
+    if (nodes.length === 0)
+        return { nodes: [], ambiguous: false };
+    // Keepers before generated stubs (.pb.go and friends), stable otherwise.
+    const isGenerated = cg.generatedFilePredicate(nodes.map((n) => n.filePath));
+    const ranked = [...nodes].sort((a, b) => (isGenerated(a.filePath) ? 1 : 0) - (isGenerated(b.filePath) ? 1 : 0));
+    return { nodes: ranked, ambiguous: groupDefinitions(ranked).groups.length > 1 };
+}
+/** One-line "kind at path:line" label used when disclosing an ambiguous query. */
+function describeSymbolNode(node) {
+    return `${node.kind} ${node.qualifiedName || node.name} (${node.language}) — ${node.filePath}:${node.startLine}`;
+}
+//# sourceMappingURL=symbol-lookup.js.map

package/dist/graph/symbol-lookup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-lookup.js","sourceRoot":"","sources":["../../src/graph/symbol-lookup.ts"],"names":[],"mappings":"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"}

package/dist/graph/traversal.d.ts

@@ -0,0 +1,127 @@
+/**
+ * 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

package/dist/graph/traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.d.ts","sourceRoot":"","sources":["../../src/graph/traversal.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAuB7C;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAe;gBAElB,OAAO,EAAE,YAAY;IAIjC;;;;;;OAMG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,QAAQ;IAmGtE;;;;;;OAMG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,QAAQ;IAyBtE;;OAEG;IACH,OAAO,CAAC,YAAY;IAkDpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;IASnF,OAAO,CAAC,mBAAmB;IA0C3B;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;IASnF,OAAO,CAAC,mBAAmB;IAsC3B;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,QAAQ;IAiCzD;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IA0B1C,OAAO,CAAC,gBAAgB;IAyBxB,OAAO,CAAC,kBAAkB;IAyB1B;;;;;OAKG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;IAiB7D;;;;;;;;OAQG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU,GAAG,QAAQ;IAuB/D,OAAO,CAAC,kBAAkB;IAkE1B;;;;;;;OAOG;IACH,QAAQ,CACN,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,QAAQ,EAAO,GACzB,KAAK,CAAC;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;KAAE,CAAC,GAAG,IAAI;IAuDlD;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE;IAgCpC;;;;;OAKG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE;CAapC"}