@praneeth_54/agentdoctor 2.0.1 → 2.1.0

package/dist/cli/commands/chat.js

@@ -0,0 +1,155 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { ChatService, CHAT_PROVIDER_NONE_MESSAGE, formatChatResponseForCli, } from "../../agent/chat/index.js";
+import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { colors } from "../../utils/colors.js";
+function printBanner(options) {
+    const lines = [
+        "",
+        colors.bold("AgentDoctor Project Chat"),
+        "",
+        `Project:`,
+        `  ${options.name}`,
+        `  ${options.root}`,
+        "",
+        `Detected:`,
+        `  ${(options.languages.length ? options.languages : ["(none)"]).join(", ")}`,
+        `  frameworks: ${(options.frameworks.length ? options.frameworks : ["(none)"]).join(", ")}`,
+        "",
+        `AI:`,
+        `  ${options.providerLabel}`,
+        "",
+        "Ask questions about your project.",
+        "",
+        "Commands:",
+        "  /help     Show help",
+        "  /project  Project summary",
+        "  /context  Context used for last answer",
+        "  /clear    Clear conversation memory",
+        "  /exit     Leave chat",
+        "",
+        "Milestone 2 does not edit files or run commands.",
+        "",
+    ];
+    process.stdout.write(`${lines.join("\n")}\n`);
+}
+function printHelp() {
+    process.stdout.write([
+        "",
+        "Ask natural-language questions about this repository.",
+        "Answers use project evidence (Brain/graph/context) when available.",
+        "",
+        "Truth labels: VERIFIED | INFERRED | UNKNOWN | EXTERNAL",
+        "",
+        "Examples:",
+        "  Explain my project.",
+        "  How does authentication work?",
+        "  Explain this like I'm a beginner.",
+        "",
+    ].join("\n"));
+}
+export async function runAskCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const chat = new ChatService({
+        root,
+        provider,
+        persistAudit: !options.useMock,
+    });
+    try {
+        const response = await chat.ask(options.question);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatChatResponseForCli(response));
+        }
+        if (response.status === "provider-none")
+            return EXIT_CODES.USAGE_ERROR;
+        if (response.status === "provider-error" || response.status === "failed") {
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        await chat.end();
+    }
+}
+export async function runChatCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const chat = new ChatService({
+        root,
+        provider,
+        persistAudit: !options.useMock,
+    });
+    const started = await chat.start();
+    printBanner({
+        root: started.summary.root,
+        name: started.summary.name,
+        providerLabel: started.providerLabel,
+        languages: started.summary.languages,
+        frameworks: started.summary.frameworks,
+    });
+    if (provider.id === "none" && !options.useMock) {
+        process.stdout.write(`${CHAT_PROVIDER_NONE_MESSAGE}\n`);
+        await chat.end();
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    const scripted = options.scriptedInputs ? [...options.scriptedInputs] : undefined;
+    const rl = scripted === undefined
+        ? readline.createInterface({ input, output, terminal: Boolean(output.isTTY) })
+        : undefined;
+    const readLine = async () => {
+        if (scripted) {
+            if (scripted.length === 0)
+                return null;
+            return scripted.shift() ?? null;
+        }
+        const answer = await rl.question("You:\n> ");
+        return answer;
+    };
+    try {
+        while (true) {
+            const raw = await readLine();
+            if (raw === null)
+                break;
+            const line = raw.trim();
+            if (!line)
+                continue;
+            if (line === "/exit" || line === "exit" || line === "quit") {
+                process.stdout.write("Goodbye.\n");
+                break;
+            }
+            if (line === "/help" || line === "help") {
+                printHelp();
+                continue;
+            }
+            if (line === "/project") {
+                process.stdout.write(await chat.formatProject());
+                continue;
+            }
+            if (line === "/context") {
+                process.stdout.write(chat.formatContext());
+                continue;
+            }
+            if (line === "/clear") {
+                chat.clearMemory();
+                process.stdout.write("Conversation memory cleared.\n");
+                continue;
+            }
+            const response = await chat.ask(line);
+            process.stdout.write(chat.formatResponse(response));
+            if (response.status === "provider-error") {
+                // stay in loop; user may fix provider elsewhere
+            }
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        rl?.close();
+        await chat.end();
+    }
+}

package/dist/cli/commands/learn.d.ts

@@ -0,0 +1,12 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runLearnCommand(options: {
+    root?: string;
+    mode?: string;
+    viva?: boolean;
+    docs?: boolean;
+    build?: string;
+    approve?: boolean;
+    applyOpsJson?: string;
+    json?: boolean;
+    useMock?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/learn.js

@@ -0,0 +1,107 @@
+import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/index.js";
+import { StudentService } from "../../agent/student.js";
+import { parseAgentMode, defaultStudentMode } from "../../agent/modes.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+export async function runLearnCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const mode = parseAgentMode(options.mode) ?? defaultStudentMode();
+    const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
+    const resolvedMode = options.build
+        ? mode === "LEARN"
+            ? "BUILD_WITH_ME"
+            : mode
+        : options.viva || options.docs
+            ? "LEARN"
+            : mode;
+    const student = new StudentService({
+        root,
+        provider,
+        mode: resolvedMode,
+    });
+    try {
+        if (options.build) {
+            let toolCalls;
+            if (options.applyOpsJson) {
+                try {
+                    const parsed = JSON.parse(options.applyOpsJson);
+                    if (!Array.isArray(parsed))
+                        throw new Error("expected array");
+                    toolCalls = parsed.map((item) => {
+                        const row = item;
+                        if (!row.name || typeof row.name !== "string")
+                            throw new Error("ops need name");
+                        return {
+                            name: row.name,
+                            arguments: row.arguments ?? {},
+                        };
+                    });
+                }
+                catch (error) {
+                    process.stderr.write(`Invalid --apply-ops JSON: ${error instanceof Error ? error.message : String(error)}\n`);
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+            }
+            const result = await student.buildFeature({
+                goal: options.build,
+                approvedByHuman: options.approve === true,
+                ...(toolCalls ? { toolCalls } : {}),
+            });
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            }
+            else {
+                process.stdout.write(result.explanation);
+                if (result.status === "awaiting-approval") {
+                    process.stdout.write("\nRe-run with --approve to execute the coding loop.\n");
+                }
+                else if (result.coding) {
+                    process.stdout.write(result.evidenceText);
+                }
+                else {
+                    process.stdout.write(`${result.evidenceText}\n`);
+                }
+            }
+            if (result.status === "awaiting-approval" || result.status === "mode_forbidden") {
+                return EXIT_CODES.USAGE_ERROR;
+            }
+            if (result.status === "failed" || result.status === "limit") {
+                return EXIT_CODES.INTERNAL_ERROR;
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.viva) {
+            const questions = await student.generateVivaQuestions();
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ mode, questions }, null, 2)}\n`);
+            else {
+                process.stdout.write("\nViva questions (grounded in detected stack):\n\n");
+                for (const [i, q] of questions.entries())
+                    process.stdout.write(`  ${i + 1}. ${q}\n`);
+                process.stdout.write("\n");
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.docs) {
+            const sections = await student.generateProjectDocumentation();
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ mode, sections }, null, 2)}\n`);
+            else {
+                for (const s of sections) {
+                    process.stdout.write(`\n[${s.truth}] ${s.title}\n${s.body}\n`);
+                }
+                process.stdout.write("\n");
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        const explained = await student.explainProject();
+        if (options.json)
+            process.stdout.write(`${JSON.stringify({ mode, ...explained }, null, 2)}\n`);
+        else
+            process.stdout.write(explained.text);
+        return EXIT_CODES.SUCCESS;
+    }
+    finally {
+        await student.end();
+    }
+}

package/dist/cli/program.js

@@ -17,6 +17,9 @@ import { runChangeAnalyzeCommand, runChangeDiffCommand, runChangeExplainCommand,
 import { runGraphSurfaceCommand, runPolicyCheckCommand, runPolicyEnforceCommand, runPolicyExplainCommand, runRunCommand, runRunExplainCommand, } from "./commands/policy-graph-run.js";
 import { runArchitectureCommand } from "./commands/architecture.js";
 import { runWorkspaceCommand } from "./commands/workspace.js";
+import { runAskCommand, runChatCommand } from "./commands/chat.js";
+import { runAgentCommand, runPlanCommand } from "./commands/agent.js";
+import { runLearnCommand } from "./commands/learn.js";
 import { collectOpsHealth } from "../ops/health.js";
 import { listSessions, loadSession } from "../platform/sessions/store.js";
 import { exportReports } from "../platform/reports/export.js";
@@ -1235,6 +1238,95 @@ export function createProgram() {
             json: Boolean(options.json),
         });
     });
