@praneeth_54/agentdoctor 2.0.1 → 2.1.0

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);
+        }
+    }
+}

package/dist/ai/redact.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Redaction for outbound model payloads.
+ * Extends the local-ai redaction patterns; never send raw secrets to providers.
+ */
+export declare function redactForModel(text: string): string;
+export declare function redactMessages<T extends {
+    content: string;
+}>(messages: T[]): T[];

package/dist/ai/redact.js

@@ -0,0 +1,21 @@
+/**
+ * Redaction for outbound model payloads.
+ * Extends the local-ai redaction patterns; never send raw secrets to providers.
+ */
+const SECRET_PATTERNS = [
+    /\b(AKIA[0-9A-Z]{16})\b/g,
+    /\b(ghp_[A-Za-z0-9]{36})\b/g,
+    /\b(sk-[A-Za-z0-9]{20,})\b/g,
+    /-----BEGIN [^-]+PRIVATE KEY-----[\s\S]*?-----END [^-]+PRIVATE KEY-----/g,
+    /\b((?:export\s+)?(?:AWS_SECRET_ACCESS_KEY|GITHUB_TOKEN|NPM_TOKEN|OPENAI_API_KEY|ANTHROPIC_API_KEY|STRIPE_SECRET_KEY|AGENTDOCTOR_AI_API_KEY)\s*=\s*)(['"]?)[^\s'"]+\2/gi,
+];
+export function redactForModel(text) {
+    let out = text;
+    for (const re of SECRET_PATTERNS) {
+        out = out.replace(re, "[REDACTED]");
+    }
+    return out;
+}
+export function redactMessages(messages) {
+    return messages.map((m) => ({ ...m, content: redactForModel(m.content) }));
+}

package/dist/ai/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Provider-agnostic model types for AgentDoctor 2.1 Project AI Agent.
+ * The model reasons; AgentDoctor owns context, tools, and verification.
+ */
+export type AiProviderId = "none" | "mock" | "openai-compatible" | "ollama" | "anthropic" | "gemini";
+export type ChatRole = "system" | "user" | "assistant" | "tool";
+export interface ChatMessage {
+    role: ChatRole;
+    content: string;
+    /** Tool call id when role is tool */
+    toolCallId?: string;
+    name?: string;
+}
+export interface ToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema object for arguments */
+    parameters: Record<string, unknown>;
+}
+export interface ToolCallRequest {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface TokenUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    tools?: ToolSpec[];
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** AbortSignal for cancellation when supported */
+    signal?: AbortSignal;
+}
+export interface ChatResponse {
+    provider: AiProviderId;
+    model: string;
+    message: ChatMessage;
+    toolCalls: ToolCallRequest[];
+    usage?: TokenUsage;
+    finishReason?: string;
+    /** Always true for model-generated content */
+    aiGenerated: true;
+    error?: string;
+}
+export interface ModelMetadata {
+    provider: AiProviderId;
+    model: string;
+    supportsTools: boolean;
+    supportsStreaming: boolean;
+    supportsStructuredOutput: boolean;
+}
+export interface ModelProvider {
+    readonly id: AiProviderId;
+    metadata(): ModelMetadata;
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    /**
+     * Optional streaming. Providers that do not support streaming reject.
+     */
+    streamChat?(request: ChatRequest): AsyncIterable<{
+        delta: string;
+        done: boolean;
+        response?: ChatResponse;
+    }>;
+}
+/** User-facing copy when AI is not configured. */
+export declare const AI_PROVIDER_REQUIRED_MESSAGE = "AI features require an AI provider. AgentDoctor's project analysis features continue to work without AI.";

package/dist/ai/types.js

@@ -0,0 +1,6 @@
+/**
+ * Provider-agnostic model types for AgentDoctor 2.1 Project AI Agent.
+ * The model reasons; AgentDoctor owns context, tools, and verification.
+ */
+/** User-facing copy when AI is not configured. */
+export const AI_PROVIDER_REQUIRED_MESSAGE = "AI features require an AI provider. AgentDoctor's project analysis features continue to work without AI.";

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

@@ -0,0 +1,27 @@
+import { type ExitCode } from "../../types/index.js";
+/**
+ * agentdoctor plan — produce an implementation plan (no writes unless --apply elsewhere).
+ */
+export declare function runPlanCommand(options: {
+    goal: string;
+    root?: string;
+    json?: boolean;
+    approve?: boolean;
+}): Promise<ExitCode>;
+/**
+ * agentdoctor agent — inspect, plan, and (with --approve) mutate via controlled tools.
+ */
+export declare function runAgentCommand(options: {
+    root?: string;
+    goal?: string;
+    tool?: string;
+    toolArgs?: Record<string, unknown>;
+    listTools?: boolean;
+    json?: boolean;
+    approve?: boolean;
+    apply?: boolean;
+    /** JSON array of {name, arguments} for deterministic apply */
+    applyOpsJson?: string;
+    verify?: boolean;
+    runTests?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/agent.js

@@ -0,0 +1,153 @@
+import { approvePlan, buildAgentPlan, formatAgentPlan } from "../../agent/plan.js";
+import { evaluateApproval, formatApprovalPrompt } from "../../agent/approvals.js";
+import { runCodingLoop } from "../../agent/loop.js";
+import { executeAgentTool, getToolSpec, listAgentToolSpecs, newToolCall, } from "../../agent/tools/index.js";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { colors } from "../../utils/colors.js";
+/**
+ * agentdoctor plan — produce an implementation plan (no writes unless --apply elsewhere).
+ */
+export async function runPlanCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const plan = await buildAgentPlan({ root, goal: options.goal });
+    if (options.approve) {
+        const approved = approvePlan(plan, true);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ ...approved, note: "Approval recorded; use agent --apply to mutate" }, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatAgentPlan(approved));
+            process.stdout.write(`${colors.yellow('\nApproval recorded. Use: agentdoctor agent --goal "..." --approve --apply\n')}\n`);
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(formatAgentPlan(plan));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+/**
+ * agentdoctor agent — inspect, plan, and (with --approve) mutate via controlled tools.
+ */
+export async function runAgentCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const approvedByHuman = options.approve === true;
+    if (options.listTools) {
+        const tools = listAgentToolSpecs({ includeWrite: true, includeExecute: true });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(tools, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(`\n${colors.bold("AgentDoctor tools")}\n\n`);
+            for (const t of tools) {
+                process.stdout.write(`  [${t.risk}] ${t.name} (${t.category}) — ${t.description}\n`);
+            }
+            process.stdout.write("\n");
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.tool) {
+        const name = options.tool;
+        const spec = getToolSpec(name);
+        if (!spec) {
+            process.stderr.write(`Unknown tool: ${name}\n`);
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        const approval = evaluateApproval({ action: `tool:${name}`, risk: spec.risk, toolName: name }, { approvedByHuman });
+        if (approval.needsHumanApproval) {
+            process.stderr.write(formatApprovalPrompt({ action: `tool:${name}`, risk: approval.risk, toolName: name }, approval));
+            process.stderr.write("Re-run with --approve for write/execute tools.\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        const call = newToolCall("cli-agent", name, options.toolArgs ?? {});
+        const result = await executeAgentTool(root, call, {
+            allowWrite: approvedByHuman,
+            allowExecute: approvedByHuman,
+            approvedByHuman,
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else if (result.ok) {
+            process.stdout.write(`${JSON.stringify(result.data, null, 2)}\n`);
+        }
+        else {
+            process.stderr.write(`Tool failed: ${result.error?.code} — ${result.error?.message}\n`);
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.goal && options.apply) {
+        if (!approvedByHuman) {
+            process.stderr.write("Refusing --apply without --approve (human approval required).\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        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 runCodingLoop({
+            root,
+            goal: options.goal,
+            approvedByHuman: true,
+            ...(toolCalls ? { toolCalls } : {}),
+            verify: options.verify !== false,
+            runTests: options.runTests === true,
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(result.responseText);
+        }
+        if (result.stoppedReason === "awaiting-approval")
+            return EXIT_CODES.USAGE_ERROR;
+        if (result.stoppedReason === "failed" || result.stoppedReason === "limit") {
+            return EXIT_CODES.INTERNAL_ERROR;
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    if (options.goal) {
+        return runPlanCommand({
+            goal: options.goal,
+            root,
+            ...(options.json !== undefined ? { json: options.json } : {}),
+            ...(approvedByHuman ? { approve: true } : {}),
+        });
+    }
+    process.stderr.write([
+        "",
+        "AgentDoctor agent (Milestone 4)",
+        "",
+        "Usage:",
+        "  agentdoctor agent --list-tools",
+        "  agentdoctor agent --tool inspect_project [path]",
+        '  agentdoctor plan "Add registration" [path]',
+        "  agentdoctor agent --goal \"Add registration\" --approve --apply --apply-ops '[...]' [path]",
+        "",
+        "Writes require --approve. Unrestricted shell is never exposed.",
+        "",
+    ].join("\n"));
+    return EXIT_CODES.USAGE_ERROR;
+}

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

@@ -0,0 +1,14 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runAskCommand(options: {
+    question: string;
+    root?: string;
+    json?: boolean;
+    /** Test-only: force mock provider */
+    useMock?: boolean;
+}): Promise<ExitCode>;
+export declare function runChatCommand(options: {
+    root?: string;
+    /** Non-interactive scripted lines (tests) */
+    scriptedInputs?: string[];
+    useMock?: boolean;
+}): Promise<ExitCode>;