@praneeth_54/agentdoctor 2.0.1 → 2.1.0

package/dist/index.js

@@ -36,3 +36,11 @@ export { buildFixPlan } from "./core/fix/plan.js";
 export { applyFixPlan } from "./core/fix/apply.js";
 export { runFix } from "./core/fix/run.js";
 export { evaluatePolicy, evaluateScanPolicy, evaluateVerifyPolicy, parseFailOnRules, parseSeverityGate, } from "./core/policy/evaluate.js";
+/** AgentDoctor 2.1 AI provider layer (optional — core works without AI). */
+export { createModelProvider, loadAiConfig, publicAiConfig, redactForModel, AI_PROVIDER_REQUIRED_MESSAGE, NoneModelProvider, MockModelProvider, OpenAiCompatibleProvider, } from "./ai/index.js";
+/** AgentDoctor 2.1 Project AI Agent core (M1 scaffolding). */
+export { AgentState, AgentStateMachine, AgentRuntime, DEFAULT_AGENT_LIMITS, retrieveProjectContext, truthLabelHelp, minTruth, } from "./agent/index.js";
+export { ChatService, createChatService, ChatMemory, CHAT_PROVIDER_NONE_MESSAGE, buildChatTurnResponse, formatChatResponseForCli, summarizeProjectForChat, } from "./agent/chat/index.js";
+/** AgentDoctor 2.1 agent tools + plan (M3). */
+export { listAgentToolSpecs, getToolSpec, riskForTool, executeAgentTool, isReadTool, newToolCall, evaluateApproval, formatApprovalPrompt, buildAgentPlan, formatAgentPlan, approvePlan, runCodingLoop, verifyAgentWork, formatVerificationReport, } from "./agent/index.js";
+export { getModeProfile, defaultStudentMode, parseAgentMode, modeAllowsMutation, modeBlocksToolCategory, StudentService, } from "./agent/index.js";

