@mars167/git-ai 2.3.0

package/dist/src/commands/dsr.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dsrCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const gitContext_1 = require("../core/dsr/gitContext");
+const generate_1 = require("../core/dsr/generate");
+const indexMaterialize_1 = require("../core/dsr/indexMaterialize");
+const query_1 = require("../core/dsr/query");
+const state_1 = require("../core/dsr/state");
+exports.dsrCommand = new commander_1.Command('dsr')
+    .description('Deterministic Semantic Record (per-commit, immutable, Git-addressable)');
+exports.dsrCommand
+    .command('context')
+    .description('Discover repository root, HEAD, branch, and DSR directory state')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--json', 'Output machine-readable JSON', false)
+    .action(async (options) => {
+    const start = path_1.default.resolve(options.path);
+    const ctx = await (0, gitContext_1.detectRepoGitContext)(start);
+    const state = await (0, state_1.getDsrDirectoryState)(ctx.repo_root);
+    const out = {
+        commit_hash: ctx.head_commit,
+        repo_root: ctx.repo_root,
+        branch: ctx.branch,
+        detached: ctx.detached,
+        dsr_directory_state: state,
+    };
+    if (options.json) {
+        console.log(JSON.stringify(out, null, 2));
+        process.exit(0);
+    }
+    const lines = [];
+    lines.push(`repo: ${out.repo_root}`);
+    lines.push(`head: ${out.commit_hash}`);
+    lines.push(`branch: ${out.detached ? '(detached)' : out.branch}`);
+    lines.push(`dsrCacheRoot: ${out.dsr_directory_state.cache_root} (${out.dsr_directory_state.cache_root_exists ? 'exists' : 'missing'})`);
+    lines.push(`dsrDir: ${out.dsr_directory_state.dsr_dir} (${out.dsr_directory_state.dsr_dir_exists ? 'exists' : 'missing'})`);
+    lines.push(`dsrFiles: ${String(out.dsr_directory_state.dsr_file_count)}`);
+    console.log(lines.join('\n'));
+    process.exit(0);
+});
+exports.dsrCommand
+    .command('generate')
+    .description('Generate DSR for exactly one commit')
+    .argument('<commit>', 'Commit hash (any rev that resolves to a commit)')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--json', 'Output machine-readable JSON', false)
+    .action(async (commit, options) => {
+    const start = path_1.default.resolve(options.path);
+    const ctx = await (0, gitContext_1.detectRepoGitContext)(start);
+    const res = await (0, generate_1.generateDsrForCommit)(ctx.repo_root, String(commit));
+    const out = {
+        commit_hash: res.dsr.commit_hash,
+        file_path: res.file_path,
+        existed: res.existed,
+        counts: {
+            affected_symbols: res.dsr.affected_symbols.length,
+            ast_operations: res.dsr.ast_operations.length,
+        },
+        semantic_change_type: res.dsr.semantic_change_type,
+        risk_level: res.dsr.risk_level,
+    };
+    if (options.json) {
+        console.log(JSON.stringify(out, null, 2));
+        process.exit(0);
+    }
+    const lines = [];
+    lines.push(`commit: ${out.commit_hash}`);
+    lines.push(`dsr: ${out.file_path}`);
+    lines.push(`status: ${out.existed ? 'exists' : 'generated'}`);
+    lines.push(`ops: ${String(out.counts.ast_operations)}`);
+    lines.push(`affected_symbols: ${String(out.counts.affected_symbols)}`);
+    lines.push(`semantic_change_type: ${out.semantic_change_type}`);
+    lines.push(`risk_level: ${out.risk_level ?? 'unknown'}`);
+    console.log(lines.join('\n'));
+    process.exit(0);
+});
+exports.dsrCommand
+    .command('rebuild-index')
+    .description('Rebuild performance-oriented DSR index from DSR files')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--json', 'Output machine-readable JSON', false)
+    .action(async (options) => {
+    const start = path_1.default.resolve(options.path);
+    const ctx = await (0, gitContext_1.detectRepoGitContext)(start);
+    const res = await (0, indexMaterialize_1.materializeDsrIndex)(ctx.repo_root);
+    if (options.json) {
+        console.log(JSON.stringify({ repo_root: ctx.repo_root, ...res }, null, 2));
+        process.exit(res.enabled ? 0 : 2);
+    }
+    if (!res.enabled) {
+        console.error(res.skippedReason ?? 'rebuild-index skipped');
+        process.exit(2);
+    }
+    const lines = [];
+    lines.push(`repo: ${ctx.repo_root}`);
+    lines.push(`engine: ${res.engine}`);
+    if (res.dbPath)
+        lines.push(`db: ${res.dbPath}`);
+    if (res.exportPath)
+        lines.push(`export: ${res.exportPath}`);
+    if (res.counts) {
+        lines.push(`commits: ${String(res.counts.commits)}`);
+        lines.push(`affected_symbols: ${String(res.counts.affected_symbols)}`);
+        lines.push(`ast_operations: ${String(res.counts.ast_operations)}`);
+    }
+    console.log(lines.join('\n'));
+    process.exit(0);
+});
+const queryCommand = new commander_1.Command('query').description('Read-only semantic queries over Git DAG + DSR');
+queryCommand
+    .command('symbol-evolution')
+    .description('List commits where a symbol changed (requires DSR per traversed commit)')
+    .argument('<symbol>', 'Symbol name')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--all', 'Traverse all refs (default: from HEAD)', false)
+    .option('--start <commit>', 'Start commit (default: HEAD)')
+    .option('--limit <n>', 'Max commits to traverse', (v) => Number(v), 200)
+    .option('--contains', 'Match by substring instead of exact match', false)
+    .option('--json', 'Output machine-readable JSON', false)
+    .action(async (symbol, options) => {
+    const startDir = path_1.default.resolve(options.path);
+    const ctx = await (0, gitContext_1.detectRepoGitContext)(startDir);
+    const res = await (0, query_1.symbolEvolution)(ctx.repo_root, String(symbol), {
+        all: Boolean(options.all),
+        start: options.start ? String(options.start) : undefined,
+        limit: Number(options.limit),
+        contains: Boolean(options.contains),
+    });
+    if (options.json) {
+        console.log(JSON.stringify({ repo_root: ctx.repo_root, symbol, ...res }, null, 2));
+        process.exit(res.ok ? 0 : 2);
+    }
+    if (!res.ok) {
+        console.error(`missing DSR for commit: ${res.missing_dsrs?.[0] ?? 'unknown'}`);
+        process.exit(2);
+    }
+    const hits = res.hits ?? [];
+    const lines = [];
+    lines.push(`repo: ${ctx.repo_root}`);
+    lines.push(`symbol: ${symbol}`);
+    lines.push(`hits: ${String(hits.length)}`);
+    for (const h of hits.slice(0, 50)) {
+        const opKinds = Array.from(new Set(h.operations.map((o) => o.op))).sort().join(',');
+        lines.push(`${h.commit_hash} ${h.semantic_change_type} ${h.risk_level ?? ''} ops=${String(h.operations.length)} kinds=${opKinds} ${h.summary ?? ''}`.trim());
+    }
+    if (hits.length > 50)
+        lines.push(`... (${hits.length - 50} more)`);
+    console.log(lines.join('\n'));
+    process.exit(0);
+});
+exports.dsrCommand.addCommand(queryCommand);

