@mars167/git-ai 2.3.0

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

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDfgLayer = buildDfgLayer;
+exports.buildDFG = buildDFG;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const tree_sitter_typescript_1 = __importDefault(require("tree-sitter-typescript"));
+const types_1 = require("./types");
+const IDENTIFIER_TYPES = new Set(['identifier', 'property_identifier']);
+const ASSIGNMENT_TYPES = new Set([
+    'assignment_expression',
+    'augmented_assignment_expression',
+    'variable_declarator',
+]);
+const ASSIGNMENT_OPERATORS = new Set([
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '||=',
+    '&&=',
+    '??=',
+    '|=',
+    '&=',
+    '^=',
+    '<<=',
+    '>>=',
+    '>>>=',
+]);
+function isIdentifier(node) {
+    return IDENTIFIER_TYPES.has(node.type) || node.type === 'shorthand_property_identifier';
+}
+function collectIdentifiers(node, out) {
+    if (isIdentifier(node))
+        out.push(node);
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child)
+            collectIdentifiers(child, out);
+    }
+}
+function collectPatternIdentifiers(node, out) {
+    if (isIdentifier(node)) {
+        out.push(node);
+        return;
+    }
+    if (node.type === 'shorthand_property_identifier') {
+        out.push(node);
+        return;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        collectPatternIdentifiers(child, out);
+    }
+}
+function collectAssignments(root) {
+    const nodes = [];
+    const visit = (node) => {
+        if (ASSIGNMENT_TYPES.has(node.type))
+            nodes.push(node);
+        if (node.type === 'formal_parameters')
+            nodes.push(node);
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                visit(child);
+        }
+    };
+    visit(root);
+    return nodes;
+}
+function getAssignmentOperator(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (ASSIGNMENT_OPERATORS.has(child.type))
+            return child.type;
+    }
+    return null;
+}
+function isCompoundAssignment(node) {
+    if (node.type === 'augmented_assignment_expression')
+        return true;
+    if (node.type !== 'assignment_expression')
+        return false;
+    const op = getAssignmentOperator(node);
+    return op !== null && op !== '=';
+}
+function extractDefinitions(node, filePath) {
+    const defs = [];
+    if (node.type === 'formal_parameters') {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const param = node.namedChild(i);
+            if (!param)
+                continue;
+            const ids = [];
+            const paramNode = param.childForFieldName('name') ?? param;
+            collectPatternIdentifiers(paramNode, ids);
+            for (const id of ids) {
+                defs.push({ id: (0, types_1.astNodeId)(filePath, id), name: id.text, node: id });
+            }
+        }
+        return defs;
+    }
+    const left = node.childForFieldName('left') ?? node.childForFieldName('name');
+    if (!left)
+        return defs;
+    const ids = [];
+    collectPatternIdentifiers(left, ids);
+    for (const id of ids) {
+        defs.push({ id: (0, types_1.astNodeId)(filePath, id), name: id.text, node: id });
+    }
+    return defs;
+}
+function extractUses(node, filePath) {
+    const uses = [];
+    if (node.type === 'formal_parameters')
+        return uses;
+    const assignmentLeft = node.childForFieldName('left') ?? node.childForFieldName('name');
+    const right = node.childForFieldName('right') ?? node.childForFieldName('value');
+    if (!right) {
+        if (isCompoundAssignment(node) && assignmentLeft) {
+            const leftIds = [];
+            collectIdentifiers(assignmentLeft, leftIds);
+            for (const id of leftIds) {
+                uses.push({ id: (0, types_1.astNodeId)(filePath, id), name: id.text, node: id });
+            }
+        }
+        return uses;
+    }
+    const ids = [];
+    collectIdentifiers(right, ids);
+    for (const id of ids) {
+        if (assignmentLeft && id.startIndex >= assignmentLeft.startIndex && id.endIndex <= assignmentLeft.endIndex) {
+            continue;
+        }
+        uses.push({ id: (0, types_1.astNodeId)(filePath, id), name: id.text, node: id });
+    }
+    if (isCompoundAssignment(node) && assignmentLeft) {
+        const leftIds = [];
+        collectIdentifiers(assignmentLeft, leftIds);
+        for (const id of leftIds) {
+            uses.push({ id: (0, types_1.astNodeId)(filePath, id), name: id.text, node: id });
+        }
+    }
+    return uses;
+}
+function addDefinedByEdges(edges, filePath, defs, assignmentNode) {
+    const assignmentId = (0, types_1.astNodeId)(filePath, assignmentNode);
+    for (const def of defs) {
+        edges.push({ from: def.id, to: assignmentId, type: types_1.EdgeType.DEFINED_BY });
+    }
+}
+function buildDfgInternal(filePath, root) {
+    const edges = [];
+    const nodes = [];
+    const seenNodes = new Set();
+    const assignments = collectAssignments(root);
+    for (const assignment of assignments) {
+        const defs = extractDefinitions(assignment, filePath);
+        const uses = extractUses(assignment, filePath);
+        for (const def of defs) {
+            if (!seenNodes.has(def.id)) {
+                nodes.push({
+                    id: def.id,
+                    kind: 'dfg',
+                    label: def.name,
+                    startLine: def.node.startPosition.row + 1,
+                    endLine: def.node.endPosition.row + 1,
+                });
+                seenNodes.add(def.id);
+            }
+            for (const use of uses) {
+                if (!seenNodes.has(use.id)) {
+                    nodes.push({
+                        id: use.id,
+                        kind: 'dfg',
+                        label: use.name,
+                        startLine: use.node.startPosition.row + 1,
+                        endLine: use.node.endPosition.row + 1,
+                    });
+                    seenNodes.add(use.id);
+                }
+                edges.push({ from: use.id, to: def.id, type: types_1.EdgeType.COMPUTED_FROM });
+            }
+        }
+        if (defs.length > 0) {
+            addDefinedByEdges(edges, filePath, defs, assignment);
+        }
+    }
+    return { nodes, edges };
+}
+function buildDfgLayer(filePath, root) {
+    const edgeTypes = [types_1.EdgeType.COMPUTED_FROM, types_1.EdgeType.DEFINED_BY];
+    const internal = buildDfgInternal(filePath, root);
+    return { nodes: internal.nodes, edges: internal.edges, edgeTypes };
+}
+function buildDFG(filePath, content) {
+    const parser = new tree_sitter_1.default();
+    parser.setLanguage(tree_sitter_typescript_1.default.typescript);
+    const tree = parser.parse(content);
+    const root = tree.rootNode;
+    const nodeMap = new Map();
+    const edges = [];
+    const assignments = collectAssignments(root);
+    for (const assignment of assignments) {
+        const defs = extractDefinitions(assignment, filePath);
+        const uses = extractUses(assignment, filePath);
+        for (const def of defs) {
+            let defNode = nodeMap.get(def.id);
+            if (!defNode) {
+                defNode = {
+                    id: def.id,
+                    varName: def.name,
+                    defLine: def.node.startPosition.row + 1,
+                    useLines: [],
+                };
+                nodeMap.set(def.id, defNode);
+            }
+            for (const use of uses) {
+                edges.push({ from: def.id, to: use.id, varName: def.name });
+                const useLine = use.node.startPosition.row + 1;
+                if (!defNode.useLines.includes(useLine)) {
+                    defNode.useLines.push(useLine);
+                }
+            }
+        }
+    }
+    return { nodes: Array.from(nodeMap.values()), edges };
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCpgForFile = buildCpgForFile;
+exports.buildCpgForFiles = buildCpgForFiles;
+const parser_1 = require("../parser");
+const paths_1 = require("../paths");
+const astLayer_1 = require("./astLayer");
+const cfgLayer_1 = require("./cfgLayer");
+const dfgLayer_1 = require("./dfgLayer");
+const callGraph_1 = require("./callGraph");
+function mergeLayers(layers) {
+    const nodesMap = new Map();
+    const edges = [];
+    const edgeTypes = new Set();
+    for (const layer of layers) {
+        for (const node of layer.nodes)
+            nodesMap.set(node.id, node);
+        for (const edge of layer.edges)
+            edges.push(edge);
+        for (const type of layer.edgeTypes)
+            edgeTypes.add(type);
+    }
+    return {
+        nodes: Array.from(nodesMap.values()),
+        edges,
+        edgeTypes: Array.from(edgeTypes),
+    };
+}
+function buildCpgForFile(filePath, lang, root) {
+    const ast = (0, astLayer_1.buildAstLayer)(filePath, lang, root);
+    const cfg = (0, cfgLayer_1.buildCfgLayer)(filePath, root);
+    const dfg = (0, dfgLayer_1.buildDfgLayer)(filePath, root);
+    return {
+        ast,
+        cfg,
+        dfg,
+        callGraph: { nodes: [], edges: [], edgeTypes: [] },
+        importGraph: { nodes: [], edges: [], edgeTypes: [] },
+    };
+}
+function buildCpgForFiles(files) {
+    const parser = new parser_1.CodeParser();
+    const contexts = [];
+    const astLayers = [];
+    const cfgLayers = [];
+    const dfgLayers = [];
+    for (const file of files) {
+        const filePath = (0, paths_1.toPosixPath)(file.filePath);
+        let tree = null;
+        try {
+            const adapter = parser.pickAdapter?.(filePath);
+            if (adapter) {
+                parser.parser.setLanguage(adapter.getTreeSitterLanguage());
+                tree = parser.parser.parse(file.content);
+            }
+        }
+        catch {
+            tree = null;
+        }
+        if (!tree)
+            continue;
+        const root = tree.rootNode;
+        const ast = (0, astLayer_1.buildAstLayer)(filePath, file.lang, root);
+        const cfg = (0, cfgLayer_1.buildCfgLayer)(filePath, root);
+        const dfg = (0, dfgLayer_1.buildDfgLayer)(filePath, root);
+        astLayers.push(ast);
+        cfgLayers.push(cfg);
+        dfgLayers.push(dfg);
+        contexts.push({ filePath, lang: file.lang, root });
+    }
+    const callGraph = (0, callGraph_1.buildCallGraph)(contexts);
+    const importGraph = (0, callGraph_1.buildImportGraph)(contexts);
+    return {
+        ast: mergeLayers(astLayers),
+        cfg: mergeLayers(cfgLayers),
+        dfg: mergeLayers(dfgLayers),
+        callGraph,
+        importGraph,
+    };
+}

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeType = void 0;
+exports.fileNodeId = fileNodeId;
+exports.moduleNodeId = moduleNodeId;
+exports.astNodeId = astNodeId;
+exports.buildSymbolChunkText = buildSymbolChunkText;
+exports.symbolNodeId = symbolNodeId;
+exports.createFileNode = createFileNode;
+exports.createModuleNode = createModuleNode;
+exports.createAstNode = createAstNode;
+exports.createSymbolNode = createSymbolNode;
+const crypto_1 = require("../crypto");
+const paths_1 = require("../paths");
+var EdgeType;
+(function (EdgeType) {
+    EdgeType["CHILD"] = "CHILD";
+    EdgeType["NEXT_TOKEN"] = "NEXT_TOKEN";
+    EdgeType["NEXT_STATEMENT"] = "NEXT_STATEMENT";
+    EdgeType["TRUE_BRANCH"] = "TRUE_BRANCH";
+    EdgeType["FALSE_BRANCH"] = "FALSE_BRANCH";
+    EdgeType["FALLTHROUGH"] = "FALLTHROUGH";
+    EdgeType["COMPUTED_FROM"] = "COMPUTED_FROM";
+    EdgeType["DEFINED_BY"] = "DEFINED_BY";
+    EdgeType["CALLS"] = "CALLS";
+    EdgeType["DEFINES"] = "DEFINES";
+    EdgeType["IMPORTS"] = "IMPORTS";
+    EdgeType["INHERITS"] = "INHERITS";
+    EdgeType["IMPLEMENTS"] = "IMPLEMENTS";
+})(EdgeType || (exports.EdgeType = EdgeType = {}));
+function fileNodeId(filePath) {
+    const filePosix = (0, paths_1.toPosixPath)(filePath);
+    return (0, crypto_1.sha256Hex)(`file:${filePosix}`);
+}
+function moduleNodeId(name) {
+    return (0, crypto_1.sha256Hex)(`module:${name}`);
+}
+function astNodeId(filePath, node) {
+    const filePosix = (0, paths_1.toPosixPath)(filePath);
+    const start = `${node.startPosition.row + 1}:${node.startPosition.column + 1}`;
+    const end = `${node.endPosition.row + 1}:${node.endPosition.column + 1}`;
+    return (0, crypto_1.sha256Hex)(`cpg:${filePosix}:${node.type}:${start}:${end}`);
+}
+function buildSymbolChunkText(filePath, symbol) {
+    const filePosix = (0, paths_1.toPosixPath)(filePath);
+    return `file:${filePosix}\nkind:${symbol.kind}\nname:${symbol.name}\nsignature:${symbol.signature}`;
+}
+function symbolNodeId(filePath, symbol) {
+    const filePosix = (0, paths_1.toPosixPath)(filePath);
+    const chunk = buildSymbolChunkText(filePosix, symbol);
+    const contentHash = (0, crypto_1.sha256Hex)(chunk);
+    return (0, crypto_1.sha256Hex)(`${filePosix}:${symbol.name}:${symbol.kind}:${symbol.startLine}:${symbol.endLine}:${contentHash}`);
+}
+function createFileNode(filePath, lang) {
+    const filePosix = (0, paths_1.toPosixPath)(filePath);
+    return {
+        id: fileNodeId(filePosix),
+        kind: 'file',
+        label: filePosix,
+        file: filePosix,
+        lang,
+        startLine: 0,
+        endLine: 0,
+        startCol: 0,
+        endCol: 0,
+    };
+}
+function createModuleNode(name) {
+    return {
+        id: moduleNodeId(name),
+        kind: 'module',
+        label: name,
+        file: '',
+        lang: '',
+        startLine: 0,
+        endLine: 0,
+        startCol: 0,
+        endCol: 0,
+    };
+}
+function createAstNode(filePath, lang, node) {
+    const filePosix = (0, paths_1.toPosixPath)(filePath);
+    return {
+        id: astNodeId(filePosix, node),
+        kind: 'ast',
+        label: node.type,
+        file: filePosix,
+        lang,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        startCol: node.startPosition.column + 1,
+        endCol: node.endPosition.column + 1,
+    };
+}
+function createSymbolNode(filePath, lang, symbol) {
+    const filePosix = (0, paths_1.toPosixPath)(filePath);
+    return {
+        id: symbolNodeId(filePosix, symbol),
+        kind: 'symbol',
+        label: symbol.name,
+        file: filePosix,
+        lang,
+        startLine: symbol.startLine,
+        endLine: symbol.endLine,
+        startCol: 0,
+        endCol: 0,
+    };
+}

package/dist/src/core/crypto.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256Hex = sha256Hex;
+const crypto_1 = __importDefault(require("crypto"));
+function sha256Hex(input) {
+    return crypto_1.default.createHash('sha256').update(input).digest('hex');
+}