@mars167/git-ai 2.3.0

package/dist/src/core/dsr/generate.js

@@ -0,0 +1,308 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDsrForCommit = generateDsrForCommit;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("../crypto");
+const paths_1 = require("../paths");
+const gitContext_1 = require("./gitContext");
+const paths_2 = require("./paths");
+const snapshotParser_1 = require("./snapshotParser");
+function normalizeFilePath(p) {
+    return (0, paths_1.toPosixPath)(p);
+}
+function symbolContainerKey(s) {
+    if (!s.container)
+        return '';
+    return `${s.container.kind}:${s.container.name}`;
+}
+function symbolKeyFull(file, s) {
+    return `${file}|${symbolContainerKey(s)}|${s.kind}|${s.name}|${s.signature}`;
+}
+function symbolKeyNoSig(file, s) {
+    return `${file}|${symbolContainerKey(s)}|${s.kind}|${s.name}`;
+}
+function clampLine(n, min, max) {
+    if (!Number.isFinite(n))
+        return min;
+    if (n < min)
+        return min;
+    if (n > max)
+        return max;
+    return n;
+}
+function computeRangeHash(content, startLine, endLine) {
+    const lines = content.split('\n');
+    const maxLine = Math.max(1, lines.length);
+    const s = clampLine(startLine, 1, maxLine);
+    const e = clampLine(endLine, 1, maxLine);
+    const from = Math.min(s, e);
+    const to = Math.max(s, e);
+    const slice = lines.slice(from - 1, to).join('\n');
+    return (0, crypto_1.sha256Hex)(slice);
+}
+function toDescriptor(file, s) {
+    const out = {
+        file,
+        kind: String(s.kind),
+        name: String(s.name),
+        signature: String(s.signature ?? ''),
+        start_line: Number(s.startLine ?? 0),
+        end_line: Number(s.endLine ?? 0),
+    };
+    if (s.container?.name) {
+        out.container = {
+            kind: String(s.container.kind),
+            name: String(s.container.name),
+            signature: String(s.container.signature ?? ''),
+        };
+    }
+    return out;
+}
+function riskFromOps(ops) {
+    let max = 'low';
+    for (const op of ops) {
+        if (op.op === 'delete' || op.op === 'rename')
+            return 'high';
+        if (op.op === 'modify')
+            max = 'medium';
+    }
+    return max;
+}
+function semanticTypeFromOps(ops) {
+    if (ops.length === 0)
+        return 'no-op';
+    const kinds = new Set(ops.map((o) => o.op));
+    if (kinds.size === 1) {
+        const only = Array.from(kinds)[0];
+        if (only === 'add')
+            return 'additive';
+        if (only === 'modify')
+            return 'modification';
+        if (only === 'delete')
+            return 'deletion';
+        if (only === 'rename')
+            return 'rename';
+    }
+    return 'mixed';
+}
+function stableSortDescriptor(a, b) {
+    const ak = `${a.file}|${a.kind}|${a.name}|${a.signature}|${a.container?.kind ?? ''}|${a.container?.name ?? ''}`;
+    const bk = `${b.file}|${b.kind}|${b.name}|${b.signature}|${b.container?.kind ?? ''}|${b.container?.name ?? ''}`;
+    return ak.localeCompare(bk);
+}
+function stableSortOp(a, b) {
+    const ak = `${a.op}|${a.symbol.file}|${a.symbol.kind}|${a.symbol.name}|${a.symbol.signature}|${a.previous?.name ?? ''}|${a.previous?.signature ?? ''}|${a.content_hash}`;
+    const bk = `${b.op}|${b.symbol.file}|${b.symbol.kind}|${b.symbol.name}|${b.symbol.signature}|${b.previous?.name ?? ''}|${b.previous?.signature ?? ''}|${b.content_hash}`;
+    return ak.localeCompare(bk);
+}
+function canonDsr(dsr) {
+    const affected = [...dsr.affected_symbols].sort(stableSortDescriptor);
+    const ops = [...dsr.ast_operations].sort(stableSortOp);
+    const out = {
+        commit_hash: dsr.commit_hash,
+        affected_symbols: affected,
+        ast_operations: ops,
+        semantic_change_type: dsr.semantic_change_type,
+    };
+    if (dsr.summary)
+        out.summary = dsr.summary;
+    if (dsr.risk_level)
+        out.risk_level = dsr.risk_level;
+    return out;
+}
+function stringifyDsr(dsr) {
+    return JSON.stringify(canonDsr(dsr), null, 2) + '\n';
+}
+async function generateDsrForCommit(repoRoot, commitHash) {
+    const resolvedCommit = await (0, gitContext_1.resolveCommitHash)(repoRoot, commitHash);
+    await (0, gitContext_1.assertCommitExists)(repoRoot, resolvedCommit);
+    const parents = await (0, gitContext_1.getCommitParents)(repoRoot, resolvedCommit);
+    const parent = parents.length > 0 ? parents[0] : null;
+    const changes = await (0, gitContext_1.getNameStatusBetween)(repoRoot, parent, resolvedCommit);
+    const parser = new snapshotParser_1.SnapshotCodeParser();
+    const beforeSnaps = [];
+    const afterSnaps = [];
+    for (const ch of changes) {
+        const status = String(ch.status);
+        const file = normalizeFilePath(String(ch.path));
+        const includeBefore = status !== 'A';
+        const includeAfter = status !== 'D';
+        if (includeBefore && parent) {
+            const beforeContent = await (0, gitContext_1.gitShowFile)(repoRoot, parent, file);
+            if (beforeContent != null) {
+                const parsed = parser.parseContent(file, beforeContent);
+                for (const s of parsed.symbols) {
+                    const desc = toDescriptor(file, s);
+                    const content_hash = computeRangeHash(beforeContent, desc.start_line, desc.end_line);
+                    beforeSnaps.push({ desc, content_hash });
+                }
+            }
+        }
+        if (includeAfter) {
+            const afterContent = await (0, gitContext_1.gitShowFile)(repoRoot, resolvedCommit, file);
+            if (afterContent != null) {
+                const parsed = parser.parseContent(file, afterContent);
+                for (const s of parsed.symbols) {
+                    const desc = toDescriptor(file, s);
+                    const content_hash = computeRangeHash(afterContent, desc.start_line, desc.end_line);
+                    afterSnaps.push({ desc, content_hash });
+                }
+            }
+        }
+    }
+    const beforeByFull = new Map();
+    const afterByFull = new Map();
+    const beforeByNoSig = new Map();
+    const afterByNoSig = new Map();
+    for (const s of beforeSnaps) {
+        const file = s.desc.file;
+        const kFull = symbolKeyFull(file, s.desc);
+        const kNoSig = symbolKeyNoSig(file, s.desc);
+        beforeByFull.set(kFull, [...(beforeByFull.get(kFull) ?? []), s]);
+        beforeByNoSig.set(kNoSig, [...(beforeByNoSig.get(kNoSig) ?? []), s]);
+    }
+    for (const s of afterSnaps) {
+        const file = s.desc.file;
+        const kFull = symbolKeyFull(file, s.desc);
+        const kNoSig = symbolKeyNoSig(file, s.desc);
+        afterByFull.set(kFull, [...(afterByFull.get(kFull) ?? []), s]);
+        afterByNoSig.set(kNoSig, [...(afterByNoSig.get(kNoSig) ?? []), s]);
+    }
+    const usedBefore = new Set();
+    const usedAfter = new Set();
+    const ops = [];
+    for (const [kFull, bList] of beforeByFull.entries()) {
+        const aList = afterByFull.get(kFull) ?? [];
+        if (aList.length === 0)
+            continue;
+        const pairs = Math.min(bList.length, aList.length);
+        for (let i = 0; i < pairs; i++) {
+            const b = bList[i];
+            const a = aList[i];
+            usedBefore.add(b);
+            usedAfter.add(a);
+            if (b.content_hash !== a.content_hash) {
+                ops.push({
+                    op: 'modify',
+                    symbol: a.desc,
+                    previous: { name: b.desc.name, signature: b.desc.signature },
+                    content_hash: a.content_hash,
+                });
+            }
+        }
+    }
+    const remainingBefore = beforeSnaps.filter((s) => !usedBefore.has(s));
+    const remainingAfter = afterSnaps.filter((s) => !usedAfter.has(s));
+    const remainingAfterByNoSig = new Map();
+    for (const a of remainingAfter) {
+        const k = symbolKeyNoSig(a.desc.file, a.desc);
+        remainingAfterByNoSig.set(k, [...(remainingAfterByNoSig.get(k) ?? []), a]);
+    }
+    for (const b of remainingBefore) {
+        const k = symbolKeyNoSig(b.desc.file, b.desc);
+        const candidates = remainingAfterByNoSig.get(k) ?? [];
+        if (candidates.length !== 1)
+            continue;
+        const a = candidates[0];
+        if (usedAfter.has(a))
+            continue;
+        usedBefore.add(b);
+        usedAfter.add(a);
+        if (b.content_hash !== a.content_hash || b.desc.signature !== a.desc.signature) {
+            ops.push({
+                op: 'modify',
+                symbol: a.desc,
+                previous: { name: b.desc.name, signature: b.desc.signature },
+                content_hash: a.content_hash,
+            });
+        }
+    }
+    const remBefore2 = beforeSnaps.filter((s) => !usedBefore.has(s));
+    const remAfter2 = afterSnaps.filter((s) => !usedAfter.has(s));
+    const afterByHash = new Map();
+    for (const a of remAfter2) {
+        const k = `${a.desc.file}|${symbolContainerKey(a.desc)}|${a.desc.kind}|${a.content_hash}`;
+        afterByHash.set(k, [...(afterByHash.get(k) ?? []), a]);
+    }
+    for (const b of remBefore2) {
+        const k = `${b.desc.file}|${symbolContainerKey(b.desc)}|${b.desc.kind}|${b.content_hash}`;
+        const candidates = afterByHash.get(k) ?? [];
+        if (candidates.length !== 1)
+            continue;
+        const a = candidates[0];
+        if (usedAfter.has(a))
+            continue;
+        usedBefore.add(b);
+        usedAfter.add(a);
+        if (b.desc.name !== a.desc.name || b.desc.signature !== a.desc.signature) {
+            ops.push({
+                op: 'rename',
+                symbol: a.desc,
+                previous: { name: b.desc.name, signature: b.desc.signature },
+                content_hash: a.content_hash,
+            });
+        }
+        else if (b.content_hash !== a.content_hash) {
+            ops.push({
+                op: 'modify',
+                symbol: a.desc,
+                previous: { name: b.desc.name, signature: b.desc.signature },
+                content_hash: a.content_hash,
+            });
+        }
+    }
+    for (const a of afterSnaps) {
+        if (usedAfter.has(a))
+            continue;
+        ops.push({
+            op: 'add',
+            symbol: a.desc,
+            content_hash: a.content_hash,
+        });
+    }
+    for (const b of beforeSnaps) {
+        if (usedBefore.has(b))
+            continue;
+        ops.push({
+            op: 'delete',
+            symbol: b.desc,
+            content_hash: b.content_hash,
+        });
+    }
+    const affectedMap = new Map();
+    for (const op of ops) {
+        const s = op.symbol;
+        const k = symbolKeyFull(s.file, s);
+        affectedMap.set(k, s);
+    }
+    const subject = await (0, gitContext_1.getCommitSubject)(repoRoot, resolvedCommit).catch(() => '');
+    const risk_level = riskFromOps(ops);
+    const semantic_change_type = semanticTypeFromOps(ops);
+    const dsr = canonDsr({
+        commit_hash: resolvedCommit,
+        affected_symbols: Array.from(affectedMap.values()),
+        ast_operations: ops,
+        semantic_change_type,
+        summary: subject || undefined,
+        risk_level,
+    });
+    const dir = (0, paths_2.dsrDirectory)(repoRoot);
+    const file_path = (0, paths_2.dsrFilePath)(repoRoot, resolvedCommit);
+    await fs_extra_1.default.ensureDir(dir);
+    const rendered = stringifyDsr(dsr);
+    if (await fs_extra_1.default.pathExists(file_path)) {
+        const existing = await fs_extra_1.default.readFile(file_path, 'utf-8').catch(() => '');
+        if (existing.trimEnd() !== rendered.trimEnd()) {
+            throw new Error(`DSR already exists but differs: ${file_path}`);
+        }
+        return { dsr, file_path, existed: true };
+    }
+    const tmp = path_1.default.join(dir, `${commitHash}.json.tmp-${process.pid}-${Date.now()}`);
+    await fs_extra_1.default.writeFile(tmp, rendered, 'utf-8');
+    await fs_extra_1.default.move(tmp, file_path, { overwrite: false });
+    return { dsr, file_path, existed: false };
+}

