@mars167/git-ai 2.3.0

package/dist/src/commands/query.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const git_1 = require("../core/git");
+const lancedb_1 = require("../core/lancedb");
+const workspace_1 = require("../core/workspace");
+const symbolSearch_1 = require("../core/symbolSearch");
+const log_1 = require("../core/log");
+const indexCheck_1 = require("../core/indexCheck");
+const repoMap_1 = require("../core/repoMap");
+exports.queryCommand = new commander_1.Command('query')
+    .description('Query refs table by symbol match (substring/prefix/wildcard/regex/fuzzy)')
+    .argument('<keyword>', 'Symbol substring')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--limit <n>', 'Limit results', '50')
+    .option('--mode <mode>', 'Mode: substring|prefix|wildcard|regex|fuzzy (default: auto)')
+    .option('--case-insensitive', 'Case-insensitive matching', false)
+    .option('--max-candidates <n>', 'Max candidates to fetch before filtering', '1000')
+    .option('--lang <lang>', 'Language: auto|all|java|ts|python|go|rust|c|markdown|yaml', 'auto')
+    .option('--with-repo-map', 'Attach a lightweight repo map (ranked files + top symbols + wiki links)', false)
+    .option('--repo-map-files <n>', 'Max repo map files', '20')
+    .option('--repo-map-symbols <n>', 'Max repo map symbols per file', '5')
+    .option('--wiki <dir>', 'Wiki directory (default: docs/wiki or wiki)', '')
+    .action(async (keyword, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai query' });
+    const startedAt = Date.now();
+    try {
+        const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+        const limit = Number(options.limit);
+        const q = String(keyword);
+        const mode = (0, symbolSearch_1.inferSymbolSearchMode)(q, options.mode);
+        const caseInsensitive = Boolean(options.caseInsensitive ?? false);
+        const maxCandidates = Math.max(limit, Number(options.maxCandidates ?? Math.min(2000, limit * 20)));
+        const langSel = String(options.lang ?? 'auto');
+        const withRepoMap = Boolean(options.withRepoMap ?? false);
+        if ((0, git_1.inferWorkspaceRoot)(repoRoot)) {
+            const coarse = (mode === 'substring' || mode === 'prefix') ? q : (0, symbolSearch_1.pickCoarseToken)(q);
+            const res = await (0, workspace_1.queryManifestWorkspace)({ manifestRepoRoot: repoRoot, keyword: coarse, limit: maxCandidates });
+            const filteredByLang = filterWorkspaceRowsByLang(res.rows, langSel);
+            const rows = (0, symbolSearch_1.filterAndRankSymbolRows)(filteredByLang, { query: q, mode, caseInsensitive, limit });
+            log.info('query_symbols', { ok: true, repoRoot, workspace: true, mode, case_insensitive: caseInsensitive, limit, max_candidates: maxCandidates, candidates: res.rows.length, rows: rows.length, duration_ms: Date.now() - startedAt });
+            const repoMap = withRepoMap ? { enabled: false, skippedReason: 'workspace_mode_not_supported' } : undefined;
+            console.log(JSON.stringify({ ...res, rows, ...(repoMap ? { repo_map: repoMap } : {}) }, null, 2));
+            return;
+        }
+        const status = await (0, indexCheck_1.checkIndex)(repoRoot);
+        if (!status.ok) {
+            process.stderr.write(JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) + '\n');
+            process.exit(2);
+            return;
+        }
+        const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+        if (langs.length === 0) {
+            process.stderr.write(JSON.stringify({ ok: false, reason: 'lang_not_available', lang: langSel, available: status.found.meta?.languages ?? [] }, null, 2) + '\n');
+            process.exit(2);
+            return;
+        }
+        const dbDir = (0, lancedb_1.defaultDbDir)(repoRoot);
+        const dim = typeof status.found.meta?.dim === 'number' ? status.found.meta.dim : 256;
+        const { byLang } = await (0, lancedb_1.openTablesByLang)({ dbDir, dim, mode: 'open_only', languages: langs });
+        const where = (0, symbolSearch_1.buildCoarseWhere)({ query: q, mode, caseInsensitive });
+        const candidates = [];
+        for (const lang of langs) {
+            const t = byLang[lang];
+            if (!t)
+                continue;
+            const rows = where
+                ? await t.refs.query().where(where).limit(maxCandidates).toArray()
+                : await t.refs.query().limit(maxCandidates).toArray();
+            for (const r of rows)
+                candidates.push({ ...r, lang });
+        }
+        const rows = (0, symbolSearch_1.filterAndRankSymbolRows)(candidates, { query: q, mode, caseInsensitive, limit });
+        log.info('query_symbols', { ok: true, repoRoot, workspace: false, lang: langSel, langs, mode, case_insensitive: caseInsensitive, limit, max_candidates: maxCandidates, candidates: candidates.length, rows: rows.length, duration_ms: Date.now() - startedAt });
+        const repoMap = withRepoMap ? await buildRepoMapAttachment(repoRoot, options) : undefined;
+        console.log(JSON.stringify({ repoRoot, count: rows.length, lang: langSel, rows, ...(repoMap ? { repo_map: repoMap } : {}) }, null, 2));
+    }
+    catch (e) {
+        log.error('query_symbols', { ok: false, duration_ms: Date.now() - startedAt, err: e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : { message: String(e) } });
+        process.exit(1);
+    }
+});
+async function buildRepoMapAttachment(repoRoot, options) {
+    try {
+        const wikiDir = resolveWikiDir(repoRoot, String(options.wiki ?? ''));
+        const files = await (0, repoMap_1.generateRepoMap)({
+            repoRoot,
+            maxFiles: Number(options.repoMapFiles ?? 20),
+            maxSymbolsPerFile: Number(options.repoMapSymbols ?? 5),
+            wikiDir,
+        });
+        return { enabled: true, wikiDir, files };
+    }
+    catch (e) {
+        return { enabled: false, skippedReason: String(e?.message ?? e) };
+    }
+}
+function resolveWikiDir(repoRoot, wikiOpt) {
+    const w = String(wikiOpt ?? '').trim();
+    if (w)
+        return path_1.default.resolve(repoRoot, w);
+    const candidates = [path_1.default.join(repoRoot, 'docs', 'wiki'), path_1.default.join(repoRoot, 'wiki')];
+    for (const c of candidates) {
+        if (fs_extra_1.default.existsSync(c))
+            return c;
+    }
+    return '';
+}
+function inferLangFromFile(file) {
+    const f = String(file);
+    if (f.endsWith('.md') || f.endsWith('.mdx'))
+        return 'markdown';
+    if (f.endsWith('.yml') || f.endsWith('.yaml'))
+        return 'yaml';
+    if (f.endsWith('.java'))
+        return 'java';
+    if (f.endsWith('.c') || f.endsWith('.h'))
+        return 'c';
+    if (f.endsWith('.go'))
+        return 'go';
+    if (f.endsWith('.py'))
+        return 'python';
+    if (f.endsWith('.rs'))
+        return 'rust';
+    return 'ts';
+}
+function filterWorkspaceRowsByLang(rows, langSel) {
+    const sel = String(langSel ?? 'auto');
+    if (sel === 'auto' || sel === 'all')
+        return rows;
+    const target = sel;
+    return rows.filter(r => inferLangFromFile(String(r.file ?? '')) === target);
+}