package/dist/languages/go.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+const GO_PROBE_TIMEOUT_MS = 5_000;
 /**
  * Go toolchain bridge placeholder.
  * Prefer real `go/ast` via `go run` when the Go toolchain is present; until an
@@ -6,8 +7,12 @@ import { spawnSync } from "node:child_process";
  * Today: always unsupported (no bundled extractor; avoids fake AST claims).
  */
 export function goAvailable() {
-    const r = spawnSync("go", ["version"], { encoding: "utf8" });
-    return r.status === 0;
+    const r = spawnSync("go", ["version"], {
+        encoding: "utf8",
+        timeout: GO_PROBE_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    return r.status === 0 && !r.error;
 }
 export const goAdapter = {
     id: "go",

package/dist/languages/php.d.ts

@@ -2,6 +2,7 @@ import type { LanguageAdapter } from "./types.js";
 /**
  * Real PHP token extractor via `php -r` + token_get_all (requires `php` on PATH).
  * Not regex. If php is missing, capabilities are unsupported.
+ * Probe timeout skips hanging Windows Store / stub `php` binaries.
  */
 export declare function phpAvailable(): boolean;
 export declare const phpAdapter: LanguageAdapter;

package/dist/languages/php.js

@@ -3,13 +3,20 @@ import { createHash } from "node:crypto";
 function sid(kind, key) {
     return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
 }
+const PHP_PROBE_TIMEOUT_MS = 5_000;
+const PHP_EXTRACT_TIMEOUT_MS = 15_000;
 /**
  * Real PHP token extractor via `php -r` + token_get_all (requires `php` on PATH).
  * Not regex. If php is missing, capabilities are unsupported.
+ * Probe timeout skips hanging Windows Store / stub `php` binaries.
  */
 export function phpAvailable() {
-    const r = spawnSync("php", ["-r", "echo PHP_VERSION;"], { encoding: "utf8" });
-    return r.status === 0 && Boolean(r.stdout?.trim());
+    const r = spawnSync("php", ["-r", "echo PHP_VERSION;"], {
+        encoding: "utf8",
+        timeout: PHP_PROBE_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    return r.status === 0 && !r.error && Boolean(r.stdout?.trim());
 }
 const PHP_EXTRACTOR = `
 $source = stream_get_contents(STDIN);
@@ -117,6 +124,8 @@ export const phpAdapter = {
             input: source,
             encoding: "utf8",
             maxBuffer: 8 * 1024 * 1024,
+            timeout: PHP_EXTRACT_TIMEOUT_MS,
+            windowsHide: true,
         });
         if (r.status !== 0 || !r.stdout) {
             return {

package/dist/languages/python.d.ts

@@ -1,7 +1,11 @@
 import type { LanguageAdapter } from "./types.js";
 /**
- * Real Python AST via the CPython `ast` module (requires `python3` on PATH).
- * Not regex. If python3 is missing, capabilities are unsupported.
+ * Resolve a working CPython binary, or null if none responds in time.
+ */
+export declare function resolvePythonBin(): string | null;
+/**
+ * Real Python AST via the CPython `ast` module (requires python on PATH).
+ * Not regex. If no interpreter is available, capabilities are unsupported.
  */
 export declare function pythonAvailable(): boolean;
 export declare const pythonAdapter: LanguageAdapter;

package/dist/languages/python.js

@@ -3,13 +3,40 @@ import { createHash } from "node:crypto";
 function sid(kind, key) {
     return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
 }
+const PYTHON_PROBE_TIMEOUT_MS = 5_000;
 /**
- * Real Python AST via the CPython `ast` module (requires `python3` on PATH).
- * Not regex. If python3 is missing, capabilities are unsupported.
+ * Prefer real interpreters; skip hanging Windows Store `python3` stubs via timeout.
+ */
+function pythonCandidates() {
+    return process.platform === "win32" ? ["python", "py", "python3"] : ["python3", "python"];
+}
+let cachedPythonBin;
+/**
+ * Resolve a working CPython binary, or null if none responds in time.
+ */
+export function resolvePythonBin() {
+    if (cachedPythonBin !== undefined)
+        return cachedPythonBin;
+    for (const bin of pythonCandidates()) {
+        const r = spawnSync(bin, ["-c", "import ast, json"], {
+            encoding: "utf8",
+            timeout: PYTHON_PROBE_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        if (r.status === 0 && !r.error) {
+            cachedPythonBin = bin;
+            return bin;
+        }
+    }
+    cachedPythonBin = null;
+    return null;
+}
+/**
+ * Real Python AST via the CPython `ast` module (requires python on PATH).
+ * Not regex. If no interpreter is available, capabilities are unsupported.
  */
 export function pythonAvailable() {
-    const r = spawnSync("python3", ["-c", "import ast, json"], { encoding: "utf8" });
-    return r.status === 0;
+    return resolvePythonBin() !== null;
 }
 const PY_EXTRACTOR = `
 import ast, json, sys
@@ -59,7 +86,8 @@ export const pythonAdapter = {
         };
     },
     async parse(filePath, source) {
-        if (!pythonAvailable()) {
+        const pythonBin = resolvePythonBin();
+        if (!pythonBin) {
             return {
                 language: "python",
                 file: filePath,
@@ -68,14 +96,16 @@ export const pythonAdapter = {
                 symbols: [],
                 imports: [],
                 calls: [],
-                diagnostics: ["python3 not available on PATH"],
-                limitations: ["Python AST adapter requires python3 with stdlib ast module"],
+                diagnostics: ["python not available on PATH"],
+                limitations: ["Python AST adapter requires python3/python with stdlib ast module"],
             };
         }
-        const r = spawnSync("python3", ["-c", PY_EXTRACTOR, filePath], {
+        const r = spawnSync(pythonBin, ["-c", PY_EXTRACTOR, filePath], {
             input: source,
             encoding: "utf8",
             maxBuffer: 8 * 1024 * 1024,
+            timeout: 15_000,
+            windowsHide: true,
         });
         if (r.status !== 0 || !r.stdout) {
             return {
@@ -86,7 +116,7 @@ export const pythonAdapter = {
                 symbols: [],
                 imports: [],
                 calls: [],
-                diagnostics: [r.stderr || "python3 extractor failed"],
+                diagnostics: [r.stderr || r.error?.message || "python extractor failed"],
                 limitations: [],
             };
         }

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/security/paths.js

@@ -49,17 +49,6 @@ export function rejectHostilePathInput(candidate) {
         }
     }
 }
-function realpathOrSelf(target) {
-    try {
-        if (fs.existsSync(target)) {
-            return fs.realpathSync(target);
-        }
-    }
-    catch {
-        // fall through
-    }
-    return target;
-}
 function realpathRoot(root) {
     try {
         return fs.realpathSync(root);
@@ -85,12 +74,51 @@ export function resolveSafeRepoPath(rootInput, candidate) {
         throw new PathEscapeError("path escapes repository root");
     }
     const realRoot = realpathRoot(root);
-    const realTarget = realpathOrSelf(absolute);
-    // Symlink / realpath escape check (both sides realpath'd when possible).
-    if (!isPathInsideRoot(realRoot, realTarget) && realTarget !== realRoot) {
+    // Existing path: realpath and verify (catches symlink escape).
+    if (fs.existsSync(absolute)) {
+        let realTarget;
+        try {
+            realTarget = fs.realpathSync(absolute);
+        }
+        catch {
+            realTarget = absolute;
+        }
+        if (!isPathInsideRoot(realRoot, realTarget) && realTarget !== realRoot) {
+            throw new PathEscapeError("path escapes repository root");
+        }
+        return realTarget;
+    }
+    // Non-existent path (create): reject if any existing ancestor realpath escapes
+    // (symlink-dir escape), then map under realRoot for /var vs /private/var.
+    let ancestor = path.dirname(absolute);
+    for (;;) {
+        if (fs.existsSync(ancestor)) {
+            let realAncestor;
+            try {
+                realAncestor = fs.realpathSync(ancestor);
+            }
+            catch {
+                realAncestor = ancestor;
+            }
+            if (!isPathInsideRoot(realRoot, realAncestor) && realAncestor !== realRoot) {
+                throw new PathEscapeError("path escapes repository root");
+            }
+            break;
+        }
+        const parent = path.dirname(ancestor);
+        if (parent === ancestor)
+            break;
+        ancestor = parent;
+    }
+    const rel = path.relative(root, absolute);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new PathEscapeError("path escapes repository root");
+    }
+    const mapped = path.resolve(realRoot, rel);
+    if (!isPathInsideRoot(realRoot, mapped) && mapped !== realRoot) {
         throw new PathEscapeError("path escapes repository root");
     }
-    return realTarget;
+    return mapped;
 }
 /** Assert `candidate` resolves inside `root`; throws PathEscapeError otherwise. */
 export function assertInsideRepo(rootInput, candidate) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praneeth_54/agentdoctor",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Engineering assurance for AI coding agents — repository intelligence, change evidence, safety controls, and MCP tools.",
   "type": "module",
   "bin": {