package/dist/src/core/dsr/gitContext.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRepoGitContext = detectRepoGitContext;
+exports.getCommitParents = getCommitParents;
+exports.getCommitSubject = getCommitSubject;
+exports.assertCommitExists = assertCommitExists;
+exports.resolveCommitHash = resolveCommitHash;
+exports.getNameStatusBetween = getNameStatusBetween;
+exports.gitShowFile = gitShowFile;
+const simple_git_1 = __importDefault(require("simple-git"));
+async function detectRepoGitContext(startDir) {
+    const git = (0, simple_git_1.default)(startDir);
+    const repo_root = (await git.raw(['rev-parse', '--show-toplevel'])).trim();
+    const head_commit = (await (0, simple_git_1.default)(repo_root).raw(['rev-parse', 'HEAD'])).trim();
+    const branchRaw = (await (0, simple_git_1.default)(repo_root).raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+    const detached = branchRaw === 'HEAD';
+    return {
+        repo_root,
+        head_commit,
+        branch: detached ? null : branchRaw,
+        detached,
+    };
+}
+async function getCommitParents(repoRoot, commitHash) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    const out = (await git.raw(['show', '-s', '--format=%P', commitHash])).trim();
+    if (!out)
+        return [];
+    return out.split(/\s+/).map((s) => s.trim()).filter(Boolean);
+}
+async function getCommitSubject(repoRoot, commitHash) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    return (await git.raw(['show', '-s', '--format=%s', commitHash])).trim();
+}
+async function assertCommitExists(repoRoot, commitHash) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    await git.raw(['cat-file', '-e', `${commitHash}^{commit}`]);
+}
+async function resolveCommitHash(repoRoot, rev) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    return (await git.raw(['rev-parse', `${rev}^{commit}`])).trim();
+}
+async function getNameStatusBetween(repoRoot, parent, commit) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    const lines = parent
+        ? (await git.raw(['diff', '--name-status', '--no-renames', parent, commit])).trim().split('\n')
+        : (await git.raw(['diff-tree', '--root', '--no-commit-id', '--name-status', '-r', commit])).trim().split('\n');
+    const rows = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const parts = trimmed.split('\t');
+        const status = (parts[0] ?? '').trim();
+        const p = (parts[1] ?? '').trim();
+        if (!status || !p)
+            continue;
+        rows.push({ status, path: p });
+    }
+    rows.sort((a, b) => (a.status + '\t' + a.path).localeCompare(b.status + '\t' + b.path));
+    return rows;
+}
+async function gitShowFile(repoRoot, commitHash, filePath) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    try {
+        return await git.raw(['show', `${commitHash}:${filePath}`]);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/core/dsr/indexMaterialize.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializeDsrIndex = materializeDsrIndex;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const cozo_1 = require("../cozo");
+const paths_1 = require("./paths");
+async function materializeDsrIndex(repoRoot) {
+    const dsrDir = (0, paths_1.dsrDirectory)(repoRoot);
+    if (!await fs_extra_1.default.pathExists(dsrDir)) {
+        return { enabled: false, skippedReason: `DSR directory missing: ${dsrDir}` };
+    }
+    const files = (await fs_extra_1.default.readdir(dsrDir).catch(() => []))
+        .filter((f) => f.endsWith('.json'))
+        .filter((f) => !f.endsWith('.export.json'))
+        .sort((a, b) => a.localeCompare(b));
+    const dsrs = [];
+    for (const f of files) {
+        const full = path_1.default.join(dsrDir, f);
+        const data = await fs_extra_1.default.readJSON(full).catch(() => null);
+        if (!data || typeof data !== 'object')
+            continue;
+        if (typeof data.commit_hash !== 'string')
+            continue;
+        dsrs.push(data);
+    }
+    const dbPath = (0, paths_1.dsrIndexDbPath)(repoRoot);
+    const exportPath = (0, paths_1.dsrIndexExportPath)(repoRoot);
+    const db = await (0, cozo_1.openCozoDbAtPath)(dbPath, exportPath);
+    if (!db)
+        return { enabled: false, skippedReason: 'Cozo backend not available (see cozo.error.json next to dsr-index.sqlite)' };
+    const commits = [];
+    const affected = [];
+    const ops = [];
+    for (const r of dsrs) {
+        const commit = String(r.commit_hash);
+        commits.push([
+            commit,
+            String(r.semantic_change_type ?? ''),
+            String(r.risk_level ?? ''),
+            String(r.summary ?? ''),
+        ]);
+        for (const s of Array.isArray(r.affected_symbols) ? r.affected_symbols : []) {
+            affected.push([
+                commit,
+                String(s.file ?? ''),
+                String(s.kind ?? ''),
+                String(s.name ?? ''),
+                String(s.signature ?? ''),
+                String(s.container?.kind ?? ''),
+                String(s.container?.name ?? ''),
+                String(s.container?.signature ?? ''),
+            ]);
+        }
+        for (const o of Array.isArray(r.ast_operations) ? r.ast_operations : []) {
+            const sym = o.symbol ?? {};
+            ops.push([
+                commit,
+                String(o.op ?? ''),
+                String(sym.file ?? ''),
+                String(sym.kind ?? ''),
+                String(sym.name ?? ''),
+                String(sym.signature ?? ''),
+                String(o.previous?.name ?? ''),
+                String(o.previous?.signature ?? ''),
+                String(o.content_hash ?? ''),
+            ]);
+        }
+    }
+    const script = `
+{
+  ?[commit_hash, semantic_change_type, risk_level, summary] <- $commits
+  :replace dsr_commit { commit_hash: String => semantic_change_type: String, risk_level: String, summary: String }
+}
+{
+  ?[commit_hash, file, kind, name, signature, container_kind, container_name, container_signature] <- $affected
+  :replace dsr_affected_symbol { commit_hash: String, file: String, kind: String, name: String, signature: String, container_kind: String, container_name: String, container_signature: String }
+}
+{
+  ?[commit_hash, op, file, kind, name, signature, prev_name, prev_signature, content_hash] <- $ops
+  :replace dsr_ast_operation { commit_hash: String, op: String, file: String, kind: String, name: String, signature: String, prev_name: String, prev_signature: String, content_hash: String }
+}
+`;
+    await db.run(script, { commits, affected, ops });
+    if (db.engine !== 'sqlite' && db.exportRelations) {
+        const exported = await db.exportRelations(['dsr_commit', 'dsr_affected_symbol', 'dsr_ast_operation']);
+        await fs_extra_1.default.ensureDir(path_1.default.dirname(exportPath));
+        await fs_extra_1.default.writeJSON(exportPath, exported, { spaces: 2 });
+    }
+    if (db.close)
+        await db.close();
+    return {
+        enabled: true,
+        engine: db.engine,
+        dbPath: db.dbPath,
+        exportPath: db.engine !== 'sqlite' ? exportPath : undefined,
+        counts: {
+            commits: commits.length,
+            affected_symbols: affected.length,
+            ast_operations: ops.length,
+        },
+    };
+}

package/dist/src/core/dsr/paths.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dsrCacheRoot = dsrCacheRoot;
+exports.dsrDirectory = dsrDirectory;
+exports.dsrFilePath = dsrFilePath;
+exports.dsrIndexDbPath = dsrIndexDbPath;
+exports.dsrIndexExportPath = dsrIndexExportPath;
+const path_1 = __importDefault(require("path"));
+function dsrCacheRoot(repoRoot) {
+    return path_1.default.join(repoRoot, '.git-ai');
+}
+function dsrDirectory(repoRoot) {
+    return path_1.default.join(dsrCacheRoot(repoRoot), 'dsr');
+}
+function dsrFilePath(repoRoot, commitHash) {
+    return path_1.default.join(dsrDirectory(repoRoot), `${commitHash}.json`);
+}
+function dsrIndexDbPath(repoRoot) {
+    return path_1.default.join(dsrDirectory(repoRoot), 'dsr-index.sqlite');
+}
+function dsrIndexExportPath(repoRoot) {
+    return path_1.default.join(dsrDirectory(repoRoot), 'dsr-index.export.json');
+}

package/dist/src/core/dsr/query.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommitsTopological = listCommitsTopological;
+exports.symbolEvolution = symbolEvolution;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const paths_1 = require("./paths");
+async function listCommitsTopological(repoRoot, opts) {
+    const git = (0, simple_git_1.default)(repoRoot);
+    const args = ['rev-list', '--topo-order'];
+    if (opts.limit && opts.limit > 0)
+        args.push('-n', String(opts.limit));
+    if (opts.all)
+        args.push('--all');
+    else
+        args.push(String(opts.start ?? 'HEAD'));
+    const out = (await git.raw(args)).trim();
+    if (!out)
+        return [];
+    return out.split('\n').map((l) => l.trim()).filter(Boolean);
+}
+async function symbolEvolution(repoRoot, symbol, opts) {
+    const commits = await listCommitsTopological(repoRoot, opts);
+    const missing_dsrs = [];
+    const hits = [];
+    const needle = String(symbol ?? '').trim();
+    if (!needle)
+        return { ok: true, hits: [] };
+    const matches = (name) => {
+        if (opts.contains)
+            return name.includes(needle);
+        return name === needle;
+    };
+    for (const c of commits) {
+        const p = (0, paths_1.dsrFilePath)(repoRoot, c);
+        if (!await fs_extra_1.default.pathExists(p)) {
+            missing_dsrs.push(c);
+            break;
+        }
+        const rec = await fs_extra_1.default.readJSON(p).catch(() => null);
+        if (!rec)
+            continue;
+        const ops = Array.isArray(rec.ast_operations) ? rec.ast_operations : [];
+        const matchedOps = ops
+            .filter((o) => matches(String(o?.symbol?.name ?? '')) || matches(String(o?.previous?.name ?? '')))
+            .map((o) => ({
+            op: String(o?.op ?? ''),
+            file: String(o?.symbol?.file ?? ''),
+            kind: String(o?.symbol?.kind ?? ''),
+            name: String(o?.symbol?.name ?? ''),
+            signature: String(o?.symbol?.signature ?? ''),
+            previous_name: o?.previous?.name ? String(o.previous.name) : undefined,
+            previous_signature: o?.previous?.signature ? String(o.previous.signature) : undefined,
+            content_hash: String(o?.content_hash ?? ''),
+        }))
+            .sort((a, b) => `${a.op}|${a.file}|${a.kind}|${a.name}|${a.signature}|${a.previous_name ?? ''}`.localeCompare(`${b.op}|${b.file}|${b.kind}|${b.name}|${b.signature}|${b.previous_name ?? ''}`));
+        if (matchedOps.length === 0)
+            continue;
+        hits.push({
+            commit_hash: String(rec.commit_hash),
+            semantic_change_type: String(rec.semantic_change_type ?? ''),
+            risk_level: rec.risk_level,
+            summary: rec.summary,
+            operations: matchedOps,
+        });
+    }
+    if (missing_dsrs.length > 0)
+        return { ok: false, missing_dsrs };
+    return { ok: true, hits };
+}

package/dist/src/core/dsr/snapshotParser.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotCodeParser = void 0;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+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 SnapshotCodeParser {
+    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(),
+        ];
+    }
+    parseContent(filePath, content) {
+        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.SnapshotCodeParser = SnapshotCodeParser;
+function isMarkdownFile(filePath) {
+    return filePath.endsWith('.md') || filePath.endsWith('.mdx');
+}
+function isYamlFile(filePath) {
+    return filePath.endsWith('.yml') || filePath.endsWith('.yaml');
+}

package/dist/src/core/dsr/state.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDsrDirectoryState = getDsrDirectoryState;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+async function getDsrDirectoryState(repoRoot) {
+    const cache_root = (0, paths_1.dsrCacheRoot)(repoRoot);
+    const dsr_dir = (0, paths_1.dsrDirectory)(repoRoot);
+    const cache_root_exists = await fs_extra_1.default.pathExists(cache_root);
+    const dsr_dir_exists = await fs_extra_1.default.pathExists(dsr_dir);
+    let dsr_file_count = 0;
+    if (dsr_dir_exists) {
+        const entries = await fs_extra_1.default.readdir(dsr_dir).catch(() => []);
+        dsr_file_count = entries.filter((e) => e.endsWith('.json') && !e.endsWith('.export.json')).length;
+    }
+    return {
+        cache_root: path_1.default.resolve(cache_root),
+        cache_root_exists,
+        dsr_dir: path_1.default.resolve(dsr_dir),
+        dsr_dir_exists,
+        dsr_file_count,
+    };
+}