@sean.holung/minicode 0.3.9 → 0.3.11

package/dist/src/cli/benchmark-run.js

@@ -0,0 +1,432 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { CodingAgent, createModelClient, } from "@minicode/agent-sdk";
+import { getConfigSetupMessage } from "../agent/config.js";
+import { buildBenchmarkAgentConfig, resolveBenchmarkEnv, } from "../benchmark/config.js";
+import { collectWorkspaceChanges, writeWorkspaceDiff, } from "../benchmark/workspace-changes.js";
+import { buildProjectIndex } from "../indexer/project-index.js";
+import { createToolRegistry } from "../tools/registry.js";
+import { CliUsageError } from "./args.js";
+const BENCHMARK_SYSTEM_PROMPT_SUFFIX = [
+    "[Benchmark Execution Mode]",
+    "- This task is running in a non-interactive benchmark harness.",
+    "- The task is already approved. Do not ask for confirmation, permission, or whether you should proceed.",
+    "- If the task requires code changes, make them immediately using the available tools.",
+    "- Do not stop after presenting a plan. Either complete the task or explain a concrete blocker.",
+    "- When validation is part of the task, run the required command once after making changes.",
+].join("\n");
+const BENCHMARK_RETRY_REMINDER = [
+    "Benchmark harness reminder:",
+    "- This task is already approved.",
+    "- Do not ask for confirmation or present a plan without acting.",
+    "- Use tools, make the required edits immediately, and finish the task.",
+].join("\n");
+const CONFIRMATION_REQUEST_PATTERNS = [
+    /\bplease confirm\b/i,
+    /\bconfirm and i(?:'|’)ll\b/i,
+    /\bmay i proceed\b/i,
+    /\bshould i proceed\b/i,
+    /\bwould you like me to proceed\b/i,
+    /\bwant me to proceed\b/i,
+    /\bdo you want me to proceed\b/i,
+    /\bask for your approval\b/i,
+    /\bneed your approval\b/i,
+    /\bpermission\b/i,
+];
+const SPECIALIZED_TOOL_NAMES = new Set([
+    "read_symbol",
+    "find_references",
+    "get_dependencies",
+    "search_code_map",
+    "find_path",
+]);
+const FILE_READ_TOOL_NAMES = new Set(["read_file"]);
+const SEARCH_TOOL_NAMES = new Set(["search"]);
+const MUTATION_TOOL_NAMES = new Set(["edit_file", "write_file"]);
+const COMMAND_TOOL_NAMES = new Set(["run_command"]);
+const REPEATED_TOOL_CALL_STOP_TEXT = "Stopped due to repeated identical tool calls";
+export function getBenchmarkSystemPromptSuffix() {
+    return BENCHMARK_SYSTEM_PROMPT_SUFFIX;
+}
+export function isBenchmarkApprovalSeekingResponse(text) {
+    if (text.trim().length === 0) {
+        return false;
+    }
+    return CONFIRMATION_REQUEST_PATTERNS.some((pattern) => pattern.test(text));
+}
+function stableSerialize(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableSerialize(entryValue)}`);
+        return `{${entries.join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function signatureForToolCall(toolCall) {
+    return `${toolCall.name}:${stableSerialize(toolCall.input)}`;
+}
+export function buildBenchmarkToolTrace(messages) {
+    const toolResults = new Map();
+    for (const message of messages) {
+        if (message.role === "tool") {
+            toolResults.set(message.toolCallId, message.content);
+        }
+    }
+    const traces = [];
+    let step = 0;
+    for (const message of messages) {
+        if (message.role !== "assistant" || !message.toolCalls?.length) {
+            continue;
+        }
+        step += 1;
+        for (const toolCall of message.toolCalls) {
+            const result = toolResults.get(toolCall.id) ?? null;
+            traces.push({
+                step,
+                name: toolCall.name,
+                input: toolCall.input,
+                result,
+                skipped: result?.startsWith("Tool skipped:") ?? false,
+            });
+        }
+    }
+    return traces;
+}
+export function summarizeBenchmarkToolUsage(toolCalls, finalText) {
+    const byName = {};
+    const specializedByName = {};
+    const repeatedCounts = new Map();
+    let specializedTotal = 0;
+    let fileReadTotal = 0;
+    let searchTotal = 0;
+    let mutationTotal = 0;
+    let commandTotal = 0;
+    let skippedTotal = 0;
+    for (const toolCall of toolCalls) {
+        byName[toolCall.name] = (byName[toolCall.name] ?? 0) + 1;
+        if (SPECIALIZED_TOOL_NAMES.has(toolCall.name)) {
+            specializedTotal += 1;
+            specializedByName[toolCall.name] = (specializedByName[toolCall.name] ?? 0) + 1;
+        }
+        if (FILE_READ_TOOL_NAMES.has(toolCall.name)) {
+            fileReadTotal += 1;
+        }
+        if (SEARCH_TOOL_NAMES.has(toolCall.name)) {
+            searchTotal += 1;
+        }
+        if (MUTATION_TOOL_NAMES.has(toolCall.name)) {
+            mutationTotal += 1;
+        }
+        if (COMMAND_TOOL_NAMES.has(toolCall.name)) {
+            commandTotal += 1;
+        }
+        if (toolCall.skipped) {
+            skippedTotal += 1;
+        }
+        const signature = signatureForToolCall(toolCall);
+        const existing = repeatedCounts.get(signature);
+        if (existing) {
+            existing.count += 1;
+        }
+        else {
+            repeatedCounts.set(signature, {
+                name: toolCall.name,
+                input: toolCall.input,
+                count: 1,
+            });
+        }
+    }
+    return {
+        total: toolCalls.length,
+        byName,
+        specializedTotal,
+        specializedByName,
+        fileReadTotal,
+        searchTotal,
+        mutationTotal,
+        commandTotal,
+        skippedTotal,
+        repeatedStop: finalText.includes(REPEATED_TOOL_CALL_STOP_TEXT) ||
+            toolCalls.some((toolCall) => toolCall.result?.includes(REPEATED_TOOL_CALL_STOP_TEXT)),
+        repeatedToolCalls: [...repeatedCounts.values()]
+            .filter((entry) => entry.count > 1)
+            .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)),
+    };
+}
+function readFlagValue(args, index, flagName) {
+    const next = args[index + 1];
+    if (!next || next.startsWith("-")) {
+        throw new CliUsageError(`${flagName} requires a value.`);
+    }
+    return { value: next, nextIndex: index + 1 };
+}
+export function parseBenchmarkRunArgs(argv) {
+    const envFiles = [];
+    const promptParts = [];
+    let promptFile;
+    let configPath;
+    let provider;
+    let model;
+    let baseUrl;
+    let workspaceRoot;
+    let diffOut;
+    let outFile;
+    let verbose = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined) {
+            continue;
+        }
+        if (arg === "--verbose" || arg === "-v") {
+            verbose = true;
+            continue;
+        }
+        if (arg === "--config") {
+            const parsed = readFlagValue(argv, i, "--config");
+            configPath = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--config=")) {
+            configPath = arg.slice("--config=".length).trim();
+            continue;
+        }
+        if (arg === "--env-file") {
+            const parsed = readFlagValue(argv, i, "--env-file");
+            envFiles.push(parsed.value);
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--env-file=")) {
+            envFiles.push(arg.slice("--env-file=".length).trim());
+            continue;
+        }
+        if (arg === "--provider") {
+            const parsed = readFlagValue(argv, i, "--provider");
+            provider = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--provider=")) {
+            provider = arg.slice("--provider=".length).trim();
+            continue;
+        }
+        if (arg === "--model") {
+            const parsed = readFlagValue(argv, i, "--model");
+            model = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            model = arg.slice("--model=".length).trim();
+            continue;
+        }
+        if (arg === "--base-url") {
+            const parsed = readFlagValue(argv, i, "--base-url");
+            baseUrl = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--base-url=")) {
+            baseUrl = arg.slice("--base-url=".length).trim();
+            continue;
+        }
+        if (arg === "--workspace-root") {
+            const parsed = readFlagValue(argv, i, "--workspace-root");
+            workspaceRoot = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--workspace-root=")) {
+            workspaceRoot = arg.slice("--workspace-root=".length).trim();
+            continue;
+        }
+        if (arg === "--diff-out") {
+            const parsed = readFlagValue(argv, i, "--diff-out");
+            diffOut = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--diff-out=")) {
+            diffOut = arg.slice("--diff-out=".length).trim();
+            continue;
+        }
+        if (arg === "--out") {
+            const parsed = readFlagValue(argv, i, "--out");
+            outFile = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--out=")) {
+            outFile = arg.slice("--out=".length).trim();
+            continue;
+        }
+        if (arg === "--prompt-file") {
+            const parsed = readFlagValue(argv, i, "--prompt-file");
+            promptFile = parsed.value;
+            i = parsed.nextIndex;
+            continue;
+        }
+        if (arg.startsWith("--prompt-file=")) {
+            promptFile = arg.slice("--prompt-file=".length).trim();
+            continue;
+        }
+        promptParts.push(arg);
+    }
+    if (promptFile && promptParts.length > 0) {
+        throw new CliUsageError("Provide either prompt text or --prompt-file, not both.");
+    }
+    return {
+        prompt: promptParts.join(" ").trim(),
+        ...(promptFile ? { promptFile } : {}),
+        ...(configPath ? { configPath } : {}),
+        envFiles,
+        ...(provider ? { provider } : {}),
+        ...(model ? { model } : {}),
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(workspaceRoot ? { workspaceRoot } : {}),
+        ...(diffOut ? { diffOut } : {}),
+        ...(outFile ? { outFile } : {}),
+        verbose,
+    };
+}
+async function resolvePrompt(args, cwd) {
+    if (args.promptFile) {
+        const promptFilePath = path.resolve(cwd, args.promptFile);
+        return (await readFile(promptFilePath, "utf8")).trim();
+    }
+    return args.prompt;
+}
+function createBenchmarkAgent(params) {
+    return new CodingAgent({
+        config: params.config,
+        modelClient: params.modelClient,
+        toolRegistry: params.toolRegistry,
+        verbose: params.verbose,
+        getSystemPromptSuffix: () => getBenchmarkSystemPromptSuffix(),
+        ...(params.projectIndex !== undefined
+            ? {
+                getCodeMap: (focusSymbols) => params.projectIndex.getCodeMap(undefined, focusSymbols),
+            }
+            : {}),
+    });
+}
+async function runBenchmarkAttempt(prompt, params) {
+    const agent = createBenchmarkAgent(params);
+    const result = await agent.runTurn(prompt);
+    return {
+        ...result,
+        messages: agent.getSession().getMessages(),
+    };
+}
+export async function runBenchmarkCommand(argv) {
+    const cwd = process.cwd();
+    const args = parseBenchmarkRunArgs(argv);
+    const prompt = await resolvePrompt(args, cwd);
+    if (prompt.length === 0) {
+        throw new CliUsageError("benchmark run requires prompt text or --prompt-file. Example: minicode benchmark run --prompt-file prompt.txt");
+    }
+    const benchmarkOptions = {
+        cwd,
+        envFiles: args.envFiles,
+        env: process.env,
+        ...(args.configPath ? { configPath: args.configPath } : {}),
+    };
+    const resolvedEnv = await resolveBenchmarkEnv(benchmarkOptions);
+    const config = await buildBenchmarkAgentConfig({
+        ...benchmarkOptions,
+        overrides: {
+            ...(args.provider ? { provider: args.provider } : {}),
+            ...(args.model ? { model: args.model } : {}),
+            ...(args.baseUrl ? { baseUrl: args.baseUrl } : {}),
+            ...(args.workspaceRoot ? { workspaceRoot: args.workspaceRoot } : {}),
+        },
+    });
+    const previousAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
+    if (resolvedEnv.values.ANTHROPIC_API_KEY !== undefined) {
+        process.env.ANTHROPIC_API_KEY = resolvedEnv.values.ANTHROPIC_API_KEY;
+    }
+    try {
+        const setupMessage = getConfigSetupMessage(config);
+        if (setupMessage) {
+            throw new CliUsageError(`${setupMessage}\n\nBenchmark mode does not read ~/.minicode/.env unless you pass it explicitly with --env-file.`);
+        }
+        const modelClient = createModelClient(config);
+        let projectIndex;
+        try {
+            projectIndex = await buildProjectIndex(config.workspaceRoot);
+        }
+        catch {
+            projectIndex = undefined;
+        }
+        const toolRegistry = createToolRegistry(config, projectIndex);
+        const startedAt = new Date().toISOString();
+        const started = performance.now();
+        let attempt = await runBenchmarkAttempt(prompt, {
+            config,
+            modelClient,
+            toolRegistry,
+            verbose: args.verbose,
+            ...(projectIndex !== undefined ? { projectIndex } : {}),
+        });
+        if (isBenchmarkApprovalSeekingResponse(attempt.text)) {
+            if (args.verbose) {
+                console.error("[benchmark] Model asked for confirmation; retrying once with a non-interactive reminder.");
+            }
+            attempt = await runBenchmarkAttempt(`${prompt}\n\n${BENCHMARK_RETRY_REMINDER}`, {
+                config,
+                modelClient,
+                toolRegistry,
+                verbose: args.verbose,
+                ...(projectIndex !== undefined ? { projectIndex } : {}),
+            });
+        }
+        const durationMs = performance.now() - started;
+        const completedAt = new Date().toISOString();
+        const changes = await collectWorkspaceChanges(config.workspaceRoot);
+        let diffOutPath;
+        if (args.diffOut) {
+            diffOutPath = path.resolve(cwd, args.diffOut);
+            await writeWorkspaceDiff(config.workspaceRoot, diffOutPath);
+        }
+        const toolCalls = buildBenchmarkToolTrace(attempt.messages);
+        const result = {
+            text: attempt.text,
+            usage: attempt.usage ?? null,
+            durationMs,
+            startedAt,
+            completedAt,
+            workspaceRoot: config.workspaceRoot,
+            provider: config.modelProvider,
+            model: config.model,
+            openAiBaseUrl: config.openAiBaseUrl,
+            isGitRepo: changes.isGitRepo,
+            changedFiles: changes.changedFiles,
+            ...(diffOutPath ? { diffOut: diffOutPath } : {}),
+            toolCalls,
+            toolUsage: summarizeBenchmarkToolUsage(toolCalls, attempt.text),
+        };
+        const payload = JSON.stringify(result, null, 2);
+        if (args.outFile) {
+            const outPath = path.resolve(cwd, args.outFile);
+            await mkdir(path.dirname(outPath), { recursive: true });
+            await writeFile(outPath, payload + "\n", "utf8");
+        }
+        else {
+            console.log(payload);
+        }
+    }
+    finally {
+        if (previousAnthropicApiKey === undefined) {
+            delete process.env.ANTHROPIC_API_KEY;
+        }
+        else {
+            process.env.ANTHROPIC_API_KEY = previousAnthropicApiKey;
+        }
+    }
+}

