@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/mcp/agentdoctor/server.js

@@ -0,0 +1,67 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { PACKAGE_VERSION } from "../../constants.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { BrainMcpSession } from "../brain/session.js";
+import { BRAIN_MCP_TOOL_NAMES, invokeBrainMcpTool, listBrainMcpTools, } from "../brain/tools/registry.js";
+import { INTELLIGENCE_MCP_TOOL_NAMES, invokeIntelligenceMcpTool, listIntelligenceMcpTools, } from "../intelligence/registry.js";
+/**
+ * Combined AgentDoctor MCP server: preserves all Brain tool names and adds
+ * intelligence tools. No arbitrary shell execution; policy_evaluate is evaluate-only.
+ */
+export async function startAgentDoctorMcpServer(options) {
+    const root = resolveRepoRoot(options.root);
+    const session = new BrainMcpSession({
+        root,
+        buildIfMissing: options.buildIfMissing !== false,
+    });
+    await session.initialize();
+    const brainNames = new Set(BRAIN_MCP_TOOL_NAMES);
+    const intelNames = new Set(INTELLIGENCE_MCP_TOOL_NAMES);
+    const server = new Server({
+        name: "agentdoctor",
+        version: PACKAGE_VERSION,
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [...listBrainMcpTools(), ...listIntelligenceMcpTools()],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const name = request.params.name;
+        const args = (request.params.arguments ?? {});
+        let structured;
+        let isError = false;
+        if (brainNames.has(name)) {
+            const result = await invokeBrainMcpTool(session, name, args);
+            structured = result.structured;
+            isError = result.isError;
+        }
+        else if (intelNames.has(name)) {
+            const result = await invokeIntelligenceMcpTool(root, name, args);
+            structured = result.structured;
+            isError = result.isError;
+        }
+        else {
+            structured = {
+                ok: false,
+                error: { code: "invalid_argument", message: `unknown tool: ${name}` },
+            };
+            isError = true;
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(structured) }],
+            structuredContent: structured,
+            isError,
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    return { server, session, root };
+}
+export async function runAgentDoctorMcpStdio(options) {
+    await startAgentDoctorMcpServer(options);
+}

package/dist/mcp/brain/session.js

@@ -1,4 +1,4 @@
-import { LocalBrainStore, } from "../../core/understanding/brain/index.js";
+import { LocalBrainStore, redactBrainForStorage, } from "../../core/understanding/brain/index.js";
 import { compileProjectBrain } from "./compile.js";
 import { BrainMcpError } from "./errors.js";
 import { resolveProjectRoot } from "./security/root.js";
@@ -32,8 +32,8 @@ export class BrainMcpSession {
             throw new BrainMcpError("brain_corrupt", message);
         }
         if (loaded) {
-            this.brain = loaded;
-            this.log(`agentdoctor brain-mcp: loaded snapshot ${loaded.snapshot.id} from ${this.root}`);
+            this.brain = redactBrainForStorage(loaded);
+            this.log(`agentdoctor brain-mcp: loaded snapshot ${this.brain.snapshot.id} from ${this.root}`);
             return;
         }
         if (!this.buildIfMissing) {
@@ -84,15 +84,15 @@ export class BrainMcpSession {
                     : new BrainMcpError("brain_corrupt", message || "failed to save snapshot");
             }
         }
-        this.brain = brain;
-        return brain;
+        this.brain = redactBrainForStorage(brain);
+        return this.brain;
     }
     async loadSnapshot(snapshotId) {
         const store = this.getStore();
         try {
             const brain = await store.loadSnapshot(snapshotId);
-            this.brain = brain;
-            return brain;
+            this.brain = redactBrainForStorage(brain);
+            return this.brain;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "failed to load snapshot";

package/dist/mcp/intelligence/handlers.d.ts

@@ -0,0 +1,16 @@
+export declare function handleRepoOverview(rootInput: string): Promise<unknown>;
+export declare function handleCodebaseSearch(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleSymbolLookup(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleDependencyLookup(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleCallGraphLookup(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleTestImpactTool(rootInput: string): Promise<unknown>;
+export declare function handleRefactorImpactTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleCodeHealthTool(rootInput: string): Promise<unknown>;
+export declare function handleArchitectureTool(rootInput: string): Promise<unknown>;
+export declare function handleKnowledgeTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handlePolicyEvalTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleChangeAnalyzeTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleArchitectureCheckTool(rootInput: string): Promise<unknown>;
+export declare function handleProofInspectTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleEvidenceInspectTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleGraphQueryTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;

package/dist/mcp/intelligence/handlers.js

@@ -0,0 +1,364 @@
+import { buildC4Views } from "../../architecture/c4.js";
+import { checkArchitectureAtRoot } from "../../architecture/contract.js";
+import { analyzeChange, inspectEvidence } from "../../assurance/change.js";
+import { inspectProof } from "../../assurance/proof.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { graphStatus } from "../../intelligence/graph/incremental.js";
+import { analyzeGitIntelligence } from "../../intelligence/git/analyze.js";
+import { listKnowledge, retrieveAuthoritative } from "../../knowledge/store.js";
+import { analyzeRenameImpact, analyzeTestImpact, buildRepositoryGraph, evaluateAgentAction, } from "../../platform/index.js";
+import { redactSecrets } from "../../platform/security/redact.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { CONTRACTS_VERSION } from "../../contracts/index.js";
+import { assertSafeRepoTarget } from "./path-safety.js";
+function requireString(args, key) {
+    const value = args[key];
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function redactDeep(value) {
+    if (typeof value === "string") {
+        return redactSecrets(value).text;
+    }
+    if (Array.isArray(value)) {
+        return value.map(redactDeep);
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = redactDeep(v);
+        }
+        return out;
+    }
+    return value;
+}
+function invalidArgument(message) {
+    return { ok: false, error: { code: "invalid_argument", message } };
+}
+function pathEscape() {
+    return { ok: false, error: { code: "path_escape", message: "path escapes repository root" } };
+}
+export async function handleRepoOverview(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+    return redactDeep({
+        ok: true,
+        contractsVersion: CONTRACTS_VERSION,
+        root,
+        builder: graph.builder,
+        nodeCount: graph.nodes.length,
+        edgeCount: graph.edges.length,
+        limitations: graph.limitations,
+    });
+}
+export async function handleCodebaseSearch(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const query = requireString(args, "query")?.toLowerCase() ?? "";
+    if (!query) {
+        return invalidArgument("query required");
+    }
+    const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+    const hits = graph.nodes
+        .filter((n) => n.label.toLowerCase().includes(query) ||
+        n.id.toLowerCase().includes(query) ||
+        (n.path ?? "").toLowerCase().includes(query))
+        .slice(0, 50);
+    return redactDeep({
+        ok: true,
+        query,
+        hits,
+        confidence: graph.builder === "typescript-ast" ? 0.85 : 0.55,
+        evidenceKind: graph.builder === "typescript-ast" ? "observed" : "inferred",
+        limitations: graph.limitations,
+    });
+}
+export async function handleSymbolLookup(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const name = requireString(args, "name");
+    if (!name) {
+        return invalidArgument("name required");
+    }
+    const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+    const matches = graph.nodes.filter((n) => (n.kind === "function" || n.kind === "class" || n.kind === "module") &&
+        (n.label === name || n.label.endsWith(`.${name}`)));
+    return redactDeep({
+        ok: true,
+        name,
+        matches,
+        confidence: matches.length > 0 ? 0.8 : 0.2,
+        limitations: ["Import/call resolution is best-effort; unsupported languages omitted."],
+    });
+}
+export async function handleDependencyLookup(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const target = requireString(args, "target");
+    if (!target) {
+        return invalidArgument("target required");
+    }
+    let safeRelative = null;
+    try {
+        safeRelative = assertSafeRepoTarget(root, target);
+    }
+    catch {
+        return pathEscape();
+    }
+    const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+    const lookupKeys = [target, safeRelative].filter((v) => Boolean(v));
+    const node = graph.nodes.find((n) => lookupKeys.includes(n.id) ||
+        (n.path !== undefined && lookupKeys.includes(n.path)) ||
+        lookupKeys.includes(n.label));
+    if (!node) {
+        return redactDeep({ ok: true, target, edges: [], limitations: ["Target not found in graph"] });
+    }
+    const edges = graph.edges.filter((e) => e.from === node.id || e.to === node.id);
+    return redactDeep({ ok: true, target: node, edges, confidence: 0.75 });
+}
+export async function handleCallGraphLookup(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const symbol = requireString(args, "symbol");
+    if (!symbol) {
+        return invalidArgument("symbol required");
+    }
+    const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+    const calls = graph.edges.filter((e) => e.kind === "calls" && (e.from.includes(symbol) || e.to.includes(symbol)));
+    return redactDeep({
+        ok: true,
+        symbol,
+        calls,
+        confidence: graph.builder === "typescript-ast" ? 0.7 : 0.4,
+        limitations: ["Call edges may be incomplete for dynamic/dispatch patterns."],
+    });
+}
+export async function handleTestImpactTool(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const impact = await analyzeTestImpact(root);
+    return redactDeep({
+        ok: true,
+        impact,
+        resultKind: impact.gitAvailable ? "graph-inferred" : "unknown",
+        limitations: ["Coverage-backed mapping requires external coverage data (not bundled)."],
+    });
+}
+export async function handleRefactorImpactTool(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const symbol = requireString(args, "symbol");
+    if (!symbol) {
+        return invalidArgument("symbol required");
+    }
+    const graph = await buildRepositoryGraph(root);
+    const impact = await analyzeRenameImpact({ root, symbol, graph });
+    return redactDeep({ ok: true, impact });
+}
+export async function handleCodeHealthTool(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const report = await analyzeGitIntelligence(root);
+    return redactDeep({
+        ok: true,
+        report,
+        methodDisclosure: report.hotspots[0]?.method ?? "see per-metric method fields",
+        limitations: report.limitations,
+    });
+}
+export async function handleArchitectureTool(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+    const views = buildC4Views(graph);
+    return redactDeep({
+        ok: true,
+        views,
+        label: "Inferred/proposed from graph evidence — not approved architecture facts",
+    });
+}
+export async function handleKnowledgeTool(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const list = await listKnowledge(root);
+    const query = typeof args.query === "string" ? args.query.trim() : "";
+    if (!query) {
+        return redactDeep({
+            ok: true,
+            records: list.filter((r) => r.status === "approved").slice(0, 50),
+        });
+    }
+    const result = retrieveAuthoritative(list, query);
+    return redactDeep({ ok: true, ...result });
+}
+export async function handlePolicyEvalTool(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const command = requireString(args, "command");
+    if (!command) {
+        return invalidArgument("command required");
+    }
+    const verdict = await evaluateAgentAction(root, {
+        actionId: `mcp_${Date.now()}`,
+        agentId: "agentdoctor-mcp",
+        timestamp: new Date().toISOString(),
+        type: "shell",
+        params: { command },
+        repositoryRoot: root,
+    });
+    return redactDeep({
+        ok: true,
+        verdict,
+        executionResult: "not-executed",
+        notice: "Evaluate-only: AgentDoctor MCP does not execute shell commands.",
+    });
+}
+export async function handleChangeAnalyzeTool(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const since = typeof args.since === "string" && args.since.trim() ? args.since.trim() : undefined;
+    const changeId = typeof args.changeId === "string" && args.changeId.trim() ? args.changeId.trim() : undefined;
+    if (args.coveragePath !== undefined) {
+        if (typeof args.coveragePath !== "string" || !args.coveragePath.trim()) {
+            return invalidArgument("coveragePath must be a non-empty string when provided");
+        }
+        try {
+            assertSafeRepoTarget(root, args.coveragePath);
+        }
+        catch {
+            return pathEscape();
+        }
+    }
+    const assessment = await analyzeChange({
+        root,
+        ...(since ? { since } : {}),
+        ...(changeId ? { changeId } : {}),
+        ...(typeof args.coveragePath === "string" ? { coveragePath: args.coveragePath } : {}),
+    });
+    return redactDeep({
+        ok: true,
+        assessment,
+        limitations: assessment.limitations,
+    });
+}
+export async function handleArchitectureCheckTool(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const graph = await buildRepositoryGraph(root);
+    const result = await checkArchitectureAtRoot(root, graph);
+    return redactDeep({
+        ok: true,
+        result,
+        violationCount: result.violations.length,
+    });
+}
+export async function handleProofInspectTool(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const id = requireString(args, "id");
+    if (!id) {
+        return invalidArgument("id required");
+    }
+    if (id.includes("/") || id.includes("\\") || id.includes("..")) {
+        try {
+            assertSafeRepoTarget(root, id);
+        }
+        catch {
+            return pathEscape();
+        }
+    }
+    const inspected = await inspectProof(root, id);
+    if (!inspected.ok) {
+        return {
+            ok: false,
+            error: { code: "not_found", message: inspected.error ?? "proof not found" },
+        };
+    }
+    return redactDeep({
+        ok: true,
+        proof: inspected.proof,
+        path: inspected.path,
+        notice: "Integrity/inspect only — engineering correctness is not claimed",
+    });
+}
+export async function handleEvidenceInspectTool(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const changeId = requireString(args, "changeId");
+    if (!changeId) {
+        return invalidArgument("changeId required");
+    }
+    if (changeId.includes("/") || changeId.includes("\\") || changeId.includes("..")) {
+        try {
+            assertSafeRepoTarget(root, changeId);
+        }
+        catch {
+            return pathEscape();
+        }
+    }
+    const inspected = await inspectEvidence({ root, changeId });
+    if (!inspected.ok) {
+        return {
+            ok: false,
+            error: { code: "not_found", message: inspected.error ?? "evidence not found" },
+        };
+    }
+    return redactDeep({
+        ok: true,
+        directory: inspected.directory,
+        manifest: inspected.manifest,
+        presentFiles: inspected.presentFiles,
+    });
+}
+export async function handleGraphQueryTool(rootInput, args) {
+    const root = resolveRepoRoot(rootInput);
+    const query = requireString(args, "query");
+    if (!query) {
+        return invalidArgument("query required");
+    }
+    const kindFilter = typeof args.kind === "string" && args.kind.trim() ? args.kind.trim().toLowerCase() : null;
+    const limitRaw = args.limit;
+    const limit = typeof limitRaw === "number" && Number.isFinite(limitRaw)
+        ? Math.max(1, Math.min(100, Math.floor(limitRaw)))
+        : 25;
+    if (args.path !== undefined) {
+        if (typeof args.path !== "string" || !args.path.trim()) {
+            return invalidArgument("path must be a non-empty string when provided");
+        }
+        try {
+            assertSafeRepoTarget(root, args.path);
+        }
+        catch {
+            return pathEscape();
+        }
+    }
+    const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+    const status = await graphStatus({ root });
+    const q = query.toLowerCase();
+    const pathFilter = typeof args.path === "string" ? args.path.trim().toLowerCase().replace(/\\/g, "/") : null;
+    const nodes = graph.nodes
+        .filter((n) => {
+        if (kindFilter && n.kind.toLowerCase() !== kindFilter)
+            return false;
+        if (pathFilter && !(n.path ?? "").toLowerCase().includes(pathFilter))
+            return false;
+        return (n.id.toLowerCase().includes(q) ||
+            n.label.toLowerCase().includes(q) ||
+            (n.path ?? "").toLowerCase().includes(q));
+    })
+        .slice(0, limit);
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    const edges = graph.edges
+        .filter((e) => nodeIds.has(e.from) ||
+        nodeIds.has(e.to) ||
+        e.from.toLowerCase().includes(q) ||
+        e.to.toLowerCase().includes(q) ||
+        e.kind.toLowerCase().includes(q))
+        .slice(0, limit);
+    return redactDeep({
+        ok: true,
+        query,
+        kind: kindFilter,
+        path: pathFilter,
+        nodes,
+        edges,
+        index: {
+            present: status.present,
+            nodeCount: status.nodeCount,
+            edgeCount: status.edgeCount,
+            corrupt: status.corrupt ?? false,
+        },
+        limitations: [
+            "Query is substring match over in-memory / rebuilt graph — not a production graph DB",
+            ...graph.limitations,
+        ],
+    });
+}

package/dist/mcp/intelligence/path-safety.d.ts

@@ -0,0 +1,9 @@
+import { tryDecodeUriComponent } from "../../security/paths.js";
+export { tryDecodeUriComponent };
+/**
+ * Validate a user-supplied repository-relative or in-repo target.
+ * Returns a normalized path relative to root (POSIX) when the target is path-like and safe,
+ * or null when the target is treated as a non-path identifier (graph id / label).
+ * Throws a safe Error (no outside path leakage) when a path-like target escapes the root.
+ */
+export declare function assertSafeRepoTarget(root: string, rawTarget: string): string | null;

package/dist/mcp/intelligence/path-safety.js

@@ -0,0 +1,63 @@
+import path from "node:path";
+import { PathEscapeError, rejectHostilePathInput, resolveSafeRepoPath, tryDecodeUriComponent, } from "../../security/paths.js";
+import { sanitizeForOutput } from "../../utils/path.js";
+export { tryDecodeUriComponent };
+/**
+ * Validate a user-supplied repository-relative or in-repo target.
+ * Returns a normalized path relative to root (POSIX) when the target is path-like and safe,
+ * or null when the target is treated as a non-path identifier (graph id / label).
+ * Throws a safe Error (no outside path leakage) when a path-like target escapes the root.
+ */
+export function assertSafeRepoTarget(root, rawTarget) {
+    if (typeof rawTarget !== "string" || rawTarget.includes("\0")) {
+        throw new Error("invalid target");
+    }
+    const cleaned = sanitizeForOutput(rawTarget).trim();
+    if (!cleaned) {
+        throw new Error("invalid target");
+    }
+    if (cleaned.includes("\0")) {
+        throw new Error("invalid target");
+    }
+    const decoded = tryDecodeUriComponent(cleaned);
+    if (decoded === null) {
+        throw new Error("invalid target");
+    }
+    const candidates = decoded === cleaned ? [cleaned] : [cleaned, decoded];
+    let pathLike = false;
+    for (const candidate of candidates) {
+        const looksLikePath = path.isAbsolute(candidate) ||
+            candidate.includes("..") ||
+            candidate.includes("/") ||
+            candidate.includes("\\") ||
+            /^[A-Za-z]:[\\/]/.test(candidate);
+        if (!looksLikePath) {
+            continue;
+        }
+        pathLike = true;
+        try {
+            rejectHostilePathInput(candidate);
+            resolveSafeRepoPath(root, candidate);
+        }
+        catch (error) {
+            if (error instanceof PathEscapeError) {
+                throw new Error(error.message);
+            }
+            throw new Error("invalid target");
+        }
+    }
+    if (!pathLike) {
+        return null;
+    }
+    const primary = candidates[candidates.length - 1];
+    try {
+        const abs = resolveSafeRepoPath(root, primary);
+        return path.relative(root, abs).split(path.sep).join("/");
+    }
+    catch (error) {
+        if (error instanceof PathEscapeError) {
+            throw new Error(error.message);
+        }
+        throw new Error("invalid target");
+    }
+}

package/dist/mcp/intelligence/registry.d.ts

@@ -0,0 +1,8 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const INTELLIGENCE_MCP_TOOL_NAMES: readonly ["repo_overview", "codebase_search", "symbol_lookup", "dependency_lookup", "call_graph_lookup", "test_impact", "refactor_impact", "code_health", "architecture_info", "architecture_check", "knowledge_retrieve", "policy_evaluate", "change_analyze", "proof_inspect", "evidence_inspect", "graph_query"];
+export type IntelligenceMcpToolName = (typeof INTELLIGENCE_MCP_TOOL_NAMES)[number];
+export declare function listIntelligenceMcpTools(): Tool[];
+export declare function invokeIntelligenceMcpTool(root: string, name: string, args: Record<string, unknown>): Promise<{
+    structured: unknown;
+    isError: boolean;
+}>;