vexp-cli 1.2.12

package/dist/agent-config.js

@@ -0,0 +1,791 @@
+/**
+ * Agent auto-detection and configuration for the vexp CLI.
+ *
+ * Ported from packages/vexp-vscode/src/providers/agent-auto-config.ts
+ * with VS Code dependencies removed. Uses the Rust binary path
+ * (`~/.vexp/bin/vexp-core mcp`) as the MCP command instead of
+ * `node <mcp-server.cjs>`.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const VEXP_MARKER_RE = /<!-- vexp(?:\s+v[\d.]+)? -->/;
+const VEXP_MARKER_END = "<!-- /vexp -->";
+// All vexp MCP tools (all read-only — safe to pre-approve).
+const VEXP_TOOLS = [
+    "get_context_capsule",
+    "get_impact_graph",
+    "search_logic_flow",
+    "get_skeleton",
+    "index_status",
+    "workspace_setup",
+    "submit_lsp_edges",
+    "get_session_context",
+    "search_memory",
+    "save_observation",
+];
+// ---------------------------------------------------------------------------
+// Agent detectors — mirrors VS Code extension's AGENT_DETECTORS
+// ---------------------------------------------------------------------------
+const AGENT_DETECTORS = [
+    {
+        agent: "Claude Code",
+        detectPath: ".claude",
+        configFile: ".claude/CLAUDE.md",
+        templateName: "claude-code",
+        // MCP configured in ~/.claude.json (user-scope) via configureClaudeCodeGlobal()
+    },
+    {
+        agent: "Cursor",
+        detectPath: ".cursor",
+        configFile: ".cursor/rules",
+        templateName: "cursor",
+        mcpConfigFile: ".cursor/mcp.json",
+    },
+    {
+        agent: "Windsurf",
+        detectPath: ".windsurf",
+        configFile: ".windsurf/rules.md",
+        templateName: "windsurf",
+        mcpConfigFile: ".windsurf/mcp.json",
+    },
+    {
+        agent: "Continue.dev",
+        detectPath: ".continue",
+        configFile: ".continue/config.json",
+        templateName: "continue",
+    },
+    {
+        agent: "Augment",
+        detectPath: ".augment",
+        configFile: ".augment/guidelines.md",
+        templateName: "augment",
+    },
+    {
+        agent: "GitHub Copilot",
+        detectPath: ".github",
+        configFile: ".github/copilot-instructions.md",
+        templateName: "copilot",
+    },
+    {
+        agent: "Zed",
+        detectPath: ".zed",
+        configFile: ".zed/rules.md",
+        templateName: "zed",
+    },
+    {
+        agent: "Codex",
+        detectPath: "AGENTS.md",
+        configFile: "AGENTS.md",
+        templateName: "agents-md",
+    },
+    {
+        agent: "Opencode",
+        detectPath: "opencode.json",
+        configFile: "AGENTS.md",
+        templateName: "agents-md",
+    },
+    {
+        agent: "Kilo Code",
+        detectPath: ".kilocode",
+        configFile: ".kilocode/rules.md",
+        templateName: "generic",
+    },
+    {
+        agent: "Kiro",
+        detectPath: ".kiro",
+        configFile: ".kiro/steering/vexp.md",
+        templateName: "kiro",
+    },
+    {
+        agent: "Antigravity",
+        detectPath: ".antigravity",
+        configFile: ".antigravity/rules.md",
+        templateName: "generic",
+    },
+];
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Detect which AI coding agents are present in the workspace.
+ */
+export function detectAgents(workspaceRoot) {
+    return AGENT_DETECTORS.filter((d) => {
+        const absPath = path.join(workspaceRoot, d.detectPath);
+        return fs.existsSync(absPath);
+    });
+}
+/**
+ * Configure all detected agents: write instruction files + MCP configs.
+ * If `agentFilter` is provided, only configure those agents.
+ */
+export function configureAgents(workspaceRoot, binaryPath, version, agentFilter) {
+    const results = [];
+    const mcpConfigs = [];
+    const writtenConfigFiles = new Set();
+    let agents = detectAgents(workspaceRoot);
+    if (agentFilter && agentFilter.length > 0) {
+        const filter = agentFilter.map((a) => a.toLowerCase());
+        agents = agents.filter((d) => filter.includes(d.agent.toLowerCase()));
+    }
+    for (const detector of agents) {
+        const configFilePath = path.join(workspaceRoot, detector.configFile);
+        const alreadyExists = fs.existsSync(configFilePath);
+        const content = generateAgentConfig(detector.templateName, {
+            workspaceRoot,
+            binaryPath,
+            configFile: detector.configFile,
+            version,
+        });
+        // Write instruction file (deduplicated by configFile path)
+        let action = "skipped";
+        if (!writtenConfigFiles.has(detector.configFile)) {
+            if (detector.templateName === "continue") {
+                const continuePayload = {
+                    customCommands: [
+                        {
+                            name: "vexp-context",
+                            description: "Get vexp context capsule for current task",
+                            prompt: "{{{ input }}}\n\nFirst, call get_context_capsule with the above task description.",
+                        },
+                    ],
+                    contextProviders: [
+                        {
+                            name: "vexp",
+                            params: {},
+                        },
+                    ],
+                    mcpServers: [
+                        {
+                            name: "vexp",
+                            command: binaryPath,
+                            args: ["mcp"],
+                            type: "stdio",
+                        },
+                    ],
+                };
+                const mergeResult = mergeJsonConfig(configFilePath, continuePayload, version);
+                action = mergeResult === "merged" ? "updated" : "skipped";
+            }
+            else {
+                action = appendOrCreate(configFilePath, content, version);
+            }
+            writtenConfigFiles.add(detector.configFile);
+        }
+        // Write MCP config JSON (Cursor, Windsurf)
+        if (detector.mcpConfigFile) {
+            const mcpConfigPath = path.join(workspaceRoot, detector.mcpConfigFile);
+            const alwaysAllow = detector.agent === "Windsurf" ? VEXP_TOOLS : undefined;
+            if (writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow)) {
+                mcpConfigs.push(detector.mcpConfigFile);
+            }
+        }
+        // Claude Code: configure MCP in ~/.claude.json (user-scope, stdio)
+        if (detector.agent === "Claude Code") {
+            const wrote = configureClaudeCodeGlobal(binaryPath);
+            if (wrote)
+                mcpConfigs.push("~/.claude.json");
+        }
+        // GitHub Copilot: VS Code format (.vscode/mcp.json with "servers" key)
+        if (detector.agent === "GitHub Copilot") {
+            const mcpPath = path.join(workspaceRoot, ".vscode/mcp.json");
+            if (writeVsCodeMcpConfig(mcpPath, binaryPath)) {
+                mcpConfigs.push(".vscode/mcp.json");
+            }
+        }
+        // Zed: context_servers in .zed/settings.json
+        if (detector.agent === "Zed") {
+            const zedPath = path.join(workspaceRoot, ".zed/settings.json");
+            if (writeZedMcpConfig(zedPath, binaryPath)) {
+                mcpConfigs.push(".zed/settings.json");
+            }
+        }
+        results.push({
+            agent: detector.agent,
+            configFile: detector.configFile,
+            content,
+            alreadyExists,
+            action,
+        });
+    }
+    return { agents: results, mcpConfigs };
+}
+// ---------------------------------------------------------------------------
+// File helpers — ported from agent-auto-config.ts
+// ---------------------------------------------------------------------------
+function appendOrCreate(filePath, content, version) {
+    if (!fs.existsSync(filePath)) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content, "utf-8");
+        return "created";
+    }
+    const existing = fs.readFileSync(filePath, "utf-8");
+    const markerMatch = existing.match(VEXP_MARKER_RE);
+    if (!markerMatch) {
+        fs.appendFileSync(filePath, "\n\n" + content);
+        return "appended";
+    }
+    const versionMatch = markerMatch[0].match(/v([\d.]+)/);
+    if (versionMatch && versionMatch[1] === version)
+        return "skipped";
+    const startIdx = existing.indexOf(markerMatch[0]);
+    const endIdx = existing.indexOf(VEXP_MARKER_END);
+    if (endIdx !== -1) {
+        const before = existing.substring(0, startIdx);
+        const after = existing.substring(endIdx + VEXP_MARKER_END.length);
+        fs.writeFileSync(filePath, before + content + after, "utf-8");
+    }
+    else {
+        const before = existing.substring(0, startIdx);
+        fs.writeFileSync(filePath, before + content, "utf-8");
+    }
+    return "updated";
+}
+function mergeJsonConfig(filePath, mergePayload, version) {
+    let existing = {};
+    if (fs.existsSync(filePath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            // Malformed JSON: overwrite
+        }
+    }
+    const existingVersion = existing.__vexp_version ?? (existing.__vexp ? "0.0.0" : undefined);
+    if (existingVersion === version)
+        return "skipped";
+    for (const [key, value] of Object.entries(mergePayload)) {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            existing[key] = {
+                ...(existing[key] ?? {}),
+                ...value,
+            };
+        }
+        else if (Array.isArray(value) && Array.isArray(existing[key])) {
+            existing[key] = [...existing[key], ...value];
+        }
+        else {
+            existing[key] = value;
+        }
+    }
+    delete existing.__vexp;
+    existing.__vexp_version = version;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(existing, null, 2), "utf-8");
+    return "merged";
+}
+// ---------------------------------------------------------------------------
+// MCP config writers — adapted for Rust binary path
+// ---------------------------------------------------------------------------
+/**
+ * Write MCP config JSON for agents that use mcpServers format (Cursor, Windsurf).
+ * Returns true if a new entry was written.
+ */
+function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow) {
+    let existing = {};
+    if (fs.existsSync(mcpConfigPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
+        }
+        catch {
+            // Malformed JSON: overwrite
+        }
+    }
+    const servers = existing.mcpServers;
+    if (servers && "vexp" in servers)
+        return false;
+    existing.mcpServers = {
+        ...(servers ?? {}),
+        vexp: {
+            command: binaryPath,
+            args: ["mcp"],
+            ...(alwaysAllow && alwaysAllow.length > 0 ? { alwaysAllow } : {}),
+        },
+    };
+    fs.mkdirSync(path.dirname(mcpConfigPath), { recursive: true });
+    fs.writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2), "utf-8");
+    return true;
+}
+/**
+ * Write .vscode/mcp.json for GitHub Copilot.
+ * VS Code uses "servers" (not "mcpServers") + "type": "stdio".
+ */
+function writeVsCodeMcpConfig(p, binaryPath) {
+    let existing = {};
+    if (fs.existsSync(p)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(p, "utf-8"));
+        }
+        catch {
+            // Malformed JSON: overwrite
+        }
+    }
+    const servers = existing.servers;
+    if (servers && "vexp" in servers)
+        return false;
+    existing.servers = {
+        ...(servers ?? {}),
+        vexp: { type: "stdio", command: binaryPath, args: ["mcp"] },
+    };
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(existing, null, 2), "utf-8");
+    return true;
+}
+/**
+ * Write context_servers in .zed/settings.json for Zed.
+ */
+function writeZedMcpConfig(p, binaryPath) {
+    let settings = {};
+    if (fs.existsSync(p)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(p, "utf-8"));
+        }
+        catch {
+            // Malformed JSON: overwrite
+        }
+    }
+    const cs = settings.context_servers;
+    if (cs && "vexp" in cs)
+        return false;
+    settings.context_servers = {
+        ...(cs ?? {}),
+        vexp: { command: { path: binaryPath, args: ["mcp"] } },
+    };
+    // Pre-approve all vexp tools
+    const agent = (settings.agent ?? {});
+    const tp = (agent.tool_permissions ?? {});
+    const tools = (tp.tools ?? {});
+    for (const tool of VEXP_TOOLS) {
+        tools[`mcp:vexp:${tool}`] = { default: "allow" };
+    }
+    settings.agent = { ...agent, tool_permissions: { ...tp, tools } };
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
+    return true;
+}
+/**
+ * Configure vexp MCP in ~/.claude.json (user-scope) using the Rust binary.
+ * Returns true if config was written/updated.
+ */
+function configureClaudeCodeGlobal(binaryPath) {
+    const home = os.homedir();
+    if (!home)
+        return false;
+    const configPath = path.join(home, ".claude.json");
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        }
+        catch {
+            // Malformed JSON: overwrite
+        }
+    }
+    const servers = config.mcpServers;
+    const existing = servers?.["vexp"];
+    // Skip if already configured with this exact binary path
+    if (existing?.["command"] === binaryPath &&
+        Array.isArray(existing?.["args"]) &&
+        existing["args"].includes("mcp")) {
+        return false;
+    }
+    config.mcpServers = {
+        ...(servers ?? {}),
+        vexp: {
+            command: binaryPath,
+            args: ["mcp"],
+        },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    return true;
+}
+function generateAgentConfig(template, vars) {
+    switch (template) {
+        case "claude-code":
+            return claudeCodeTemplate(vars);
+        case "cursor":
+            return cursorTemplate(vars);
+        case "windsurf":
+            return windsurfTemplate(vars);
+        case "continue":
+            return continueTemplate(vars);
+        case "augment":
+            return augmentTemplate(vars);
+        case "copilot":
+            return copilotTemplate(vars);
+        case "zed":
+            return zedTemplate(vars);
+        case "agents-md":
+            return agentsMdTemplate(vars);
+        case "kiro":
+            return kiroTemplate(vars);
+        default:
+            return genericTemplate(vars);
+    }
+}
+// ---------------------------------------------------------------------------
+// Templates — copied verbatim from agent-auto-config.ts
+// ---------------------------------------------------------------------------
+function claudeCodeTemplate(vars) {
+    return `## vexp — Context-Aware AI Coding <!-- vexp v${vars.version} -->
+
+### MANDATORY: use vexp MCP tools before ANYTHING else
+For every task — questions, bug fixes, features, exploration:
+**call the \`get_context_capsule\` MCP tool first**.
+
+Do NOT use grep, glob, Bash, or Read to search/explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+### Available MCP tools (invoke via tool interface, NOT via HTTP or bash)
+- \`get_context_capsule\` — most relevant code for your task or question (ALWAYS FIRST)
+- \`get_impact_graph\` — what breaks if you change a symbol
+- \`search_logic_flow\` — execution paths between functions
+- \`get_skeleton\` — token-efficient file structure
+- \`index_status\` — indexing status and health check
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`submit_lsp_edges\` — submit type-resolved call edges (used by VS Code extension)
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions, insights, and explored code
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Smart Features (automatic — no action needed)
+- **Intent Detection**: vexp auto-detects query intent from your prompt keywords.
+  "fix bug" → Debug mode (follows error paths), "refactor" → blast-radius mode,
+  "add feature" → Modify mode, default → Read mode. Each mode optimizes result ranking.
+- **Hybrid Search**: combines keyword matching (FTS) + semantic similarity (TF-IDF) + graph
+  centrality for better results. Finds \`validateCredentials\` when searching "authentication".
+- **Session Memory**: every tool call is auto-captured as an observation. Relevant memories
+  from previous sessions are auto-surfaced inside \`get_context_capsule\` results. Observations
+  linked to code symbols are auto-flagged stale when that code changes.
+- **Feedback Loop**: repeated queries with similar terms auto-expand the result budget.
+- **LSP Bridge**: VS Code captures type-resolved call edges for high-confidence call graphs.
+- **Change Coupling**: files modified together in git history are included as related context.
+- **Context Lineage**: frequently modified code gets a boost in relevance ranking.
+
+### Workflow
+1. \`get_context_capsule("your task or question")\` — ALWAYS FIRST (includes relevant memories)
+2. Read the pivot files returned (full content)
+3. Review supporting skeletons for broader context
+4. Make targeted changes based on the context
+5. \`get_impact_graph\` before refactoring to verify no regressions
+6. \`save_observation\` to persist important decisions with code symbol links
+7. \`search_memory\` or \`get_session_context\` to recall past work
+
+### Advanced Parameters
+- \`include_tests: true\` — include test files (useful for debugging)
+- \`max_tokens: 12000\` — increase token budget for complex tasks
+- \`pivot_depth: 3\` — deeper graph traversal for broad exploration
+- \`skeleton_detail: "detailed"\` — more verbose skeletons
+
+### Multi-Repo Workspaces
+When multiple repos are indexed (monorepos, frontend+backend, microservices):
+- \`get_context_capsule\` queries **all repos** automatically — results show repo alias per file
+- Use \`repos: ["alias"]\` to restrict queries to specific repos
+- Use \`cross_repo: true\` on \`get_impact_graph\` and \`search_logic_flow\` to trace across repo boundaries
+- Use \`index_status\` to discover available repo aliases
+- \`get_skeleton\` accepts \`repo: "alias"\` to target a specific repo's files
+<!-- /vexp -->`;
+}
+function cursorTemplate(vars) {
+    return `## vexp rules for Cursor <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+### Workflow
+1. \`get_context_capsule\` with your task description — ALWAYS FIRST
+2. Review the provided pivot files and skeletons
+3. Make targeted changes based on the context
+4. \`get_impact_graph\` before refactoring exported symbols
+
+### Available MCP tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent: "fix bug" → debug mode, "refactor" → blast-radius mode
+- \`get_impact_graph\` — what breaks if you change a symbol
+- \`search_logic_flow\` — execution paths between functions
+- \`get_skeleton\` — token-efficient file structure
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Tips
+- vexp uses hybrid search (keywords + semantic similarity + graph centrality) — natural language queries work well
+- Add \`include_tests: true\` when debugging to include test files in results
+- Repeated queries auto-expand result budget via feedback loop
+- Session memory auto-captures observations; use \`save_observation\` for important decisions
+
+### Multi-Repo
+\`get_context_capsule\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope, \`cross_repo: true\` on \`get_impact_graph\`/\`search_logic_flow\` to trace across repos. Run \`index_status\` to see available aliases.
+
+> **Tip:** To avoid confirmation prompts on every tool call, enable Yolo mode:
+> Cursor Settings → Features → Agent → Enable Yolo Mode.
+<!-- /vexp -->`;
+}
+function windsurfTemplate(vars) {
+    return `## vexp for Windsurf <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+### Workflow
+1. \`get_context_capsule\` — ALWAYS FIRST for any task or question
+2. Review pivot files and skeletons returned
+3. Make targeted changes based on the context
+4. \`get_impact_graph\` before refactoring exported symbols
+
+### Available MCP tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent from your query
+- \`get_impact_graph\` — what breaks if you change a symbol
+- \`search_logic_flow\` — execution paths between functions
+- \`get_skeleton\` — token-efficient file structure
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Smart Features (automatic)
+- **Intent Detection**: "fix bug" → debug mode, "refactor" → blast-radius, "add" → modify
+- **Hybrid Search**: keyword + semantic + graph centrality ranking
+- **Session Memory**: auto-captures observations; use \`save_observation\` for important decisions
+- **Feedback Loop**: repeated queries auto-expand result budget
+
+### Multi-Repo Workspaces
+When multiple repos are indexed (monorepos, frontend+backend, microservices):
+- \`get_context_capsule\` queries **all repos** automatically — results show repo alias per file
+- Use \`repos: ["alias"]\` to restrict queries to specific repos
+- Use \`cross_repo: true\` on \`get_impact_graph\` and \`search_logic_flow\` to trace across repo boundaries
+- Use \`index_status\` to discover available repo aliases
+- \`get_skeleton\` accepts \`repo: "alias"\` to target a specific repo's files
+<!-- /vexp -->`;
+}
+function continueTemplate(vars) {
+    return JSON.stringify({
+        customCommands: [
+            {
+                name: "vexp-context",
+                description: "Get vexp context capsule for current task",
+                prompt: "{{{ input }}}\n\nFirst, call get_context_capsule with the above task description.",
+            },
+        ],
+        mcpServers: [
+            {
+                name: "vexp",
+                command: vars.binaryPath,
+                args: ["mcp"],
+                type: "stdio",
+            },
+        ],
+    }, null, 2);
+}
+function augmentTemplate(vars) {
+    return `## vexp for Augment <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+When working on this codebase:
+1. Start every task by calling \`get_context_capsule\` — ALWAYS FIRST
+2. The capsule provides full content of pivot files + skeletons of related files
+3. Use \`get_impact_graph\` before refactoring exported symbols
+
+### Available MCP tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent from your query
+- \`get_impact_graph\` — what breaks if you change a symbol
+- \`search_logic_flow\` — execution paths between functions
+- \`get_skeleton\` — token-efficient file structure
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Smart Features
+vexp auto-detects query intent (debug/refactor/modify/read) and uses hybrid ranking
+(keyword + semantic + graph centrality). Session memory auto-captures observations.
+Repeated queries auto-expand result budget.
+
+### Multi-Repo Workspaces
+When multiple repos are indexed (monorepos, frontend+backend, microservices):
+- \`get_context_capsule\` queries **all repos** automatically — results show repo alias per file
+- Use \`repos: ["alias"]\` to restrict queries to specific repos
+- Use \`cross_repo: true\` on \`get_impact_graph\` and \`search_logic_flow\` to trace across repo boundaries
+- Use \`index_status\` to discover available repo aliases
+- \`get_skeleton\` accepts \`repo: "alias"\` to target a specific repo's files
+<!-- /vexp -->`;
+}
+function copilotTemplate(vars) {
+    return `## vexp context tools <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+### Workflow
+1. \`get_context_capsule\` — ALWAYS FIRST for every task or question
+2. Review the provided pivot files and skeletons
+3. Make targeted changes based on the context
+4. \`get_impact_graph\` before refactoring exported symbols
+
+### Available MCP tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent from your query
+- \`get_impact_graph\` — shows which symbols depend on a given function/class
+- \`search_logic_flow\` — traces execution paths between functions
+- \`get_skeleton\` — token-efficient structural overview of a file
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Smart Features
+vexp auto-detects query intent (debug/refactor/modify/read) and uses hybrid ranking
+(keyword + semantic + graph centrality). Session memory auto-captures observations.
+Repeated queries auto-expand result budget.
+
+### Multi-Repo
+\`get_context_capsule\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope, \`cross_repo: true\` on \`get_impact_graph\`/\`search_logic_flow\` to trace across repos. Run \`index_status\` to see available aliases.
+<!-- /vexp -->`;
+}
+function zedTemplate(vars) {
+    return `## vexp for Zed <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+### Workflow
+1. \`get_context_capsule\` — ALWAYS FIRST for any task or question
+2. Review pivot files and skeletons returned
+3. Make targeted changes based on the context
+4. \`get_impact_graph\` before refactoring exported symbols
+
+### Available MCP tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent from your query
+- \`get_impact_graph\` — dependency impact of a symbol change
+- \`search_logic_flow\` — execution paths between functions
+- \`get_skeleton\` — compact structural view of a file
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Smart Features
+vexp auto-detects query intent (debug/refactor/modify/read) and uses hybrid ranking
+(keyword + semantic + graph centrality). Session memory auto-captures observations.
+Repeated queries auto-expand result budget.
+
+### Multi-Repo
+\`get_context_capsule\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope, \`cross_repo: true\` on \`get_impact_graph\`/\`search_logic_flow\` to trace across repos. Run \`index_status\` to see available aliases.
+<!-- /vexp -->`;
+}
+function agentsMdTemplate(vars) {
+    return `## vexp <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+Before any code change or question, call \`get_context_capsule\` with a description of your task.
+This provides the most relevant source files and their skeletons with minimal token usage.
+
+### Workflow
+1. \`get_context_capsule\` — ALWAYS FIRST for any task or question
+2. Review the provided pivot files and skeletons
+3. Make targeted changes based on the context
+4. \`get_impact_graph\` before refactoring exported symbols
+
+### Available MCP tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent from your query
+- \`get_impact_graph\` — what breaks if you change a symbol
+- \`search_logic_flow\` — execution paths between functions
+- \`get_skeleton\` — token-efficient file structure
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Smart Features
+vexp auto-detects query intent (debug/refactor/modify/read) and uses hybrid ranking
+(keyword + semantic + graph centrality). Session memory auto-captures observations.
+Repeated queries auto-expand result budget. Use \`include_tests: true\` when debugging.
+
+### Multi-Repo
+\`get_context_capsule\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope, \`cross_repo: true\` on \`get_impact_graph\`/\`search_logic_flow\` to trace across repos. Run \`index_status\` to see available aliases.
+<!-- /vexp -->`;
+}
+function kiroTemplate(vars) {
+    return `# vexp steering <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+Always start tasks by calling \`get_context_capsule\` with a description of what you need.
+
+## Workflow
+1. \`get_context_capsule\` — ALWAYS FIRST for any task or question
+2. Review the provided pivot files and skeletons
+3. Make targeted changes based on the context
+4. \`get_impact_graph\` before refactoring exported symbols
+
+## Available vexp tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent from your query
+- \`get_impact_graph\` — impact analysis before refactoring
+- \`search_logic_flow\` — trace execution paths
+- \`get_skeleton\` — compact file structure
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap config for new projects
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+## Smart Features
+Intent detection (debug/refactor/modify/read), hybrid search, session memory, auto-expanding budget on repeated queries.
+
+## Multi-Repo
+\`get_context_capsule\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope, \`cross_repo: true\` on impact/flow. Run \`index_status\` to see aliases.
+<!-- /vexp -->`;
+}
+function genericTemplate(vars) {
+    return `## vexp <!-- vexp v${vars.version} -->
+
+**MANDATORY: use vexp MCP tools for ALL file analysis.**
+Do NOT use grep, glob, search, or file reads to explore the codebase.
+Use vexp MCP tools instead — they return pre-indexed, relevant context.
+
+### Workflow
+1. \`get_context_capsule\` — ALWAYS FIRST for any task or question
+2. Review the provided pivot files and skeletons
+3. Make targeted changes based on the context
+4. \`get_impact_graph\` before refactoring exported symbols
+
+### Available MCP tools
+- \`get_context_capsule\` — most relevant code (ALWAYS FIRST). Auto-detects intent from your query
+- \`get_impact_graph\` — what breaks if you change a symbol
+- \`search_logic_flow\` — execution paths between functions
+- \`get_skeleton\` — token-efficient file structure
+- \`index_status\` — indexing status
+- \`workspace_setup\` — bootstrap vexp config for a new project
+- \`get_session_context\` — recall observations from current/previous sessions
+- \`search_memory\` — cross-session search for past decisions and insights
+- \`save_observation\` — persist important insights with optional code symbol linking
+
+### Smart Features
+Intent detection (debug/refactor/modify/read), hybrid search, session memory, auto-expanding budget on repeated queries.
+
+### Multi-Repo
+\`get_context_capsule\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope, \`cross_repo: true\` on impact/flow. Run \`index_status\` to see aliases.
+<!-- /vexp -->`;
+}
+//# sourceMappingURL=agent-config.js.map