package/dist/src/commands/graph.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const git_1 = require("../core/git");
+const crypto_1 = require("../core/crypto");
+const astGraphQuery_1 = require("../core/astGraphQuery");
+const paths_1 = require("../core/paths");
+const log_1 = require("../core/log");
+const indexCheck_1 = require("../core/indexCheck");
+exports.graphCommand = new commander_1.Command('graph')
+    .description('AST graph search powered by CozoDB')
+    .addCommand(new commander_1.Command('query')
+    .description('Run a CozoScript query against the AST graph database')
+    .argument('<script...>', 'CozoScript query')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--params <json>', 'JSON params object', '{}')
+    .action(async (scriptParts, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai graph query' });
+    const startedAt = Date.now();
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    const query = Array.isArray(scriptParts) ? scriptParts.join(' ') : String(scriptParts ?? '');
+    const params = JSON.parse(String(options.params ?? '{}'));
+    const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, query, params);
+    log.info('ast_graph_query', { ok: true, repoRoot, duration_ms: Date.now() - startedAt });
+    console.log(JSON.stringify({ repoRoot, result }, null, 2));
+}))
+    .addCommand(new commander_1.Command('find')
+    .description('Find symbols by name prefix')
+    .argument('<prefix>', 'Name prefix (case-insensitive)')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--lang <lang>', 'Language: auto|all|java|ts|python|go|rust|c|markdown|yaml', 'auto')
+    .action(async (prefix, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai graph find' });
+    const startedAt = Date.now();
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    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 langSel = String(options.lang ?? 'auto');
+    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+    const allRows = [];
+    for (const lang of langs) {
+        const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, (0, astGraphQuery_1.buildFindSymbolsQuery)(lang), { prefix: String(prefix), lang });
+        const rows = Array.isArray(result?.rows) ? result.rows : [];
+        for (const r of rows)
+            allRows.push(r);
+    }
+    const result = { headers: ['ref_id', 'file', 'lang', 'name', 'kind', 'signature', 'start_line', 'end_line'], rows: allRows };
+    log.info('ast_graph_find', { ok: true, repoRoot, prefix: String(prefix), lang: langSel, langs, rows: allRows.length, duration_ms: Date.now() - startedAt });
+    console.log(JSON.stringify({ repoRoot, lang: langSel, result }, null, 2));
+}))
+    .addCommand(new commander_1.Command('children')
+    .description('List direct children in the AST containment graph')
+    .argument('<id>', 'Parent id (ref_id or file_id)')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--as-file', 'Treat <id> as a repository-relative file path and hash it to file_id', false)
+    .action(async (id, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai graph children' });
+    const startedAt = Date.now();
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    const parentId = options.asFile ? (0, crypto_1.sha256Hex)(`file:${(0, paths_1.toPosixPath)(String(id))}`) : String(id);
+    const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, (0, astGraphQuery_1.buildChildrenQuery)(), { parent_id: parentId });
+    log.info('ast_graph_children', { ok: true, repoRoot, parent_id: parentId, rows: Array.isArray(result?.rows) ? result.rows.length : 0, duration_ms: Date.now() - startedAt });
+    console.log(JSON.stringify({ repoRoot, parent_id: parentId, result }, null, 2));
+}))
+    .addCommand(new commander_1.Command('refs')
+    .description('Find reference locations by name (calls/new/type)')
+    .argument('<name>', 'Symbol name')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--limit <n>', 'Limit results', '200')
+    .option('--lang <lang>', 'Language: auto|all|java|ts|python|go|rust|c|markdown|yaml', 'auto')
+    .action(async (name, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai graph refs' });
+    const startedAt = Date.now();
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    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 limit = Number(options.limit ?? 200);
+    const langSel = String(options.lang ?? 'auto');
+    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+    const allRows = [];
+    for (const lang of langs) {
+        const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, (0, astGraphQuery_1.buildFindReferencesQuery)(lang), { name: String(name), lang });
+        const rows = Array.isArray(result?.rows) ? result.rows : [];
+        for (const r of rows)
+            allRows.push(r);
+    }
+    const rows = allRows.slice(0, limit);
+    log.info('ast_graph_refs', { ok: true, repoRoot, name: String(name), lang: langSel, langs, rows: rows.length, duration_ms: Date.now() - startedAt });
+    console.log(JSON.stringify({ repoRoot, name: String(name), lang: langSel, result: { headers: ['file', 'line', 'col', 'ref_kind', 'from_id', 'from_kind', 'from_name', 'from_lang'], rows } }, null, 2));
+}))
+    .addCommand(new commander_1.Command('callers')
+    .description('Find callers by callee name')
+    .argument('<name>', 'Callee name')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--limit <n>', 'Limit results', '200')
+    .option('--lang <lang>', 'Language: auto|all|java|ts|python|go|rust|c|markdown|yaml', 'auto')
+    .action(async (name, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai graph callers' });
+    const startedAt = Date.now();
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    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 limit = Number(options.limit ?? 200);
+    const langSel = String(options.lang ?? 'auto');
+    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+    const allRows = [];
+    for (const lang of langs) {
+        const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, (0, astGraphQuery_1.buildCallersByNameQuery)(lang), { name: String(name), lang });
+        const rows = Array.isArray(result?.rows) ? result.rows : [];
+        for (const r of rows)
+            allRows.push(r);
+    }
+    const rows = allRows.slice(0, limit);
+    log.info('ast_graph_callers', { ok: true, repoRoot, name: String(name), lang: langSel, langs, rows: rows.length, duration_ms: Date.now() - startedAt });
+    console.log(JSON.stringify({ repoRoot, name: String(name), lang: langSel, result: { headers: ['caller_id', 'caller_kind', 'caller_name', 'file', 'line', 'col', 'caller_lang'], rows } }, null, 2));
+}))
+    .addCommand(new commander_1.Command('callees')
+    .description('Find callees by caller name (resolved by exact callee name match in graph)')
+    .argument('<name>', 'Caller name')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--limit <n>', 'Limit results', '200')
+    .option('--lang <lang>', 'Language: auto|all|java|ts|python|go|rust|c|markdown|yaml', 'auto')
+    .action(async (name, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai graph callees' });
+    const startedAt = Date.now();
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    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 limit = Number(options.limit ?? 200);
+    const langSel = String(options.lang ?? 'auto');
+    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+    const allRows = [];
+    for (const lang of langs) {
+        const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, (0, astGraphQuery_1.buildCalleesByNameQuery)(lang), { name: String(name), lang });
+        const rows = Array.isArray(result?.rows) ? result.rows : [];
+        for (const r of rows)
+            allRows.push(r);
+    }
+    const rows = allRows.slice(0, limit);
+    log.info('ast_graph_callees', { ok: true, repoRoot, name: String(name), lang: langSel, langs, rows: rows.length, duration_ms: Date.now() - startedAt });
+    console.log(JSON.stringify({ repoRoot, name: String(name), lang: langSel, result: { headers: ['caller_id', 'caller_lang', 'callee_id', 'callee_file', 'callee_name', 'callee_kind', 'file', 'line', 'col'], rows } }, null, 2));
+}))
+    .addCommand(new commander_1.Command('chain')
+    .description('Compute call chain by symbol name (heuristic, name-based)')
+    .argument('<name>', 'Start symbol name')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--direction <direction>', 'Direction: downstream|upstream', 'downstream')
+    .option('--depth <n>', 'Max depth', '3')
+    .option('--limit <n>', 'Limit results', '500')
+    .option('--min-name-len <n>', 'Filter out edges with very short names (default: 1)', '1')
+    .option('--lang <lang>', 'Language: auto|all|java|ts|python|go|rust|c|markdown|yaml', 'auto')
+    .action(async (name, options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai graph chain' });
+    const startedAt = Date.now();
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    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 direction = String(options.direction ?? 'downstream');
+    const maxDepth = Number(options.depth ?? 3);
+    const limit = Number(options.limit ?? 500);
+    const minNameLen = Math.max(1, Number(options.minNameLen ?? 1));
+    const langSel = String(options.lang ?? 'auto');
+    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+    const query = direction === 'upstream' ? (0, astGraphQuery_1.buildCallChainUpstreamByNameQuery)() : (0, astGraphQuery_1.buildCallChainDownstreamByNameQuery)();
+    const allRows = [];
+    for (const lang of langs) {
+        const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, query, { name: String(name), max_depth: maxDepth, lang });
+        const rawRows = Array.isArray(result?.rows) ? result.rows : [];
+        for (const r of rawRows)
+            allRows.push(r);
+    }
+    const filtered = minNameLen > 1
+        ? allRows.filter((r) => String(r?.[3] ?? '').length >= minNameLen && String(r?.[4] ?? '').length >= minNameLen)
+        : allRows;
+    const rows = filtered.slice(0, limit);
+    log.info('ast_graph_chain', { ok: true, repoRoot, name: String(name), lang: langSel, langs, direction, max_depth: maxDepth, rows: rows.length, min_name_len: minNameLen, duration_ms: Date.now() - startedAt });
+    console.log(JSON.stringify({ repoRoot, name: String(name), lang: langSel, direction, max_depth: maxDepth, min_name_len: minNameLen, result: { headers: ['caller_id', 'callee_id', 'depth', 'caller_name', 'callee_name', 'lang'], rows } }, null, 2));
+}));

