@mars167/git-ai 2.3.0

package/dist/src/core/astGraph.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAstGraphToCozo = writeAstGraphToCozo;
+exports.removeFileFromAstGraph = removeFileFromAstGraph;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const cozo_1 = require("./cozo");
+const crypto_1 = require("./crypto");
+const paths_1 = require("./paths");
+async function writeAstGraphToCozo(repoRoot, data, opts) {
+    const db = await (0, cozo_1.openRepoCozoDb)(repoRoot);
+    if (!db)
+        return { enabled: false, skippedReason: 'Cozo backend not available (see .git-ai/cozo.error.json)' };
+    const mode = opts?.mode ?? 'replace';
+    const op = mode === 'put' ? ':put' : ':replace';
+    const script = `
+{
+  ?[file_id, file, lang] <- $files
+  ${op} ast_file { file_id: String => file: String, lang: String }
+}
+{
+  ?[ref_id, file, lang, name, kind, signature, start_line, end_line] <- $symbols
+  ${op} ast_symbol { ref_id: String => file: String, lang: String, name: String, kind: String, signature: String, start_line: Int, end_line: Int }
+}
+{
+  ?[parent_id, child_id] <- $contains
+  ${op} ast_contains { parent_id: String, child_id: String }
+}
+{
+  ?[sub_id, super_name] <- $extends_name
+  ${op} ast_extends_name { sub_id: String, super_name: String }
+}
+{
+  ?[sub_id, iface_name] <- $implements_name
+  ${op} ast_implements_name { sub_id: String, iface_name: String }
+}
+{
+  ?[from_id, from_lang, name, ref_kind, file, line, col] <- $refs_name
+  ${op} ast_ref_name { from_id: String, from_lang: String, name: String, ref_kind: String, file: String, line: Int, col: Int }
+}
+{
+  ?[caller_id, caller_lang, callee_name, file, line, col] <- $calls_name
+  ${op} ast_call_name { caller_id: String, caller_lang: String, callee_name: String, file: String, line: Int, col: Int }
+}
+`;
+    await db.run(script, data);
+    if (db.engine !== 'sqlite' && db.exportRelations) {
+        const exported = await db.exportRelations(['ast_file', 'ast_symbol', 'ast_contains', 'ast_extends_name', 'ast_implements_name', 'ast_ref_name', 'ast_call_name']);
+        await fs_extra_1.default.writeJSON((0, cozo_1.repoAstGraphExportPath)(repoRoot), exported, { spaces: 2 });
+    }
+    if (db.close)
+        await db.close();
+    return {
+        enabled: true,
+        engine: db.engine,
+        dbPath: db.dbPath,
+        counts: {
+            files: data.files.length,
+            symbols: data.symbols.length,
+            contains: data.contains.length,
+            extends_name: data.extends_name.length,
+            implements_name: data.implements_name.length,
+            refs_name: data.refs_name.length,
+            calls_name: data.calls_name.length,
+        },
+    };
+}
+async function removeFileFromAstGraph(repoRoot, file) {
+    const db = await (0, cozo_1.openRepoCozoDb)(repoRoot);
+    if (!db)
+        return { enabled: false, skippedReason: 'Cozo backend not available (see .git-ai/cozo.error.json)' };
+    const filePosix = (0, paths_1.toPosixPath)(file);
+    const file_id = (0, crypto_1.sha256Hex)(`file:${filePosix}`);
+    const script = `
+syms[ref_id] := *ast_symbol{ref_id, file}, file == $file
+{
+  ?[ref_id] := syms[ref_id]
+  :rm ast_symbol { ref_id }
+}
+{
+  ?[parent_id, child_id] := *ast_contains{parent_id, child_id}, syms[child_id]
+  :rm ast_contains { parent_id, child_id }
+}
+{
+  ?[parent_id, child_id] := *ast_contains{parent_id, child_id}, syms[parent_id]
+  :rm ast_contains { parent_id, child_id }
+}
+{
+  ?[parent_id, child_id] := *ast_contains{parent_id, child_id}, parent_id == $file_id
+  :rm ast_contains { parent_id, child_id }
+}
+{
+  ?[sub_id, super_name] := *ast_extends_name{sub_id, super_name}, syms[sub_id]
+  :rm ast_extends_name { sub_id, super_name }
+}
+{
+  ?[sub_id, iface_name] := *ast_implements_name{sub_id, iface_name}, syms[sub_id]
+  :rm ast_implements_name { sub_id, iface_name }
+}
+{
+  ?[from_id, from_lang, name, ref_kind, file, line, col] := *ast_ref_name{from_id, from_lang, name, ref_kind, file, line, col}, file == $file
+  :rm ast_ref_name { from_id, from_lang, name, ref_kind, file, line, col }
+}
+{
+  ?[caller_id, caller_lang, callee_name, file, line, col] := *ast_call_name{caller_id, caller_lang, callee_name, file, line, col}, file == $file
+  :rm ast_call_name { caller_id, caller_lang, callee_name, file, line, col }
+}
+{
+  ?[file_id] <- [[$file_id]]
+  :rm ast_file { file_id }
+}
+`;
+    await db.run(script, { file: filePosix, file_id });
+    if (db.engine !== 'sqlite' && db.exportRelations) {
+        const exported = await db.exportRelations(['ast_file', 'ast_symbol', 'ast_contains', 'ast_extends_name', 'ast_implements_name', 'ast_ref_name', 'ast_call_name']);
+        await fs_extra_1.default.writeJSON((0, cozo_1.repoAstGraphExportPath)(repoRoot), exported, { spaces: 2 });
+    }
+    if (db.close)
+        await db.close();
+    return {
+        enabled: true,
+        engine: db.engine,
+        dbPath: db.dbPath,
+    };
+}