package/dist/src/commands/semantic.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.semanticCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const git_1 = require("../core/git");
+const lancedb_1 = require("../core/lancedb");
+const search_1 = require("../core/search");
+const log_1 = require("../core/log");
+const indexCheck_1 = require("../core/indexCheck");
+const repoMap_1 = require("../core/repoMap");
+exports.semanticCommand = new commander_1.Command('semantic')
+    .description('Semantic search using SQ8 vectors (brute-force over chunks)')
+    .argument('<text>', 'Query text')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('-k, --topk <k>', 'Top K results', '10')
+    .option('--lang <lang>', 'Language: auto|all|java|ts|python|go|rust|c|markdown|yaml', 'auto')
+    .option('--with-repo-map', 'Attach a lightweight repo map (ranked files + top symbols + wiki links)', false)
+    .option('--repo-map-files <n>', 'Max repo map files', '20')
+    .option('--repo-map-symbols <n>', 'Max repo map symbols per file', '5')
+    .option('--wiki <dir>', 'Wiki directory (default: docs/wiki or wiki)', '')
+    .action(async (text, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai semantic' });
+    const startedAt = Date.now();
+    try {
+        const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+        const withRepoMap = Boolean(options.withRepoMap ?? false);
+        const status = await (0, indexCheck_1.checkIndex)(repoRoot);
+        if (!status.ok) {
+            process.stderr.write(JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) + '\n');
+            process.exit(2);
+            return;
+        }
+        const dbDir = (0, lancedb_1.defaultDbDir)(repoRoot);
+        const k = Number(options.topk);
+        const dim = typeof status.found.meta?.dim === 'number' ? status.found.meta.dim : 256;
+        const q = (0, search_1.buildQueryVector)(String(text), dim);
+        const langSel = String(options.lang ?? 'auto');
+        const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+        if (langs.length === 0) {
+            process.stderr.write(JSON.stringify({ ok: false, reason: 'lang_not_available', lang: langSel, available: status.found.meta?.languages ?? [] }, null, 2) + '\n');
+            process.exit(2);
+            return;
+        }
+        const { byLang } = await (0, lancedb_1.openTablesByLang)({ dbDir, dim, mode: 'open_only', languages: langs });
+        const allScored = [];
+        let totalChunks = 0;
+        for (const lang of langs) {
+            const t = byLang[lang];
+            if (!t)
+                continue;
+            const chunkRows = await t.chunks.query().select(['content_hash', 'text', 'dim', 'scale', 'qvec_b64']).limit(1000000).toArray();
+            totalChunks += chunkRows.length;
+            for (const r of chunkRows) {
+                allScored.push({
+                    lang,
+                    content_hash: String(r.content_hash),
+                    score: (0, search_1.scoreAgainst)(q, { dim: Number(r.dim), scale: Number(r.scale), qvec: new Int8Array(Buffer.from(String(r.qvec_b64), 'base64')) }),
+                    text: String(r.text),
+                });
+            }
+        }
+        const scored = allScored.sort((a, b) => b.score - a.score).slice(0, k);
+        const neededByLang = {};
+        for (const s of scored) {
+            if (!neededByLang[s.lang])
+                neededByLang[s.lang] = new Set();
+            neededByLang[s.lang].add(String(s.content_hash));
+        }
+        const refsByLangAndId = new Map();
+        for (const lang of langs) {
+            const t = byLang[lang];
+            if (!t)
+                continue;
+            const needed = neededByLang[lang];
+            if (!needed || needed.size === 0)
+                continue;
+            const refsRows = await t.refs.query().select(['content_hash', 'file', 'symbol', 'kind', 'signature', 'start_line', 'end_line'])
+                .limit(1000000)
+                .toArray();
+            const byId = new Map();
+            for (const r of refsRows) {
+                const id = String(r.content_hash);
+                if (!needed.has(id))
+                    continue;
+                if (!byId.has(id))
+                    byId.set(id, []);
+                byId.get(id).push(r);
+            }
+            refsByLangAndId.set(lang, byId);
+        }
+        const hits = scored.map(s => ({
+            ...s,
+            refs: (refsByLangAndId.get(s.lang)?.get(s.content_hash) || []).slice(0, 5),
+        }));
+        log.info('semantic_search', { ok: true, repoRoot, topk: k, lang: langSel, langs, chunks: totalChunks, hits: hits.length, duration_ms: Date.now() - startedAt });
+        const repoMap = withRepoMap ? await buildRepoMapAttachment(repoRoot, options) : undefined;
+        console.log(JSON.stringify({ repoRoot, topk: k, lang: langSel, hits, ...(repoMap ? { repo_map: repoMap } : {}) }, null, 2));
+    }
+    catch (e) {
+        log.error('semantic_search', { ok: false, duration_ms: Date.now() - startedAt, err: e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : { message: String(e) } });
+        process.exit(1);
+    }
+});
+async function buildRepoMapAttachment(repoRoot, options) {
+    try {
+        const wikiDir = resolveWikiDir(repoRoot, String(options.wiki ?? ''));
+        const files = await (0, repoMap_1.generateRepoMap)({
+            repoRoot,
+            maxFiles: Number(options.repoMapFiles ?? 20),
+            maxSymbolsPerFile: Number(options.repoMapSymbols ?? 5),
+            wikiDir,
+        });
+        return { enabled: true, wikiDir, files };
+    }
+    catch (e) {
+        return { enabled: false, skippedReason: String(e?.message ?? e) };
+    }
+}
+function resolveWikiDir(repoRoot, wikiOpt) {
+    const w = String(wikiOpt ?? '').trim();
+    if (w)
+        return path_1.default.resolve(repoRoot, w);
+    const candidates = [path_1.default.join(repoRoot, 'docs', 'wiki'), path_1.default.join(repoRoot, 'wiki')];
+    for (const c of candidates) {
+        if (fs_extra_1.default.existsSync(c))
+            return c;
+    }
+    return '';
+}

