@praneeth_54/agentdoctor 2.0.1 → 3.0.0

package/dist/agent/verify.js

@@ -0,0 +1,210 @@
+import { analyzeChange, verifyChange } from "../assurance/change.js";
+import { buildProofFromEvidence } from "../assurance/proof.js";
+import { checkArchitectureAtRoot } from "../architecture/contract.js";
+import { buildRepositoryGraph } from "../platform/graph/build.js";
+import { analyzeChanges } from "../core/changes/analyze.js";
+import { resolveRepoRoot } from "../utils/path.js";
+import { executeAgentTool, newToolCall } from "./tools/index.js";
+/**
+ * Post-change verification for the coding agent (M5).
+ * Reuses analyzeChange / verifyChange / proof / architecture — does not invent results.
+ */
+export async function verifyAgentWork(options) {
+    const root = resolveRepoRoot(options.root);
+    const checks = [];
+    const verified = [];
+    const notVerified = [
+        "production database",
+        "external deployment",
+        "external API behavior",
+        "full product correctness",
+    ];
+    const git = await analyzeChanges({ root, impact: true });
+    checks.push({
+        id: "git-status",
+        label: "Git status / change set",
+        status: git.gitAvailable ? "passed" : "skipped",
+        detail: git.gitAvailable
+            ? `${git.files.length} changed path(s); impact=${git.impact?.status ?? "n/a"}`
+            : "Git not available — change set UNKNOWN",
+    });
+    if (git.gitAvailable)
+        verified.push("Git change set inspected");
+    const filesChanged = options.filesChanged?.length
+        ? options.filesChanged
+        : git.files.map((f) => f.path).slice(0, 50);
+    let changeId = null;
+    let proofId = null;
+    try {
+        const assessment = await analyzeChange({ root });
+        changeId = assessment.changeId;
+        checks.push({
+            id: "change-analyze",
+            label: "Change impact analyzed",
+            status: "passed",
+            detail: `changeId=${assessment.changeId}; symbols=${assessment.changedSymbols.length}`,
+        });
+        verified.push("Change impact analyzed");
+        const { assessment: verifiedAssessment, manifest } = await verifyChange({
+            root,
+            changeId: assessment.changeId,
+        });
+        checks.push({
+            id: "change-verify",
+            label: "Evidence bundle produced",
+            status: verifiedAssessment.verificationStatus === "evidence-produced" ? "passed" : "failed",
+            detail: `status=${verifiedAssessment.verificationStatus}; evidence=${manifest.changeId}`,
+        });
+        if (verifiedAssessment.verificationStatus === "evidence-produced") {
+            verified.push("Evidence bundle produced");
+        }
+        try {
+            const proof = await buildProofFromEvidence(root, assessment.changeId);
+            proofId = proof.proofId;
+            checks.push({
+                id: "proof",
+                label: "Change proof",
+                status: "passed",
+                detail: `proofId=${proof.proofId}; integrity=${proof.integrityStatus}; correctness=${proof.correctnessStatus}`,
+            });
+            verified.push(`Proof built (${proof.integrityStatus})`);
+        }
+        catch (error) {
+            checks.push({
+                id: "proof",
+                label: "Change proof",
+                status: "failed",
+                detail: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    catch (error) {
+        checks.push({
+            id: "change-analyze",
+            label: "Change impact analyzed",
+            status: "failed",
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+    try {
+        const graph = await buildRepositoryGraph(root);
+        const arch = await checkArchitectureAtRoot(root, graph);
+        const hasContract = Boolean(arch.contractPath && arch.contract);
+        const ok = arch.violations.length === 0;
+        checks.push({
+            id: "architecture",
+            label: "Architecture check",
+            status: !hasContract ? "skipped" : ok ? "passed" : "failed",
+            detail: !hasContract
+                ? "No architecture contract present"
+                : `${arch.violations.length} violation(s); edges checked=${arch.importEdgesChecked}`,
+        });
+        if (hasContract) {
+            if (ok)
+                verified.push("Architecture check passed");
+            else
+                verified.push("Architecture check ran (violations found)");
+        }
+        else {
+            notVerified.push("architecture contract (none present)");
+        }
+    }
+    catch (error) {
+        checks.push({
+            id: "architecture",
+            label: "Architecture check",
+            status: "failed",
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+    if (options.runTests && options.approvedByHuman) {
+        const testResult = await executeAgentTool(root, newToolCall("verify", "run_tests", {}), {
+            allowExecute: true,
+            approvedByHuman: true,
+        });
+        checks.push({
+            id: "tests",
+            label: "Controlled test run",
+            status: testResult.ok ? "passed" : "failed",
+            detail: testResult.ok
+                ? `exit=${testResult.data.exitCode ?? 0}`
+                : `${testResult.error?.code}: ${testResult.error?.message}`,
+        });
+        if (testResult.ok)
+            verified.push("Relevant tests executed (controlled runner)");
+        else
+            notVerified.push("test suite (execution failed or policy blocked)");
+    }
+    else {
+        checks.push({
+            id: "tests",
+            label: "Controlled test run",
+            status: "not-run",
+            detail: options.runTests
+                ? "Tests requested but human approval missing"
+                : "Tests not requested for this verification pass",
+        });
+        notVerified.push("test execution (not run in this pass)");
+    }
+    checks.push({
+        id: "workspace",
+        label: "Workspace boundary",
+        status: "passed",
+        detail: "All prior agent writes used path-safe resolveSafeRepoPath",
+    });
+    verified.push("Workspace boundary respected (write path)");
+    const summaryText = formatVerificationReport({
+        root,
+        changeId,
+        proofId,
+        filesChanged,
+        checks,
+        verified,
+        notVerified,
+        correctnessStatus: "ENGINEERING_CORRECTNESS_NOT_CLAIMED",
+        summaryText: "",
+    });
+    return {
+        root,
+        changeId,
+        proofId,
+        filesChanged,
+        checks,
+        verified,
+        notVerified,
+        correctnessStatus: "ENGINEERING_CORRECTNESS_NOT_CLAIMED",
+        summaryText,
+    };
+}
+export function formatVerificationReport(report) {
+    const lines = [
+        "",
+        "IMPLEMENTATION COMPLETE",
+        "",
+        report.filesChanged.length
+            ? `Changed:\n${report.filesChanged.map((f) => `  - ${f}`).join("\n")}`
+            : "Changed: (none recorded)",
+        "",
+        "Verification:",
+        ...report.checks.map((c) => {
+            const mark = c.status === "passed"
+                ? "✓"
+                : c.status === "failed"
+                    ? "✗"
+                    : c.status === "skipped"
+                        ? "○"
+                        : "·";
+            return `  ${mark} ${c.label} — ${c.detail}`;
+        }),
+        "",
+        "Verified:",
+        ...report.verified.map((v) => `  - ${v}`),
+        "",
+        "Not verified:",
+        ...report.notVerified.map((v) => `  - ${v}`),
+        "",
+        report.correctnessStatus,
+        "",
+    ];
+    return lines.join("\n");
+}

package/dist/ai/config.d.ts

@@ -0,0 +1,22 @@
+import type { AiProviderId } from "./types.js";
+/**
+ * AI provider configuration.
+ * Secrets come only from environment variables — never from Brain or committed files.
+ */
+export interface AiConfig {
+    provider: AiProviderId;
+    model: string;
+    baseUrl?: string;
+    /** Present only in memory from env — never serialized to Brain/evidence */
+    apiKey?: string;
+    configured: boolean;
+}
+/**
+ * Load AI config from environment.
+ * Does not read API keys from disk. Does not write secrets anywhere.
+ */
+export declare function loadAiConfig(env?: NodeJS.ProcessEnv): AiConfig;
+/** Safe view for logs / CLI — never includes apiKey. */
+export declare function publicAiConfig(config: AiConfig): Omit<AiConfig, "apiKey"> & {
+    apiKeySet: boolean;
+};

package/dist/ai/config.js

@@ -0,0 +1,69 @@
+const DEFAULT_MODELS = {
+    none: "none",
+    deterministic: "local-analyzers",
+    mock: "mock",
+    "openai-compatible": "gpt-4o-mini",
+    ollama: "llama3.2",
+    anthropic: "claude-sonnet-4-5",
+    gemini: "gemini-2.0-flash",
+};
+function normalizeProvider(raw) {
+    const v = (raw ?? "none").trim().toLowerCase();
+    switch (v) {
+        case "none":
+        case "":
+            return "none";
+        case "mock":
+            return "mock";
+        case "openai":
+        case "openai-compatible":
+        case "openrouter":
+            return "openai-compatible";
+        case "ollama":
+            return "ollama";
+        case "anthropic":
+            return "anthropic";
+        case "gemini":
+        case "google":
+            return "gemini";
+        default:
+            return "none";
+    }
+}
+/**
+ * Load AI config from environment.
+ * Does not read API keys from disk. Does not write secrets anywhere.
+ */
+export function loadAiConfig(env = process.env) {
+    const provider = normalizeProvider(env.AGENTDOCTOR_AI_PROVIDER);
+    const model = (env.AGENTDOCTOR_AI_MODEL ?? DEFAULT_MODELS[provider]).trim();
+    const baseUrl = env.AGENTDOCTOR_AI_BASE_URL?.trim() || undefined;
+    const apiKey = env.AGENTDOCTOR_AI_API_KEY?.trim() || undefined;
+    const configured = provider !== "none" &&
+        (provider === "mock" ||
+            provider === "ollama" ||
+            Boolean(apiKey) ||
+            (provider === "openai-compatible" && Boolean(baseUrl)));
+    const result = {
+        provider,
+        model,
+        configured: provider === "mock" ? true : configured,
+    };
+    if (baseUrl)
+        result.baseUrl = baseUrl;
+    if (apiKey)
+        result.apiKey = apiKey;
+    return result;
+}
+/** Safe view for logs / CLI — never includes apiKey. */
+export function publicAiConfig(config) {
+    const pub = {
+        provider: config.provider,
+        model: config.model,
+        configured: config.configured,
+        apiKeySet: Boolean(config.apiKey),
+    };
+    if (config.baseUrl)
+        pub.baseUrl = config.baseUrl;
+    return pub;
+}

package/dist/ai/index.d.ts

@@ -0,0 +1,17 @@
+import { type AiConfig } from "./config.js";
+import type { ModelProvider } from "./types.js";
+export type { AiConfig } from "./config.js";
+export { loadAiConfig, publicAiConfig } from "./config.js";
+export { redactForModel, redactMessages } from "./redact.js";
+export type { AiProviderId, ChatMessage, ChatRequest, ChatResponse, ModelMetadata, ModelProvider, ToolCallRequest, ToolSpec, TokenUsage, } from "./types.js";
+export { AI_PROVIDER_REQUIRED_MESSAGE } from "./types.js";
+export { NoneModelProvider } from "./providers/none.js";
+export { MockModelProvider } from "./providers/mock.js";
+export { OpenAiCompatibleProvider } from "./providers/openai-compatible.js";
+/**
+ * Create a ModelProvider from config / env.
+ * Unsupported providers (anthropic/gemini native) return none with a clear error path via none,
+ * unless mapped later — for M1 only none/mock/openai-compatible/ollama-via-compatible are live.
+ */
+export declare function createModelProvider(config?: AiConfig): ModelProvider;
+export declare function requireAiProviderMessage(provider: ModelProvider): string | null;

package/dist/ai/index.js

@@ -0,0 +1,52 @@
+import { loadAiConfig } from "./config.js";
+import { NoneModelProvider } from "./providers/none.js";
+import { MockModelProvider } from "./providers/mock.js";
+import { OpenAiCompatibleProvider } from "./providers/openai-compatible.js";
+import { AI_PROVIDER_REQUIRED_MESSAGE } from "./types.js";
+export { loadAiConfig, publicAiConfig } from "./config.js";
+export { redactForModel, redactMessages } from "./redact.js";
+export { AI_PROVIDER_REQUIRED_MESSAGE } from "./types.js";
+export { NoneModelProvider } from "./providers/none.js";
+export { MockModelProvider } from "./providers/mock.js";
+export { OpenAiCompatibleProvider } from "./providers/openai-compatible.js";
+/**
+ * Create a ModelProvider from config / env.
+ * Unsupported providers (anthropic/gemini native) return none with a clear error path via none,
+ * unless mapped later — for M1 only none/mock/openai-compatible/ollama-via-compatible are live.
+ */
+export function createModelProvider(config = loadAiConfig()) {
+    switch (config.provider) {
+        case "mock":
+            return new MockModelProvider();
+        case "openai-compatible": {
+            const opts = {
+                model: config.model,
+            };
+            if (config.apiKey)
+                opts.apiKey = config.apiKey;
+            if (config.baseUrl)
+                opts.baseUrl = config.baseUrl;
+            return new OpenAiCompatibleProvider(opts);
+        }
+        case "ollama":
+            // Ollama OpenAI-compatible endpoint when available; otherwise fail closed via HTTP errors.
+            return new OpenAiCompatibleProvider({
+                apiKey: config.apiKey ?? "ollama",
+                baseUrl: config.baseUrl ?? "http://127.0.0.1:11434/v1",
+                model: config.model,
+            });
+        case "anthropic":
+        case "gemini":
+            // Native SDKs are NOT IMPLEMENTED in M1 — fail closed via none message.
+            return new NoneModelProvider();
+        case "none":
+        default:
+            return new NoneModelProvider();
+    }
+}
+export function requireAiProviderMessage(provider) {
+    if (provider.id === "none") {
+        return AI_PROVIDER_REQUIRED_MESSAGE;
+    }
+    return null;
+}

package/dist/ai/providers/mock.d.ts

@@ -0,0 +1,20 @@
+import type { ChatRequest, ChatResponse, ModelMetadata, ModelProvider, ToolCallRequest } from "../types.js";
+export interface MockScriptStep {
+    content?: string;
+    toolCalls?: ToolCallRequest[];
+}
+/**
+ * Deterministic mock provider for tests and offline demos.
+ * Never calls the network.
+ * Optional `script` advances one step per chat() for coding-loop tests.
+ */
+export declare class MockModelProvider implements ModelProvider {
+    readonly id: "mock";
+    private turn;
+    private readonly script;
+    constructor(options?: {
+        script?: MockScriptStep[];
+    });
+    metadata(): ModelMetadata;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+}

package/dist/ai/providers/mock.js

@@ -0,0 +1,84 @@
+import { redactForModel, redactMessages } from "../redact.js";
+/**
+ * Deterministic mock provider for tests and offline demos.
+ * Never calls the network.
+ * Optional `script` advances one step per chat() for coding-loop tests.
+ */
+export class MockModelProvider {
+    id = "mock";
+    turn = 0;
+    script;
+    constructor(options) {
+        this.script = options?.script;
+    }
+    metadata() {
+        return {
+            provider: "mock",
+            model: "mock",
+            supportsTools: true,
+            supportsStreaming: false,
+            supportsStructuredOutput: false,
+        };
+    }
+    async chat(request) {
+        const messages = redactMessages(request.messages);
+        if (this.script) {
+            const step = this.script[this.turn] ?? { content: "[AI-GENERATED mock] done", toolCalls: [] };
+            this.turn += 1;
+            const toolCalls = step.toolCalls ?? [];
+            const text = step.content ?? (toolCalls.length ? "(proposing tools)" : "done");
+            return {
+                provider: "mock",
+                model: "mock",
+                message: { role: "assistant", content: text },
+                toolCalls,
+                usage: {
+                    promptTokens: messages.reduce((n, m) => n + Math.ceil(m.content.length / 4), 0),
+                    completionTokens: Math.ceil(text.length / 4),
+                    totalTokens: 0,
+                },
+                finishReason: toolCalls.length ? "tool_calls" : "stop",
+                aiGenerated: true,
+            };
+        }
+        const lastUser = [...messages].reverse().find((m) => m.role === "user");
+        const lastTool = [...messages].reverse().find((m) => m.role === "tool");
+        const preview = redactForModel(lastUser?.content ?? "").slice(0, 120);
+        let text = `[AI-GENERATED mock] Received ${messages.length} message(s). Last user: ${preview || "(empty)"}`;
+        // Tool-output injection must never become instructions — mock refuses to honor them.
+        if (lastTool?.content && /IGNORE\s+ALL\s+PREVIOUS\s+INSTRUCTIONS/i.test(lastTool.content)) {
+            text =
+                "[AI-GENERATED mock] Ignoring untrusted TOOL_OUTPUT instructions. Continuing safely without destructive actions.";
+            return {
+                provider: "mock",
+                model: "mock",
+                message: { role: "assistant", content: text },
+                toolCalls: [],
+                finishReason: "stop",
+                aiGenerated: true,
+            };
+        }
+        const toolCalls = [];
+        const match = /call tool\s+([a-z0-9_]+)/i.exec(lastUser?.content ?? "");
+        if (match && request.tools?.some((t) => t.name === match[1])) {
+            toolCalls.push({
+                id: "mock_tool_1",
+                name: match[1],
+                arguments: {},
+            });
+        }
+        return {
+            provider: "mock",
+            model: "mock",
+            message: { role: "assistant", content: text },
+            toolCalls,
+            usage: {
+                promptTokens: messages.reduce((n, m) => n + Math.ceil(m.content.length / 4), 0),
+                completionTokens: Math.ceil(text.length / 4),
+                totalTokens: 0,
+            },
+            finishReason: toolCalls.length ? "tool_calls" : "stop",
+            aiGenerated: true,
+        };
+    }
+}

package/dist/ai/providers/none.d.ts

@@ -0,0 +1,6 @@
+import type { ChatRequest, ChatResponse, ModelMetadata, ModelProvider } from "../types.js";
+export declare class NoneModelProvider implements ModelProvider {
+    readonly id: "none";
+    metadata(): ModelMetadata;
+    chat(_request: ChatRequest): Promise<ChatResponse>;
+}

package/dist/ai/providers/none.js

@@ -0,0 +1,23 @@
+import { AI_PROVIDER_REQUIRED_MESSAGE } from "../types.js";
+export class NoneModelProvider {
+    id = "none";
+    metadata() {
+        return {
+            provider: "none",
+            model: "none",
+            supportsTools: false,
+            supportsStreaming: false,
+            supportsStructuredOutput: false,
+        };
+    }
+    async chat(_request) {
+        return {
+            provider: "none",
+            model: "none",
+            message: { role: "assistant", content: "" },
+            toolCalls: [],
+            aiGenerated: true,
+            error: AI_PROVIDER_REQUIRED_MESSAGE,
+        };
+    }
+}

package/dist/ai/providers/openai-compatible.d.ts

@@ -0,0 +1,21 @@
+import type { ChatRequest, ChatResponse, ModelMetadata, ModelProvider } from "../types.js";
+export interface OpenAiCompatibleOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    model: string;
+    timeoutMs?: number;
+}
+/**
+ * Minimal OpenAI-compatible Chat Completions client (custom base URL supported).
+ * Uses Node fetch. Does not silently fall back to another provider.
+ */
+export declare class OpenAiCompatibleProvider implements ModelProvider {
+    readonly id: "openai-compatible";
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly model;
+    private readonly timeoutMs;
+    constructor(options: OpenAiCompatibleOptions);
+    metadata(): ModelMetadata;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+}

package/dist/ai/providers/openai-compatible.js

@@ -0,0 +1,151 @@
+import { redactMessages } from "../redact.js";
+/**
+ * Minimal OpenAI-compatible Chat Completions client (custom base URL supported).
+ * Uses Node fetch. Does not silently fall back to another provider.
+ */
+export class OpenAiCompatibleProvider {
+    id = "openai-compatible";
+    apiKey;
+    baseUrl;
+    model;
+    timeoutMs;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+        this.model = options.model;
+        this.timeoutMs = options.timeoutMs ?? 60_000;
+    }
+    metadata() {
+        return {
+            provider: "openai-compatible",
+            model: this.model,
+            supportsTools: true,
+            supportsStreaming: false,
+            supportsStructuredOutput: false,
+        };
+    }
+    async chat(request) {
+        if (!this.apiKey &&
+            !this.baseUrl.includes("localhost") &&
+            !this.baseUrl.includes("127.0.0.1")) {
+            return {
+                provider: "openai-compatible",
+                model: this.model,
+                message: { role: "assistant", content: "" },
+                toolCalls: [],
+                aiGenerated: true,
+                error: "AI provider unavailable: AGENTDOCTOR_AI_API_KEY is not set.",
+            };
+        }
+        const messages = redactMessages(request.messages).map((m) => ({
+            role: m.role === "tool" ? "tool" : m.role,
+            content: m.content,
+            ...(m.toolCallId ? { tool_call_id: m.toolCallId } : {}),
+            ...(m.name ? { name: m.name } : {}),
+        }));
+        const body = {
+            model: request.model ?? this.model,
+            messages,
+            temperature: request.temperature ?? 0.2,
+            max_tokens: request.maxTokens ?? 2048,
+        };
+        if (request.tools && request.tools.length > 0) {
+            body.tools = request.tools.map((t) => ({
+                type: "function",
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                },
+            }));
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        const onAbort = () => controller.abort();
+        request.signal?.addEventListener("abort", onAbort);
+        try {
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            if (this.apiKey) {
+                headers.Authorization = `Bearer ${this.apiKey}`;
+            }
+            const res = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const errText = await res.text().catch(() => "");
+                return {
+                    provider: "openai-compatible",
+                    model: this.model,
+                    message: { role: "assistant", content: "" },
+                    toolCalls: [],
+                    aiGenerated: true,
+                    error: `AI provider unavailable: HTTP ${res.status}${errText ? ` (${errText.slice(0, 200)})` : ""}`,
+                };
+            }
+            const data = (await res.json());
+            const choice = data.choices?.[0];
+            const rawTools = choice?.message?.tool_calls ?? [];
+            const toolCalls = rawTools.map((tc) => {
+                let args = {};
+                try {
+                    args = JSON.parse(tc.function?.arguments ?? "{}");
+                }
+                catch {
+                    args = {};
+                }
+                return {
+                    id: tc.id,
+                    name: tc.function?.name ?? "unknown",
+                    arguments: args,
+                };
+            });
+            const message = {
+                role: "assistant",
+                content: String(choice?.message?.content ?? ""),
+            };
+            return {
+                provider: "openai-compatible",
+                model: data.model ?? this.model,
+                message,
+                toolCalls,
+                ...(data.usage
+                    ? {
+                        usage: {
+                            ...(data.usage.prompt_tokens !== undefined
+                                ? { promptTokens: data.usage.prompt_tokens }
+                                : {}),
+                            ...(data.usage.completion_tokens !== undefined
+                                ? { completionTokens: data.usage.completion_tokens }
+                                : {}),
+                            ...(data.usage.total_tokens !== undefined
+                                ? { totalTokens: data.usage.total_tokens }
+                                : {}),
+                        },
+                    }
+                    : {}),
+                ...(choice?.finish_reason ? { finishReason: choice.finish_reason } : {}),
+                aiGenerated: true,
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return {
+                provider: "openai-compatible",
+                model: this.model,
+                message: { role: "assistant", content: "" },
+                toolCalls: [],
+                aiGenerated: true,
+                error: `AI provider unavailable: ${msg}`,
+            };
+        }
+        finally {
+            clearTimeout(timer);
+            request.signal?.removeEventListener("abort", onAbort);
+        }
+    }
+}