@praneeth_54/agentdoctor 2.1.0 → 3.0.0

package/dist/agent/chat/deterministic.d.ts

@@ -0,0 +1,6 @@
+import type { ChatTurnResponse } from "./types.js";
+export declare function answerDeterministicProjectQuestion(options: {
+    root: string;
+    question: string;
+    sessionId: string;
+}): Promise<ChatTurnResponse>;

package/dist/agent/chat/deterministic.js

@@ -0,0 +1,180 @@
+import { getBrainStatus } from "../../core/brain-cli/service.js";
+import { buildProjectDna } from "../../product/dna/build.js";
+import { analyzeDependencies } from "../../product/deps/analyze.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { retrieveProjectContext } from "../context/retrieve.js";
+import { buildChatTurnResponse } from "./response.js";
+const ARCH_RE = /architecture|structure|module|layout|how.*(project|repo|codebase)|explain.*(project|repo|codebase|this)|what (is|does) (this|my) project|project overview|understand (my |this )?project/i;
+const AUTH_RE = /auth|login|password|session|jwt|oauth/i;
+const DEPS_RE = /depend|package|lockfile|npm|yarn|pnpm/i;
+const START_RE = /where.*(start|entry|boot|main)|application start|entry\s*point/i;
+const DB_RE = /database|db\.|sql|prisma|query\(/i;
+export async function answerDeterministicProjectQuestion(options) {
+    const root = resolveRepoRoot(options.root);
+    const q = options.question.trim();
+    const context = await retrieveProjectContext({
+        root,
+        query: q,
+        budgetTokens: 4_000,
+    });
+    const sections = [
+        "Deterministic project answer (no LLM). Evidence from DNA, graph, brain, and dependency analyzers.",
+        "",
+    ];
+    const dna = await buildProjectDna(root);
+    sections.push(`[VERIFIED] Project: ${dna.name}`);
+    sections.push(`Languages: ${dna.languages.join(", ") || "UNKNOWN"}`);
+    sections.push(`Frameworks: ${dna.frameworks.join(", ") || "UNKNOWN"}`);
+    sections.push(`Monorepo: ${dna.monorepo.isMonorepo ? dna.monorepo.tool : "no"}`);
+    sections.push("");
+    if (AUTH_RE.test(q)) {
+        const authFiles = context.citations
+            .filter((c) => c.path && /auth|login|session|password/i.test(c.path))
+            .slice(0, 8);
+        sections.push("[INFERRED] Authentication-related paths from retrieval:");
+        if (authFiles.length) {
+            for (const c of authFiles) {
+                sections.push(`  - ${c.path} (${c.confidence})`);
+            }
+        }
+        else {
+            try {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const paths = [
+                    ...new Set(graph.nodes
+                        .map((n) => n.path)
+                        .filter((p) => typeof p === "string" && /auth|login|session|password/i.test(p))),
+                ].slice(0, 8);
+                if (paths.length) {
+                    for (const p of paths) {
+                        sections.push(`  - ${p} (INFERRED from graph)`);
+                    }
+                }
+                else {
+                    sections.push("  UNKNOWN — no auth paths matched; scan src/**/auth* or routes manually.");
+                }
+            }
+            catch {
+                sections.push("  UNKNOWN — no auth paths matched; scan src/**/auth* or routes manually.");
+            }
+        }
+        sections.push("");
+    }
+    if (START_RE.test(q)) {
+        const startHits = context.citations
+            .filter((c) => c.path && /(server|index|main|app)\.[jt]sx?$/i.test(c.path))
+            .slice(0, 6);
+        sections.push("[INFERRED] Likely entry-related paths:");
+        if (startHits.length) {
+            for (const c of startHits) {
+                sections.push(`  - ${c.path} (${c.confidence})`);
+            }
+        }
+        else {
+            try {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const paths = [
+                    ...new Set(graph.nodes
+                        .map((n) => n.path)
+                        .filter((p) => typeof p === "string" && /(server|index|main|app)\.[jt]sx?$/i.test(p))),
+                ].slice(0, 6);
+                if (paths.length) {
+                    for (const p of paths)
+                        sections.push(`  - ${p} (INFERRED from graph)`);
+                }
+                else {
+                    sections.push("  UNKNOWN — no clear entrypoint path in graph.");
+                }
+            }
+            catch {
+                sections.push("  UNKNOWN — no clear entrypoint path in graph.");
+            }
+        }
+        sections.push("");
+    }
+    if (DB_RE.test(q)) {
+        const dbHits = context.citations
+            .filter((c) => c.path && /(db|database|prisma|sql|migration)/i.test(c.path))
+            .slice(0, 6);
+        sections.push("[INFERRED] Database-related paths:");
+        if (dbHits.length) {
+            for (const c of dbHits)
+                sections.push(`  - ${c.path} (${c.confidence})`);
+        }
+        else {
+            try {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const paths = [
+                    ...new Set(graph.nodes
+                        .map((n) => n.path)
+                        .filter((p) => typeof p === "string" && /(db|database|prisma|sql)/i.test(p))),
+                ].slice(0, 6);
+                if (paths.length) {
+                    for (const p of paths)
+                        sections.push(`  - ${p} (INFERRED from graph)`);
+                }
+                else {
+                    sections.push("  UNKNOWN — no database path markers in graph.");
+                }
+            }
+            catch {
+                sections.push("  UNKNOWN — no database path markers in graph.");
+            }
+        }
+        sections.push("");
+    }
+    if (DEPS_RE.test(q)) {
+        const deps = await analyzeDependencies(root);
+        sections.push("[VERIFIED] Direct dependencies (sample):");
+        for (const d of deps.directDependencies.slice(0, 12)) {
+            sections.push(`  - ${d.name} ${d.versionRange} (${d.packageJsonPath})`);
+        }
+        if (deps.transitiveFromLockfile?.length) {
+            sections.push("[VERIFIED] Transitive versions from lockfile (sample):");
+            for (const t of deps.transitiveFromLockfile.slice(0, 12)) {
+                sections.push(`  - ${t.name}@${t.version}`);
+            }
+        }
+        sections.push(`Lockfiles: ${deps.lockfilesPresent.join(", ") || "none"}`);
+        sections.push("");
+    }
+    if (ARCH_RE.test(q)) {
+        try {
+            const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+            sections.push(`[INFERRED] Graph: ${graph.nodes.length} nodes, ${graph.edges.length} edges (${graph.builder})`);
+            const sample = graph.nodes.filter((n) => n.path).slice(0, 6);
+            for (const n of sample) {
+                sections.push(`  - ${n.kind}: ${n.label}${n.path ? ` @ ${n.path}` : ""}`);
+            }
+        }
+        catch {
+            sections.push("[UNKNOWN] Intelligence graph build failed.");
+        }
+        sections.push("");
+    }
+    const brain = await getBrainStatus(root);
+    if (brain.hasSnapshot) {
+        sections.push(`[INFERRED] Project brain snapshot present (${brain.snapshotCount} stored; latest ${brain.latestSnapshotId ?? "unknown"}).`);
+    }
+    else {
+        sections.push("[UNKNOWN] No project brain snapshot — run brain compile for richer answers.");
+    }
+    sections.push("");
+    sections.push("Limitations: deterministic answers cannot invent behavior not present in evidence.");
+    const bundle = {
+        ...context,
+        limitations: [
+            ...context.limitations,
+            "Deterministic chat mode — no LLM; answers are template + local analyzers only.",
+        ],
+    };
+    return buildChatTurnResponse({
+        sessionId: options.sessionId,
+        modelText: sections.join("\n"),
+        context: bundle,
+        provider: "deterministic",
+        model: "local-analyzers",
+        status: "ok",
+    });
+}

package/dist/agent/chat/service.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { AI_PROVIDER_REQUIRED_MESSAGE, createModelProvider, loadAiConfig, publicAiConfig, redactForModel, } from "../../ai/index.js";
+import { createModelProvider, loadAiConfig, publicAiConfig, redactForModel, } from "../../ai/index.js";
 import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
 import { appendSessionEvent, createSession, endSession, } from "../../platform/sessions/store.js";
 import { resolveRepoRoot } from "../../utils/path.js";
@@ -8,6 +8,7 @@ import { ChatMemory } from "./memory.js";
 import { PROJECT_CHAT_SYSTEM_PROMPT, wrapProjectData } from "./prompts.js";
 import { formatProjectSummary, summarizeProjectForChat, } from "./project-summary.js";
 import { buildChatTurnResponse, formatChatResponseForCli } from "./response.js";
+import { answerDeterministicProjectQuestion } from "./deterministic.js";
 export const CHAT_PROVIDER_NONE_MESSAGE = `AI chat is not configured.
 
 Configure an AI provider to use AgentDoctor Project Chat.
@@ -99,20 +100,13 @@ export class ChatService {
             chars: String(safeUser.length),
         });
         if (this.provider.id === "none") {
-            const response = {
+            const response = await answerDeterministicProjectQuestion({
+                root: this.root,
+                question: safeUser,
                 sessionId: this.sessionId,
-                message: CHAT_PROVIDER_NONE_MESSAGE,
-                truthClaims: [],
-                citations: [],
-                provider: "none",
-                model: "none",
-                status: "provider-none",
-                error: AI_PROVIDER_REQUIRED_MESSAGE,
-                contextPaths: [],
-                contextTruncated: false,
-                limitations: [],
-            };
-            await this.audit("error", "CHAT_FAILED", { reason: "provider-none" });
+            });
+            this.memory.addAssistant(response.message, response.contextPaths);
+            await this.audit("prompt", "CHAT_DETERMINISTIC", { status: response.status });
             return response;
         }
         const query = this.memory.resolveQuery(safeUser);

package/dist/agent/index.d.ts

@@ -18,6 +18,8 @@ export { buildAgentPlan, formatAgentPlan, approvePlan } from "./plan.js";
 export type { AgentPlan, AgentPlanStep } from "./plan.js";
 export { runCodingLoop } from "./loop.js";
 export type { CodingLoopOptions, CodingLoopResult } from "./loop.js";
+export { rolePrompt, roleAllowedTools, runRoleAgent } from "./roles.js";
+export type { AgentRole, RoleAgentOptions } from "./roles.js";
 export { verifyAgentWork, formatVerificationReport } from "./verify.js";
 export type { AgentVerificationReport, VerificationCheck } from "./verify.js";
 export { getModeProfile, defaultStudentMode, parseAgentMode, modeAllowsMutation, modeBlocksToolCategory, } from "./modes.js";

package/dist/agent/index.js

@@ -9,6 +9,7 @@ export { listAgentToolSpecs, getToolSpec, riskForTool, executeAgentTool, isReadT
 export { evaluateApproval, formatApprovalPrompt } from "./approvals.js";
 export { buildAgentPlan, formatAgentPlan, approvePlan } from "./plan.js";
 export { runCodingLoop } from "./loop.js";
+export { rolePrompt, roleAllowedTools, runRoleAgent } from "./roles.js";
 export { verifyAgentWork, formatVerificationReport } from "./verify.js";
 export { getModeProfile, defaultStudentMode, parseAgentMode, modeAllowsMutation, modeBlocksToolCategory, } from "./modes.js";
 export { StudentService } from "./student.js";

package/dist/agent/loop.d.ts

@@ -30,6 +30,8 @@ export interface CodingLoopOptions {
     mode?: AgentMode;
     /** Optional workspace isolation context */
     workspace?: WorkspaceModel | null;
+    /** When set, only these tools may run (role agents / restricted turns) */
+    allowedTools?: AgentToolName[];
 }
 export interface CodingLoopResult {
     state: AgentState;

package/dist/agent/loop.js

@@ -6,6 +6,7 @@ import { executeAgentTool, listAgentToolSpecs, newToolCall } from "./tools/index
 import { getToolSpec } from "./tools/registry.js";
 import { verifyAgentWork } from "./verify.js";
 import { modeAllowsMutation } from "./modes.js";
+import { appendChangeLedgerEntry } from "../product/ledger/change-ledger.js";
 function toProviderTools(mode) {
     const includeWrite = modeAllowsMutation(mode);
     return listAgentToolSpecs({
@@ -88,6 +89,22 @@ export async function runCodingLoop(options) {
             ...(options.workspace !== undefined ? { workspace: options.workspace } : {}),
         };
         const runOne = async (call) => {
+            if (options.allowedTools && !options.allowedTools.includes(call.name)) {
+                const denied = {
+                    callId: call.id,
+                    name: call.name,
+                    ok: false,
+                    data: null,
+                    risk: "LOW",
+                    durationMs: 0,
+                    error: {
+                        code: "role_forbidden",
+                        message: `Tool ${call.name} is not allowed for this role/session allowlist`,
+                    },
+                };
+                toolResults.push(denied);
+                return denied;
+            }
             const spec = getToolSpec(call.name);
             const pendingWrite = spec?.category === "write";
             toolCalls += 1;
@@ -191,6 +208,20 @@ export async function runCodingLoop(options) {
             toolResults.push(status);
         }
         machine.transition(AgentState.COMPLETED, "coding loop done");
+        if (filesChanged.length > 0) {
+            try {
+                await appendChangeLedgerEntry(options.root, {
+                    task: options.goal,
+                    plan: plan.goal,
+                    approval: "approvedByHuman",
+                    files: [...new Set(filesChanged)],
+                    note: "coding-loop:completed",
+                });
+            }
+            catch {
+                // best-effort — never fail the loop on ledger persistence
+            }
+        }
         const text = verification
             ? verification.summaryText
             : [

package/dist/agent/roles.d.ts

@@ -0,0 +1,12 @@
+import type { AgentToolName } from "./tools/types.js";
+import { type CodingLoopOptions, type CodingLoopResult } from "./loop.js";
+export type AgentRole = "planner" | "coder" | "tester" | "reviewer" | "security" | "refactoring" | "migration" | "documentation" | "release" | "verifier";
+export declare function rolePrompt(role: AgentRole): string;
+export declare function roleAllowedTools(role: AgentRole): AgentToolName[];
+export type RoleAgentOptions = CodingLoopOptions & {
+    role: AgentRole;
+};
+/**
+ * Same coding loop as the main agent, with a role-specific system note prepended to the goal.
+ */
+export declare function runRoleAgent(options: RoleAgentOptions): Promise<CodingLoopResult>;

package/dist/agent/roles.js

@@ -0,0 +1,138 @@
+import { listAgentToolSpecs } from "./tools/registry.js";
+import { runCodingLoop } from "./loop.js";
+const ALL_TOOL_NAMES = listAgentToolSpecs({
+    includeWrite: true,
+    includeExecute: true,
+}).map((t) => t.name);
+const ROLE_TOOL_ALLOWLIST = {
+    planner: [
+        "read_file",
+        "list_files",
+        "search_code",
+        "find_symbol",
+        "inspect_project",
+        "inspect_architecture",
+        "inspect_dependencies",
+        "inspect_git_status",
+        "inspect_git_diff",
+    ],
+    coder: ALL_TOOL_NAMES,
+    tester: [
+        "read_file",
+        "list_files",
+        "search_code",
+        "find_symbol",
+        "inspect_project",
+        "inspect_tests",
+        "run_tests",
+        "run_command",
+        "inspect_git_diff",
+    ],
+    reviewer: [
+        "read_file",
+        "list_files",
+        "search_code",
+        "find_symbol",
+        "find_references",
+        "find_callers",
+        "find_callees",
+        "inspect_project",
+        "inspect_architecture",
+        "inspect_findings",
+        "inspect_git_diff",
+    ],
+    security: [
+        "read_file",
+        "list_files",
+        "search_code",
+        "inspect_project",
+        "inspect_findings",
+        "inspect_git_diff",
+    ],
+    refactoring: [
+        "read_file",
+        "list_files",
+        "search_code",
+        "find_symbol",
+        "find_references",
+        "find_callers",
+        "find_callees",
+        "inspect_dependencies",
+        "edit_file",
+        "create_file",
+    ],
+    migration: [
+        "read_file",
+        "list_files",
+        "search_code",
+        "find_symbol",
+        "inspect_project",
+        "create_file",
+        "edit_file",
+        "run_command",
+        "run_tests",
+    ],
+    documentation: [
+        "read_file",
+        "list_files",
+        "search_code",
+        "inspect_project",
+        "create_file",
+        "edit_file",
+    ],
+    release: [
+        "read_file",
+        "list_files",
+        "inspect_project",
+        "inspect_git_status",
+        "inspect_git_diff",
+        "run_command",
+        "run_tests",
+    ],
+    verifier: [
+        "read_file",
+        "list_files",
+        "inspect_tests",
+        "inspect_findings",
+        "run_tests",
+        "run_command",
+        "inspect_git_diff",
+    ],
+};
+const ROLE_PROMPTS = {
+    planner: "Role: planner. Produce a concise, evidence-backed plan. Prefer read-only inspection; do not mutate files unless explicitly approved.",
+    coder: "Role: coder. Implement the goal with minimal, focused diffs. Respect approval gates for writes and command execution.",
+    tester: "Role: tester. Focus on test coverage, failing cases, and controlled test runs. Avoid unrelated refactors.",
+    reviewer: "Role: reviewer. Critique changes for correctness, regressions, and architecture fit. Stay read-only.",
+    security: "Role: security. Hunt for secrets, unsafe patterns, and auth gaps. Never exfiltrate or log secret values.",
+    refactoring: "Role: refactoring. Improve structure without behavior changes; use reference/call tools before edits.",
+    migration: "Role: migration. Coordinate mechanical moves/upgrades with verification after each batch.",
+    documentation: "Role: documentation. Update docs and comments for accuracy; match project tone.",
+    release: "Role: release. Prepare release checks (git status, tests, changelog hints); avoid drive-by changes.",
+    verifier: "Role: verifier. Re-run tests and scans to confirm the goal is met; report evidence clearly.",
+};
+export function rolePrompt(role) {
+    return ROLE_PROMPTS[role];
+}
+export function roleAllowedTools(role) {
+    return [...ROLE_TOOL_ALLOWLIST[role]];
+}
+/**
+ * Same coding loop as the main agent, with a role-specific system note prepended to the goal.
+ */
+export async function runRoleAgent(options) {
+    const allowed = new Set(roleAllowedTools(options.role));
+    const roleNote = [
+        rolePrompt(options.role),
+        `Allowed tools for this role: ${[...allowed].join(", ")}.`,
+        "If a tool is outside the role allowlist, explain the limitation instead of attempting it.",
+    ].join("\n");
+    const goal = `${roleNote}\n\nUser goal:\n${options.goal}`;
+    const filteredToolCalls = options.toolCalls?.filter((tc) => allowed.has(tc.name));
+    return runCodingLoop({
+        ...options,
+        goal,
+        allowedTools: [...allowed],
+        ...(filteredToolCalls !== undefined ? { toolCalls: filteredToolCalls } : {}),
+    });
+}

package/dist/agent/runtime.d.ts

@@ -1,6 +1,8 @@
 import type { ModelProvider } from "../ai/index.js";
 import { AgentState, AgentStateMachine, type AgentStateTransition } from "./state.js";
 import type { ContextBundle } from "./context/types.js";
+import type { AgentToolName } from "./tools/types.js";
+import { type AgentMode } from "./modes.js";
 export interface AgentLimits {
     maxToolCalls: number;
     maxIterations: number;
@@ -9,7 +11,7 @@ export interface AgentLimits {
     maxContextChars: number;
 }
 export declare const DEFAULT_AGENT_LIMITS: AgentLimits;
-export type AgentAuditEventType = "session-start" | "state-transition" | "context-retrieved" | "model-call" | "model-error" | "limit-exceeded" | "session-end";
+export type AgentAuditEventType = "session-start" | "state-transition" | "context-retrieved" | "model-call" | "model-error" | "tool-call" | "tool-result" | "limit-exceeded" | "session-end";
 export interface AgentAuditEvent {
     id: string;
     sessionId: string;
@@ -32,10 +34,16 @@ export interface AgentTurnResult {
     transitions: readonly AgentStateTransition[];
     audit: readonly AgentAuditEvent[];
     context?: ContextBundle;
+    toolResults?: Array<{
+        name: string;
+        ok: boolean;
+        error?: string;
+    }>;
+    filesChanged?: string[];
 }
 /**
- * Minimal agent runtime for M1: state machine + provider chat + limits.
- * Tool execution and approvals arrive in later milestones.
+ * Agent runtime: state machine + provider chat + optional tool execution.
+ * Shares the same tool execution + approval gates as runCodingLoop.
  */
 export declare class AgentRuntime {
     readonly sessionId: string;
@@ -48,6 +56,7 @@ export declare class AgentRuntime {
     private readonly startedAt;
     private toolCalls;
     private iterations;
+    private filesModified;
     private cancelled;
     constructor(options: AgentRuntimeOptions);
     get events(): readonly AgentAuditEvent[];
@@ -55,13 +64,20 @@ export declare class AgentRuntime {
     private emit;
     private transition;
     private assertWithinLimits;
+    private providerTools;
     /**
-     * M1 turn: UNDERSTANDING → (optional context) → model chat → COMPLETED/FAILED.
-     * Does not execute tools yet.
+     * Full turn: UNDERSTANDING → model chat → optional tool execution loop → VERIFYING → COMPLETED.
+     * Tool writes/executes require approvedByHuman=true (same gate as runCodingLoop).
      */
     runTurn(options: {
         userMessage: string;
         systemPrompt?: string;
         context?: ContextBundle;
+        /** Execute model-proposed tools (default true when tools present) */
+        executeTools?: boolean;
+        /** Required for write/execute tools */
+        approvedByHuman?: boolean;
+        mode?: AgentMode;
+        allowedTools?: AgentToolName[];
     }): Promise<AgentTurnResult>;
 }