package/dist/src/cli/permissions-slash-command.js

@@ -0,0 +1,50 @@
+import { AUTO_ALLOW_MODES, isAutoAllowMode, } from "../auto-allow.js";
+const MODE_LIST = AUTO_ALLOW_MODES.join("|");
+const HELP = `Usage: /permissions auto ${MODE_LIST}\n` +
+    "\n" +
+    "  none      prompt for every write_file, edit_file, and run_command call (default)\n" +
+    "  writes    auto-allow write_file and edit_file; still prompt for run_command\n" +
+    "  commands  auto-allow run_command; still prompt for write_file and edit_file\n" +
+    "  all       auto-allow every gated tool (YOLO)\n" +
+    "\n" +
+    "Or: /permissions status  (show current mode).";
+function describeMode(mode) {
+    switch (mode) {
+        case "none":
+            return "Auto-allow is OFF. You'll be prompted before every write_file, edit_file, and run_command.";
+        case "writes":
+            return "Auto-allow is set to WRITES. write_file and edit_file run without prompting; run_command still prompts.";
+        case "commands":
+            return "Auto-allow is set to COMMANDS. run_command runs without prompting; write_file and edit_file still prompt.";
+        case "all":
+            return "Auto-allow is set to ALL. Every gated tool runs without prompting (YOLO).";
+    }
+}
+/**
+ * Handle the `/permissions` slash command, used to view and set the
+ * per-session auto-allow mode. Returns `{ handled: false }` for any
+ * input that isn't a permissions command.
+ */
+export function handlePermissionsSlashCommand(input, store) {
+    const trimmed = input.trim();
+    if (trimmed !== "/permissions" && !trimmed.startsWith("/permissions ")) {
+        return { handled: false };
+    }
+    const args = trimmed
+        .slice("/permissions".length)
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+    if (args.length === 0 || args[0] === "status") {
+        return { handled: true, message: describeMode(store.getAutoAllowMode()) };
+    }
+    if (args[0] === "auto") {
+        const value = args[1];
+        if (isAutoAllowMode(value)) {
+            store.setAutoAllowMode(value);
+            return { handled: true, message: describeMode(value) };
+        }
+        return { handled: true, message: HELP };
+    }
+    return { handled: true, message: HELP };
+}