package/dist/src/core/astGraphQuery.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAstGraphQuery = runAstGraphQuery;
+exports.buildFindSymbolsQuery = buildFindSymbolsQuery;
+exports.buildChildrenQuery = buildChildrenQuery;
+exports.buildFindReferencesQuery = buildFindReferencesQuery;
+exports.buildCallersByNameQuery = buildCallersByNameQuery;
+exports.buildCalleesByNameQuery = buildCalleesByNameQuery;
+exports.buildCallChainByNameQuery = buildCallChainByNameQuery;
+exports.buildCallChainDownstreamByNameQuery = buildCallChainDownstreamByNameQuery;
+exports.buildCallChainUpstreamByNameQuery = buildCallChainUpstreamByNameQuery;
+const cozo_1 = require("./cozo");
+async function runAstGraphQuery(repoRoot, query, params) {
+    const db = await (0, cozo_1.openRepoCozoDb)(repoRoot);
+    if (!db) {
+        throw new Error('AST graph is not available: Cozo backend not available (see .git-ai/cozo.error.json)');
+    }
+    try {
+        return await db.run(query, params ?? {});
+    }
+    finally {
+        if (db.close)
+            await db.close();
+    }
+}
+function buildFindSymbolsQuery(lang) {
+    return `
+?[ref_id, file, lang, name, kind, signature, start_line, end_line] :=
+  *ast_symbol{ref_id, file, lang, name, kind, signature, start_line, end_line},
+  starts_with(lowercase(name), lowercase($prefix))${lang ? `,
+  lowercase(lang) == lowercase($lang)` : ''}
+`;
+}
+function buildChildrenQuery() {
+    return `
+?[child_id, file, lang, name, kind, signature, start_line, end_line] :=
+  *ast_contains{parent_id: $parent_id, child_id},
+  *ast_symbol{ref_id: child_id, file, lang, name, kind, signature, start_line, end_line}
+`;
+}
+function buildFindReferencesQuery(lang) {
+    return `
+?[file, line, col, ref_kind, from_id, from_kind, from_name, from_lang] :=
+  *ast_ref_name{from_id, from_lang, name, ref_kind, file, line, col},
+  lowercase(name) == lowercase($name),
+  *ast_symbol{ref_id: from_id, name: from_name, kind: from_kind, lang: from_lang}${lang ? `,
+  lowercase(from_lang) == lowercase($lang)` : ''}
+
+?[file, line, col, ref_kind, from_id, from_kind, from_name, from_lang] :=
+  *ast_ref_name{from_id, from_lang, name, ref_kind, file, line, col},
+  lowercase(name) == lowercase($name),
+  *ast_file{file_id: from_id, file: from_name, lang: from_lang},
+  from_kind = 'file'${lang ? `,
+  lowercase(from_lang) == lowercase($lang)` : ''}
+`;
+}
+function buildCallersByNameQuery(lang) {
+    return `
+?[caller_id, caller_kind, caller_name, file, line, col, caller_lang] :=
+  *ast_call_name{caller_id, caller_lang, callee_name, file, line, col},
+  lowercase(callee_name) == lowercase($name),
+  *ast_symbol{ref_id: caller_id, name: caller_name, kind: caller_kind, lang: caller_lang}${lang ? `,
+  lowercase(caller_lang) == lowercase($lang)` : ''}
+
+?[caller_id, caller_kind, caller_name, file, line, col, caller_lang] :=
+  *ast_call_name{caller_id, caller_lang, callee_name, file, line, col},
+  lowercase(callee_name) == lowercase($name),
+  *ast_file{file_id: caller_id, file: caller_name, lang: caller_lang},
+  caller_kind = 'file'${lang ? `,
+  lowercase(caller_lang) == lowercase($lang)` : ''}
+`;
+}
+function buildCalleesByNameQuery(lang) {
+    return `
+?[caller_id, caller_lang, callee_id, callee_file, callee_name, callee_kind, file, line, col] :=
+  *ast_symbol{ref_id: caller_id, name: caller_name, lang: caller_lang},
+  lowercase(caller_name) == lowercase($name)${lang ? `, lowercase(caller_lang) == lowercase($lang)` : ''},
+  *ast_call_name{caller_id, caller_lang, callee_name, file, line, col},
+  *ast_symbol{ref_id: callee_id, file: callee_file, name: callee_name, kind: callee_kind, lang: caller_lang}
+`;
+}
+function buildCallChainByNameQuery() {
+    throw new Error('Deprecated: use buildCallChainDownstreamByNameQuery or buildCallChainUpstreamByNameQuery');
+}
+function buildCallChainDownstreamByNameQuery() {
+    return `
+start_ids[ref_id] :=
+  *ast_symbol{ref_id, name, lang},
+  lowercase(name) == lowercase($name),
+  lowercase(lang) == lowercase($lang)
+
+step[caller_id, callee_id, depth, lang] :=
+  start_ids[caller_id],
+  *ast_call_name{caller_id, caller_lang: lang, callee_name},
+  *ast_symbol{ref_id: callee_id, name: callee_name, lang},
+  depth = 1,
+  lowercase(lang) == lowercase($lang)
+
+step[caller_id, callee_id, depth, lang] :=
+  step[prev_caller_id, prev_callee_id, d1, lang],
+  *ast_call_name{caller_id: prev_callee_id, caller_lang: lang, callee_name},
+  *ast_symbol{ref_id: callee_id, name: callee_name, lang},
+  caller_id = prev_callee_id,
+  depth = d1 + 1,
+  depth <= $max_depth,
+  lowercase(lang) == lowercase($lang)
+
+?[caller_id, callee_id, depth, caller_name, callee_name, lang] :=
+  step[caller_id, callee_id, depth, lang],
+  *ast_symbol{ref_id: caller_id, name: caller_name, lang},
+  *ast_symbol{ref_id: callee_id, name: callee_name, lang}
+`;
+}
+function buildCallChainUpstreamByNameQuery() {
+    return `
+start_ids[ref_id] :=
+  *ast_symbol{ref_id, name, lang},
+  lowercase(name) == lowercase($name),
+  lowercase(lang) == lowercase($lang)
+
+step[caller_id, callee_id, depth, lang] :=
+  start_ids[callee_id],
+  *ast_symbol{ref_id: callee_id, name: callee_name, lang},
+  *ast_call_name{caller_id, caller_lang: lang, callee_name},
+  depth = 1,
+  lowercase(lang) == lowercase($lang)
+
+step[caller_id, callee_id, depth, lang] :=
+  step[prev_caller_id, prev_callee_id, d1, lang],
+  *ast_symbol{ref_id: prev_caller_id, name: prev_name, lang},
+  *ast_call_name{caller_id, caller_lang: lang, callee_name: prev_name},
+  callee_id = prev_caller_id,
+  depth = d1 + 1,
+  depth <= $max_depth,
+  lowercase(lang) == lowercase($lang)
+
+?[caller_id, callee_id, depth, caller_name, callee_name, lang] :=
+  step[caller_id, callee_id, depth, lang],
+  *ast_symbol{ref_id: caller_id, name: caller_name, lang},
+  *ast_symbol{ref_id: callee_id, name: callee_name, lang}
+`;
+}