+    program
+        .command("chat")
+        .description("Project Chat (2.1): evidence-backed conversation about this repository (requires AI provider)")
+        .argument("[path]", "Repository path (default: current directory)")
+        .action(async (pathArg) => {
+        process.exitCode = await runChatCommand({
+            root: resolveTargetArgument(pathArg),
+        });
+    });
+    program
+        .command("ask")
+        .description("One-shot Project Chat question (same engine as chat)")
+        .argument("<question>", "Question about the project")
+        .argument("[path]", "Repository path (default: current directory)")
+        .option("--json", "Emit JSON response", false)
+        .action(async (question, pathArg, options) => {
+        process.exitCode = await runAskCommand({
+            question,
+            root: resolveTargetArgument(pathArg),
+            json: Boolean(options.json),
+        });
+    });
+    program
+        .command("plan")
+        .description("Project Agent plan (2.1 M3): understand goal, list likely files, request approval — no file edits")
+        .argument("<goal>", "What you want to build or change")
+        .argument("[path]", "Repository path (default: current directory)")
+        .option("--json", "Emit JSON plan", false)
+        .option("--approve", "Record human approval (still no writes in M3)", false)
+        .action(async (goal, pathArg, options) => {
+        process.exitCode = await runPlanCommand({
+            goal,
+            root: resolveTargetArgument(pathArg),
+            json: Boolean(options.json),
+            approve: Boolean(options.approve),
+        });
+    });
+    program
+        .command("agent")
+        .description("Project Agent (2.1): list tools, run tools, plan, or apply approved file/command changes")
+        .argument("[path]", "Repository path (default: current directory)")
+        .option("--list-tools", "List available agent tools", false)
+        .option("--tool <name>", "Run a single tool by name")
+        .option("--goal <text>", "Build a change plan for this goal")
+        .option("--approve", "Record explicit human approval", false)
+        .option("--apply", "Apply approved changes (requires --approve)", false)
+        .option("--apply-ops <json>", "JSON array of {name, arguments} tool ops for --apply")
+        .option("--skip-verify", "Skip post-change verification after apply", false)
+        .option("--run-tests", "Run controlled tests during verification", false)
+        .option("--json", "Emit JSON", false)
+        .action(async (pathArg, options) => {
+        process.exitCode = await runAgentCommand({
+            root: resolveTargetArgument(pathArg),
+            listTools: Boolean(options.listTools),
+            ...(options.tool !== undefined ? { tool: options.tool } : {}),
+            ...(options.goal !== undefined ? { goal: options.goal } : {}),
+            approve: Boolean(options.approve),
+            apply: Boolean(options.apply),
+            ...(options.applyOps !== undefined ? { applyOpsJson: options.applyOps } : {}),
+            verify: !options.skipVerify,
+            runTests: Boolean(options.runTests),
+            json: Boolean(options.json),
+        });
+    });
+    program
+        .command("learn")
+        .description("Student Learn mode (2.1 M6): explain project, viva questions, grounded documentation")
+        .argument("[path]", "Repository path (default: current directory)")
+        .option("--mode <mode>", "LEARN | BUILD_WITH_ME | BUILD_FOR_ME | DEVELOPER", "LEARN")
+        .option("--viva", "Generate viva questions from detected stack", false)
+        .option("--docs", "Generate project documentation sections", false)
+        .option("--build <goal>", "BUILD_WITH_ME / BUILD_FOR_ME: explain, plan, then coding loop")
+        .option("--approve", "Human approval required before BUILD writes", false)
+        .option("--apply-ops <json>", "Deterministic tool ops JSON array for --build --approve")
+        .option("--json", "Emit JSON", false)
+        .option("--mock", "Use MockModelProvider", false)
+        .action(async (pathArg, options) => {
+        process.exitCode = await runLearnCommand({
+            root: resolveTargetArgument(pathArg),
+            ...(options.mode !== undefined ? { mode: options.mode } : {}),
+            viva: Boolean(options.viva),
+            docs: Boolean(options.docs),
+            ...(options.build !== undefined ? { build: options.build } : {}),
+            approve: Boolean(options.approve),
+            ...(options.applyOps !== undefined ? { applyOpsJson: options.applyOps } : {}),
+            json: Boolean(options.json),
+            useMock: Boolean(options.mock),
+        });
+    });
     const platform = program
         .command("platform")
         .description("AgentDoctor 2.0 local platform (intelligence, Action Policy Evaluator, sessions, reports)");

