mcp-probe-kit 3.0.9 → 3.0.10

package/build/lib/gitnexus-bridge.js

@@ -1,12 +1,41 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { execFileSync, spawn } from "node:child_process";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { isAbortError, throwIfAborted, } from "./tool-execution-context.js";
 const DEFAULT_CONNECT_TIMEOUT_MS = readIntEnv("MCP_GITNEXUS_CONNECT_TIMEOUT_MS", 12000);
 const DEFAULT_CALL_TIMEOUT_MS = readIntEnv("MCP_GITNEXUS_TIMEOUT_MS", 20000);
 const DEFAULT_GITNEXUS_ARGS = ["-y", "gitnexus@latest", "mcp"];
 const FAILURE_CACHE_TTL_MS = readIntEnv("MCP_GITNEXUS_FAILURE_CACHE_TTL_MS", 30000);
+const DEFAULT_IGNORED_DIRS = new Set([
+    ".git",
+    ".gitnexus",
+    ".mcp-probe-kit",
+    ".playwright-cli",
+    ".turbo",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".idea",
+    ".vscode",
+    ".gradle",
+    ".npm",
+    ".pnpm-store",
+    ".yarn",
+    ".cache",
+    ".cargo",
+    ".rustup",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "output",
+    "temp",
+    "tmp",
+]);
+const DEFAULT_IGNORED_FILES = [/^\.env(\..+)?$/i];
 let bridgeFailureUntil = 0;
 let bridgeFailureReason = "";
 function readIntEnv(name, fallback) {
@@ -40,31 +69,206 @@ function splitArgs(raw) {
         .split(/\s+/)
         .filter(Boolean);
 }
-function inferDefaultRepoName() {
+function resolvePreferredRepoName(requestedRepo) {
+    const requested = requestedRepo?.trim();
+    if (requested) {
+        return requested;
+    }
     const explicit = process.env.MCP_GITNEXUS_REPO?.trim();
     if (explicit) {
         return explicit;
     }
-    const pkgPath = path.join(process.cwd(), "package.json");
+    return undefined;
+}
+function resolveRequestedProjectRoot(projectRoot) {
+    const requested = projectRoot?.trim();
+    if (requested) {
+        return path.resolve(requested);
+    }
+    return path.resolve(process.cwd());
+}
+function inferCandidateRepoNames(baseDir = process.cwd()) {
+    const candidates = [];
+    const pkgPath = path.join(baseDir, "package.json");
     try {
         if (fs.existsSync(pkgPath)) {
             const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
             const pkgName = typeof parsed.name === "string" ? parsed.name.trim() : "";
             if (pkgName) {
-                return pkgName;
+                candidates.push(pkgName);
             }
         }
     }
     catch {
         // ignore parse failure
     }
-    const base = path.basename(process.cwd()).trim();
-    return base || undefined;
+    const base = path.basename(baseDir).trim();
+    if (base) {
+        candidates.push(base);
+    }
+    return Array.from(new Set(candidates.filter(Boolean)));
+}
+function parseAvailableReposFromError(text) {
+    const match = text.match(/Available:\s*(.+)$/i);
+    if (!match) {
+        return [];
+    }
+    return match[1]
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
 }
 function resolveBridgeCommand() {
     const command = (process.env.MCP_GITNEXUS_COMMAND || "npx").trim() || "npx";
     const args = splitArgs(process.env.MCP_GITNEXUS_ARGS);
-    return { command, args };
+    return resolveSpawnCommand(command, args);
+}
+function resolveGitNexusCliCommand(subcommand) {
+    const command = (process.env.MCP_GITNEXUS_COMMAND || "npx").trim() || "npx";
+    const bridgeArgs = splitArgs(process.env.MCP_GITNEXUS_ARGS);
+    const flags = [];
+    let packageSpec = "gitnexus@latest";
+    for (const arg of bridgeArgs) {
+        if (arg === "mcp") {
+            break;
+        }
+        if (arg.startsWith("-")) {
+            flags.push(arg);
+            continue;
+        }
+        packageSpec = arg;
+        break;
+    }
+    return resolveSpawnCommand(command, [...flags, packageSpec, subcommand]);
+}
+export function resolveExecutableCommand(command, platform = process.platform) {
+    const normalized = (command || "").trim();
+    if (!normalized) {
+        return resolveExecutableCommand("npx", platform);
+    }
+    if (path.isAbsolute(normalized) && fs.existsSync(normalized)) {
+        return normalized;
+    }
+    const found = findExecutablePath(normalized, platform);
+    if (found) {
+        return found;
+    }
+    if (platform !== "win32") {
+        return normalized;
+    }
+    const lower = normalized.toLowerCase();
+    if (lower.endsWith(".cmd") || lower.endsWith(".exe") || lower.endsWith(".bat")) {
+        return normalized;
+    }
+    if (lower === "npx" || lower === "npm" || lower === "git") {
+        return `${normalized}.cmd`;
+    }
+    return normalized;
+}
+function findExecutablePath(command, platform = process.platform) {
+    const trimmed = (command || "").trim();
+    if (!trimmed || path.isAbsolute(trimmed)) {
+        return undefined;
+    }
+    const preferredPath = (candidates) => {
+        const existing = candidates.filter((candidate) => candidate && fs.existsSync(candidate));
+        if (existing.length === 0) {
+            return undefined;
+        }
+        if (platform !== "win32") {
+            return existing[0];
+        }
+        const lower = trimmed.toLowerCase();
+        const preferredExts = lower === "npx" || lower === "npm"
+            ? [".cmd", ".exe", ".bat", ""]
+            : lower === "git"
+                ? [".exe", ".cmd", ".bat", ""]
+                : [".exe", ".cmd", ".bat", ""];
+        for (const ext of preferredExts) {
+            const match = existing.find((candidate) => path.extname(candidate).toLowerCase() === ext);
+            if (match) {
+                return match;
+            }
+        }
+        return existing[0];
+    };
+    if (platform === "win32") {
+        try {
+            const output = execFileSync("where.exe", [trimmed], {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+                windowsHide: true,
+            }).trim();
+            const candidates = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+            const preferred = preferredPath(candidates);
+            if (preferred) {
+                return preferred;
+            }
+        }
+        catch {
+            // fall back to PATH scan
+        }
+    }
+    const pathEntries = (process.env.PATH || "")
+        .split(path.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    const lower = trimmed.toLowerCase();
+    const extensions = platform === "win32"
+        ? lower === "npx" || lower === "npm"
+            ? [".cmd", ".exe", ".bat", ""]
+            : lower === "git"
+                ? [".exe", ".cmd", ".bat", ""]
+                : [".exe", ".cmd", ".bat", ""]
+        : [""];
+    for (const entry of pathEntries) {
+        for (const ext of extensions) {
+            const candidate = path.join(entry, `${trimmed}${ext}`);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    if (platform === "win32" && trimmed.toLowerCase() === "git") {
+        const commonCandidates = [
+            path.join(process.env["ProgramFiles"] || "C:\\Program Files", "Git", "cmd", "git.exe"),
+            path.join(process.env["ProgramFiles"] || "C:\\Program Files", "Git", "bin", "git.exe"),
+            path.join(process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)", "Git", "cmd", "git.exe"),
+        ];
+        return preferredPath(commonCandidates);
+    }
+    return undefined;
+}
+function shouldWrapWithCmd(rawCommand, executable, platform = process.platform) {
+    if (platform !== "win32") {
+        return false;
+    }
+    const rawLower = (rawCommand || "").trim().toLowerCase();
+    const executableLower = (executable || "").trim().toLowerCase();
+    const ext = path.extname(executableLower);
+    if (!rawLower && !executableLower) {
+        return true;
+    }
+    if (ext === ".cmd" || ext === ".bat") {
+        return true;
+    }
+    if (ext === ".exe") {
+        return false;
+    }
+    return rawLower === "npx" || rawLower === "npm";
+}
+export function resolveSpawnCommand(command, args, platform = process.platform) {
+    const executable = resolveExecutableCommand(command, platform);
+    if (!shouldWrapWithCmd(command, executable, platform)) {
+        return {
+            command: executable,
+            args,
+        };
+    }
+    return {
+        command: process.env.ComSpec || "cmd.exe",
+        args: ["/d", "/s", "/c", executable, ...args],
+    };
 }
 function extractText(result) {
     if (!result || typeof result !== "object") {
@@ -102,6 +306,225 @@ function normalizeError(error) {
     }
     return String(error);
 }
+function findGitRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const gitPath = path.join(current, ".git");
+        if (fs.existsSync(gitPath)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+function createWorkspaceId(sourceRoot) {
+    const base = path.basename(sourceRoot).replace(/[^a-zA-Z0-9._-]+/g, "-") || "workspace";
+    return `${base}-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+}
+function shouldIgnoreForTempWorkspace(sourceRoot, entryPath) {
+    const relative = path.relative(sourceRoot, entryPath);
+    if (!relative || relative.startsWith("..")) {
+        return false;
+    }
+    const parts = relative.split(path.sep).filter(Boolean);
+    if (parts.some((part) => DEFAULT_IGNORED_DIRS.has(part))) {
+        return true;
+    }
+    const name = parts[parts.length - 1] || "";
+    return DEFAULT_IGNORED_FILES.some((pattern) => pattern.test(name));
+}
+async function runProcess(command, args, cwd, signal) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            signal,
+            windowsHide: true,
+        });
+        let stderr = "";
+        child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() || `${command} ${args.join(" ")} 退出码 ${code ?? "unknown"}`));
+        });
+    });
+}
+async function removePathWithRetry(targetPath, attempts = 6) {
+    let lastError;
+    for (let index = 0; index < attempts; index += 1) {
+        try {
+            fs.rmSync(targetPath, { recursive: true, force: true });
+            if (!fs.existsSync(targetPath)) {
+                return;
+            }
+        }
+        catch (error) {
+            lastError = error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 150 * (index + 1)));
+    }
+    if (fs.existsSync(targetPath)) {
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`无法删除临时目录: ${targetPath}`);
+    }
+}
+async function cleanupStaleTempWorkspaces(tempWorkspaceRoot, keepPath) {
+    if (!fs.existsSync(tempWorkspaceRoot)) {
+        return;
+    }
+    const entries = fs.readdirSync(tempWorkspaceRoot, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const fullPath = path.join(tempWorkspaceRoot, entry.name);
+        if (keepPath && path.resolve(fullPath) === path.resolve(keepPath)) {
+            continue;
+        }
+        try {
+            await removePathWithRetry(fullPath, 3);
+        }
+        catch {
+            // keep best-effort cleanup silent; current run should not fail because of stale dirs
+        }
+    }
+}
+function copyIntoAnalysisWorkspace(sourceRoot, analysisRoot) {
+    fs.mkdirSync(analysisRoot, { recursive: true });
+    const walk = (fromDir, toDir) => {
+        fs.mkdirSync(toDir, { recursive: true });
+        const entries = fs.readdirSync(fromDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fromPath = path.join(fromDir, entry.name);
+            if (shouldIgnoreForTempWorkspace(sourceRoot, fromPath)) {
+                continue;
+            }
+            const toPath = path.join(toDir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fromPath, toPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                fs.copyFileSync(fromPath, toPath);
+            }
+        }
+    };
+    walk(sourceRoot, analysisRoot);
+}
+async function createTempAnalysisWorkspace(sourceRoot, signal, options) {
+    const tempWorkspaceRoot = path.join(sourceRoot, ".mcp-probe-kit", "gitnexus-temp");
+    const workspaceId = createWorkspaceId(sourceRoot);
+    const analysisRoot = path.join(tempWorkspaceRoot, workspaceId);
+    fs.mkdirSync(tempWorkspaceRoot, { recursive: true });
+    await cleanupStaleTempWorkspaces(tempWorkspaceRoot);
+    copyIntoAnalysisWorkspace(sourceRoot, analysisRoot);
+    throwIfAborted(signal, "GitNexus 临时工作区创建已取消");
+    if (options?.bootstrap !== false) {
+        const gitInit = resolveSpawnCommand("git", ["init", "-q"]);
+        await runProcess(gitInit.command, gitInit.args, analysisRoot, signal);
+        const analyzeCli = resolveGitNexusCliCommand("analyze");
+        await runProcess(analyzeCli.command, analyzeCli.args, analysisRoot, signal);
+    }
+    return {
+        workspaceMode: "temp-repo",
+        sourceRoot,
+        analysisRoot,
+        repoName: path.basename(analysisRoot),
+        pathMapped: true,
+        cleanup: async () => {
+            if (options?.bootstrap !== false) {
+                try {
+                    const cleanCli = resolveGitNexusCliCommand("clean");
+                    await runProcess(cleanCli.command, cleanCli.args, analysisRoot, undefined);
+                }
+                catch {
+                    // best effort cleanup only
+                }
+            }
+            await removePathWithRetry(analysisRoot);
+            try {
+                const remaining = fs.existsSync(tempWorkspaceRoot)
+                    ? fs.readdirSync(tempWorkspaceRoot).filter(Boolean)
+                    : [];
+                if (remaining.length === 0) {
+                    fs.rmSync(tempWorkspaceRoot, { recursive: true, force: true });
+                }
+            }
+            catch {
+                // best effort only
+            }
+        },
+    };
+}
+export async function prepareBridgeWorkspace(cwd = process.cwd(), signal, options) {
+    const resolvedCwd = path.resolve(cwd);
+    const gitRoot = findGitRoot(resolvedCwd);
+    if (gitRoot) {
+        return {
+            workspaceMode: "direct",
+            sourceRoot: gitRoot,
+            analysisRoot: gitRoot,
+            repoName: inferCandidateRepoNames(gitRoot)[0],
+            pathMapped: false,
+        };
+    }
+    return createTempAnalysisWorkspace(resolvedCwd, signal, options);
+}
+async function ensureWorkspaceIndexed(workspace, signal) {
+    if (workspace.workspaceMode !== "direct") {
+        return;
+    }
+    const analyzeCli = resolveGitNexusCliCommand("analyze");
+    await runProcess(analyzeCli.command, analyzeCli.args, workspace.analysisRoot, signal);
+}
+function isUnsafeHomeRoot(sourceRoot) {
+    return path.resolve(sourceRoot) === path.resolve(os.homedir());
+}
+function mapStringToSourceRoot(value, workspace) {
+    if (!workspace.pathMapped || !value) {
+        return value;
+    }
+    const candidates = [
+        [workspace.analysisRoot, workspace.sourceRoot],
+        [workspace.analysisRoot.replace(/\\/g, "/"), workspace.sourceRoot.replace(/\\/g, "/")],
+        [workspace.analysisRoot.replace(/\//g, "\\"), workspace.sourceRoot.replace(/\//g, "\\")],
+    ];
+    let mapped = value;
+    for (const [from, to] of candidates) {
+        if (from && mapped.includes(from)) {
+            mapped = mapped.replaceAll(from, to);
+        }
+    }
+    return mapped;
+}
+function mapValueToSourceRoot(value, workspace) {
+    if (!workspace.pathMapped) {
+        return value;
+    }
+    if (typeof value === "string") {
+        return mapStringToSourceRoot(value, workspace);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => mapValueToSourceRoot(item, workspace));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            mapValueToSourceRoot(item, workspace),
+        ]));
+    }
+    return value;
+}
 function resolveMode(request) {
     const mode = request.mode || "auto";
     if (mode === "query" || mode === "context" || mode === "impact") {
@@ -115,7 +538,7 @@ function resolveMode(request) {
     }
     return "query";
 }
-async function callBridgeTool(client, tool, args, signal) {
+async function callBridgeTool(client, tool, args, signal, workspace) {
     const startedAt = Date.now();
     try {
         const result = await client.callTool({
@@ -134,9 +557,13 @@ async function callBridgeTool(client, tool, args, signal) {
                 args,
                 ok: false,
                 durationMs,
-                text,
-                structuredContent: result.structuredContent,
-                error: text || `GitNexus 工具 ${tool} 返回错误`,
+                text: workspace ? mapValueToSourceRoot(text, workspace) : text,
+                structuredContent: workspace
+                    ? mapValueToSourceRoot(result.structuredContent, workspace)
+                    : result.structuredContent,
+                error: workspace
+                    ? mapValueToSourceRoot(text || `GitNexus 工具 ${tool} 返回错误`, workspace)
+                    : text || `GitNexus 工具 ${tool} 返回错误`,
             };
         }
         return {
@@ -144,8 +571,10 @@ async function callBridgeTool(client, tool, args, signal) {
             args,
             ok: true,
             durationMs,
-            text,
-            structuredContent: result.structuredContent,
+            text: workspace ? mapValueToSourceRoot(text, workspace) : text,
+            structuredContent: workspace
+                ? mapValueToSourceRoot(result.structuredContent, workspace)
+                : result.structuredContent,
         };
     }
     catch (error) {
@@ -164,8 +593,9 @@ async function callBridgeTool(client, tool, args, signal) {
 export async function runCodeInsightBridge(request) {
     const modeRequested = request.mode || "auto";
     const modeResolved = resolveMode(request);
-    const effectiveRepo = request.repo || inferDefaultRepoName();
+    const requestedProjectRoot = resolveRequestedProjectRoot(request.projectRoot);
     if (!isBridgeEnabled() || isEnvDisabled("MCP_ENABLE_GITNEXUS_BRIDGE")) {
+        const sourceRoot = findGitRoot(requestedProjectRoot) || requestedProjectRoot;
         return {
             provider: "gitnexus",
             enabled: false,
@@ -176,10 +606,15 @@ export async function runCodeInsightBridge(request) {
             summary: "GitNexus bridge 已禁用（MCP_ENABLE_GITNEXUS_BRIDGE=0）。",
             executions: [],
             warnings: ["bridge_disabled"],
-            repo: effectiveRepo,
+            repo: resolvePreferredRepoName(request.repo),
+            workspaceMode: "direct",
+            sourceRoot,
+            analysisRoot: sourceRoot,
+            pathMapped: false,
         };
     }
     if (Date.now() < bridgeFailureUntil) {
+        const sourceRoot = findGitRoot(requestedProjectRoot) || requestedProjectRoot;
         return {
             provider: "gitnexus",
             enabled: true,
@@ -190,18 +625,48 @@ export async function runCodeInsightBridge(request) {
             summary: `GitNexus bridge 暂不可用（缓存中）: ${bridgeFailureReason || "请稍后重试"}`,
             executions: [],
             warnings: ["bridge_failure_cached"],
-            repo: effectiveRepo,
+            repo: resolvePreferredRepoName(request.repo),
+            workspaceMode: "direct",
+            sourceRoot,
+            analysisRoot: sourceRoot,
+            pathMapped: false,
         };
     }
     throwIfAborted(request.signal, "GitNexus bridge 已取消");
+    if (isUnsafeHomeRoot(requestedProjectRoot) && !findGitRoot(requestedProjectRoot)) {
+        return {
+            provider: "gitnexus",
+            enabled: true,
+            available: false,
+            degraded: true,
+            modeRequested,
+            modeResolved,
+            summary: "GitNexus bridge 已降级：当前工作目录看起来是用户家目录。请显式传入 project_root 指向实际项目目录，避免复制 .gradle/.npm 等本地缓存。",
+            executions: [],
+            warnings: ["project_root_required", "unsafe_home_directory"],
+            repo: resolvePreferredRepoName(request.repo),
+            workspaceMode: "direct",
+            sourceRoot: requestedProjectRoot,
+            analysisRoot: requestedProjectRoot,
+            pathMapped: false,
+        };
+    }
+    const workspace = await prepareBridgeWorkspace(requestedProjectRoot, request.signal);
+    await ensureWorkspaceIndexed(workspace, request.signal);
+    const effectiveRepo = workspace.workspaceMode === "temp-repo"
+        ? workspace.repoName
+        : resolvePreferredRepoName(request.repo) || workspace.repoName;
     const { command, args } = resolveBridgeCommand();
     const warnings = [];
+    if (workspace.workspaceMode === "temp-repo") {
+        warnings.push("temp_repo_workspace");
+    }
     const executions = [];
     const stderrLogs = [];
     const transport = new StdioClientTransport({
         command,
         args,
-        cwd: process.cwd(),
+        cwd: workspace.analysisRoot,
         stderr: "pipe",
     });
     if (transport.stderr) {
@@ -233,7 +698,7 @@ export async function runCodeInsightBridge(request) {
                 ...(request.goal ? { goal: request.goal } : {}),
                 ...(request.taskContext ? { task_context: request.taskContext } : {}),
                 ...(effectiveRepo ? { repo: effectiveRepo } : {}),
-            }, request.signal));
+            }, request.signal, workspace));
         };
         const runContext = async () => {
             if (!request.target) {
@@ -243,7 +708,7 @@ export async function runCodeInsightBridge(request) {
             executions.push(await callBridgeTool(client, "context", {
                 name: request.target,
                 ...(effectiveRepo ? { repo: effectiveRepo } : {}),
-            }, request.signal));
+            }, request.signal, workspace));
         };
         const runImpact = async () => {
             if (!request.target) {
@@ -258,7 +723,7 @@ export async function runCodeInsightBridge(request) {
                     ? { includeTests: request.includeTests }
                     : {}),
                 ...(effectiveRepo ? { repo: effectiveRepo } : {}),
-            }, request.signal));
+            }, request.signal, workspace));
         };
         if (modeRequested === "auto") {
             await runQuery();
@@ -298,13 +763,32 @@ export async function runCodeInsightBridge(request) {
             executions: [],
             warnings: ["bridge_unavailable", ...warnings],
             repo: effectiveRepo,
+            workspaceMode: workspace.workspaceMode,
+            sourceRoot: workspace.sourceRoot,
+            analysisRoot: workspace.analysisRoot,
+            pathMapped: workspace.pathMapped,
         };
     }
     finally {
         await client.close().catch(() => undefined);
+        await transport.close().catch(() => undefined);
+        await workspace.cleanup?.().catch(() => undefined);
     }
     const successful = executions.filter((item) => item.ok);
     const failed = executions.filter((item) => !item.ok);
+    if (successful.length === 0
+        && !effectiveRepo
+        && failed.length > 0
+        && failed.every((item) => (item.error || item.text || "").includes("Multiple repositories indexed"))) {
+        const availableRepos = parseAvailableReposFromError(failed.map((item) => item.error || item.text || "").join(" | "));
+        const retryRepo = inferCandidateRepoNames(workspace.sourceRoot).find((candidate) => availableRepos.includes(candidate));
+        if (retryRepo) {
+            return runCodeInsightBridge({
+                ...request,
+                repo: retryRepo,
+            });
+        }
+    }
     bridgeFailureUntil = 0;
     bridgeFailureReason = "";
     if (successful.length === 0) {
@@ -322,6 +806,10 @@ export async function runCodeInsightBridge(request) {
             executions,
             warnings: ["bridge_call_failed", ...warnings],
             repo: effectiveRepo,
+            workspaceMode: workspace.workspaceMode,
+            sourceRoot: workspace.sourceRoot,
+            analysisRoot: workspace.analysisRoot,
+            pathMapped: workspace.pathMapped,
         };
     }
     const summaryParts = successful.map((item) => `${item.tool}: ${shorten(item.text || "已返回结构化结果", 110)}`);
@@ -337,6 +825,10 @@ export async function runCodeInsightBridge(request) {
         executions,
         warnings,
         repo: effectiveRepo,
+        workspaceMode: workspace.workspaceMode,
+        sourceRoot: workspace.sourceRoot,
+        analysisRoot: workspace.analysisRoot,
+        pathMapped: workspace.pathMapped,
     };
 }
 function toEmbeddedGraphContext(result) {
@@ -356,11 +848,14 @@ function toEmbeddedGraphContext(result) {
 }
 export async function buildFeatureGraphContext(input) {
     const bridge = await runCodeInsightBridge({
-        mode: "query",
+        mode: "auto",
         query: `${input.featureName} ${input.description}`,
+        target: input.featureName,
+        direction: "upstream",
         goal: "Find related modules and execution flows for feature planning",
-        taskContext: "start_feature planning",
+        taskContext: "start_feature planning with query/context/impact narrowing",
         repo: input.repo,
+        projectRoot: input.projectRoot,
         signal: input.signal,
     });
     return toEmbeddedGraphContext(bridge);
@@ -373,6 +868,7 @@ export async function buildBugfixGraphContext(input) {
         goal: "Find likely root-cause symbols and impacted flows for bug fixing",
         taskContext: "start_bugfix diagnosis",
         repo: input.repo,
+        projectRoot: input.projectRoot,
         signal: input.signal,
     });
     return toEmbeddedGraphContext(bridge);