@praneeth_54/agentdoctor 2.0.0 → 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/architecture/contract.d.ts

@@ -0,0 +1,64 @@
+import type { RepositoryGraph } from "../platform/types.js";
+export interface ArchitectureLayer {
+    id: string;
+    paths: string[];
+}
+export interface ForbiddenDependency {
+    fromLayer: string;
+    toLayer: string;
+    id: string;
+    description: string;
+}
+export interface AllowedDependency {
+    fromLayer: string;
+    toLayer: string;
+}
+export interface ArchitectureContract {
+    version: "1";
+    layers: ArchitectureLayer[];
+    forbidden: ForbiddenDependency[];
+    allowed: AllowedDependency[];
+}
+export interface ArchitectureViolation {
+    ruleId: string;
+    kind: "forbidden" | "not-allowed";
+    description: string;
+    fromPath: string;
+    toPath: string;
+    fromLayer: string;
+    toLayer: string;
+    evidence: {
+        edgeId: string;
+        edgeKind: string;
+        evidenceKind: string;
+    };
+}
+export interface ArchitectureCheckResult {
+    root: string;
+    contractPath: string | null;
+    contract: ArchitectureContract | null;
+    violations: ArchitectureViolation[];
+    importEdgesChecked: number;
+    limitations: string[];
+}
+export declare const DEFAULT_ARCHITECTURE_CONTRACT: ArchitectureContract;
+export declare function layerForPath(filePath: string, layers: ArchitectureLayer[]): string | null;
+/**
+ * Minimal YAML subset parser for architecture contracts.
+ * Also accepts JSON content inside .yml files.
+ */
+export declare function parseArchitectureYamlSubset(text: string): ArchitectureContract;
+export declare function parseArchitectureJson(text: string): ArchitectureContract;
+export declare function loadArchitectureContract(rootInput: string): Promise<{
+    contract: ArchitectureContract;
+    path: string;
+} | null>;
+export declare function initArchitecture(rootInput: string): Promise<string>;
+/**
+ * Check import edges against the architecture contract.
+ * Forbidden rules always apply. When `allowed` is non-empty, cross-layer
+ * imports not listed in allowed (and not same-layer) are reported as not-allowed.
+ */
+export declare function checkArchitecture(rootInput: string, graph: RepositoryGraph, contract?: ArchitectureContract | null, contractPath?: string | null): ArchitectureCheckResult;
+export declare function checkArchitectureAtRoot(rootInput: string, graph: RepositoryGraph): Promise<ArchitectureCheckResult>;
+export declare function explainArchitecture(contract: ArchitectureContract | null, check?: ArchitectureCheckResult | null): string;