@praneeth_54/agentdoctor 2.0.0 → 2.1.0

package/dist/languages/typescript.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import ts from "typescript";
+function sid(kind, key) {
+    return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
+}
+function parseTsJs(filePath, source, language) {
+    const kind = language === "typescript" ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+    const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.ES2022, true, kind);
+    const symbols = [];
+    const imports = [];
+    const calls = [];
+    const diagnostics = [];
+    const visit = (node) => {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const name = node.name.text;
+            symbols.push({
+                id: sid("fn", `${filePath}:${name}`),
+                name,
+                kind: "function",
+                file: filePath,
+                line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
+                evidence: "ast",
+            });
+        }
+        if (ts.isClassDeclaration(node) && node.name) {
+            const name = node.name.text;
+            symbols.push({
+                id: sid("class", `${filePath}:${name}`),
+                name,
+                kind: "class",
+                file: filePath,
+                line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
+                evidence: "ast",
+            });
+        }
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            imports.push({
+                fromFile: filePath,
+                specifier: node.moduleSpecifier.text,
+                evidence: "ast",
+            });
+        }
+        if (ts.isCallExpression(node)) {
+            const callee = node.expression.getText(sf);
+            calls.push({ fromFile: filePath, callee, evidence: "ast" });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return {
+        language,
+        file: filePath,
+        ok: true,
+        capabilities: {
+            parse: "supported",
+            symbols: "supported",
+            definitions: "supported",
+            imports: "supported",
+            calls: "supported",
+            references: "unsupported",
+            diagnostics: "unsupported",
+        },
+        symbols,
+        imports,
+        calls,
+        diagnostics,
+        limitations: [
+            "TypeScript compiler API parse (single-file); cross-file references unsupported in adapter",
+        ],
+    };
+}
+export const typescriptAdapter = {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".mts", ".cts"],
+    capabilities: () => ({
+        parse: "supported",
+        symbols: "supported",
+        definitions: "supported",
+        imports: "supported",
+        calls: "supported",
+        references: "unsupported",
+        diagnostics: "unsupported",
+    }),
+    async parse(filePath, source) {
+        return parseTsJs(filePath, source, "typescript");
+    },
+};
+export const javascriptAdapter = {
+    id: "javascript",
+    extensions: [".js", ".jsx", ".mjs", ".cjs"],
+    capabilities: () => typescriptAdapter.capabilities(),
+    async parse(filePath, source) {
+        return parseTsJs(filePath, source, "javascript");
+    },
+};

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

@@ -0,0 +1,13 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { ModelProvider } from "../../ai/types.js";
+export declare const AGENT_MCP_TOOL_NAMES: readonly ["project_context", "project_ask", "code_search", "file_read", "file_create", "file_edit", "agent_plan", "change_verify"];
+export type AgentMcpToolName = (typeof AGENT_MCP_TOOL_NAMES)[number];
+export declare function listAgentMcpTools(): Tool[];
+export declare function invokeAgentMcpTool(root: string, name: string, args: Record<string, unknown>, options?: {
+    provider?: ModelProvider;
+}): Promise<{
+    structured: unknown;
+    isError: boolean;
+}>;
+/** Convenience for tests */
+export declare function projectFingerprint(root: string): Promise<unknown>;

package/dist/mcp/agent/registry.js