package/dist/src/commands/serve.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveCommand = void 0;
+const commander_1 = require("commander");
+const server_1 = require("../mcp/server");
+exports.serveCommand = new commander_1.Command('serve')
+    .description('Start MCP server (stdio). Repository is specified by path in each tool call.')
+    .option('--disable-mcp-log', 'Disable MCP access logging')
+    .action(async (options) => {
+    const server = new server_1.GitAIV2MCPServer(process.cwd(), {
+        disableAccessLog: !!options.disableMcpLog,
+    });
+    await server.start();
+});

package/dist/src/commands/status.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const git_1 = require("../core/git");
+const indexCheck_1 = require("../core/indexCheck");
+const lancedb_1 = require("../core/lancedb");
+exports.statusCommand = new commander_1.Command('status')
+    .description('Show repository index status')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--json', 'Output machine-readable JSON', false)
+    .action(async (options) => {
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    const res = await (0, indexCheck_1.checkIndex)(repoRoot);
+    if (options.json) {
+        console.log(JSON.stringify({ repoRoot, ...res }, null, 2));
+        process.exit(res.ok ? 0 : 2);
+    }
+    const meta = res.found.meta ?? null;
+    const lines = [];
+    lines.push(`repo: ${repoRoot}`);
+    lines.push(`index: ${res.ok ? 'ok' : 'not_ready'}`);
+    if (meta) {
+        lines.push(`schema: ${String(meta.index_schema_version ?? 'unknown')} (expected ${res.expected.index_schema_version})`);
+        if (meta.dim !== undefined)
+            lines.push(`dim: ${String(meta.dim)}`);
+        const rawLangs = Array.isArray(meta.languages) ? meta.languages.map((v) => String(v)) : [];
+        const supported = rawLangs.filter((l) => lancedb_1.ALL_INDEX_LANGS.includes(l));
+        const unsupported = rawLangs.filter((l) => !lancedb_1.ALL_INDEX_LANGS.includes(l));
+        if (supported.length > 0)
+            lines.push(`languages: ${supported.join(', ')}`);
+        if (unsupported.length > 0)
+            lines.push(`unsupportedLanguages: ${unsupported.join(', ')}`);
+        if (meta.dbDir)
+            lines.push(`db: ${meta.dbDir}`);
+        if (meta.scanRoot)
+            lines.push(`scanRoot: ${meta.scanRoot}`);
+        // Display commit information
+        if (meta.commit_hash) {
+            const shortHash = meta.commit_hash.slice(0, 7);
+            const currentHash = res.found.currentCommitHash;
+            if (currentHash) {
+                const currentShort = currentHash.slice(0, 7);
+                if (meta.commit_hash === currentHash) {
+                    lines.push(`commit: ${shortHash} (up-to-date)`);
+                }
+                else {
+                    lines.push(`commit: ${shortHash} (HEAD is ${currentShort})`);
+                }
+            }
+            else {
+                lines.push(`commit: ${shortHash}`);
+            }
+        }
+        else if (res.found.currentCommitHash) {
+            lines.push(`commit: not recorded (HEAD is ${res.found.currentCommitHash.slice(0, 7)})`);
+        }
+    }
+    else {
+        lines.push(`meta: missing (${res.found.metaPath})`);
+    }
+    if (!res.ok) {
+        lines.push(`problems: ${res.problems.join(', ')}`);
+        lines.push(`hint: ${res.hint}`);
+    }
+    if (res.warnings.length > 0) {
+        lines.push(`warnings: ${res.warnings.join(', ')}`);
+        if (res.warnings.some(w => w.startsWith('index_commit_mismatch'))) {
+            lines.push(`hint: Index may be out of date. Run: git-ai ai index --incremental`);
+        }
+    }
+    console.log(lines.join('\n'));
+    process.exit(res.ok ? 0 : 2);
+});

