@mars167/git-ai 2.3.0

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

@@ -0,0 +1,490 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCfgLayer = buildCfgLayer;
+exports.buildCFG = buildCFG;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const tree_sitter_typescript_1 = __importDefault(require("tree-sitter-typescript"));
+const types_1 = require("./types");
+const SIMPLE_STATEMENT_TYPES = new Set([
+    'expression_statement',
+    'variable_declaration',
+    'lexical_declaration',
+    'empty_statement',
+    'debugger_statement',
+]);
+const LOOP_TYPES = new Set([
+    'for_statement',
+    'for_in_statement',
+    'for_of_statement',
+    'while_statement',
+    'do_statement',
+]);
+const CONDITIONAL_TYPES = new Set(['if_statement', 'conditional_expression']);
+const SHORT_CIRCUIT_TYPES = new Set(['logical_expression', 'conditional_expression']);
+const FUNCTION_TYPES = new Set(['function_declaration', 'function', 'arrow_function', 'method_definition']);
+function isStatementNode(node) {
+    if (node.type === 'statement_block')
+        return true;
+    if (node.type === 'block')
+        return true;
+    if (node.type.endsWith('_statement'))
+        return true;
+    if (node.type.endsWith('_declaration'))
+        return true;
+    if (CONDITIONAL_TYPES.has(node.type))
+        return true;
+    if (SHORT_CIRCUIT_TYPES.has(node.type))
+        return true;
+    if (LOOP_TYPES.has(node.type))
+        return true;
+    if (node.type === 'switch_statement' || node.type === 'try_statement')
+        return true;
+    if (node.type === 'switch_case' || node.type === 'switch_default')
+        return true;
+    if (node.type === 'variable_declaration' || node.type === 'lexical_declaration')
+        return true;
+    return false;
+}
+function emitEdge(edges, from, to, type) {
+    if (!from || !to)
+        return;
+    if (from === to && type !== types_1.EdgeType.TRUE_BRANCH && type !== types_1.EdgeType.FALSE_BRANCH)
+        return;
+    edges.push({ from, to, type });
+}
+function collectNamedChildren(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            out.push(child);
+    }
+    return out;
+}
+// helper inlined to avoid unused warning
+function buildBlock(nodes, filePath, edges, loop) {
+    let entryId = null;
+    let exits = [];
+    for (const stmt of nodes) {
+        if (!isStatementNode(stmt)) {
+            if (stmt.type === 'expression_statement' || stmt.type === 'return_statement') {
+                const exprEdges = buildExpressionEdges(stmt, filePath, edges, loop);
+                if (exprEdges.entryId) {
+                    if (!entryId)
+                        entryId = exprEdges.entryId;
+                    for (const exit of exits) {
+                        emitEdge(edges, exit, exprEdges.entryId, types_1.EdgeType.NEXT_STATEMENT);
+                    }
+                    exits = exprEdges.exits;
+                }
+            }
+            continue;
+        }
+        const result = buildStatement(stmt, filePath, edges, loop);
+        if (!result.entryId)
+            continue;
+        if (!entryId)
+            entryId = result.entryId;
+        for (const exit of exits) {
+            emitEdge(edges, exit, result.entryId, types_1.EdgeType.NEXT_STATEMENT);
+        }
+        exits = result.exits;
+    }
+    return { entryId, exits };
+}
+function buildSimple(node, filePath) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    return { entryId: id, exits: [id] };
+}
+function buildReturn(node, filePath) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    return { entryId: id, exits: [] };
+}
+function buildThrow(node, filePath) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    return { entryId: id, exits: [] };
+}
+function buildBreak(node, filePath, loop) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    if (loop)
+        loop.breakTargets.push(id);
+    return { entryId: id, exits: [] };
+}
+function buildContinue(node, filePath, edges, loop) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    if (loop?.continueTarget) {
+        emitEdge(edges, id, loop.continueTarget, types_1.EdgeType.NEXT_STATEMENT);
+    }
+    return { entryId: id, exits: [] };
+}
+function buildIf(node, filePath, edges, loop) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    const consequence = node.childForFieldName('consequence') ?? node.childForFieldName('body');
+    const alternate = node.childForFieldName('alternative');
+    let trueResult = null;
+    let falseResult = null;
+    if (consequence) {
+        const block = consequence.type === 'block' ? collectNamedChildren(consequence) : [consequence];
+        trueResult = buildBlock(block, filePath, edges, loop);
+        emitEdge(edges, id, trueResult.entryId, types_1.EdgeType.TRUE_BRANCH);
+    }
+    if (alternate) {
+        const altBody = alternate.type === 'else_clause' ? alternate.namedChild(0) : alternate;
+        if (altBody) {
+            const block = altBody.type === 'block' ? collectNamedChildren(altBody) : [altBody];
+            falseResult = buildBlock(block, filePath, edges, loop);
+            emitEdge(edges, id, falseResult.entryId, types_1.EdgeType.FALSE_BRANCH);
+        }
+    }
+    else {
+        // explicit false branch to allow branch detection in CFG
+        emitEdge(edges, id, id, types_1.EdgeType.FALSE_BRANCH);
+    }
+    const exits = [];
+    if (trueResult)
+        exits.push(...trueResult.exits);
+    if (falseResult)
+        exits.push(...falseResult.exits);
+    if (!alternate)
+        exits.push(id);
+    return { entryId: id, exits };
+}
+function buildConditionalExpression(node, filePath, edges) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    const consequence = node.childForFieldName('consequence');
+    const alternate = node.childForFieldName('alternative');
+    if (consequence)
+        emitEdge(edges, id, (0, types_1.astNodeId)(filePath, consequence), types_1.EdgeType.TRUE_BRANCH);
+    if (alternate)
+        emitEdge(edges, id, (0, types_1.astNodeId)(filePath, alternate), types_1.EdgeType.FALSE_BRANCH);
+    return { entryId: id, exits: [id] };
+}
+function buildFunctionBody(node, filePath, edges) {
+    const body = node.childForFieldName('body');
+    if (!body)
+        return;
+    const block = body.type === 'block' ? collectNamedChildren(body) : [body];
+    buildBlock(block, filePath, edges, undefined);
+}
+function buildClassBodies(node, filePath, edges) {
+    const body = node.childForFieldName('body');
+    if (!body)
+        return;
+    for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'method_definition')
+            buildFunctionBody(child, filePath, edges);
+    }
+}
+function buildDeclaratorBodies(node, filePath, edges) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const declarator = node.namedChild(i);
+        if (!declarator || declarator.type !== 'variable_declarator')
+            continue;
+        const value = declarator.childForFieldName('value');
+        if (!value)
+            continue;
+        if (FUNCTION_TYPES.has(value.type))
+            buildFunctionBody(value, filePath, edges);
+    }
+}
+function buildLoop(node, filePath, edges, loop) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    const body = node.childForFieldName('body') ?? node.childForFieldName('consequence');
+    const loopCtx = {
+        continueTarget: id,
+        breakTargets: [],
+    };
+    let bodyResult = null;
+    if (body) {
+        const block = body.type === 'block' ? collectNamedChildren(body) : [body];
+        bodyResult = buildBlock(block, filePath, edges, loopCtx);
+        emitEdge(edges, id, bodyResult.entryId, types_1.EdgeType.TRUE_BRANCH);
+        for (const exit of bodyResult.exits) {
+            emitEdge(edges, exit, id, types_1.EdgeType.NEXT_STATEMENT);
+        }
+    }
+    const exits = [...loopCtx.breakTargets, ...(loop ? [] : [id])];
+    return { entryId: id, exits };
+}
+function buildDoWhile(node, filePath, edges, loop) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    const body = node.childForFieldName('body');
+    const loopCtx = {
+        continueTarget: id,
+        breakTargets: [],
+    };
+    let bodyResult = null;
+    if (body) {
+        const block = body.type === 'block' ? collectNamedChildren(body) : [body];
+        bodyResult = buildBlock(block, filePath, edges, loopCtx);
+        emitEdge(edges, id, bodyResult.entryId, types_1.EdgeType.TRUE_BRANCH);
+        for (const exit of bodyResult.exits) {
+            emitEdge(edges, exit, id, types_1.EdgeType.NEXT_STATEMENT);
+        }
+    }
+    const exits = [...loopCtx.breakTargets, ...(loop ? [] : [id])];
+    return { entryId: id, exits };
+}
+function buildSwitch(node, filePath, edges) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    const body = node.childForFieldName('body');
+    const caseNodes = body ? collectNamedChildren(body) : [];
+    let hasDefault = false;
+    const exits = [];
+    const breakTargets = [];
+    let previousCaseExit = null;
+    for (const caseNode of caseNodes) {
+        if (caseNode.type !== 'switch_case' && caseNode.type !== 'switch_default')
+            continue;
+        if (caseNode.type === 'switch_default')
+            hasDefault = true;
+        const statements = collectNamedChildren(caseNode).filter(isStatementNode);
+        const caseEntry = statements[0] ?? caseNode;
+        const caseEntryId = (0, types_1.astNodeId)(filePath, caseEntry);
+        const caseResult = buildBlock(statements, filePath, edges, { continueTarget: null, breakTargets });
+        emitEdge(edges, id, caseResult.entryId ?? caseEntryId, types_1.EdgeType.TRUE_BRANCH);
+        if (previousCaseExit)
+            emitEdge(edges, previousCaseExit, caseResult.entryId ?? caseEntryId, types_1.EdgeType.FALLTHROUGH);
+        previousCaseExit = caseResult.exits.length > 0 ? caseResult.exits[caseResult.exits.length - 1] : null;
+        exits.push(...caseResult.exits);
+    }
+    if (!hasDefault)
+        exits.push(id);
+    exits.push(...breakTargets);
+    return { entryId: id, exits };
+}
+function buildTry(node, filePath, edges, loop) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    const body = node.childForFieldName('body');
+    const handler = node.childForFieldName('handler');
+    const finalizer = node.childForFieldName('finalizer');
+    let bodyResult = null;
+    let handlerResult = null;
+    let finalResult = null;
+    if (body) {
+        const block = body.type === 'block' ? collectNamedChildren(body) : [body];
+        bodyResult = buildBlock(block, filePath, edges, loop);
+        emitEdge(edges, id, bodyResult.entryId, types_1.EdgeType.TRUE_BRANCH);
+    }
+    if (handler) {
+        const handlerBody = handler.childForFieldName('body') ?? handler;
+        const block = handlerBody.type === 'block' ? collectNamedChildren(handlerBody) : [handlerBody];
+        handlerResult = buildBlock(block, filePath, edges, loop);
+        emitEdge(edges, id, handlerResult.entryId, types_1.EdgeType.FALSE_BRANCH);
+    }
+    if (finalizer) {
+        const block = finalizer.type === 'block' ? collectNamedChildren(finalizer) : [finalizer];
+        finalResult = buildBlock(block, filePath, edges, loop);
+    }
+    const exits = [];
+    const bodyExits = bodyResult?.exits ?? [];
+    const handlerExits = handlerResult?.exits ?? [];
+    if (finalResult) {
+        for (const exit of [...bodyExits, ...handlerExits]) {
+            emitEdge(edges, exit, finalResult.entryId, types_1.EdgeType.NEXT_STATEMENT);
+        }
+        exits.push(...finalResult.exits);
+    }
+    else {
+        exits.push(...bodyExits, ...handlerExits);
+    }
+    return { entryId: id, exits };
+}
+function buildLogicalExpression(node, filePath, edges) {
+    const id = (0, types_1.astNodeId)(filePath, node);
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    const operator = extractLogicalOperator(node);
+    if (left)
+        emitEdge(edges, id, (0, types_1.astNodeId)(filePath, left), types_1.EdgeType.NEXT_STATEMENT);
+    if (right) {
+        if (operator === '||') {
+            // only evaluate right when left is false
+            emitEdge(edges, id, (0, types_1.astNodeId)(filePath, right), types_1.EdgeType.FALSE_BRANCH);
+            emitEdge(edges, id, id, types_1.EdgeType.TRUE_BRANCH);
+        }
+        else {
+            // && : only evaluate right when left is true
+            emitEdge(edges, id, (0, types_1.astNodeId)(filePath, right), types_1.EdgeType.TRUE_BRANCH);
+            emitEdge(edges, id, id, types_1.EdgeType.FALSE_BRANCH);
+        }
+    }
+    return { entryId: id, exits: [id] };
+}
+function buildConditionalExpressionNode(node, filePath, edges) {
+    return buildConditionalExpression(node, filePath, edges);
+}
+function buildExpressionEdges(node, filePath, edges, loop) {
+    if (node.type === 'expression_statement' || node.type === 'return_statement') {
+        const expr = node.namedChild(0);
+        if (expr)
+            return buildExpressionEdges(expr, filePath, edges, loop);
+    }
+    if (node.type === 'logical_expression')
+        return buildLogicalExpression(node, filePath, edges);
+    if (node.type === 'conditional_expression')
+        return buildConditionalExpressionNode(node, filePath, edges);
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'logical_expression')
+            return buildLogicalExpression(child, filePath, edges);
+        if (child.type === 'conditional_expression')
+            return buildConditionalExpressionNode(child, filePath, edges);
+    }
+    return { entryId: null, exits: [] };
+}
+function extractLogicalOperator(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (child.type === '&&' || child.type === '||')
+            return child.type;
+    }
+    return null;
+}
+function addShortCircuitEdges(root, filePath, edges) {
+    const visit = (node) => {
+        if (node.type === 'logical_expression' || node.type === 'binary_expression') {
+            const op = extractLogicalOperator(node);
+            if (op)
+                buildLogicalExpression(node, filePath, edges);
+        }
+        else if (node.type === 'conditional_expression' || node.type === 'ternary_expression') {
+            buildConditionalExpression(node, filePath, edges);
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visit(child);
+        }
+    };
+    visit(root);
+}
+function buildStatement(node, filePath, edges, loop) {
+    if (FUNCTION_TYPES.has(node.type)) {
+        buildFunctionBody(node, filePath, edges);
+        return buildSimple(node, filePath);
+    }
+    if (node.type === 'class_declaration') {
+        buildClassBodies(node, filePath, edges);
+        return buildSimple(node, filePath);
+    }
+    if (node.type === 'variable_declaration' || node.type === 'lexical_declaration') {
+        buildDeclaratorBodies(node, filePath, edges);
+        return buildSimple(node, filePath);
+    }
+    if (node.type === 'expression_statement') {
+        const expr = node.namedChild(0);
+        if (expr?.type === 'assignment_expression') {
+            const value = expr.childForFieldName('right');
+            if (value && FUNCTION_TYPES.has(value.type))
+                buildFunctionBody(value, filePath, edges);
+        }
+    }
+    if (node.type === 'return_statement')
+        return buildReturn(node, filePath);
+    if (node.type === 'throw_statement')
+        return buildThrow(node, filePath);
+    if (node.type === 'break_statement')
+        return buildBreak(node, filePath, loop);
+    if (node.type === 'continue_statement')
+        return buildContinue(node, filePath, edges, loop);
+    if (node.type === 'if_statement')
+        return buildIf(node, filePath, edges, loop);
+    if (node.type === 'conditional_expression')
+        return buildConditionalExpression(node, filePath, edges);
+    if (LOOP_TYPES.has(node.type)) {
+        if (node.type === 'do_statement')
+            return buildDoWhile(node, filePath, edges, loop);
+        return buildLoop(node, filePath, edges, loop);
+    }
+    if (node.type === 'switch_statement')
+        return buildSwitch(node, filePath, edges);
+    if (node.type === 'try_statement')
+        return buildTry(node, filePath, edges, loop);
+    if (node.type === 'block' || node.type === 'statement_block') {
+        const block = collectNamedChildren(node);
+        return buildBlock(block, filePath, edges, loop);
+    }
+    if (SIMPLE_STATEMENT_TYPES.has(node.type))
+        return buildSimple(node, filePath);
+    return buildSimple(node, filePath);
+}
+function collectCfgNodes(root, filePath) {
+    const out = [];
+    const visit = (node) => {
+        if (isStatementNode(node)) {
+            out.push({
+                id: (0, types_1.astNodeId)(filePath, node),
+                stmtType: node.type,
+                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(root);
+    return out;
+}
+function buildCfgInternal(filePath, root) {
+    const edges = [];
+    const topStatements = root.type === 'program' ? collectNamedChildren(root) : [root];
+    const result = buildBlock(topStatements, filePath, edges, undefined);
+    addShortCircuitEdges(root, filePath, edges);
+    const cfgNodes = collectCfgNodes(root, filePath);
+    const nodes = cfgNodes.map((node) => ({
+        id: node.id,
+        kind: 'cfg',
+        label: node.stmtType,
+        startLine: node.startLine,
+        endLine: node.endLine,
+    }));
+    return {
+        nodes,
+        edges,
+        entryId: result.entryId,
+        exitIds: result.exits,
+        rawNodes: cfgNodes,
+    };
+}
+function buildCfgLayer(filePath, root) {
+    const edgeTypes = [types_1.EdgeType.NEXT_STATEMENT, types_1.EdgeType.TRUE_BRANCH, types_1.EdgeType.FALSE_BRANCH, types_1.EdgeType.FALLTHROUGH];
+    const internal = buildCfgInternal(filePath, root);
+    return { nodes: internal.nodes, edges: internal.edges, edgeTypes };
+}
+function buildCFG(filePath, content) {
+    const parser = new tree_sitter_1.default();
+    parser.setLanguage(tree_sitter_typescript_1.default.typescript);
+    const tree = parser.parse(content);
+    const internal = buildCfgInternal(filePath, tree.rootNode);
+    const nodes = internal.rawNodes.map((node) => ({
+        id: node.id,
+        stmtType: node.stmtType,
+        startLine: node.startLine,
+        endLine: node.endLine,
+    }));
+    const edges = internal.edges.map((edge) => ({
+        from: edge.from,
+        to: edge.to,
+        edgeType: edge.type,
+    }));
+    return {
+        nodes,
+        edges,
+        entryPoint: internal.entryId ?? '',
+        exitPoints: internal.exitIds,
+    };
+}