@mars167/git-ai 2.3.0

package/dist/src/core/parser/chunkRelations.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferChunkRelations = inferChunkRelations;
+exports.getRelatedChunks = getRelatedChunks;
+exports.getChunksReferencingSymbol = getChunksReferencingSymbol;
+exports.getChunksDefiningSymbol = getChunksDefiningSymbol;
+/**
+ * Build relationships between chunks
+ */
+function inferChunkRelations(chunks) {
+    const relations = {
+        callerMap: new Map(),
+        calleeMap: new Map(),
+        parentMap: new Map(),
+        childMap: new Map(),
+        typeMap: new Map(),
+        fileMap: new Map(),
+    };
+    // Build file map
+    for (const chunk of chunks) {
+        if (!relations.fileMap.has(chunk.filePath)) {
+            relations.fileMap.set(chunk.filePath, []);
+        }
+        relations.fileMap.get(chunk.filePath).push(chunk.id);
+    }
+    // Build type map
+    for (const chunk of chunks) {
+        if (!relations.typeMap.has(chunk.nodeType)) {
+            relations.typeMap.set(chunk.nodeType, []);
+        }
+        relations.typeMap.get(chunk.nodeType).push(chunk.id);
+    }
+    // Build parent-child relationships based on AST path nesting
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        // Find parent (chunk whose AST path is a prefix of this chunk's path)
+        for (let j = 0; j < i; j++) {
+            const other = chunks[j];
+            if (other.filePath !== chunk.filePath)
+                continue;
+            if (isParentPath(other.astPath, chunk.astPath)) {
+                relations.parentMap.set(chunk.id, other.id);
+                if (!relations.childMap.has(other.id)) {
+                    relations.childMap.set(other.id, []);
+                }
+                relations.childMap.get(other.id).push(chunk.id);
+                break;
+            }
+        }
+    }
+    // Infer call relationships from symbol references
+    for (const chunk of chunks) {
+        const calls = [];
+        for (const ref of chunk.symbolReferences) {
+            // Find chunks that define this symbol
+            for (const other of chunks) {
+                if (other.id === chunk.id)
+                    continue;
+                if (extractDefNames(other.content).includes(ref)) {
+                    calls.push(other.id);
+                }
+            }
+        }
+        if (calls.length > 0) {
+            relations.callerMap.set(chunk.id, [...new Set(calls)]);
+            for (const calleeId of calls) {
+                if (!relations.calleeMap.has(calleeId)) {
+                    relations.calleeMap.set(calleeId, []);
+                }
+                relations.calleeMap.get(calleeId).push(chunk.id);
+            }
+        }
+    }
+    return relations;
+}
+/**
+ * Check if pathA is a parent prefix of pathB
+ */
+function isParentPath(pathA, pathB) {
+    if (pathA.length >= pathB.length)
+        return false;
+    for (let i = 0; i < pathA.length; i++) {
+        if (pathA[i] !== pathB[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Extract definition names from chunk content
+ */
+function extractDefNames(content) {
+    const names = [];
+    // Match function declarations
+    const fnMatch = content.match(/function\s+(\w+)/g);
+    if (fnMatch) {
+        for (const m of fnMatch) {
+            names.push(m.replace('function ', ''));
+        }
+    }
+    // Match class declarations
+    const classMatch = content.match(/class\s+(\w+)/g);
+    if (classMatch) {
+        for (const m of classMatch) {
+            names.push(m.replace('class ', ''));
+        }
+    }
+    // Match method definitions (simplified)
+    const methodMatch = content.match(/(\w+)\s*\([^)]*\)\s*\{/g);
+    if (methodMatch) {
+        for (const m of methodMatch) {
+            const match = m.match(/^(\w+)/);
+            if (match)
+                names.push(match[1]);
+        }
+    }
+    return [...new Set(names)];
+}
+/**
+ * Find related chunks for a given chunk
+ */
+function getRelatedChunks(chunkId, relations, maxDepth = 2) {
+    const visited = new Set([chunkId]);
+    const queue = [{ id: chunkId, depth: 0 }];
+    const result = [];
+    while (queue.length > 0) {
+        const { id, depth } = queue.shift();
+        if (depth > 0) {
+            result.push(id);
+        }
+        if (depth >= maxDepth)
+            continue;
+        // Get all related chunk IDs
+        const related = [];
+        // Parents
+        const parent = relations.parentMap.get(id);
+        if (parent && !visited.has(parent)) {
+            related.push(parent);
+        }
+        // Children
+        const children = relations.childMap.get(id) || [];
+        for (const child of children) {
+            if (!visited.has(child))
+                related.push(child);
+        }
+        // Callers
+        const callers = relations.calleeMap.get(id) || [];
+        for (const caller of callers) {
+            if (!visited.has(caller))
+                related.push(caller);
+        }
+        // Callees
+        const callersOf = relations.callerMap.get(id) || [];
+        for (const callee of callersOf) {
+            if (!visited.has(callee))
+                related.push(callee);
+        }
+        for (const rid of related) {
+            visited.add(rid);
+            queue.push({ id: rid, depth: depth + 1 });
+        }
+    }
+    return result;
+}
+/**
+ * Get chunks that reference a given symbol
+ */
+function getChunksReferencingSymbol(symbolName, chunks) {
+    return chunks.filter(chunk => chunk.symbolReferences.includes(symbolName));
+}
+/**
+ * Get chunks that define a given symbol
+ */
+function getChunksDefiningSymbol(symbolName, chunks) {
+    return chunks.filter(chunk => {
+        const defs = extractDefNames(chunk.content);
+        return defs.includes(symbolName);
+    });
+}

package/dist/src/core/parser/chunker.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultChunkingConfig = void 0;
+exports.countTokens = countTokens;
+exports.getAstPath = getAstPath;
+exports.findTopLevelDefinitions = findTopLevelDefinitions;
+exports.astAwareChunking = astAwareChunking;
+exports.defaultChunkingConfig = {
+    maxTokens: 512,
+    minTokens: 50,
+    priorityConstructs: [
+        'function_declaration',
+        'method_definition',
+        'class_declaration',
+        'interface_declaration',
+        'module',
+        'namespace',
+        'arrow_function',
+    ],
+    preserveContext: true,
+    overlapTokens: 32,
+};
+function countTokens(text) {
+    return text.split(/\s+/).filter(t => t.length > 0).length;
+}
+function getAstPath(node) {
+    const path = [];
+    let current = node;
+    while (current) {
+        path.unshift(current.type);
+        current = current.parent;
+    }
+    return path;
+}
+function isDefinitionNode(node) {
+    const defTypes = [
+        'function_declaration',
+        'method_definition',
+        'class_declaration',
+        'interface_declaration',
+        'module',
+        'namespace',
+        'arrow_function',
+        'const_declaration',
+        'let_declaration',
+        'variable_declaration',
+    ];
+    return defTypes.includes(node.type);
+}
+function findTopLevelDefinitions(root) {
+    const definitions = [];
+    for (let i = 0; i < root.childCount; i++) {
+        const child = root.child(i);
+        if (child && isDefinitionNode(child)) {
+            definitions.push(child);
+        }
+    }
+    return definitions;
+}
+function buildChunkContent(node, filePath) {
+    return {
+        text: node.text,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+    };
+}
+function generateChunkId(filePath, nodeType, startLine, contentHash) {
+    return `${filePath}:${nodeType}:${startLine}:${contentHash.slice(0, 8)}`;
+}
+function hashContent(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+        const char = text.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+}
+function extractSymbolReferences(node) {
+    const symbols = [];
+    const traverse = (n) => {
+        if (n.type === 'identifier') {
+            symbols.push(n.text);
+        }
+        for (let i = 0; i < n.childCount; i++) {
+            traverse(n.child(i));
+        }
+    };
+    traverse(node);
+    return [...new Set(symbols)];
+}
+function astAwareChunking(tree, filePath, config = exports.defaultChunkingConfig) {
+    const chunks = [];
+    const root = tree.rootNode;
+    const topLevelDefs = findTopLevelDefinitions(root);
+    for (const def of topLevelDefs) {
+        const defChunks = chunkNode(def, filePath, config);
+        chunks.push(...defChunks);
+    }
+    // Handle remaining content
+    const coveredLines = new Set();
+    for (const chunk of chunks) {
+        for (let line = chunk.startLine; line <= chunk.endLine; line++) {
+            coveredLines.add(line);
+        }
+    }
+    const remainingChunks = chunkRemainingContent(root, filePath, coveredLines, config);
+    chunks.push(...remainingChunks);
+    chunks.sort((a, b) => a.startLine - b.startLine);
+    return {
+        chunks,
+        totalTokens: chunks.reduce((sum, c) => sum + c.tokenCount, 0),
+        totalChunks: chunks.length,
+    };
+}
+function chunkNode(node, filePath, config) {
+    const chunks = [];
+    const { text, startLine, endLine } = buildChunkContent(node, filePath);
+    const tokenCount = countTokens(text);
+    const astPath = getAstPath(node);
+    const contentHash = hashContent(text);
+    if (tokenCount <= config.maxTokens) {
+        const chunk = {
+            id: generateChunkId(filePath, node.type, startLine, contentHash),
+            content: text,
+            astPath,
+            filePath,
+            startLine,
+            endLine,
+            symbolReferences: extractSymbolReferences(node),
+            relatedChunkIds: [],
+            tokenCount,
+            nodeType: node.type,
+        };
+        chunks.push(chunk);
+        return chunks;
+    }
+    // Try to split by children
+    const childChunks = [];
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && isDefinitionNode(child)) {
+            const subChunks = chunkNode(child, filePath, config);
+            childChunks.push(...subChunks);
+        }
+    }
+    if (childChunks.length > 0) {
+        for (const childChunk of childChunks) {
+            chunks.push(childChunk);
+        }
+        const usedLines = new Set();
+        for (const chunk of childChunks) {
+            for (let line = chunk.startLine; line <= chunk.endLine; line++) {
+                usedLines.add(line);
+            }
+        }
+        const remaining = chunkRemainingContent(node, filePath, usedLines, config);
+        chunks.push(...remaining);
+    }
+    else {
+        const forcedChunks = createForcedChunks(node, filePath, config);
+        chunks.push(...forcedChunks);
+    }
+    return chunks;
+}
+function chunkRemainingContent(node, filePath, coveredLines, config, baseLine = node.startPosition.row + 1) {
+    const chunks = [];
+    const lines = node.text.split('\n');
+    let currentChunkLines = [];
+    let chunkStartLine = baseLine;
+    let currentLine = baseLine;
+    for (let i = 0; i < lines.length; i++) {
+        const lineNum = baseLine + i;
+        if (coveredLines.has(lineNum)) {
+            if (currentChunkLines.length > 0) {
+                const chunkText = currentChunkLines.join('\n');
+                const tokenCount = countTokens(chunkText);
+                if (tokenCount >= config.minTokens) {
+                    const chunk = {
+                        id: generateChunkId(filePath, 'fragment', chunkStartLine, hashContent(chunkText)),
+                        content: chunkText,
+                        astPath: [...getAstPath(node), 'fragment'],
+                        filePath,
+                        startLine: chunkStartLine,
+                        endLine: currentLine - 1,
+                        symbolReferences: [],
+                        relatedChunkIds: [],
+                        tokenCount,
+                        nodeType: 'fragment',
+                    };
+                    chunks.push(chunk);
+                }
+                currentChunkLines = [];
+            }
+        }
+        else {
+            if (currentChunkLines.length === 0) {
+                chunkStartLine = lineNum;
+            }
+            currentChunkLines.push(lines[i]);
+        }
+        currentLine = lineNum + 1;
+    }
+    if (currentChunkLines.length > 0) {
+        const chunkText = currentChunkLines.join('\n');
+        const tokenCount = countTokens(chunkText);
+        if (tokenCount >= config.minTokens) {
+            const chunk = {
+                id: generateChunkId(filePath, 'fragment', chunkStartLine, hashContent(chunkText)),
+                content: chunkText,
+                astPath: [...getAstPath(node), 'fragment'],
+                filePath,
+                startLine: chunkStartLine,
+                endLine: currentLine - 1,
+                symbolReferences: [],
+                relatedChunkIds: [],
+                tokenCount,
+                nodeType: 'fragment',
+            };
+            chunks.push(chunk);
+        }
+    }
+    return chunks;
+}
+function createForcedChunks(node, filePath, config) {
+    const chunks = [];
+    const lines = node.text.split('\n');
+    const tokensPerLine = lines.map(l => countTokens(l));
+    let currentChunkLines = [];
+    let currentChunkTokens = 0;
+    let chunkStartLine = node.startPosition.row + 1;
+    for (let i = 0; i < lines.length; i++) {
+        const lineTokens = tokensPerLine[i];
+        if (currentChunkTokens + lineTokens > config.maxTokens && currentChunkTokens > config.minTokens) {
+            const chunkText = currentChunkLines.join('\n');
+            const chunk = {
+                id: generateChunkId(filePath, 'forced_split', chunkStartLine, hashContent(chunkText)),
+                content: chunkText,
+                astPath: [...getAstPath(node), 'forced_split'],
+                filePath,
+                startLine: chunkStartLine,
+                endLine: node.startPosition.row + 1 + i,
+                symbolReferences: [],
+                relatedChunkIds: [],
+                tokenCount: currentChunkTokens,
+                nodeType: 'forced_split',
+            };
+            chunks.push(chunk);
+            const overlapStart = Math.max(0, currentChunkLines.length - Math.ceil(config.overlapTokens / 10));
+            currentChunkLines = currentChunkLines.slice(overlapStart);
+            currentChunkTokens = currentChunkLines.reduce((sum, l) => sum + countTokens(l), 0);
+            chunkStartLine = node.startPosition.row + 1 + i - overlapStart;
+        }
+        currentChunkLines.push(lines[i]);
+        currentChunkTokens += lineTokens;
+    }
+    if (currentChunkTokens >= config.minTokens) {
+        const chunkText = currentChunkLines.join('\n');
+        const chunk = {
+            id: generateChunkId(filePath, 'forced_split', chunkStartLine, hashContent(chunkText)),
+            content: chunkText,
+            astPath: [...getAstPath(node), 'forced_split'],
+            filePath,
+            startLine: chunkStartLine,
+            endLine: node.endPosition.row + 1,
+            symbolReferences: [],
+            relatedChunkIds: [],
+            tokenCount: currentChunkTokens,
+            nodeType: 'forced_split',
+        };
+        chunks.push(chunk);
+    }
+    return chunks;
+}

package/dist/src/core/parser/go.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoAdapter = void 0;
+const tree_sitter_go_1 = __importDefault(require("tree-sitter-go"));
+const utils_1 = require("./utils");
+class GoAdapter {
+    getLanguageId() {
+        return 'go';
+    }
+    getTreeSitterLanguage() {
+        return tree_sitter_go_1.default;
+    }
+    getSupportedFileExtensions() {
+        return ['.go'];
+    }
+    extractSymbolsAndRefs(node) {
+        const symbols = [];
+        const refs = [];
+        const traverse = (n, container) => {
+            if (n.type === 'call_expression') {
+                const fn = n.childForFieldName('function');
+                const nameNode = this.getCallNameNode(fn);
+                if (nameNode)
+                    (0, utils_1.pushRef)(refs, nameNode.text, 'call', nameNode);
+            }
+            else if (n.type === 'type_identifier') {
+                (0, utils_1.pushRef)(refs, n.text, 'type', n);
+            }
+            let currentContainer = container;
+            if (n.type === 'function_declaration') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: 'function',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: this.getSignature(n),
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            else if (n.type === 'method_declaration') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: 'method',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: this.getSignature(n),
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            else if (n.type === 'type_specifier') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: 'class',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: `type ${nameNode.text}`,
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            for (let i = 0; i < n.childCount; i++)
+                traverse(n.child(i), currentContainer);
+        };
+        traverse(node, undefined);
+        return { symbols, refs };
+    }
+    getCallNameNode(node) {
+        if (!node)
+            return null;
+        if (node.type === 'identifier')
+            return node;
+        if (node.type === 'selector_expression') {
+            return node.childForFieldName('field');
+        }
+        return null;
+    }
+    getSignature(node) {
+        return node.text.split('{')[0].trim();
+    }
+}
+exports.GoAdapter = GoAdapter;

package/dist/src/core/parser/java.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaAdapter = void 0;
+const tree_sitter_java_1 = __importDefault(require("tree-sitter-java"));
+const utils_1 = require("./utils");
+class JavaAdapter {
+    getLanguageId() {
+        return 'java';
+    }
+    getTreeSitterLanguage() {
+        return tree_sitter_java_1.default;
+    }
+    getSupportedFileExtensions() {
+        return ['.java'];
+    }
+    extractSymbolsAndRefs(node) {
+        const symbols = [];
+        const refs = [];
+        const traverse = (n, container) => {
+            if (n.type === 'method_invocation') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode)
+                    (0, utils_1.pushRef)(refs, nameNode.text, 'call', nameNode);
+            }
+            else if (n.type === 'object_creation_expression') {
+                const typeNode = (0, utils_1.findFirstByType)(n, ['type_identifier', 'identifier']);
+                if (typeNode)
+                    (0, utils_1.pushRef)(refs, typeNode.text, 'new', typeNode);
+            }
+            let currentContainer = container;
+            if (n.type === 'method_declaration' || n.type === 'constructor_declaration') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const head = n.text.split('{')[0].split(';')[0].trim();
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: 'method',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: head,
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            else if (n.type === 'class_declaration'
+                || n.type === 'interface_declaration'
+                || n.type === 'enum_declaration'
+                || n.type === 'record_declaration'
+                || n.type === 'annotation_type_declaration') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const head = n.text.split('{')[0].split(';')[0].trim();
+                    const heritage = (0, utils_1.parseHeritage)(head);
+                    const classSym = {
+                        name: nameNode.text,
+                        kind: 'class',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: `${n.type.replace(/_declaration$/, '')} ${nameNode.text}`,
+                        container,
+                        extends: heritage.extends,
+                        implements: heritage.implements,
+                    };
+                    symbols.push(classSym);
+                    currentContainer = classSym;
+                }
+            }
+            for (let i = 0; i < n.childCount; i++)
+                traverse(n.child(i), currentContainer);
+        };
+        traverse(node, undefined);
+        return { symbols, refs };
+    }
+}
+exports.JavaAdapter = JavaAdapter;