@mars167/git-ai 2.3.0

package/dist/src/mcp/server.js

@@ -0,0 +1,794 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitAIV2MCPServer = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const glob_1 = require("glob");
+const git_1 = require("../core/git");
+const archive_1 = require("../core/archive");
+const lancedb_1 = require("../core/lancedb");
+const lfs_1 = require("../core/lfs");
+const search_1 = require("../core/search");
+const indexer_1 = require("../core/indexer");
+const workspace_1 = require("../core/workspace");
+const astGraphQuery_1 = require("../core/astGraphQuery");
+const symbolSearch_1 = require("../core/symbolSearch");
+const crypto_1 = require("../core/crypto");
+const paths_1 = require("../core/paths");
+const log_1 = require("../core/log");
+const indexCheck_1 = require("../core/indexCheck");
+const repoMap_1 = require("../core/repoMap");
+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");
+class GitAIV2MCPServer {
+    constructor(startDir, options = {}) {
+        this.startDir = path_1.default.resolve(startDir);
+        this.options = options;
+        this.server = new index_js_1.Server({ name: 'git-ai-v2', version: '2.0.0' }, { capabilities: { tools: {} } });
+        this.setupHandlers();
+    }
+    async openRepoContext(startDir) {
+        const repoRoot = await (0, git_1.resolveGitRoot)(path_1.default.resolve(startDir ?? this.startDir));
+        const metaPath = path_1.default.join(repoRoot, '.git-ai', 'meta.json');
+        const meta = await fs_extra_1.default.pathExists(metaPath) ? await fs_extra_1.default.readJSON(metaPath).catch(() => null) : null;
+        const dim = typeof meta?.dim === 'number' ? meta.dim : 256;
+        const scanRoot = path_1.default.resolve(repoRoot, typeof meta?.scanRoot === 'string' ? meta.scanRoot : path_1.default.relative(repoRoot, (0, git_1.inferScanRoot)(repoRoot)));
+        return { repoRoot, scanRoot, dim, meta };
+    }
+    async resolveRepoRoot(callPath) {
+        return (0, git_1.resolveGitRoot)(path_1.default.resolve(callPath ?? this.startDir));
+    }
+    assertPathInsideRoot(rootDir, file) {
+        const abs = path_1.default.resolve(rootDir, file);
+        const rel = path_1.default.relative(path_1.default.resolve(rootDir), abs);
+        if (rel.startsWith('..') || path_1.default.isAbsolute(rel))
+            throw new Error('Path escapes repository root');
+        return abs;
+    }
+    async writeAccessLog(name, args, duration, ok, repoRoot) {
+        if (this.options.disableAccessLog)
+            return;
+        if (process.env.GIT_AI_DISABLE_MCP_ACCESS_LOG === 'true' || process.env.GIT_AI_DISABLE_MCP_ACCESS_LOG === '1')
+            return;
+        try {
+            const logDir = path_1.default.join(os_1.default.homedir(), '.git-ai', 'logs');
+            await fs_extra_1.default.ensureDir(logDir);
+            const logFile = path_1.default.join(logDir, 'mcp-access.log');
+            const entry = {
+                ts: new Date().toISOString(),
+                tool: name,
+                repo: repoRoot ? path_1.default.basename(repoRoot) : 'unknown',
+                duration_ms: duration,
+                ok,
+                args: JSON.stringify(args).slice(0, 1000), // Avoid overly large logs
+            };
+            await fs_extra_1.default.appendFile(logFile, JSON.stringify(entry) + '\n', 'utf-8');
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: 'get_repo',
+                        description: 'Resolve repository root and scan root for a given path. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'search_symbols',
+                        description: 'Search symbols and return file locations (substring/prefix/wildcard/regex/fuzzy). Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: { type: 'string' },
+                                mode: { type: 'string', enum: ['substring', 'prefix', 'wildcard', 'regex', 'fuzzy'] },
+                                case_insensitive: { type: 'boolean', default: false },
+                                max_candidates: { type: 'number', default: 1000 },
+                                lang: { type: 'string', enum: ['auto', 'all', 'java', 'ts'], default: 'auto' },
+                                path: { type: 'string', description: 'Repository root path' },
+                                limit: { type: 'number', default: 50 },
+                                with_repo_map: { type: 'boolean', default: false },
+                                repo_map_max_files: { type: 'number', default: 20 },
+                                repo_map_max_symbols: { type: 'number', default: 5 },
+                                wiki_dir: { type: 'string', description: 'Wiki dir relative to repo root (optional)' },
+                            },
+                            required: ['path', 'query'],
+                        },
+                    },
+                    {
+                        name: 'semantic_search',
+                        description: 'Semantic search using SQ8 vectors stored in LanceDB (brute-force). Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: { type: 'string' },
+                                path: { type: 'string', description: 'Repository root path' },
+                                topk: { type: 'number', default: 10 },
+                                lang: { type: 'string', enum: ['auto', 'all', 'java', 'ts'], default: 'auto' },
+                                with_repo_map: { type: 'boolean', default: false },
+                                repo_map_max_files: { type: 'number', default: 20 },
+                                repo_map_max_symbols: { type: 'number', default: 5 },
+                                wiki_dir: { type: 'string', description: 'Wiki dir relative to repo root (optional)' },
+                            },
+                            required: ['path', 'query'],
+                        },
+                    },
+                    {
+                        name: 'repo_map',
+                        description: 'Generate a lightweight repository map (ranked files + top symbols + wiki links). Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                                max_files: { type: 'number', default: 20 },
+                                max_symbols: { type: 'number', default: 5 },
+                                wiki_dir: { type: 'string', description: 'Wiki dir relative to repo root (optional)' },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'check_index',
+                        description: 'Check whether the repository index structure matches current expected schema. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'rebuild_index',
+                        description: 'Rebuild full repository index under .git-ai (LanceDB + AST graph). Risk: high (writes .git-ai; can be slow).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                                dim: { type: 'number', default: 256 },
+                                overwrite: { type: 'boolean', default: true },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'pack_index',
+                        description: 'Pack .git-ai/lancedb into .git-ai/lancedb.tar.gz. Risk: medium (writes archive; may touch git-lfs config).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                                lfs: { type: 'boolean', default: false, description: 'Run git lfs track for .git-ai/lancedb.tar.gz' },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'unpack_index',
+                        description: 'Unpack .git-ai/lancedb.tar.gz into .git-ai/lancedb. Risk: medium (writes .git-ai/lancedb).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'list_files',
+                        description: 'List repository files by glob pattern. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                                pattern: { type: 'string', default: '**/*' },
+                                limit: { type: 'number', default: 500 },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'read_file',
+                        description: 'Read a repository file with optional line range. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                                file: { type: 'string', description: 'File path relative to repo root' },
+                                start_line: { type: 'number', default: 1 },
+                                end_line: { type: 'number', default: 200 },
+                            },
+                            required: ['path', 'file'],
+                        },
+                    },
+                    {
+                        name: 'ast_graph_query',
+                        description: 'Run a CozoScript query against the AST graph database (advanced). Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: { type: 'string' },
+                                params: { type: 'object', default: {} },
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path', 'query'],
+                        },
+                    },
+                    {
+                        name: 'ast_graph_find',
+                        description: 'Find symbols by name prefix (case-insensitive) using the AST graph. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                prefix: { type: 'string' },
+                                path: { type: 'string', description: 'Repository root path' },
+                                limit: { type: 'number', default: 50 },
+                                lang: { type: 'string', enum: ['auto', 'all', 'java', 'ts'], default: 'auto' },
+                            },
+                            required: ['path', 'prefix'],
+                        },
+                    },
+                    {
+                        name: 'ast_graph_children',
+                        description: 'List direct children in the AST containment graph (file -> top-level symbols, class -> methods). Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string', description: 'Parent id (ref_id or file_id; or file path when as_file=true)' },
+                                as_file: { type: 'boolean', default: false },
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path', 'id'],
+                        },
+                    },
+                    {
+                        name: 'ast_graph_refs',
+                        description: 'Find reference locations by name (calls/new/type). Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                limit: { type: 'number', default: 200 },
+                                lang: { type: 'string', enum: ['auto', 'all', 'java', 'ts'], default: 'auto' },
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path', 'name'],
+                        },
+                    },
+                    {
+                        name: 'ast_graph_callers',
+                        description: 'Find callers by callee name. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                limit: { type: 'number', default: 200 },
+                                lang: { type: 'string', enum: ['auto', 'all', 'java', 'ts'], default: 'auto' },
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path', 'name'],
+                        },
+                    },
+                    {
+                        name: 'ast_graph_callees',
+                        description: 'Find callees by caller name. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                limit: { type: 'number', default: 200 },
+                                lang: { type: 'string', enum: ['auto', 'all', 'java', 'ts'], default: 'auto' },
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path', 'name'],
+                        },
+                    },
+                    {
+                        name: 'ast_graph_chain',
+                        description: 'Compute call chain by symbol name (heuristic, name-based). Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                direction: { type: 'string', enum: ['downstream', 'upstream'], default: 'downstream' },
+                                max_depth: { type: 'number', default: 3 },
+                                limit: { type: 'number', default: 500 },
+                                min_name_len: { type: 'number', default: 1 },
+                                lang: { type: 'string', enum: ['auto', 'all', 'java', 'ts'], default: 'auto' },
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path', 'name'],
+                        },
+                    },
+                    {
+                        name: 'dsr_context',
+                        description: 'Get repository Git context and DSR directory state. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'dsr_generate',
+                        description: 'Generate DSR (Deterministic Semantic Record) for a specific commit. Risk: medium (writes .git-ai/dsr).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                                commit: { type: 'string', description: 'Commit hash or ref' },
+                            },
+                            required: ['path', 'commit'],
+                        },
+                    },
+                    {
+                        name: 'dsr_rebuild_index',
+                        description: 'Rebuild DSR index from DSR files for faster queries. Risk: medium (writes .git-ai/dsr-index).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                            },
+                            required: ['path'],
+                        },
+                    },
+                    {
+                        name: 'dsr_symbol_evolution',
+                        description: 'Query symbol evolution history across commits using DSR. Risk: low (read-only).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                path: { type: 'string', description: 'Repository root path' },
+                                symbol: { type: 'string', description: 'Symbol name to query' },
+                                start: { type: 'string', description: 'Start commit (default: HEAD)' },
+                                all: { type: 'boolean', default: false, description: 'Traverse all refs instead of just HEAD' },
+                                limit: { type: 'number', default: 200, description: 'Max commits to traverse' },
+                                contains: { type: 'boolean', default: false, description: 'Match by substring instead of exact' },
+                            },
+                            required: ['path', 'symbol'],
+                        },
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const name = request.params.name;
+            const args = request.params.arguments ?? {};
+            const callPath = typeof args.path === 'string' ? String(args.path) : undefined;
+            const log = (0, log_1.createLogger)({ component: 'mcp', tool: name });
+            const startedAt = Date.now();
+            const response = await (async () => {
+                if (typeof callPath !== 'string' || callPath.trim() === '') {
+                    throw new Error('Missing required argument: path');
+                }
+                if (name === 'get_repo') {
+                    const ctx = await this.openRepoContext(callPath);
+                    const repoRoot = ctx.repoRoot;
+                    const scanRoot = ctx.scanRoot;
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ ok: true, startDir: this.startDir, repoRoot, scanRoot }, null, 2) }],
+                    };
+                }
+                if (name === 'dsr_context') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const ctx = await (0, gitContext_1.detectRepoGitContext)(repoRoot);
+                    const state = await (0, state_1.getDsrDirectoryState)(ctx.repo_root);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    ok: true,
+                                    commit_hash: ctx.head_commit,
+                                    repo_root: ctx.repo_root,
+                                    branch: ctx.branch,
+                                    detached: ctx.detached,
+                                    dsr_directory_state: state,
+                                }, null, 2) }],
+                    };
+                }
+                if (name === 'dsr_generate') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const commit = String(args.commit ?? 'HEAD');
+                    const res = await (0, generate_1.generateDsrForCommit)(repoRoot, commit);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    ok: true,
+                                    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,
+                                }, null, 2) }],
+                    };
+                }
+                if (name === 'dsr_rebuild_index') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const res = await (0, indexMaterialize_1.materializeDsrIndex)(repoRoot);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, ...res }, null, 2) }],
+                        isError: !res.enabled,
+                    };
+                }
+                if (name === 'dsr_symbol_evolution') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const symbol = String(args.symbol ?? '');
+                    const opts = {
+                        start: args.start ? String(args.start) : undefined,
+                        all: Boolean(args.all ?? false),
+                        limit: Number(args.limit ?? 200),
+                        contains: Boolean(args.contains ?? false),
+                    };
+                    const res = await (0, query_1.symbolEvolution)(repoRoot, symbol, opts);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, symbol, ...res }, null, 2) }],
+                        isError: !res.ok,
+                    };
+                }
+                if (name === 'check_index') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const res = await (0, indexCheck_1.checkIndex)(repoRoot);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, ...res }, null, 2) }],
+                        isError: !res.ok,
+                    };
+                }
+                if (name === 'rebuild_index') {
+                    const { repoRoot, scanRoot, meta } = await this.openRepoContext(callPath);
+                    const overwrite = Boolean(args.overwrite ?? true);
+                    const dimOpt = Number(args.dim ?? 256);
+                    const dim = typeof meta?.dim === 'number' ? meta.dim : dimOpt;
+                    const indexer = new indexer_1.IndexerV2({ repoRoot, scanRoot, dim, overwrite });
+                    await indexer.run();
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ ok: true, repoRoot, scanRoot, dim, overwrite }, null, 2) }],
+                    };
+                }
+                if (name === 'pack_index') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const packed = await (0, archive_1.packLanceDb)(repoRoot);
+                    const lfs = Boolean(args.lfs ?? false) ? (0, lfs_1.ensureLfsTracking)(repoRoot, '.git-ai/lancedb.tar.gz') : { tracked: false };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ ok: true, repoRoot, ...packed, lfs }, null, 2) }],
+                    };
+                }
+                if (name === 'unpack_index') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const unpacked = await (0, archive_1.unpackLanceDb)(repoRoot);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ ok: true, repoRoot, ...unpacked }, null, 2) }],
+                    };
+                }
+                if (name === 'list_files') {
+                    const { repoRoot, scanRoot } = await this.openRepoContext(callPath);
+                    const pattern = String(args.pattern ?? '**/*');
+                    const limit = Number(args.limit ?? 500);
+                    const files = await (0, glob_1.glob)(pattern, {
+                        cwd: scanRoot,
+                        dot: true,
+                        nodir: true,
+                        ignore: ['node_modules/**', '.git/**', '**/.git/**', '.git-ai/**', '**/.git-ai/**', '.repo/**', '**/.repo/**', 'dist/**', 'target/**', '**/target/**', 'build/**', '**/build/**', '.gradle/**', '**/.gradle/**'],
+                    });
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ ok: true, repoRoot, scanRoot, files: files.slice(0, limit) }, null, 2) }],
+                    };
+                }
+                if (name === 'read_file') {
+                    const { repoRoot, scanRoot } = await this.openRepoContext(callPath);
+                    const file = String(args.file ?? '');
+                    const startLine = Math.max(1, Number(args.start_line ?? 1));
+                    const endLine = Math.max(startLine, Number(args.end_line ?? startLine + 199));
+                    const abs = this.assertPathInsideRoot(scanRoot, file);
+                    const raw = await fs_extra_1.default.readFile(abs, 'utf-8');
+                    const lines = raw.split(/\r?\n/);
+                    const slice = lines.slice(startLine - 1, endLine);
+                    const numbered = slice.map((l, idx) => `${String(startLine + idx).padStart(6, ' ')}→${l}`).join('\n');
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ ok: true, repoRoot, scanRoot, file, start_line: startLine, end_line: endLine, text: numbered }, null, 2) }],
+                    };
+                }
+                if (name === 'ast_graph_query') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const query = String(args.query ?? '');
+                    const params = args.params && typeof args.params === 'object' ? args.params : {};
+                    const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, query, params);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, result }, null, 2) }],
+                    };
+                }
+                if (name === 'ast_graph_find') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const prefix = String(args.prefix ?? '');
+                    const limit = Number(args.limit ?? 50);
+                    const langSel = String(args.lang ?? 'auto');
+                    const status = await (0, indexCheck_1.checkIndex)(repoRoot);
+                    if (!status.ok) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) }], isError: true };
+                    }
+                    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, lang });
+                        const rows = Array.isArray(result?.rows) ? result.rows : [];
+                        for (const r of rows)
+                            allRows.push(r);
+                    }
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, lang: langSel, result: { headers: ['ref_id', 'file', 'lang', 'name', 'kind', 'signature', 'start_line', 'end_line'], rows: allRows.slice(0, limit) } }, null, 2) }],
+                    };
+                }
+                if (name === 'ast_graph_children') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const id = String(args.id ?? '');
+                    const asFile = Boolean(args.as_file ?? false);
+                    const parent_id = asFile ? (0, crypto_1.sha256Hex)(`file:${(0, paths_1.toPosixPath)(id)}`) : id;
+                    const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, (0, astGraphQuery_1.buildChildrenQuery)(), { parent_id });
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, parent_id, result }, null, 2) }],
+                    };
+                }
+                if (name === 'ast_graph_refs') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const target = String(args.name ?? '');
+                    const limit = Number(args.limit ?? 200);
+                    const langSel = String(args.lang ?? 'auto');
+                    const status = await (0, indexCheck_1.checkIndex)(repoRoot);
+                    if (!status.ok) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) }], isError: true };
+                    }
+                    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: target, lang });
+                        const rows = Array.isArray(result?.rows) ? result.rows : [];
+                        for (const r of rows)
+                            allRows.push(r);
+                    }
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, name: target, lang: langSel, result: { headers: ['file', 'line', 'col', 'ref_kind', 'from_id', 'from_kind', 'from_name', 'from_lang'], rows: allRows.slice(0, limit) } }, null, 2) }],
+                    };
+                }
+                if (name === 'ast_graph_callers') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const target = String(args.name ?? '');
+                    const limit = Number(args.limit ?? 200);
+                    const langSel = String(args.lang ?? 'auto');
+                    const status = await (0, indexCheck_1.checkIndex)(repoRoot);
+                    if (!status.ok) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) }], isError: true };
+                    }
+                    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: target, lang });
+                        const rows = Array.isArray(result?.rows) ? result.rows : [];
+                        for (const r of rows)
+                            allRows.push(r);
+                    }
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, name: target, lang: langSel, result: { headers: ['caller_id', 'caller_kind', 'caller_name', 'file', 'line', 'col', 'caller_lang'], rows: allRows.slice(0, limit) } }, null, 2) }],
+                    };
+                }
+                if (name === 'ast_graph_callees') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const target = String(args.name ?? '');
+                    const limit = Number(args.limit ?? 200);
+                    const langSel = String(args.lang ?? 'auto');
+                    const status = await (0, indexCheck_1.checkIndex)(repoRoot);
+                    if (!status.ok) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) }], isError: true };
+                    }
+                    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: target, lang });
+                        const rows = Array.isArray(result?.rows) ? result.rows : [];
+                        for (const r of rows)
+                            allRows.push(r);
+                    }
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, name: target, lang: langSel, result: { headers: ['caller_id', 'caller_lang', 'callee_id', 'callee_file', 'callee_name', 'callee_kind', 'file', 'line', 'col'], rows: allRows.slice(0, limit) } }, null, 2) }],
+                    };
+                }
+                if (name === 'ast_graph_chain') {
+                    const repoRoot = await this.resolveRepoRoot(callPath);
+                    const target = String(args.name ?? '');
+                    const direction = String(args.direction ?? 'downstream');
+                    const maxDepth = Number(args.max_depth ?? 3);
+                    const limit = Number(args.limit ?? 500);
+                    const minNameLen = Math.max(1, Number(args.min_name_len ?? 1));
+                    const langSel = String(args.lang ?? 'auto');
+                    const status = await (0, indexCheck_1.checkIndex)(repoRoot);
+                    if (!status.ok) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) }], isError: true };
+                    }
+                    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+                    const query = direction === 'upstream' ? (0, astGraphQuery_1.buildCallChainUpstreamByNameQuery)() : (0, astGraphQuery_1.buildCallChainDownstreamByNameQuery)();
+                    const rawRows = [];
+                    for (const lang of langs) {
+                        const result = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, query, { name: target, max_depth: maxDepth, lang });
+                        const rows = Array.isArray(result?.rows) ? result.rows : [];
+                        for (const r of rows)
+                            rawRows.push(r);
+                    }
+                    const filtered = minNameLen > 1
+                        ? rawRows.filter((r) => String(r?.[3] ?? '').length >= minNameLen && String(r?.[4] ?? '').length >= minNameLen)
+                        : rawRows;
+                    const rows = filtered.slice(0, limit);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot, name: target, 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) }],
+                    };
+                }
+                const repoRootForDispatch = await this.resolveRepoRoot(callPath);
+                if (name === 'repo_map') {
+                    const wikiDir = resolveWikiDirInsideRepo(repoRootForDispatch, String(args.wiki_dir ?? ''));
+                    const maxFiles = Number(args.max_files ?? 20);
+                    const maxSymbolsPerFile = Number(args.max_symbols ?? 5);
+                    const repoMap = await buildRepoMapAttachment(repoRootForDispatch, wikiDir, maxFiles, maxSymbolsPerFile);
+                    return { content: [{ type: 'text', text: JSON.stringify({ repoRoot: repoRootForDispatch, repo_map: repoMap }, null, 2) }] };
+                }
+                if (name === 'search_symbols' && (0, git_1.inferWorkspaceRoot)(repoRootForDispatch)) {
+                    const query = String(args.query ?? '');
+                    const limit = Number(args.limit ?? 50);
+                    const mode = (0, symbolSearch_1.inferSymbolSearchMode)(query, args.mode);
+                    const caseInsensitive = Boolean(args.case_insensitive ?? false);
+                    const maxCandidates = Math.max(limit, Number(args.max_candidates ?? Math.min(2000, limit * 20)));
+                    const keyword = (mode === 'substring' || mode === 'prefix') ? query : (0, symbolSearch_1.pickCoarseToken)(query);
+                    const res = await (0, workspace_1.queryManifestWorkspace)({ manifestRepoRoot: repoRootForDispatch, keyword, limit: maxCandidates });
+                    const langSel = String(args.lang ?? 'auto');
+                    const filteredByLang = (langSel === 'java')
+                        ? res.rows.filter(r => String(r.file ?? '').endsWith('.java'))
+                        : (langSel === 'ts')
+                            ? res.rows.filter(r => !String(r.file ?? '').endsWith('.java'))
+                            : res.rows;
+                    const rows = (0, symbolSearch_1.filterAndRankSymbolRows)(filteredByLang, { query, mode, caseInsensitive, limit });
+                    const withRepoMap = Boolean(args.with_repo_map ?? false);
+                    const repoMap = withRepoMap ? { enabled: false, skippedReason: 'workspace_mode_not_supported' } : undefined;
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({ repoRoot: repoRootForDispatch, lang: langSel, rows, ...(repoMap ? { repo_map: repoMap } : {}) }, null, 2) }],
+                    };
+                }
+                if (name === 'search_symbols') {
+                    const query = String(args.query ?? '');
+                    const limit = Number(args.limit ?? 50);
+                    const langSel = String(args.lang ?? 'auto');
+                    const mode = (0, symbolSearch_1.inferSymbolSearchMode)(query, args.mode);
+                    const caseInsensitive = Boolean(args.case_insensitive ?? false);
+                    const maxCandidates = Math.max(limit, Number(args.max_candidates ?? Math.min(2000, limit * 20)));
+                    const withRepoMap = Boolean(args.with_repo_map ?? false);
+                    const wikiDir = resolveWikiDirInsideRepo(repoRootForDispatch, String(args.wiki_dir ?? ''));
+                    const repoMapMaxFiles = Number(args.repo_map_max_files ?? 20);
+                    const repoMapMaxSymbols = Number(args.repo_map_max_symbols ?? 5);
+                    const status = await (0, indexCheck_1.checkIndex)(repoRootForDispatch);
+                    if (!status.ok) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) }], isError: true };
+                    }
+                    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+                    const dim = typeof status.found.meta?.dim === 'number' ? status.found.meta.dim : 256;
+                    const dbDir = (0, lancedb_1.defaultDbDir)(repoRootForDispatch);
+                    const { byLang } = await (0, lancedb_1.openTablesByLang)({ dbDir, dim, mode: 'open_only', languages: langs });
+                    const where = (0, symbolSearch_1.buildCoarseWhere)({ query, 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, mode, caseInsensitive, limit });
+                    const repoMap = withRepoMap ? await buildRepoMapAttachment(repoRootForDispatch, wikiDir, repoMapMaxFiles, repoMapMaxSymbols) : undefined;
+                    return { content: [{ type: 'text', text: JSON.stringify({ repoRoot: repoRootForDispatch, lang: langSel, rows, ...(repoMap ? { repo_map: repoMap } : {}) }, null, 2) }] };
+                }
+                if (name === 'semantic_search') {
+                    const query = String(args.query ?? '');
+                    const topk = Number(args.topk ?? 10);
+                    const langSel = String(args.lang ?? 'auto');
+                    const withRepoMap = Boolean(args.with_repo_map ?? false);
+                    const wikiDir = resolveWikiDirInsideRepo(repoRootForDispatch, String(args.wiki_dir ?? ''));
+                    const repoMapMaxFiles = Number(args.repo_map_max_files ?? 20);
+                    const repoMapMaxSymbols = Number(args.repo_map_max_symbols ?? 5);
+                    const status = await (0, indexCheck_1.checkIndex)(repoRootForDispatch);
+                    if (!status.ok) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ ...status, ok: false, reason: 'index_incompatible' }, null, 2) }], isError: true };
+                    }
+                    const langs = (0, indexCheck_1.resolveLangs)(status.found.meta ?? null, langSel);
+                    const dim = typeof status.found.meta?.dim === 'number' ? status.found.meta.dim : 256;
+                    const dbDir = (0, lancedb_1.defaultDbDir)(repoRootForDispatch);
+                    const { byLang } = await (0, lancedb_1.openTablesByLang)({ dbDir, dim, mode: 'open_only', languages: langs });
+                    const q = (0, search_1.buildQueryVector)(query, dim);
+                    const allScored = [];
+                    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();
+                        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 rows = allScored.sort((a, b) => b.score - a.score).slice(0, topk);
+                    const repoMap = withRepoMap ? await buildRepoMapAttachment(repoRootForDispatch, wikiDir, repoMapMaxFiles, repoMapMaxSymbols) : undefined;
+                    return { content: [{ type: 'text', text: JSON.stringify({ repoRoot: repoRootForDispatch, lang: langSel, rows, ...(repoMap ? { repo_map: repoMap } : {}) }, null, 2) }] };
+                }
+                return {
+                    content: [{ type: 'text', text: 'Tool not found' }],
+                    isError: true,
+                };
+            })().catch((e) => {
+                const err = e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : { message: String(e) };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ ok: false, tool: name, error: err }, null, 2) }],
+                    isError: true,
+                };
+            });
+            log.info('tool_call', { ok: !response.isError, duration_ms: Date.now() - startedAt, path: callPath });
+            const repoRootForLog = await this.resolveRepoRoot(callPath).catch(() => undefined);
+            await this.writeAccessLog(name, args, Date.now() - startedAt, !response.isError, repoRootForLog);
+            return response;
+        });
+    }
+    async start() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        (0, log_1.createLogger)({ component: 'mcp' }).info('server_started', { startDir: this.startDir, transport: 'stdio' });
+    }
+}
+exports.GitAIV2MCPServer = GitAIV2MCPServer;
+async function buildRepoMapAttachment(repoRoot, wikiDir, maxFiles, maxSymbolsPerFile) {
+    try {
+        const files = await (0, repoMap_1.generateRepoMap)({ repoRoot, maxFiles, maxSymbolsPerFile, wikiDir: wikiDir || undefined });
+        return { enabled: true, wikiDir, files };
+    }
+    catch (e) {
+        return { enabled: false, skippedReason: String(e?.message ?? e) };
+    }
+}
+function resolveWikiDirInsideRepo(repoRoot, wikiOpt) {
+    const w = String(wikiOpt ?? '').trim();
+    if (w) {
+        const abs = path_1.default.resolve(repoRoot, w);
+        const rel = path_1.default.relative(repoRoot, abs);
+        if (rel.startsWith('..') || path_1.default.isAbsolute(rel))
+            throw new Error('wiki_dir escapes repository root');
+        if (fs_extra_1.default.existsSync(abs))
+            return abs;
+        return '';
+    }
+    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 '';
+}