@mars167/git-ai 2.3.0

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdown = parseMarkdown;
+const headerPattern = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
+function buildPath(current) {
+    const parts = [];
+    let cursor = current;
+    while (cursor) {
+        parts.unshift(cursor.name);
+        cursor = cursor.parent;
+    }
+    return parts.join(' > ');
+}
+function parseMarkdown(content, filePath) {
+    const lines = content.split(/\r?\n/);
+    const sections = [];
+    const stack = [];
+    const pushSection = (level, name, startLine) => {
+        while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+            const last = stack.pop();
+            if (last)
+                last.endLine = startLine - 1;
+        }
+        const parent = stack[stack.length - 1];
+        const section = { level, name, startLine, endLine: lines.length, parent };
+        sections.push(section);
+        stack.push(section);
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const match = headerPattern.exec(line);
+        if (!match)
+            continue;
+        const level = match[1].length;
+        const name = match[2].trim();
+        if (!name)
+            continue;
+        pushSection(level, name, i + 1);
+    }
+    while (stack.length > 0) {
+        const last = stack.pop();
+        if (last)
+            last.endLine = lines.length;
+    }
+    const symbols = sections.map((section) => {
+        const signature = buildPath(section) || section.name;
+        const container = section.parent
+            ? {
+                name: section.parent.name,
+                kind: 'section',
+                startLine: section.parent.startLine,
+                endLine: section.parent.endLine,
+                signature: buildPath(section.parent) || section.parent.name,
+            }
+            : undefined;
+        return {
+            name: section.name,
+            kind: 'section',
+            startLine: section.startLine,
+            endLine: section.endLine,
+            signature,
+            ...(container ? { container } : {}),
+        };
+    });
+    if (symbols.length === 0) {
+        const name = filePath.split(/[\\/]/).pop() ?? filePath;
+        symbols.push({
+            name,
+            kind: 'document',
+            startLine: 1,
+            endLine: Math.max(1, lines.length),
+            signature: name,
+        });
+    }
+    return { symbols, refs: [] };
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonAdapter = void 0;
+const tree_sitter_python_1 = __importDefault(require("tree-sitter-python"));
+const utils_1 = require("./utils");
+class PythonAdapter {
+    getLanguageId() {
+        return 'python';
+    }
+    getTreeSitterLanguage() {
+        return tree_sitter_python_1.default;
+    }
+    getSupportedFileExtensions() {
+        return ['.py'];
+    }
+    extractSymbolsAndRefs(node) {
+        const symbols = [];
+        const refs = [];
+        const traverse = (n, container) => {
+            if (n.type === 'call') {
+                const fn = n.childForFieldName('function');
+                const nameNode = this.getCallNameNode(fn);
+                if (nameNode)
+                    (0, utils_1.pushRef)(refs, nameNode.text, 'call', nameNode);
+            }
+            let currentContainer = container;
+            if (n.type === 'function_definition') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const kind = container?.kind === 'class' ? 'method' : 'function';
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind,
+                        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 === 'class_definition') {
+                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: `class ${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 === 'attribute') {
+            return node.childForFieldName('attribute');
+        }
+        return null;
+    }
+    getSignature(node) {
+        return node.text.split(':')[0].trim();
+    }
+}
+exports.PythonAdapter = PythonAdapter;

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

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RustAdapter = void 0;
+const tree_sitter_rust_1 = __importDefault(require("tree-sitter-rust"));
+const utils_1 = require("./utils");
+class RustAdapter {
+    getLanguageId() {
+        return 'rust';
+    }
+    getTreeSitterLanguage() {
+        return tree_sitter_rust_1.default;
+    }
+    getSupportedFileExtensions() {
+        return ['.rs'];
+    }
+    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_item') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    // If container is class (impl block or struct), it's a method
+                    const kind = container?.kind === 'class' ? 'method' : 'function';
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: kind,
+                        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 === 'struct_item' || n.type === 'enum_item' || n.type === 'trait_item') {
+                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: `${n.type.replace(/_item$/, '')} ${nameNode.text}`,
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            else if (n.type === 'impl_item') {
+                const typeNode = n.childForFieldName('type');
+                if (typeNode) {
+                    const newSymbol = {
+                        name: typeNode.text,
+                        kind: 'class',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: `impl ${typeNode.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 === 'scoped_identifier') {
+            return node.childForFieldName('name');
+        }
+        if (node.type === 'field_expression') {
+            return node.childForFieldName('field');
+        }
+        return null;
+    }
+    getSignature(node) {
+        return node.text.split('{')[0].trim();
+    }
+}
+exports.RustAdapter = RustAdapter;

package/dist/src/core/parser/typescript.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.TypeScriptAdapter = void 0;
+const tree_sitter_typescript_1 = __importDefault(require("tree-sitter-typescript"));
+const utils_1 = require("./utils");
+class TypeScriptAdapter {
+    constructor(isTsx = false) {
+        this.isTsx = isTsx;
+    }
+    getLanguageId() {
+        return 'typescript';
+    }
+    getTreeSitterLanguage() {
+        return this.isTsx ? tree_sitter_typescript_1.default.tsx : tree_sitter_typescript_1.default.typescript;
+    }
+    getSupportedFileExtensions() {
+        return this.isTsx ? ['.tsx', '.jsx'] : ['.ts', '.js', '.mjs', '.cjs'];
+    }
+    extractSymbolsAndRefs(node) {
+        const symbols = [];
+        const refs = [];
+        const extractTsCalleeName = (callee) => {
+            if (!callee)
+                return null;
+            if (callee.type === 'identifier')
+                return callee.text;
+            if (callee.type === 'member_expression' || callee.type === 'optional_chain') {
+                const prop = callee.childForFieldName('property');
+                if (prop)
+                    return prop.text;
+                const last = callee.namedChild(callee.namedChildCount - 1);
+                if (last)
+                    return last.text;
+            }
+            return null;
+        };
+        const traverse = (n, container) => {
+            if (n.type === 'call_expression') {
+                const fn = n.childForFieldName('function') ?? n.namedChild(0);
+                const callee = extractTsCalleeName(fn);
+                if (callee)
+                    (0, utils_1.pushRef)(refs, callee, 'call', fn ?? n);
+            }
+            else if (n.type === 'new_expression') {
+                const ctor = n.childForFieldName('constructor') ?? n.namedChild(0);
+                const callee = extractTsCalleeName(ctor);
+                if (callee)
+                    (0, utils_1.pushRef)(refs, callee, 'new', ctor ?? n);
+            }
+            else if (n.type === 'type_identifier') {
+                (0, utils_1.pushRef)(refs, n.text, 'type', n);
+            }
+            let currentContainer = container;
+            if (n.type === 'function_declaration' || n.type === 'method_definition') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: n.type === 'method_definition' ? 'method' : 'function',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: n.text.split('{')[0].trim(),
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            else if (n.type === 'class_declaration') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const head = n.text.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: `class ${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.TypeScriptAdapter = TypeScriptAdapter;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHeritage = exports.findFirstByType = exports.pushRef = void 0;
+const pushRef = (refs, name, refKind, n) => {
+    const nm = String(name ?? '').trim();
+    if (!nm)
+        return;
+    refs.push({
+        name: nm,
+        refKind,
+        line: n.startPosition.row + 1,
+        column: n.startPosition.column + 1,
+    });
+};
+exports.pushRef = pushRef;
+const findFirstByType = (n, types) => {
+    if (types.includes(n.type))
+        return n;
+    for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (!c)
+            continue;
+        const found = (0, exports.findFirstByType)(c, types);
+        if (found)
+            return found;
+    }
+    return null;
+};
+exports.findFirstByType = findFirstByType;
+const parseHeritage = (head) => {
+    const out = {};
+    const extendsMatch = head.match(/\bextends\s+([A-Za-z0-9_$.<>\[\]]+)/);
+    if (extendsMatch?.[1])
+        out.extends = [extendsMatch[1]];
+    const implMatch = head.match(/\bimplements\s+([A-Za-z0-9_$. ,<>\[\]]+)/);
+    if (implMatch?.[1]) {
+        const raw = implMatch[1];
+        const parts = [];
+        let current = '';
+        let depth = 0;
+        for (const char of raw) {
+            if (char === '<')
+                depth++;
+            else if (char === '>')
+                depth--;
+            if (char === ',' && depth === 0) {
+                if (current.trim())
+                    parts.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim())
+            parts.push(current.trim());
+        if (parts.length > 0)
+            out.implements = parts;
+    }
+    return out;
+};
+exports.parseHeritage = parseHeritage;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYaml = parseYaml;
+const keyPattern = /^\s*([A-Za-z0-9_.-]+)\s*:/;
+function isConfigPath(filePath) {
+    const p = filePath.replace(/\\/g, '/');
+    return p.includes('/.agents/') || p.includes('/templates/agents/') || p.includes('/rules/') || p.includes('/skills/');
+}
+function fileBaseName(filePath) {
+    const parts = filePath.split(/[\\/]/);
+    return parts[parts.length - 1] ?? filePath;
+}
+function parseYaml(content, filePath) {
+    const lines = content.split(/\r?\n/);
+    const nodes = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || line.trimStart().startsWith('#'))
+            continue;
+        const match = keyPattern.exec(line);
+        if (!match)
+            continue;
+        const name = match[1].trim();
+        if (!name)
+            continue;
+        if (line.trimStart().startsWith('-'))
+            continue;
+        nodes.push({ name, startLine: i + 1, endLine: lines.length });
+    }
+    for (let i = 0; i < nodes.length; i++) {
+        const next = nodes[i + 1];
+        if (next)
+            nodes[i].endLine = Math.max(nodes[i].startLine, next.startLine - 1);
+    }
+    const symbols = nodes.map((node) => ({
+        name: node.name,
+        kind: 'node',
+        startLine: node.startLine,
+        endLine: node.endLine,
+        signature: node.name,
+    }));
+    if (symbols.length === 0) {
+        const name = fileBaseName(filePath);
+        symbols.push({
+            name,
+            kind: isConfigPath(filePath) ? 'document' : 'node',
+            startLine: 1,
+            endLine: Math.max(1, lines.length),
+            signature: name,
+        });
+    }
+    return { symbols, refs: [] };
+}

package/dist/src/core/parser.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeParser = void 0;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const typescript_1 = require("./parser/typescript");
+const java_1 = require("./parser/java");
+const c_1 = require("./parser/c");
+const go_1 = require("./parser/go");
+const python_1 = require("./parser/python");
+const rust_1 = require("./parser/rust");
+const markdown_1 = require("./parser/markdown");
+const yaml_1 = require("./parser/yaml");
+class CodeParser {
+    constructor() {
+        this.parser = new tree_sitter_1.default();
+        this.adapters = [
+            new typescript_1.TypeScriptAdapter(false),
+            new typescript_1.TypeScriptAdapter(true),
+            new java_1.JavaAdapter(),
+            new c_1.CAdapter(),
+            new go_1.GoAdapter(),
+            new python_1.PythonAdapter(),
+            new rust_1.RustAdapter(),
+        ];
+    }
+    async parseFile(filePath) {
+        const content = await fs_extra_1.default.readFile(filePath, 'utf-8');
+        if (isMarkdownFile(filePath))
+            return (0, markdown_1.parseMarkdown)(content, filePath);
+        if (isYamlFile(filePath))
+            return (0, yaml_1.parseYaml)(content, filePath);
+        const adapter = this.pickAdapter(filePath);
+        if (!adapter)
+            return { symbols: [], refs: [] };
+        try {
+            this.parser.setLanguage(adapter.getTreeSitterLanguage());
+            const tree = this.parser.parse(content);
+            return adapter.extractSymbolsAndRefs(tree.rootNode);
+        }
+        catch (e) {
+            const msg = String(e?.message ?? e);
+            if (msg.includes('Invalid language object'))
+                return { symbols: [], refs: [] };
+            if (!msg.includes('Invalid argument'))
+                return { symbols: [], refs: [] };
+            try {
+                const tree = this.parser.parse(content, undefined, { bufferSize: 1024 * 1024 });
+                return adapter.extractSymbolsAndRefs(tree.rootNode);
+            }
+            catch {
+                return { symbols: [], refs: [] };
+            }
+        }
+    }
+    pickAdapter(filePath) {
+        for (const adapter of this.adapters) {
+            for (const ext of adapter.getSupportedFileExtensions()) {
+                if (filePath.endsWith(ext))
+                    return adapter;
+            }
+        }
+        return null;
+    }
+}
+exports.CodeParser = CodeParser;
+function isMarkdownFile(filePath) {
+    return filePath.endsWith('.md') || filePath.endsWith('.mdx');
+}
+function isYamlFile(filePath) {
+    return filePath.endsWith('.yml') || filePath.endsWith('.yaml');
+}

package/dist/src/core/paths.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPosixPath = toPosixPath;
+exports.splitPosixPath = splitPosixPath;
+function toPosixPath(p) {
+    return String(p).replace(/\\/g, '/');
+}
+function splitPosixPath(p) {
+    return toPosixPath(p).split('/').filter(Boolean);
+}