@@ -0,0 +1,234 @@
+import { createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { ChatService } from "../../agent/chat/service.js";
+import { buildAgentPlan } from "../../agent/plan.js";
+import { executeAgentTool, newToolCall } from "../../agent/tools/index.js";
+import { retrieveProjectContext } from "../../agent/context/retrieve.js";
+import { summarizeProjectForChat } from "../../agent/chat/project-summary.js";
+export const AGENT_MCP_TOOL_NAMES = [
+    "project_context",
+    "project_ask",
+    "code_search",
+    "file_read",
+    "file_create",
+    "file_edit",
+    "agent_plan",
+    "change_verify",
+];
+export function listAgentMcpTools() {
+    return [
+        {
+            name: "project_context",
+            description: "READ: Budgeted project context pack for a query (path-safe).",
+            inputSchema: {
+                type: "object",
+                properties: { query: { type: "string" } },
+                required: ["query"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "project_ask",
+            description: "READ: One-shot Project Chat ask (requires AI provider; no file writes).",
+            inputSchema: {
+                type: "object",
+                properties: { question: { type: "string" } },
+                required: ["question"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "code_search",
+            description: "READ: Search code via AgentDoctor graph search.",
+            inputSchema: {
+                type: "object",
+                properties: { query: { type: "string" } },
+                required: ["query"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "file_read",
+            description: "READ: Path-safe file read inside workspace.",
+            inputSchema: {
+                type: "object",
+                properties: { path: { type: "string" } },
+                required: ["path"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "file_create",
+            description: "WRITE: Create file (requires approved=true). Path-safe; never shell. Model cannot self-approve.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                    content: { type: "string" },
+                    approved: { type: "boolean" },
+                },
+                required: ["path", "content", "approved"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "file_edit",
+            description: "WRITE: Edit file (requires approved=true). Path-safe.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                    content: { type: "string" },
+                    oldContent: { type: "string" },
+                    approved: { type: "boolean" },
+                },
+                required: ["path", "approved"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "agent_plan",
+            description: "READ: Build a change plan without modifying files.",
+            inputSchema: {
+                type: "object",
+                properties: { goal: { type: "string" } },
+                required: ["goal"],
+                additionalProperties: false,
+            },
+        },
+        {
+            name: "change_verify",
+            description: "READ: Produce evidence/proof for current changes (may write evidence artifacts).",
+            inputSchema: {
+                type: "object",
+                properties: { changeId: { type: "string" } },
+                additionalProperties: false,
+            },
+        },
+    ];
+}
+export async function invokeAgentMcpTool(root, name, args, options) {
+    try {
+        switch (name) {
+            case "project_context": {
+                const query = typeof args.query === "string" ? args.query : "";
+                const bundle = await retrieveProjectContext({ root, query });
+                return { structured: { ok: true, bundle }, isError: false };
+            }
+            case "project_ask": {
+                const question = typeof args.question === "string" ? args.question : "";
+                if (!question) {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: { code: "invalid_argument", message: "question required" },
+                        },
+                        isError: true,
+                    };
+                }
+                const provider = options?.provider ?? createModelProvider(loadAiConfig());
+                if (provider.id === "none") {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: {
+                                code: "provider_none",
+                                message: "AI chat is not configured. Set AGENTDOCTOR_AI_PROVIDER=mock (or openai-compatible). Silent mock fallback is disabled.",
+                            },
+                        },
+                        isError: true,
+                    };
+                }
+                const chat = new ChatService({
+                    root,
+                    provider,
+                    persistAudit: false,
+                });
+                try {
+                    const response = await chat.ask(question);
+                    return {
+                        structured: { ok: response.status === "ok", response },
+                        isError: response.status !== "ok",
+                    };
+                }
+                finally {
+                    await chat.end();
+                }
+            }
+            case "code_search": {
+                const result = await executeAgentTool(root, newToolCall("mcp", "search_code", { query: args.query }));
+                return { structured: result, isError: !result.ok };
+            }
+            case "file_read": {
+                const result = await executeAgentTool(root, newToolCall("mcp", "read_file", { path: args.path }));
+                return { structured: result, isError: !result.ok };
+            }
+            case "file_create": {
+                if (args.approved !== true) {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: { code: "approval_required", message: "approved=true required" },
+                        },
+                        isError: true,
+                    };
+                }
+                const result = await executeAgentTool(root, newToolCall("mcp", "create_file", { path: args.path, content: args.content }), { allowWrite: true, approvedByHuman: true });
+                return { structured: result, isError: !result.ok };
+            }
+            case "file_edit": {
+                if (args.approved !== true) {
+                    return {
+                        structured: {
+                            ok: false,
+                            error: { code: "approval_required", message: "approved=true required" },
+                        },
+                        isError: true,
+                    };
+                }
+                const result = await executeAgentTool(root, newToolCall("mcp", "edit_file", {
+                    path: args.path,
+                    content: args.content,
+                    oldContent: args.oldContent,
+                }), { allowWrite: true, approvedByHuman: true });
+                return { structured: result, isError: !result.ok };
+            }
+            case "agent_plan": {
+                const goal = typeof args.goal === "string" ? args.goal : "";
+                const plan = await buildAgentPlan({ root, goal });
+                return { structured: { ok: true, plan }, isError: false };
+            }
+            case "change_verify": {
+                const { verifyChange } = await import("../../assurance/change.js");
+                const result = await verifyChange({
+                    root,
+                    ...(typeof args.changeId === "string" ? { changeId: args.changeId } : {}),
+                });
+                return { structured: { ok: true, ...result }, isError: false };
+            }
+            default:
+                return {
+                    structured: {
+                        ok: false,
+                        error: { code: "invalid_argument", message: `unknown agent tool: ${name}` },
+                    },
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            structured: {
+                ok: false,
+                error: {
+                    code: "internal",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            },
+            isError: true,
+        };
+    }
+}
+/** Convenience for tests */
+export async function projectFingerprint(root) {
+    return summarizeProjectForChat(root);
+}

package/dist/mcp/agentdoctor/server.js

@@ -6,6 +6,7 @@ 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";
+import { AGENT_MCP_TOOL_NAMES, invokeAgentMcpTool, listAgentMcpTools } from "../agent/registry.js";
 /**
  * Combined AgentDoctor MCP server: preserves all Brain tool names and adds
  * intelligence tools. No arbitrary shell execution; policy_evaluate is evaluate-only.
@@ -19,6 +20,7 @@ export async function startAgentDoctorMcpServer(options) {
     await session.initialize();
     const brainNames = new Set(BRAIN_MCP_TOOL_NAMES);
     const intelNames = new Set(INTELLIGENCE_MCP_TOOL_NAMES);
+    const agentNames = new Set(AGENT_MCP_TOOL_NAMES);
     const server = new Server({
         name: "agentdoctor",
         version: PACKAGE_VERSION,
@@ -28,7 +30,7 @@ export async function startAgentDoctorMcpServer(options) {
         },
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [...listBrainMcpTools(), ...listIntelligenceMcpTools()],
+        tools: [...listBrainMcpTools(), ...listIntelligenceMcpTools(), ...listAgentMcpTools()],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const name = request.params.name;
@@ -45,6 +47,11 @@ export async function startAgentDoctorMcpServer(options) {
             structured = result.structured;
             isError = result.isError;
         }
+        else if (agentNames.has(name)) {
+            const result = await invokeAgentMcpTool(root, name, args);
+            structured = result.structured;
+            isError = result.isError;
+        }
         else {
             structured = {
                 ok: false,

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

@@ -9,3 +9,8 @@ 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>;