package/dist/src/commands/trae.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.agentCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const git_1 = require("../core/git");
+async function findPackageRoot(startDir) {
+    let cur = path_1.default.resolve(startDir);
+    for (let i = 0; i < 12; i++) {
+        const pj = path_1.default.join(cur, 'package.json');
+        if (await fs_extra_1.default.pathExists(pj))
+            return cur;
+        const parent = path_1.default.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return path_1.default.resolve(startDir);
+}
+async function listDirNames(p) {
+    if (!await fs_extra_1.default.pathExists(p))
+        return [];
+    const entries = await fs_extra_1.default.readdir(p);
+    const out = [];
+    for (const n of entries) {
+        const full = path_1.default.join(p, n);
+        try {
+            const st = await fs_extra_1.default.stat(full);
+            if (st.isDirectory())
+                out.push(n);
+        }
+        catch {
+        }
+    }
+    return out.sort();
+}
+exports.agentCommand = new commander_1.Command('agent')
+    .description('Install Agent skills/rules templates into a target directory')
+    .alias('trae')
+    .addCommand(new commander_1.Command('install')
+    .description('Install skills/rules templates (default: <repoRoot>/.agents)')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--to <dir>', 'Destination directory (overrides default)', '')
+    .option('--agent <agent>', 'Template layout: agents|trae', 'agents')
+    .option('--overwrite', 'Overwrite existing files', false)
+    .action(async (options) => {
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    const agent = String(options.agent ?? 'agents').trim().toLowerCase();
+    const defaultDirName = agent === 'trae' ? '.trae' : '.agents';
+    const destDir = String(options.to ?? '').trim() ? path_1.default.resolve(String(options.to)) : path_1.default.join(repoRoot, defaultDirName);
+    const overwrite = Boolean(options.overwrite ?? false);
+    const packageRoot = await findPackageRoot(__dirname);
+    const srcTemplateDir = path_1.default.join(packageRoot, 'templates', 'agents', 'common');
+    const srcSkillsDir = path_1.default.join(srcTemplateDir, 'skills');
+    const srcRulesDir = path_1.default.join(srcTemplateDir, 'rules');
+    if (!await fs_extra_1.default.pathExists(srcSkillsDir) || !await fs_extra_1.default.pathExists(srcRulesDir)) {
+        console.log(JSON.stringify({ ok: false, repoRoot, error: 'template_missing', srcTemplateDir }, null, 2));
+        process.exitCode = 2;
+        return;
+    }
+    const dstSkillsDir = path_1.default.join(destDir, 'skills');
+    const dstRulesDir = path_1.default.join(destDir, 'rules');
+    await fs_extra_1.default.ensureDir(destDir);
+    await fs_extra_1.default.copy(srcSkillsDir, dstSkillsDir, { overwrite });
+    await fs_extra_1.default.copy(srcRulesDir, dstRulesDir, { overwrite });
+    const installed = {
+        skills: await listDirNames(dstSkillsDir),
+        rules: await listDirNames(dstRulesDir),
+    };
+    console.log(JSON.stringify({ ok: true, repoRoot, agent, destDir, overwrite, installed }, null, 2));
+}));

package/dist/src/commands/unpack.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpackCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const git_1 = require("../core/git");
+const archive_1 = require("../core/archive");
+const log_1 = require("../core/log");
+exports.unpackCommand = new commander_1.Command('unpack')
+    .description('Unpack .git-ai/lancedb.tar.gz into .git-ai/lancedb')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .action(async (options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai unpack' });
+    const startedAt = Date.now();
+    try {
+        const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+        const unpacked = await (0, archive_1.unpackLanceDb)(repoRoot);
+        log.info('unpack_index', { ok: true, repoRoot, unpacked: unpacked.unpacked, duration_ms: Date.now() - startedAt });
+        console.log(JSON.stringify({ repoRoot, ...unpacked }, null, 2));
+    }
+    catch (e) {
+        log.error('unpack_index', { ok: false, duration_ms: Date.now() - startedAt, err: e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : { message: String(e) } });
+        process.exit(1);
+    }
+});

package/dist/src/core/archive.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArchivePaths = getArchivePaths;
+exports.packLanceDb = packLanceDb;
+exports.unpackLanceDb = unpackLanceDb;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const tar = __importStar(require("tar"));
+const paths_1 = require("./paths");
+function getArchivePaths(repoRoot) {
+    const gitAiDir = path_1.default.join(repoRoot, '.git-ai');
+    const lancedbDir = path_1.default.join(gitAiDir, 'lancedb');
+    const archivePath = path_1.default.join(gitAiDir, 'lancedb.tar.gz');
+    return { gitAiDir, lancedbDir, archivePath };
+}
+async function packLanceDb(repoRoot) {
+    const { gitAiDir, lancedbDir, archivePath } = getArchivePaths(repoRoot);
+    await fs_extra_1.default.ensureDir(gitAiDir);
+    if (!await fs_extra_1.default.pathExists(lancedbDir)) {
+        return { archivePath, packed: false };
+    }
+    await fs_extra_1.default.remove(archivePath);
+    const entries = [];
+    const walk = async (relPosix) => {
+        const abs = path_1.default.join(gitAiDir, ...(0, paths_1.splitPosixPath)(relPosix));
+        const stat = await fs_extra_1.default.stat(abs);
+        if (stat.isDirectory()) {
+            const children = (await fs_extra_1.default.readdir(abs)).sort((a, b) => a.localeCompare(b));
+            for (const c of children) {
+                await walk(path_1.default.posix.join(relPosix, (0, paths_1.toPosixPath)(c)));
+            }
+            return;
+        }
+        entries.push(relPosix);
+    };
+    await walk('lancedb');
+    await tar.c({
+        gzip: { portable: true },
+        file: archivePath,
+        cwd: gitAiDir,
+        portable: true,
+        mtime: new Date(0),
+    }, entries.sort((a, b) => a.localeCompare(b)));
+    return { archivePath, packed: true };
+}
+async function unpackLanceDb(repoRoot) {
+    const { gitAiDir, lancedbDir, archivePath } = getArchivePaths(repoRoot);
+    if (!await fs_extra_1.default.pathExists(archivePath)) {
+        return { archivePath, unpacked: false };
+    }
+    await fs_extra_1.default.ensureDir(gitAiDir);
+    await fs_extra_1.default.remove(lancedbDir);
+    await tar.x({ file: archivePath, cwd: gitAiDir });
+    return { archivePath, unpacked: true };
+}