package/dist/src/commands/hooks.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hooksCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const git_1 = require("../core/git");
+function runGit(cwd, args) {
+    const res = (0, child_process_1.spawnSync)('git', args, { cwd, stdio: 'inherit' });
+    if (res.status !== 0)
+        throw new Error(`git ${args.join(' ')} failed`);
+}
+function getGitConfig(cwd, key) {
+    const res = (0, child_process_1.spawnSync)('git', ['config', '--get', key], { cwd, stdio: 'pipe', encoding: 'utf-8' });
+    if (res.status !== 0)
+        return null;
+    const out = String(res.stdout ?? '').trim();
+    return out.length > 0 ? out : null;
+}
+function isGitRepo(cwd) {
+    const res = (0, child_process_1.spawnSync)('git', ['rev-parse', '--show-toplevel'], { cwd, stdio: 'ignore' });
+    return res.status === 0;
+}
+async function ensureHooksExecutable(repoRoot) {
+    if (process.platform === 'win32')
+        return { changed: 0, skipped: true };
+    const hooksDir = path_1.default.join(repoRoot, '.githooks');
+    if (!await fs_extra_1.default.pathExists(hooksDir))
+        return { changed: 0, skipped: false };
+    const names = new Set(await fs_extra_1.default.readdir(hooksDir));
+    const targets = ['pre-commit', 'pre-push', 'post-checkout', 'post-merge'].filter(n => names.has(n));
+    let changed = 0;
+    for (const n of targets) {
+        const p = path_1.default.join(hooksDir, n);
+        const stat = await fs_extra_1.default.stat(p);
+        if (!stat.isFile())
+            continue;
+        await fs_extra_1.default.chmod(p, 0o755);
+        changed++;
+    }
+    return { changed, skipped: false };
+}
+async function findPackageRoot(startDir) {
+    let cur = path_1.default.resolve(startDir);
+    for (let i = 0; i < 8; 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 installHookTemplates(repoRoot) {
+    const hooksDir = path_1.default.join(repoRoot, '.githooks');
+    await fs_extra_1.default.ensureDir(hooksDir);
+    const packageRoot = await findPackageRoot(__dirname);
+    const templateDir = path_1.default.join(packageRoot, 'assets', 'hooks');
+    const names = await fs_extra_1.default.readdir(templateDir);
+    const installed = [];
+    for (const n of names) {
+        const src = path_1.default.join(templateDir, n);
+        const stat = await fs_extra_1.default.stat(src);
+        if (!stat.isFile())
+            continue;
+        const dst = path_1.default.join(hooksDir, n);
+        await fs_extra_1.default.copyFile(src, dst);
+        installed.push(n);
+    }
+    return { installed };
+}
+const install = new commander_1.Command('install')
+    .description('Install git hooks (write .githooks/* and set core.hooksPath=.githooks)')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .action(async (options) => {
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    if (!isGitRepo(repoRoot)) {
+        console.log(JSON.stringify({ ok: false, error: 'not_a_git_repo', repoRoot }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const templates = await installHookTemplates(repoRoot);
+    const exec = await ensureHooksExecutable(repoRoot);
+    runGit(repoRoot, ['config', 'core.hooksPath', '.githooks']);
+    const hooksPath = getGitConfig(repoRoot, 'core.hooksPath');
+    console.log(JSON.stringify({ ok: true, repoRoot, hooksPath, templates, executable: exec }, null, 2));
+});
+const uninstall = new commander_1.Command('uninstall')
+    .description('Uninstall git hooks (unset core.hooksPath)')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .action(async (options) => {
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    if (!isGitRepo(repoRoot)) {
+        console.log(JSON.stringify({ ok: false, error: 'not_a_git_repo', repoRoot }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    (0, child_process_1.spawnSync)('git', ['config', '--unset', 'core.hooksPath'], { cwd: repoRoot, stdio: 'ignore' });
+    const hooksPath = getGitConfig(repoRoot, 'core.hooksPath');
+    console.log(JSON.stringify({ ok: true, repoRoot, hooksPath }, null, 2));
+});
+const status = new commander_1.Command('status')
+    .description('Show current hooks configuration')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .action(async (options) => {
+    const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+    if (!isGitRepo(repoRoot)) {
+        console.log(JSON.stringify({ ok: false, error: 'not_a_git_repo', repoRoot }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const hooksPath = getGitConfig(repoRoot, 'core.hooksPath');
+    console.log(JSON.stringify({ ok: true, repoRoot, hooksPath, expected: '.githooks', installed: hooksPath === '.githooks' }, null, 2));
+});
+exports.hooksCommand = new commander_1.Command('hooks')
+    .description('Manage git hooks integration')
+    .addCommand(install)
+    .addCommand(uninstall)
+    .addCommand(status);

package/dist/src/commands/index.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexCommand = 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 indexer_1 = require("../core/indexer");
+const log_1 = require("../core/log");
+const gitDiff_1 = require("../core/gitDiff");
+const indexerIncremental_1 = require("../core/indexerIncremental");
+exports.indexCommand = new commander_1.Command('index')
+    .description('Build LanceDB+SQ8 index for the current repository (HEAD working tree)')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('-d, --dim <dim>', 'Embedding dimension', '256')
+    .option('--overwrite', 'Overwrite existing tables', false)
+    .option('--incremental', 'Incremental indexing (only changed files)', false)
+    .option('--staged', 'Read changed file contents from Git index (staged)', false)
+    .action(async (options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai index' });
+    const startedAt = Date.now();
+    try {
+        const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+        const scanRoot = (0, git_1.inferScanRoot)(repoRoot);
+        const requestedDim = Number(options.dim);
+        const overwrite = Boolean(options.overwrite);
+        const incremental = Boolean(options.incremental ?? false);
+        const staged = Boolean(options.staged ?? false);
+        const metaPath = path_1.default.join(repoRoot, '.git-ai', 'meta.json');
+        const meta = await fs_extra_1.default.readJSON(metaPath).catch(() => null);
+        const dim = typeof meta?.dim === 'number' ? meta.dim : requestedDim;
+        const isTTY = Boolean(process.stderr.isTTY) && !process.env.CI;
+        let renderedInTTY = false;
+        let finishedInTTY = false;
+        const renderProgress = (p) => {
+            const total = Math.max(0, p.totalFiles);
+            const done = Math.max(0, Math.min(total, p.processedFiles));
+            if (!isTTY) {
+                if (done === 0) {
+                    process.stderr.write(`Indexing ${total} files...\n`);
+                }
+                else if (done === total || done % 200 === 0) {
+                    process.stderr.write((`[${done}/${total}] ${p.currentFile ?? ''}`.trim()) + '\n');
+                }
+                return;
+            }
+            const columns = Math.max(40, Number(process.stderr.columns ?? 100));
+            const prefix = `${done}/${total}`;
+            const percent = total > 0 ? Math.floor((done / total) * 100) : 100;
+            const reserved = prefix.length + 1 + 6 + 1 + 1;
+            const barWidth = Math.max(10, Math.min(30, columns - reserved - 20));
+            const filled = total > 0 ? Math.round((done / total) * barWidth) : barWidth;
+            const bar = `${'='.repeat(filled)}${'-'.repeat(Math.max(0, barWidth - filled))}`;
+            const fileSuffix = p.currentFile ? ` ${p.currentFile}` : '';
+            const line = `[${bar}] ${String(percent).padStart(3)}% ${prefix}${fileSuffix}`;
+            const clipped = line.length >= columns ? line.slice(0, columns - 1) : line;
+            process.stderr.write(`\r${clipped.padEnd(columns - 1, ' ')}`);
+            renderedInTTY = true;
+            if (done === total && !finishedInTTY) {
+                process.stderr.write('\n');
+                finishedInTTY = true;
+            }
+        };
+        if (incremental) {
+            const changes = staged ? await (0, gitDiff_1.getStagedNameStatus)(repoRoot) : await (0, gitDiff_1.getWorktreeNameStatus)(repoRoot);
+            const indexer = new indexerIncremental_1.IncrementalIndexerV2({
+                repoRoot,
+                scanRoot,
+                dim,
+                source: staged ? 'staged' : 'worktree',
+                changes,
+                onProgress: renderProgress,
+            });
+            await indexer.run();
+        }
+        else {
+            const indexer = new indexer_1.IndexerV2({ repoRoot, scanRoot, dim, overwrite, onProgress: renderProgress });
+            await indexer.run();
+        }
+        if (renderedInTTY && !finishedInTTY)
+            process.stderr.write('\n');
+        log.info('index_repo', { ok: true, repoRoot, scanRoot, dim, overwrite, duration_ms: Date.now() - startedAt });
+        console.log(JSON.stringify({ ok: true, repoRoot, scanRoot, dim, overwrite, incremental, staged }, null, 2));
+    }
+    catch (e) {
+        log.error('index_repo', { 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/commands/pack.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packCommand = 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 lfs_1 = require("../core/lfs");
+const log_1 = require("../core/log");
+exports.packCommand = new commander_1.Command('pack')
+    .description('Pack .git-ai/lancedb into .git-ai/lancedb.tar.gz')
+    .option('-p, --path <path>', 'Path inside the repository', '.')
+    .option('--lfs', 'Run git lfs track for .git-ai/lancedb.tar.gz', false)
+    .action(async (options) => {
+    const log = (0, log_1.createLogger)({ component: 'cli', cmd: 'ai pack' });
+    const startedAt = Date.now();
+    try {
+        const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(options.path));
+        const packed = await (0, archive_1.packLanceDb)(repoRoot);
+        const lfs = options.lfs ? (0, lfs_1.ensureLfsTracking)(repoRoot, '.git-ai/lancedb.tar.gz') : { tracked: false };
+        log.info('pack_index', { ok: true, repoRoot, packed: packed.packed, lfs: Boolean(lfs.tracked), duration_ms: Date.now() - startedAt });
+        console.log(JSON.stringify({ repoRoot, ...packed, lfs }, null, 2));
+    }
+    catch (e) {
+        log.error('pack_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);
+    }
+});