package/dist/src/core/cozo.js

@@ -0,0 +1,266 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repoAstGraphDbPath = repoAstGraphDbPath;
+exports.repoAstGraphExportPath = repoAstGraphExportPath;
+exports.openCozoDbAtPath = openCozoDbAtPath;
+exports.openRepoCozoDb = openRepoCozoDb;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+function repoAstGraphDbPath(repoRoot) {
+    return path_1.default.join(repoRoot, '.git-ai', 'ast-graph.sqlite');
+}
+function repoAstGraphExportPath(repoRoot) {
+    return path_1.default.join(repoRoot, '.git-ai', 'ast-graph.export.json');
+}
+let cozoWasmInit = null;
+async function tryImportFromExport(repoRoot, client) {
+    if (!client.importRelations)
+        return;
+    if (client.engine === 'sqlite')
+        return;
+    const exportPath = repoAstGraphExportPath(repoRoot);
+    if (!await fs_extra_1.default.pathExists(exportPath))
+        return;
+    const data = await fs_extra_1.default.readJSON(exportPath).catch(() => null);
+    if (!data)
+        return;
+    await client.importRelations(data);
+}
+async function tryImportFromExportPath(exportPath, client) {
+    if (!exportPath)
+        return;
+    if (!client.importRelations)
+        return;
+    if (client.engine === 'sqlite')
+        return;
+    if (!await fs_extra_1.default.pathExists(exportPath))
+        return;
+    const data = await fs_extra_1.default.readJSON(exportPath).catch(() => null);
+    if (!data)
+        return;
+    await client.importRelations(data);
+}
+async function openCozoNode(repoRoot) {
+    let mod;
+    try {
+        const moduleName = 'cozo-node';
+        mod = await import(moduleName);
+    }
+    catch (e) {
+        throw new Error(`Failed to load cozo-node: ${String(e?.message ?? e)}`);
+    }
+    const CozoDb = mod?.CozoDb ?? mod?.default?.CozoDb ?? mod?.default ?? mod;
+    if (typeof CozoDb !== 'function')
+        throw new Error('cozo-node loaded but CozoDb export is missing');
+    const dbPath = repoAstGraphDbPath(repoRoot);
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(dbPath));
+    let db;
+    let engine = 'mem';
+    try {
+        db = new CozoDb('sqlite', dbPath);
+        engine = 'sqlite';
+    }
+    catch (e1) {
+        try {
+            db = new CozoDb({ engine: 'sqlite', path: dbPath });
+            engine = 'sqlite';
+        }
+        catch {
+            db = new CozoDb();
+            engine = 'mem';
+        }
+    }
+    const client = {
+        backend: 'cozo-node',
+        engine,
+        dbPath: engine === 'sqlite' ? dbPath : undefined,
+        run: async (script, params) => db.run(script, params ?? {}),
+        exportRelations: typeof db.exportRelations === 'function' ? async (rels) => db.exportRelations(rels) : undefined,
+        importRelations: typeof db.importRelations === 'function' ? async (data) => db.importRelations(data) : undefined,
+        close: typeof db.close === 'function' ? async () => { await db.close(); } : undefined,
+    };
+    await tryImportFromExport(repoRoot, client);
+    return client;
+}
+async function openCozoWasm(repoRoot) {
+    let mod;
+    try {
+        const moduleName = 'cozo-lib-wasm';
+        mod = await import(moduleName);
+    }
+    catch (e) {
+        throw new Error(`Failed to load cozo-lib-wasm: ${String(e?.message ?? e)}`);
+    }
+    const init = mod?.default;
+    const CozoDb = mod?.CozoDb;
+    if (typeof init !== 'function' || typeof CozoDb?.new !== 'function') {
+        throw new Error('cozo-lib-wasm loaded but exports are not compatible');
+    }
+    if (!cozoWasmInit)
+        cozoWasmInit = Promise.resolve(init()).then(() => { });
+    await cozoWasmInit;
+    const db = CozoDb.new();
+    const run = async (script, params) => {
+        const out = db.run(String(script), JSON.stringify(params ?? {}));
+        try {
+            return JSON.parse(String(out));
+        }
+        catch {
+            return out;
+        }
+    };
+    const exportRelations = async (relations) => {
+        if (typeof db.export_relations !== 'function')
+            return null;
+        const out = db.export_relations(JSON.stringify(relations));
+        try {
+            return JSON.parse(String(out));
+        }
+        catch {
+            return out;
+        }
+    };
+    const importRelations = async (data) => {
+        if (typeof db.import_relations !== 'function')
+            return null;
+        const out = db.import_relations(JSON.stringify(data));
+        try {
+            return JSON.parse(String(out));
+        }
+        catch {
+            return out;
+        }
+    };
+    const client = {
+        backend: 'cozo-wasm',
+        engine: 'mem',
+        run,
+        exportRelations,
+        importRelations,
+        close: typeof db.free === 'function' ? async () => { db.free(); } : undefined,
+    };
+    await tryImportFromExport(repoRoot, client);
+    return client;
+}
+async function openCozoDbAtPath(dbPath, exportPath) {
+    const errors = [];
+    try {
+        const moduleName = 'cozo-node';
+        const mod = await import(moduleName);
+        const CozoDb = mod?.CozoDb ?? mod?.default?.CozoDb ?? mod?.default ?? mod;
+        if (typeof CozoDb !== 'function')
+            throw new Error('cozo-node loaded but CozoDb export is missing');
+        await fs_extra_1.default.ensureDir(path_1.default.dirname(dbPath));
+        let db;
+        let engine = 'mem';
+        try {
+            db = new CozoDb('sqlite', dbPath);
+            engine = 'sqlite';
+        }
+        catch (e1) {
+            try {
+                db = new CozoDb({ engine: 'sqlite', path: dbPath });
+                engine = 'sqlite';
+            }
+            catch {
+                db = new CozoDb();
+                engine = 'mem';
+            }
+        }
+        const client = {
+            backend: 'cozo-node',
+            engine,
+            dbPath: engine === 'sqlite' ? dbPath : undefined,
+            run: async (script, params) => db.run(script, params ?? {}),
+            exportRelations: typeof db.exportRelations === 'function' ? async (rels) => db.exportRelations(rels) : undefined,
+            importRelations: typeof db.importRelations === 'function' ? async (data) => db.importRelations(data) : undefined,
+            close: typeof db.close === 'function' ? async () => { await db.close(); } : undefined,
+        };
+        await tryImportFromExportPath(exportPath, client);
+        return client;
+    }
+    catch (e) {
+        errors.push(String(e?.message ?? e));
+    }
+    try {
+        const moduleName = 'cozo-lib-wasm';
+        const mod = await import(moduleName);
+        const init = mod?.default;
+        const CozoDb = mod?.CozoDb;
+        if (typeof init !== 'function' || typeof CozoDb?.new !== 'function') {
+            throw new Error('cozo-lib-wasm loaded but exports are not compatible');
+        }
+        if (!cozoWasmInit)
+            cozoWasmInit = Promise.resolve(init()).then(() => { });
+        await cozoWasmInit;
+        const db = CozoDb.new();
+        const run = async (script, params) => {
+            const out = db.run(String(script), JSON.stringify(params ?? {}));
+            try {
+                return JSON.parse(String(out));
+            }
+            catch {
+                return out;
+            }
+        };
+        const exportRelations = async (relations) => {
+            if (typeof db.export_relations !== 'function')
+                return null;
+            const out = db.export_relations(JSON.stringify(relations));
+            try {
+                return JSON.parse(String(out));
+            }
+            catch {
+                return out;
+            }
+        };
+        const importRelations = async (data) => {
+            if (typeof db.import_relations !== 'function')
+                return null;
+            const out = db.import_relations(JSON.stringify(data));
+            try {
+                return JSON.parse(String(out));
+            }
+            catch {
+                return out;
+            }
+        };
+        const client = {
+            backend: 'cozo-wasm',
+            engine: 'mem',
+            run,
+            exportRelations,
+            importRelations,
+            close: typeof db.free === 'function' ? async () => { db.free(); } : undefined,
+        };
+        await tryImportFromExportPath(exportPath, client);
+        return client;
+    }
+    catch (e) {
+        errors.push(String(e?.message ?? e));
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(dbPath));
+    await fs_extra_1.default.writeJSON(path_1.default.join(path_1.default.dirname(dbPath), 'cozo.error.json'), { errors }, { spaces: 2 }).catch(() => { });
+    return null;
+}
+async function openRepoCozoDb(repoRoot) {
+    const errors = [];
+    try {
+        return await openCozoNode(repoRoot);
+    }
+    catch (e) {
+        errors.push(String(e?.message ?? e));
+    }
+    try {
+        return await openCozoWasm(repoRoot);
+    }
+    catch (e) {
+        errors.push(String(e?.message ?? e));
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.join(repoRoot, '.git-ai'));
+    await fs_extra_1.default.writeJSON(path_1.default.join(repoRoot, '.git-ai', 'cozo.error.json'), { errors }, { spaces: 2 }).catch(() => { });
+    return null;
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAstLayer = buildAstLayer;
+const types_1 = require("./types");
+function buildAstLayer(filePath, lang, root, options) {
+    const nodes = [];
+    const edges = [];
+    const edgeTypes = [types_1.EdgeType.CHILD, types_1.EdgeType.NEXT_TOKEN];
+    const includeNextToken = options?.includeNextToken ?? true;
+    const visited = new Set();
+    const pushNode = (node) => {
+        const id = (0, types_1.astNodeId)(filePath, node);
+        if (visited.has(id))
+            return id;
+        visited.add(id);
+        nodes.push((0, types_1.createAstNode)(filePath, lang, node));
+        return id;
+    };
+    const traverse = (node) => {
+        const parentId = pushNode(node);
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (!child)
+                continue;
+            const childId = pushNode(child);
+            edges.push({ from: parentId, to: childId, type: types_1.EdgeType.CHILD });
+            traverse(child);
+        }
+    };
+    const linkNextTokens = () => {
+        const tokens = [];
+        const walk = (node) => {
+            if (node.childCount === 0) {
+                tokens.push(node);
+                return;
+            }
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child)
+                    walk(child);
+            }
+        };
+        walk(root);
+        for (let i = 0; i < tokens.length - 1; i++) {
+            const fromId = (0, types_1.astNodeId)(filePath, tokens[i]);
+            const toId = (0, types_1.astNodeId)(filePath, tokens[i + 1]);
+            if (fromId === toId)
+                continue;
+            edges.push({ from: fromId, to: toId, type: types_1.EdgeType.NEXT_TOKEN });
+        }
+    };
+    traverse(root);
+    if (includeNextToken)
+        linkNextTokens();
+    return { nodes, edges, edgeTypes };
+}