package/dist/src/index.js

@@ -117,9 +117,10 @@ async function runInteractive(verbose, initialTask) {
         if (trimmed === "/compact") {
             const session = agent.getSession();
             const tokensBefore = session.getTokenEstimate();
-            const result = session.compact(config.keepRecentMessages);
+            const result = await agent.compactContext();
             if (result) {
-                console.log(`Compacted: ${result.removedMessages} messages summarized, ` +
+                const method = result.method === "llm" ? "LLM" : "mechanical";
+                console.log(`Compacted (${method}): ${result.removedMessages} messages summarized, ` +
                     `${result.previousTokens} → ${result.newTokens} tokens ` +
                     `(saved ${result.previousTokens - result.newTokens} tokens)`);
             }
@@ -280,6 +281,12 @@ async function main() {
         await installPlugin();
         return;
     }
+    if (cliArgs.benchmarkRun) {
+        const { runBenchmarkCommand } = await import("./cli/benchmark-run.js");
+        await runBenchmarkCommand(cliArgs.benchmarkArgv ?? []);
+        process.exitCode = EXIT_CODE_SUCCESS;
+        return;
+    }
     if (cliArgs.serve) {
         const { runServe } = await import("./serve/server.js");
         await runServe(cliArgs.verbose, cliArgs.port);

package/dist/src/indexer/plugin-loader.js

@@ -1,16 +1,34 @@
 import { typescriptPlugin } from "./plugins/typescript.js";
 /**
  * Load all available language plugins.
- * Built-in: TypeScript.
+ * Built-in: TypeScript, Python.
  * Also loads: npm packages (minicode-plugin-*), local plugins (.minicode/plugins/).
  */
 export async function loadPlugins(workspaceRoot) {
     const plugins = [];
     plugins.push(typescriptPlugin);
+    await loadPythonPlugin(plugins);
     await loadNpmPlugins(workspaceRoot, plugins);
     await loadLocalPlugins(workspaceRoot, plugins);
     return plugins;
 }
+/**
+ * Load the built-in Python plugin via dynamic import so a missing native
+ * dependency (e.g. failed `node-gyp` build for `tree-sitter`) degrades
+ * gracefully: Python files simply won't be indexed, but the rest of
+ * minicode keeps working.
+ */
+async function loadPythonPlugin(plugins) {
+    try {
+        const mod = await import("minicode-plugin-python");
+        if (mod.pythonPlugin)
+            plugins.push(mod.pythonPlugin);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn(`[warn] Python plugin failed to load (Python files will not be indexed): ${message}`);
+    }
+}
 async function loadNpmPlugins(workspaceRoot, plugins) {
     const path = await import("node:path");
     const { readFile } = await import("node:fs/promises");

package/dist/src/indexer/project-index.js

@@ -22,6 +22,14 @@ async function collectSourceFiles(dir, root, files, validExtensions) {
         }
     }
 }
+function filterFilesForPlugin(projectFiles, plugin) {
+    const out = new Map();
+    for (const [filePath, content] of projectFiles) {
+        if (plugin.canIndex(filePath))
+            out.set(filePath, content);
+    }
+    return out;
+}
 function buildAdjacencyFrom(edges) {
     const map = new Map();
     for (const edge of edges) {
@@ -75,16 +83,20 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
             symbols.set(qualifiedName, symbol);
         }
     }
-    function rebuildDependencyEdges() {
+    async function rebuildDependencyEdges() {
+        const allSymbols = [...symbols.values()];
+        const collected = [];
         for (const p of plugins) {
-            if (p.resolveDependencies) {
-                const allSymbols = [...symbols.values()];
-                const edges = p.resolveDependencies(allSymbols, projectFiles);
-                dependencyEdges.splice(0, dependencyEdges.length, ...edges);
-                adjacencyFrom = buildAdjacencyFrom(dependencyEdges);
-                break;
-            }
+            if (!p.resolveDependencies)
+                continue;
+            const pluginFiles = filterFilesForPlugin(projectFiles, p);
+            if (pluginFiles.size === 0)
+                continue;
+            const edges = await p.resolveDependencies(allSymbols, pluginFiles);
+            collected.push(...edges);
         }
+        dependencyEdges.splice(0, dependencyEdges.length, ...collected);
+        adjacencyFrom = buildAdjacencyFrom(dependencyEdges);
     }
     async function refreshFromWorkspace() {
         const validExtensions = new Set(plugins.flatMap((p) => p.extensions));
@@ -105,11 +117,11 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
                 continue;
             }
             projectFiles.set(relPath, content);
-            const extracted = plugin.indexFile(relPath, content);
+            const extracted = await plugin.indexFile(relPath, content);
             files.set(relPath, extracted);
         }
         rebuildSymbolsMap();
-        rebuildDependencyEdges();
+        await rebuildDependencyEdges();
     }
     return {
         symbols,
@@ -257,7 +269,7 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
         getCodeMap(tokenBudget, focusSymbols) {
             return generateCodeMap(files, tokenBudget, dependencyEdges, focusSymbols);
         },
-        reindexFile(filePath, content) {
+        async reindexFile(filePath, content) {
             const relPath = path.isAbsolute(filePath)
                 ? path.relative(workspaceRoot, filePath)
                 : path.normalize(filePath);
@@ -266,10 +278,10 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
                 return;
             files.delete(relPath);
             projectFiles.set(relPath, content);
-            const extracted = plugin.indexFile(relPath, content);
+            const extracted = await plugin.indexFile(relPath, content);
             files.set(relPath, extracted);
             rebuildSymbolsMap();
-            rebuildDependencyEdges();
+            await rebuildDependencyEdges();
         },
         refreshFromWorkspace,
     };
@@ -299,7 +311,7 @@ export async function buildProjectIndex(workspaceRoot) {
             continue;
         }
         projectFiles.set(relPath, content);
-        const extracted = plugin.indexFile(relPath, content);
+        const extracted = await plugin.indexFile(relPath, content);
         files.set(relPath, extracted);
     }
     const normalizedSymbols = normalizeIndexedSymbols(files);
@@ -307,14 +319,16 @@ export async function buildProjectIndex(workspaceRoot) {
     for (const [qualifiedName, symbol] of normalizedSymbols) {
         symbols.set(qualifiedName, symbol);
     }
-    let dependencyEdges = [];
+    const allSymbols = [...symbols.values()];
+    const dependencyEdges = [];
     for (const plugin of plugins) {
-        if (plugin.resolveDependencies) {
-            const allSymbols = [...symbols.values()];
-            const edges = plugin.resolveDependencies(allSymbols, projectFiles);
-            dependencyEdges = edges;
-            break;
-        }
+        if (!plugin.resolveDependencies)
+            continue;
+        const pluginFiles = filterFilesForPlugin(projectFiles, plugin);
+        if (pluginFiles.size === 0)
+            continue;
+        const edges = await plugin.resolveDependencies(allSymbols, pluginFiles);
+        dependencyEdges.push(...edges);
     }
     return createProjectIndex(symbols, files, dependencyEdges, plugins, projectFiles, root);
 }