@mars167/git-ai 2.3.0

package/dist/src/core/cpg/callGraph.js

@@ -0,0 +1,483 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallGraphBuilder = void 0;
+exports.buildCallGraph = buildCallGraph;
+exports.buildImportGraph = buildImportGraph;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const path_1 = __importDefault(require("path"));
+const tree_sitter_typescript_1 = __importDefault(require("tree-sitter-typescript"));
+const types_1 = require("./types");
+const paths_1 = require("../paths");
+const FUNCTION_NODE_TYPES = new Set([
+    'function_declaration',
+    'function',
+    'arrow_function',
+    'method_definition',
+]);
+const EXPORT_TYPES = new Set([
+    'export_statement',
+    'export_clause',
+    'export_specifier',
+    'export_default_declaration',
+    'export_assignment',
+]);
+const IMPORT_TYPES = new Set([
+    'import_statement',
+    'import_clause',
+    'import_specifier',
+    'namespace_import',
+]);
+function resolveModulePath(fromFile, specifier) {
+    if (!specifier)
+        return specifier;
+    if (specifier.startsWith('.')) {
+        const resolved = path_1.default.normalize(path_1.default.join(path_1.default.dirname(fromFile), specifier));
+        return (0, paths_1.toPosixPath)(resolved);
+    }
+    return specifier;
+}
+function collectSymbolTable(contexts) {
+    const table = new Map();
+    for (const ctx of contexts) {
+        const filePosix = (0, paths_1.toPosixPath)(ctx.filePath);
+        const visit = (node) => {
+            if (node.type === 'function_declaration' || node.type === 'method_definition') {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const symbol = {
+                        name: nameNode.text,
+                        kind: node.type === 'method_definition' ? 'method' : 'function',
+                        startLine: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        signature: node.text.split('{')[0].trim(),
+                    };
+                    const id = (0, types_1.symbolNodeId)(filePosix, symbol);
+                    table.set(`${filePosix}:${symbol.name}`, {
+                        id,
+                        name: symbol.name,
+                        file: filePosix,
+                        kind: symbol.kind,
+                        startLine: symbol.startLine,
+                        endLine: symbol.endLine,
+                    });
+                }
+            }
+            if (node.type === 'class_declaration') {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const symbol = {
+                        name: nameNode.text,
+                        kind: 'class',
+                        startLine: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        signature: `class ${nameNode.text}`,
+                    };
+                    const id = (0, types_1.symbolNodeId)(filePosix, symbol);
+                    table.set(`${filePosix}:${symbol.name}`, {
+                        id,
+                        name: symbol.name,
+                        file: filePosix,
+                        kind: symbol.kind,
+                        startLine: symbol.startLine,
+                        endLine: symbol.endLine,
+                    });
+                }
+            }
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child)
+                    visit(child);
+            }
+        };
+        visit(ctx.root);
+    }
+    return table;
+}
+function collectImports(context) {
+    const bindings = [];
+    const visit = (node) => {
+        if (node.type === 'import_statement') {
+            const source = node.childForFieldName('source');
+            const moduleName = source ? source.text.replace(/['"]/g, '') : '';
+            let clause = node.childForFieldName('clause') ?? node.childForFieldName('declaration');
+            if (!clause) {
+                for (let k = 0; k < node.namedChildCount; k++) {
+                    const c = node.namedChild(k);
+                    if (c?.type === 'import_clause') {
+                        clause = c;
+                        break;
+                    }
+                }
+            }
+            if (moduleName && clause) {
+                for (let i = 0; i < clause.namedChildCount; i++) {
+                    const child = clause.namedChild(i);
+                    if (!child)
+                        continue;
+                    if (child.type === 'identifier') {
+                        bindings.push({ modulePath: moduleName, importedName: 'default', localName: child.text });
+                    }
+                    else if (child.type === 'named_imports') {
+                        for (let j = 0; j < child.namedChildCount; j++) {
+                            const spec = child.namedChild(j);
+                            if (spec?.type === 'import_specifier') {
+                                const nameNode = spec.childForFieldName('name');
+                                const aliasNode = spec.childForFieldName('alias');
+                                const importedName = nameNode?.text ?? '';
+                                const localName = aliasNode?.text ?? importedName;
+                                if (localName)
+                                    bindings.push({ modulePath: moduleName, importedName, localName });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visit(child);
+        }
+    };
+    visit(context.root);
+    return bindings;
+}
+function collectCommonJsImports(context) {
+    const bindings = [];
+    const visit = (node) => {
+        if (node.type === 'call_expression') {
+            const callee = node.childForFieldName('function') ?? node.namedChild(0);
+            if (callee?.type === 'identifier' && callee.text === 'require') {
+                const args = node.childForFieldName('arguments');
+                const arg = args?.namedChild(0);
+                if (arg?.type === 'string') {
+                    const moduleName = arg.text.replace(/['"]/g, '');
+                    const parent = node.parent;
+                    if (parent?.type === 'variable_declarator') {
+                        const nameNode = parent.childForFieldName('name');
+                        if (nameNode?.type === 'identifier') {
+                            bindings.push({ modulePath: moduleName, importedName: 'default', localName: nameNode.text });
+                        }
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visit(child);
+        }
+    };
+    visit(context.root);
+    return bindings;
+}
+function collectFunctionScopes(context, symbolTable) {
+    const funcs = [];
+    const visit = (node) => {
+        if (FUNCTION_NODE_TYPES.has(node.type)) {
+            const nameNode = node.childForFieldName('name');
+            if (nameNode) {
+                const symbol = symbolTable.get(`${(0, paths_1.toPosixPath)(context.filePath)}:${nameNode.text}`);
+                const id = symbol?.id ?? (0, types_1.symbolNodeId)((0, paths_1.toPosixPath)(context.filePath), {
+                    name: nameNode.text,
+                    kind: node.type === 'method_definition' ? 'method' : 'function',
+                    signature: node.text.split('{')[0].trim(),
+                    startLine: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                });
+                funcs.push({
+                    id,
+                    name: nameNode.text,
+                    filePath: (0, paths_1.toPosixPath)(context.filePath),
+                    startLine: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                });
+            }
+        }
+        if (node.type === 'class_declaration') {
+            const nameNode = node.childForFieldName('name');
+            if (nameNode) {
+                const symbol = symbolTable.get(`${(0, paths_1.toPosixPath)(context.filePath)}:${nameNode.text}`);
+                const id = symbol?.id ?? (0, types_1.symbolNodeId)((0, paths_1.toPosixPath)(context.filePath), {
+                    name: nameNode.text,
+                    kind: 'class',
+                    signature: `class ${nameNode.text}`,
+                    startLine: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                });
+                funcs.push({
+                    id,
+                    name: nameNode.text,
+                    filePath: (0, paths_1.toPosixPath)(context.filePath),
+                    startLine: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                });
+            }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visit(child);
+        }
+    };
+    visit(context.root);
+    return funcs;
+}
+function findNearestFunction(node, symbolTable, filePath) {
+    let current = node;
+    while (current) {
+        if (FUNCTION_NODE_TYPES.has(current.type)) {
+            const nameNode = current.childForFieldName('name');
+            if (nameNode) {
+                const symbol = symbolTable.get(`${(0, paths_1.toPosixPath)(filePath)}:${nameNode.text}`);
+                const id = symbol?.id ?? (0, types_1.symbolNodeId)((0, paths_1.toPosixPath)(filePath), {
+                    name: nameNode.text,
+                    kind: current.type === 'method_definition' ? 'method' : 'function',
+                    signature: current.text.split('{')[0].trim(),
+                    startLine: current.startPosition.row + 1,
+                    endLine: current.endPosition.row + 1,
+                });
+                return { id, name: nameNode.text };
+            }
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function extractCalleeName(node) {
+    if (node.type === 'identifier')
+        return node.text;
+    if (node.type === 'member_expression' || node.type === 'optional_chain') {
+        const prop = node.childForFieldName('property');
+        if (prop)
+            return prop.text;
+        const last = node.namedChild(node.namedChildCount - 1);
+        if (last)
+            return last.text;
+    }
+    return null;
+}
+function resolveCallTarget(calleeNode, importBindings, symbolTable, currentFile) {
+    const filePosix = (0, paths_1.toPosixPath)(currentFile);
+    const lookup = (name, file) => {
+        if (file) {
+            let qualified = `${file}:${name}`;
+            if (symbolTable.has(qualified))
+                return symbolTable.get(qualified);
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.d.ts'];
+            for (const ext of extensions) {
+                qualified = `${file}${ext}:${name}`;
+                if (symbolTable.has(qualified))
+                    return symbolTable.get(qualified);
+            }
+            for (const ext of extensions) {
+                qualified = `${file}/index${ext}:${name}`;
+                if (symbolTable.has(qualified))
+                    return symbolTable.get(qualified);
+            }
+        }
+        return undefined;
+    };
+    if (calleeNode.type === 'identifier') {
+        const direct = lookup(calleeNode.text, filePosix);
+        if (direct)
+            return direct;
+        const imported = importBindings.find((binding) => binding.localName === calleeNode.text);
+        if (imported) {
+            const resolvedModule = resolveModulePath(filePosix, imported.modulePath);
+            const resolvedName = imported.importedName === 'default' ? 'default' : (imported.importedName || imported.localName);
+            if (imported.importedName === '*')
+                return null;
+            return lookup(resolvedName, resolvedModule) ?? null;
+        }
+    }
+    if (calleeNode.type === 'member_expression' || calleeNode.type === 'optional_chain') {
+        const objectNode = calleeNode.childForFieldName('object');
+        const propNode = calleeNode.childForFieldName('property') ?? calleeNode.namedChild(calleeNode.namedChildCount - 1);
+        if (objectNode?.type === 'identifier') {
+            const binding = importBindings.find((entry) => entry.localName === objectNode.text);
+            if (binding) {
+                const resolvedModule = resolveModulePath(filePosix, binding.modulePath);
+                const resolved = propNode ? lookup(propNode.text, resolvedModule) : null;
+                return resolved ?? null;
+            }
+        }
+    }
+    const fallback = extractCalleeName(calleeNode);
+    if (fallback)
+        return lookup(fallback, filePosix) ?? null;
+    return null;
+}
+function buildCallGraphLayer(contexts) {
+    const nodes = [];
+    const edges = [];
+    const edgeTypes = [types_1.EdgeType.CALLS, types_1.EdgeType.DEFINES];
+    const functions = new Map();
+    const calls = [];
+    const imports = [];
+    const symbolTable = collectSymbolTable(contexts);
+    for (const ctx of contexts) {
+        const filePosix = (0, paths_1.toPosixPath)(ctx.filePath);
+        const moduleId = (0, types_1.moduleNodeId)(filePosix);
+        const importBindings = [...collectImports(ctx), ...collectCommonJsImports(ctx)];
+        const importsByModule = new Map();
+        for (const binding of importBindings) {
+            const resolved = resolveModulePath(filePosix, binding.modulePath);
+            const set = importsByModule.get(resolved) ?? new Set();
+            set.add(binding.importedName || binding.localName);
+            importsByModule.set(resolved, set);
+        }
+        for (const [toFile, symbols] of importsByModule) {
+            imports.push({ fromFile: filePosix, toFile, importedSymbols: Array.from(symbols.values()) });
+        }
+        const fileFunctions = collectFunctionScopes(ctx, symbolTable);
+        for (const fn of fileFunctions) {
+            functions.set(fn.id, fn);
+            nodes.push({ id: fn.id, kind: 'symbol', label: fn.name, file: fn.filePath, startLine: fn.startLine, endLine: fn.endLine });
+        }
+        const visit = (node) => {
+            if (node.type === 'call_expression') {
+                const fnNode = node.childForFieldName('function') ?? node.namedChild(0);
+                if (fnNode) {
+                    const resolved = resolveCallTarget(fnNode, importBindings, symbolTable, ctx.filePath);
+                    if (resolved) {
+                        const caller = findNearestFunction(node, symbolTable, ctx.filePath) ?? { id: moduleId, name: filePosix };
+                        edges.push({ from: caller.id, to: resolved.id, type: types_1.EdgeType.CALLS });
+                        calls.push({ from: caller.id, to: resolved.id, line: node.startPosition.row + 1 });
+                    }
+                }
+            }
+            if (node.type === 'new_expression') {
+                const ctor = node.childForFieldName('constructor') ?? node.namedChild(0);
+                if (ctor) {
+                    const resolved = resolveCallTarget(ctor, importBindings, symbolTable, ctx.filePath);
+                    if (resolved) {
+                        const caller = findNearestFunction(node, symbolTable, ctx.filePath) ?? { id: moduleId, name: filePosix };
+                        edges.push({ from: caller.id, to: resolved.id, type: types_1.EdgeType.CALLS });
+                        calls.push({ from: caller.id, to: resolved.id, line: node.startPosition.row + 1 });
+                    }
+                }
+            }
+            if (EXPORT_TYPES.has(node.type)) {
+                const decl = node.childForFieldName('declaration');
+                const nameNode = decl?.childForFieldName('name');
+                if (nameNode) {
+                    const symbol = symbolTable.get(nameNode.text);
+                    if (symbol)
+                        edges.push({ from: moduleId, to: symbol.id, type: types_1.EdgeType.DEFINES });
+                }
+            }
+            if (node.type === 'class_declaration') {
+                const nameNode = node.childForFieldName('name');
+                if (nameNode) {
+                    const symbol = symbolTable.get(nameNode.text);
+                    if (symbol)
+                        edges.push({ from: moduleId, to: symbol.id, type: types_1.EdgeType.DEFINES });
+                }
+            }
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child)
+                    visit(child);
+            }
+        };
+        visit(ctx.root);
+        nodes.push((0, types_1.createModuleNode)(filePosix));
+    }
+    const graph = { functions, calls, imports };
+    const layer = { nodes, edges, edgeTypes };
+    return { graph, layer };
+}
+function buildCallGraph(contexts) {
+    return buildCallGraphLayer(contexts).layer;
+}
+function buildImportGraph(contexts) {
+    const nodes = [];
+    const edges = [];
+    const edgeTypes = [types_1.EdgeType.IMPORTS, types_1.EdgeType.INHERITS, types_1.EdgeType.IMPLEMENTS];
+    const symbolTable = collectSymbolTable(contexts);
+    for (const ctx of contexts) {
+        const filePosix = (0, paths_1.toPosixPath)(ctx.filePath);
+        const fileNode = (0, types_1.createModuleNode)(filePosix);
+        nodes.push(fileNode);
+        const visit = (node) => {
+            if (IMPORT_TYPES.has(node.type) && node.type === 'import_statement') {
+                const source = node.childForFieldName('source');
+                const moduleName = source ? source.text.replace(/['"]/g, '') : '';
+                if (moduleName) {
+                    const resolved = resolveModulePath(ctx.filePath, moduleName);
+                    nodes.push((0, types_1.createModuleNode)(resolved));
+                    edges.push({ from: fileNode.id, to: (0, types_1.moduleNodeId)(resolved), type: types_1.EdgeType.IMPORTS });
+                }
+            }
+            if (node.type === 'class_declaration') {
+                const extendsNode = node.childForFieldName('superclass');
+                if (extendsNode) {
+                    const target = symbolTable.get(extendsNode.text);
+                    if (target)
+                        edges.push({ from: fileNode.id, to: target.id, type: types_1.EdgeType.INHERITS });
+                }
+                const implNode = node.childForFieldName('interfaces');
+                if (implNode) {
+                    for (let i = 0; i < implNode.namedChildCount; i++) {
+                        const iface = implNode.namedChild(i);
+                        if (!iface)
+                            continue;
+                        const target = symbolTable.get(iface.text);
+                        if (target)
+                            edges.push({ from: fileNode.id, to: target.id, type: types_1.EdgeType.IMPLEMENTS });
+                    }
+                }
+            }
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child)
+                    visit(child);
+            }
+        };
+        visit(ctx.root);
+    }
+    return { nodes, edges, edgeTypes };
+}
+class CallGraphBuilder {
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+        this.contexts = [];
+        this.graph = null;
+    }
+    addFile(filePath, content) {
+        const parser = new tree_sitter_1.default();
+        parser.setLanguage(tree_sitter_typescript_1.default.typescript);
+        const tree = parser.parse(content);
+        const filePosix = (0, paths_1.toPosixPath)(path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(this.repoRoot, filePath));
+        this.contexts.push({ filePath: filePosix, lang: 'typescript', root: tree.rootNode });
+    }
+    build() {
+        if (!this.graph) {
+            this.graph = buildCallGraphLayer(this.contexts).graph;
+        }
+        return this.graph;
+    }
+    getCallees(functionId) {
+        const graph = this.build();
+        const callees = new Set();
+        for (const call of graph.calls) {
+            if (call.from === functionId)
+                callees.add(call.to);
+        }
+        return Array.from(callees);
+    }
+    getCallers(functionId) {
+        const graph = this.build();
+        const callers = new Set();
+        for (const call of graph.calls) {
+            if (call.to === functionId)
+                callers.add(call.from);
+        }
+        return Array.from(callers);
+    }
+}
+exports.CallGraphBuilder = CallGraphBuilder;