package/dist/constants.d.ts

@@ -1,5 +1,5 @@
 import type { AgentId } from "./types/index.js";
-export declare const PACKAGE_VERSION = "2.0.1";
+export declare const PACKAGE_VERSION = "2.1.0";
 export declare const DEFAULT_MAX_FILE_SIZE_BYTES: number;
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export declare const DEFAULT_IGNORE_DIRECTORIES: Set<string>;

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const PACKAGE_VERSION = "2.0.1";
+export const PACKAGE_VERSION = "2.1.0";
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024; // 2 MiB
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export const DEFAULT_IGNORE_DIRECTORIES = new Set([

package/dist/dashboard/server.d.ts

@@ -1,3 +1,4 @@
+import type { ModelProvider } from "../ai/types.js";
 export interface DashboardServerOptions {
     root: string;
     host?: string;
@@ -9,6 +10,11 @@ export interface DashboardServerOptions {
      * Query ?user= is a localDevIdentityHint only; role elevation requires AGENTDOCTOR_ALLOW_LOCAL_IDENTITY_HINT=1.
      */
     allowNonLoopback?: boolean;
+    /**
+     * Optional provider override (tests). Production uses loadAiConfig().
+     * When unset and provider resolves to none, /api/chat fails closed.
+     */
+    chatProvider?: ModelProvider;
 }
 export declare function isLoopbackHost(host: string): boolean;
 /**

package/dist/dashboard/server.js

@@ -21,6 +21,9 @@ import { CONTRACTS_VERSION } from "../contracts/index.js";
 import { collectOpsHealth } from "../ops/health.js";
 import { listPolicyPacks } from "../policy/packs.js";
 import { sanitizeForOutput } from "../utils/path.js";
+import { createModelProvider, loadAiConfig } from "../ai/index.js";
+import { ChatService } from "../agent/chat/service.js";
+import { formatChatResponseForCli } from "../agent/chat/response.js";
 function safeJsonError(error) {
     const raw = error instanceof Error ? error.message : String(error);
     const { text } = redactSecrets(sanitizeForOutput(raw));
@@ -102,6 +105,7 @@ function htmlPage() {
       <a href="#brain">Brain</a>
       <a href="#graph">Graph</a>
       <a href="#knowledge">Knowledge</a>
+      <a href="#chat">Project Chat</a>
       <a href="#meta">Audit / baselines</a>
     </nav>
     <section id="overview">
@@ -128,6 +132,21 @@ function htmlPage() {
       <h2>Governed knowledge</h2>
       <pre id="knowledgeBody" class="muted">Loading…</pre>
     </section>
+    <section id="chat">
+      <h2>Project Chat</h2>
+      <p class="muted">Ask about this repository. Answers use evidence + truth labels. No file writes from this panel.</p>
+      <div style="display:grid;grid-template-columns:1.4fr 1fr;gap:1rem">
+        <div>
+          <textarea id="chatInput" rows="3" style="width:100%;background:#0d1520;color:#e8eef5;border:1px solid #243040;border-radius:8px;padding:0.6rem" placeholder="How does authentication work?"></textarea>
+          <button id="chatAsk" style="margin-top:0.5rem;background:var(--accent);color:#041018;border:0;border-radius:6px;padding:0.45rem 0.9rem;font-weight:600;cursor:pointer">Ask</button>
+          <pre id="chatBody" class="muted" style="margin-top:0.75rem">Ask a question…</pre>
+        </div>
+        <div>
+          <h3 style="margin:0 0 0.5rem;font-size:0.9rem">Evidence</h3>
+          <pre id="chatEvidence" class="muted">—</pre>
+        </div>
+      </div>
+    </section>
     <section id="meta">
       <h2>Safe Fix audit / baselines / sessions</h2>
       <pre id="metaBody" class="muted">Loading…</pre>
@@ -155,6 +174,28 @@ function htmlPage() {
     load().catch(err => {
       document.getElementById('status').textContent = String(err);
     });
+    document.getElementById('chatAsk').addEventListener('click', async () => {
+      const question = document.getElementById('chatInput').value.trim();
+      if (!question) return;
+      document.getElementById('chatBody').textContent = 'Thinking…';
+      try {
+        const res = await fetch('/api/chat', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ question }),
+        });
+        const data = await res.json();
+        document.getElementById('chatBody').textContent = data.message || JSON.stringify(data, null, 2);
+        document.getElementById('chatEvidence').textContent = JSON.stringify({
+          truthClaims: data.truthClaims || [],
+          citations: data.citations || [],
+          limitations: data.limitations || [],
+          status: data.status,
+        }, null, 2);
+      } catch (err) {
+        document.getElementById('chatBody').textContent = String(err);
+      }
+    });
   </script>
 </body>
 </html>`;
@@ -186,8 +227,55 @@ export async function startDashboardServer(options) {
                 return;
             }
             const url = new URL(rawUrl, `http://${host}:${port}`);
+            if (req.method === "POST" && url.pathname === "/api/chat") {
+                const chunks = [];
+                for await (const chunk of req) {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                }
+                let body = {};
+                try {
+                    body = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+                }
+                catch {
+                    sendJson(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                const question = typeof body.question === "string" ? body.question.trim() : "";
+                if (!question) {
+                    sendJson(res, 400, { error: "question required" });
+                    return;
+                }
+                const provider = options.chatProvider ?? createModelProvider(loadAiConfig());
+                if (provider.id === "none") {
+                    sendJson(res, 503, {
+                        error: "provider-none",
+                        message: "AI chat is not configured. Set AGENTDOCTOR_AI_PROVIDER to mock or an OpenAI-compatible provider. Silent mock fallback is disabled.",
+                        status: "provider-none",
+                    });
+                    return;
+                }
+                const chat = new ChatService({
+                    root,
+                    provider,
+                    persistAudit: false,
+                });
+                try {
+                    const response = await chat.ask(question);
+                    sendJson(res, response.status === "ok" ? 200 : 502, {
+                        ...response,
+                        cliPreview: formatChatResponseForCli(response),
+                        note: "Dashboard chat is ask-only; it does not edit files or run commands.",
+                    });
+                }
+                finally {
+                    await chat.end();
+                }
+                return;
+            }
             if (req.method !== "GET") {
-                sendJson(res, 405, { error: "read-only dashboard; GET only" });
+                sendJson(res, 405, {
+                    error: "dashboard is read-only except POST /api/chat (ask-only; no repo writes)",
+                });
                 return;
             }
             if (pathnameLooksHostile(url.pathname)) {

package/dist/enforcement/runner.d.ts

@@ -1,4 +1,9 @@
 import type { PolicyDecisionContract } from "../contracts/index.js";
+/**
+ * Map argv to a portable executable form for shell:false execution.
+ * Policy evaluation still uses the original human-facing argv/command string.
+ */
+export declare function resolveExecutableArgv(argv: string[]): string[];
 export type ExecutionStatus = "executed" | "blocked-by-enforcement" | "not-executed" | "execution-failed";
 export interface EnforcementResult {
     decision: PolicyDecisionContract;

package/dist/enforcement/runner.js

@@ -4,15 +4,59 @@ import { execFile, spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
-import { realpathSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { evaluateAgentAction, EVALUATE_ONLY } from "../platform/firewall/evaluate.js";
 import { resolveRepoRoot } from "../utils/path.js";
 import { PathEscapeError, assertInsideRepo } from "../security/paths.js";
 const execFileAsync = promisify(execFile);
+/**
+ * Resolve npm/npx to `node <cli.js>` on Windows so execFile(shell:false) does not
+ * hit ENOENT on the `npm` name or fail to spawn `.cmd` shims without a shell.
+ */
+function resolveNpmCliJs(cliFile) {
+    const candidates = [
+        path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", cliFile),
+        path.join(path.dirname(process.execPath), "..", "lib", "node_modules", "npm", "bin", cliFile),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Map argv to a portable executable form for shell:false execution.
+ * Policy evaluation still uses the original human-facing argv/command string.
+ */
+export function resolveExecutableArgv(argv) {
+    if (argv.length === 0)
+        return argv;
+    const bin = argv[0];
+    if (process.platform === "win32" && (bin === "npm" || bin === "npx")) {
+        const cli = resolveNpmCliJs(bin === "npx" ? "npx-cli.js" : "npm-cli.js");
+        if (cli) {
+            return [process.execPath, cli, ...argv.slice(1)];
+        }
+        // Last resort: .cmd name (may still require shell on some hosts).
+        return [`${bin}.cmd`, ...argv.slice(1)];
+    }
+    return argv;
+}
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_BUFFER = 1024 * 1024;
 const OUTPUT_TRUNCATE = 32_768;
-const ENV_ALLOWLIST = new Set(["PATH", "NODE_ENV", "HOME", "LANG"]);
+const ENV_ALLOWLIST = new Set([
+    "PATH",
+    "Path",
+    "NODE_ENV",
+    "HOME",
+    "USERPROFILE",
+    "LANG",
+    "SystemRoot",
+    "SYSTEMROOT",
+    "ComSpec",
+    "PATHEXT",
+]);
 /**
  * Parse a command string into argv without invoking a shell.
  * Supports simple double/single quotes; rejects unclosed quotes.
@@ -195,7 +239,8 @@ async function executeArgv(options) {
             });
         });
     }
-    const [file, ...args] = options.argv;
+    const resolved = resolveExecutableArgv(options.argv);
+    const [file, ...args] = resolved;
     if (!file) {
         return {
             stdout: "",
@@ -206,6 +251,8 @@ async function executeArgv(options) {
             error: "empty command",
         };
     }
+    // Windows .cmd shims cannot be execFile'd with shell:false; use shell only then.
+    const needsWindowsCmdShell = process.platform === "win32" && /\.(cmd|bat)$/i.test(file);
     try {
         const result = await execFileAsync(file, args, {
             cwd,
@@ -213,7 +260,7 @@ async function executeArgv(options) {
             timeout: options.timeoutMs,
             maxBuffer: options.maxBuffer,
             windowsHide: true,
-            shell: false,
+            shell: needsWindowsCmdShell,
         });
         return {
             stdout: truncate(typeof result.stdout === "string" ? result.stdout : String(result.stdout)),

package/dist/index.d.ts

@@ -50,3 +50,16 @@ export { runFix } from "./core/fix/run.js";
 export { evaluatePolicy, evaluateScanPolicy, evaluateVerifyPolicy, parseFailOnRules, parseSeverityGate, } from "./core/policy/evaluate.js";
 export type { PolicyOptions, PolicyViolation, PolicyViolationCode, PolicyInput, } from "./core/policy/evaluate.js";
 export type { FixPlan, FixAction, FixApplyResult } from "./core/fix/types.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";
+export type { AiConfig, AiProviderId, ChatMessage, ChatRequest, ChatResponse, ModelMetadata, ModelProvider, ToolSpec, ToolCallRequest, TokenUsage, } 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 type { AgentLimits, AgentAuditEvent, AgentRuntimeOptions, AgentTurnResult, AgentStateTransition, ContextBundle, ContextCitation, EvidenceType, TruthLabel, RetrieveContextOptions, } from "./agent/index.js";
+export { ChatService, createChatService, ChatMemory, CHAT_PROVIDER_NONE_MESSAGE, buildChatTurnResponse, formatChatResponseForCli, summarizeProjectForChat, } from "./agent/chat/index.js";
+export type { ChatTurnResponse, ChatServiceOptions, TruthClaim, ProjectChatSummary, } 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 type { AgentToolName, AgentToolSpec, AgentToolCall, AgentToolResult, AgentRiskLevel, ApprovalRequest, ApprovalResult, ApprovalDecision, AgentPlan, AgentPlanStep, CodingLoopOptions, CodingLoopResult, AgentVerificationReport, VerificationCheck, } from "./agent/index.js";
+export { getModeProfile, defaultStudentMode, parseAgentMode, modeAllowsMutation, modeBlocksToolCategory, StudentService, } from "./agent/index.js";
+export type { AgentMode, ModeProfile, StudentDocSection, BuildWithMeResult, } from "./agent/index.js";