@praneeth_54/agentdoctor 2.0.1 → 3.0.0

package/dist/cli/commands/product.js

@@ -0,0 +1,147 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveTargetArgument } from "./scan.js";
+import { traceRequirements, analyzeApiSurface, analyzeDatabaseSchema, analyzeEvents, analyzeDependencies, analyzeCodeHealth, buildSoftwareMap, analyzeWhatIf, loadDecisionLedger, runForensicAnalysis, buildSoftwareDigitalTwin, runEvalLab, diagnoseAgentDoctorSelf, analyzeInfra, buildIncidentHypotheses, readChangeLedger, analyzeSecuritySurface, analyzePrivacySurface, searchSymbolsAndConcepts, buildTechnicalDebtRoadmap, analyzeFeatureIntelligence, buildSoftwareEvolutionTimeline, queryMemory, loadOrganizationModel, analyzeTestBrain, } from "../../product/index.js";
+import { runRoleAgent } from "../../agent/roles.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runProductCommand(options) {
+    const root = resolveRepoRoot(options.root ?? resolveTargetArgument(undefined));
+    try {
+        let payload;
+        switch (options.action) {
+            case "requirements":
+                payload = await traceRequirements(root);
+                break;
+            case "api":
+                payload = await analyzeApiSurface(root);
+                break;
+            case "database":
+                payload = await analyzeDatabaseSchema(root);
+                break;
+            case "events":
+                payload = await analyzeEvents(root);
+                break;
+            case "dependency":
+                payload = await analyzeDependencies(root);
+                break;
+            case "health-code":
+                payload = await analyzeCodeHealth(root);
+                break;
+            case "map":
+                payload = await buildSoftwareMap(root);
+                break;
+            case "what-if":
+                if (!options.target) {
+                    console.error("Error: what-if requires a file path or symbol target (--target or argument)");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                payload = await analyzeWhatIf(root, options.target);
+                break;
+            case "decisions":
+                payload = await loadDecisionLedger(root);
+                break;
+            case "forensic":
+                payload = await runForensicAnalysis(root);
+                break;
+            case "twin":
+                payload = await buildSoftwareDigitalTwin(root);
+                break;
+            case "eval-lab":
+                payload = await runEvalLab(root);
+                break;
+            case "self-check":
+                payload = await diagnoseAgentDoctorSelf(root);
+                break;
+            case "infra":
+                payload = await analyzeInfra(root);
+                break;
+            case "incident":
+                payload = await buildIncidentHypotheses(root, options.changedFiles ? { changedFiles: options.changedFiles } : undefined);
+                break;
+            case "security-doctor":
+                payload = await analyzeSecuritySurface(root);
+                break;
+            case "privacy-doctor":
+                payload = await analyzePrivacySurface(root);
+                break;
+            case "search":
+                if (!options.query?.trim()) {
+                    console.error("Error: search requires a query (--query or argument)");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                payload = await searchSymbolsAndConcepts(root, options.query);
+                break;
+            case "tech-debt":
+                payload = await buildTechnicalDebtRoadmap(root);
+                break;
+            case "features":
+                payload = await analyzeFeatureIntelligence(root);
+                break;
+            case "evolution":
+                payload = await buildSoftwareEvolutionTimeline(root);
+                break;
+            case "memory":
+                if (!options.query?.trim()) {
+                    console.error("Error: memory requires a query (--query or argument)");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                payload = await queryMemory(root, options.query);
+                break;
+            case "org":
+                payload = await loadOrganizationModel(root);
+                break;
+            case "test-brain":
+                payload = await analyzeTestBrain({ root });
+                break;
+            case "role-agent":
+                if (!options.role || !options.goal?.trim()) {
+                    console.error("Error: role-agent requires --role and --goal");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                if (options.apply && !options.approve) {
+                    console.error("Error: role-agent --apply requires --approve");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                payload = await runRoleAgent({
+                    role: options.role,
+                    goal: options.goal,
+                    root,
+                    approvedByHuman: options.approve === true,
+                });
+                break;
+            default:
+                return EXIT_CODES.USAGE_ERROR;
+        }
+        if (options.json) {
+            printJson(payload);
+        }
+        else {
+            const action = options.action;
+            process.stdout.write(`AgentDoctor ${action} completed for ${root}\n`);
+            if (action === "self-check" && payload && typeof payload === "object" && "ok" in payload) {
+                process.stdout.write(`  ok: ${payload.ok}\n`);
+            }
+            if (action === "eval-lab" && payload && typeof payload === "object" && "passed" in payload) {
+                process.stdout.write(`  passed: ${payload.passed}\n`);
+            }
+            process.stdout.write("  (use --json for full report)\n");
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeLedgerListCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const payload = await readChangeLedger(root);
+    if (options.json)
+        printJson(payload);
+    else
+        process.stdout.write(`Change ledger entries: ${payload.entries.length}\n`);
+    return EXIT_CODES.SUCCESS;
+}

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

@@ -0,0 +1,15 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runStartCommand(options: {
+    root?: string;
+    json?: boolean;
+    select?: string;
+    maxEntries?: number;
+    initBrain?: boolean;
+    rebuildBrain?: boolean;
+    listOnly?: boolean;
+}): Promise<ExitCode>;
+export declare function runDnaCommand(options: {
+    root?: string;
+    json?: boolean;
+    persist?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/start.js

@@ -0,0 +1,80 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { initBrainStore, rebuildBrain, getBrainStatus } from "../../core/brain-cli/service.js";
+import { discoverProjectRoots } from "../../product/discovery/roots.js";
+import { buildProjectDna, persistProjectDna } from "../../product/dna/build.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runStartCommand(options) {
+    const prefer = options.select ?? options.root;
+    const discovery = await discoverProjectRoots({
+        cwd: prefer ? resolveRepoRoot(prefer) : process.cwd(),
+        ...(prefer ? { prefer: resolveRepoRoot(prefer) } : {}),
+        ...(options.maxEntries !== undefined ? { maxEntries: options.maxEntries } : {}),
+        autoSelect: !options.listOnly,
+    });
+    if (options.listOnly || discovery.blocked || !discovery.selected) {
+        if (options.json) {
+            printJson({ discovery, dna: null, brain: null });
+            return discovery.blocked ? EXIT_CODES.USAGE_ERROR : EXIT_CODES.SUCCESS;
+        }
+        if (discovery.blocked) {
+            process.stderr.write(`Blocked: ${discovery.blockReason}\n`);
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        process.stdout.write("Project candidates:\n");
+        if (discovery.candidates.length === 0) {
+            process.stdout.write("  (none found — navigate into a project or pass a path)\n");
+            return EXIT_CODES.USAGE_ERROR;
+        }
+        for (const [i, c] of discovery.candidates.entries()) {
+            process.stdout.write(`  [${i + 1}] ${c.root}\n      score=${c.score} markers=${c.markers.join(", ")} (${c.reason})\n`);
+        }
+        process.stdout.write("\nRe-run with --select <path> to initialize that project.\n");
+        return EXIT_CODES.SUCCESS;
+    }
+    const root = discovery.selected.root;
+    const dna = await persistProjectDna(root);
+    let brainStatus = null;
+    if (options.initBrain !== false) {
+        brainStatus = await initBrainStore(root);
+        if (options.rebuildBrain) {
+            await rebuildBrain(root);
+            brainStatus = await getBrainStatus(root);
+        }
+    }
+    const payload = { discovery, dna, brain: brainStatus };
+    if (options.json) {
+        printJson(payload);
+    }
+    else {
+        process.stdout.write(`AgentDoctor start\n`);
+        process.stdout.write(`  root: ${root}\n`);
+        process.stdout.write(`  fingerprint: ${dna.fingerprint}\n`);
+        process.stdout.write(`  type: ${dna.projectType}\n`);
+        process.stdout.write(`  languages: ${dna.languages.join(", ") || "(none)"}\n`);
+        process.stdout.write(`  frameworks: ${dna.frameworks.join(", ") || "(none)"}\n`);
+        process.stdout.write(`  files: ${dna.counts.files} (source ${dna.counts.sourceFiles}, tests ${dna.counts.testFiles})\n`);
+        if (brainStatus) {
+            process.stdout.write(`  brain: ${brainStatus.hasSnapshot ? `snapshot ${brainStatus.latestSnapshotId}` : "initialized (no snapshot yet — run with --rebuild-brain or brain rebuild)"}\n`);
+        }
+        process.stdout.write(`  DNA written to .agentdoctor/dna/project-dna.json\n`);
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runDnaCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const dna = options.persist ? await persistProjectDna(root) : await buildProjectDna(root);
+    if (options.json) {
+        printJson(dna);
+    }
+    else {
+        process.stdout.write(`Project DNA: ${dna.name} (${dna.fingerprint})\n`);
+        process.stdout.write(`  type: ${dna.projectType}\n`);
+        process.stdout.write(`  languages: ${dna.languages.join(", ") || "(none)"}\n`);
+        process.stdout.write(`  frameworks: ${dna.frameworks.join(", ") || "(none)"}\n`);
+        process.stdout.write(`  monorepo: ${dna.monorepo.isMonorepo ? dna.monorepo.tool : "no"}\n`);
+    }
+    return EXIT_CODES.SUCCESS;
+}

package/dist/cli/program.js

@@ -17,6 +17,11 @@ 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 { runProductCommand } from "./commands/product.js";
+import { runStartCommand, runDnaCommand } from "./commands/start.js";
 import { collectOpsHealth } from "../ops/health.js";
 import { listSessions, loadSession } from "../platform/sessions/store.js";
 import { exportReports } from "../platform/reports/export.js";
@@ -1235,6 +1240,97 @@ 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("--role <role>", "Specialized role for plan/apply (planner, coder, tester, reviewer, security, …)")
+        .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 } : {}),
+            ...(options.role !== undefined ? { role: options.role } : {}),
+            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)");
@@ -1451,6 +1547,143 @@ export function createProgram() {
         const code = await runExplainCommand(rule);
         process.exitCode = code;
     });
+    function bindProductCommand(name, description, action) {
+        program
+            .command(name)
+            .description(description)
+            .argument("[path]", "Repository path")
+            .option("--json", "Emit JSON report", false)
+            .action(async (pathArg, _options, command) => {
+            const options = command.optsWithGlobals();
+            process.exitCode = await runProductCommand({
+                action,
+                root: resolveTargetArgument(pathArg),
+                json: Boolean(options.json),
+            });
+        });
+    }
+    program
+        .command("start")
+        .description("Safe project discovery: detect project root, build Project DNA, initialize Project Brain")
+        .argument("[path]", "Optional project path (default: cwd)")
+        .option("--list", "List candidates without initializing", false)
+        .option("--select <path>", "Explicitly select a project root")
+        .option("--max-entries <n>", "Refuse scans larger than this entry budget", "25000")
+        .option("--no-init-brain", "Skip Project Brain store initialization")
+        .option("--rebuild-brain", "Compile Project Brain after init", false)
+        .option("--json", "Emit JSON", false)
+        .action(async (pathArg, options) => {
+        process.exitCode = await runStartCommand({
+            ...(pathArg !== undefined ? { root: resolveTargetArgument(pathArg) } : {}),
+            listOnly: Boolean(options.list),
+            ...(options.select !== undefined ? { select: options.select } : {}),
+            maxEntries: Number(options.maxEntries ?? 25000),
+            initBrain: options.initBrain !== false,
+            rebuildBrain: Boolean(options.rebuildBrain),
+            json: Boolean(options.json),
+        });
+    });
+    program
+        .command("dna")
+        .description("Build deterministic Project DNA fingerprint")
+        .argument("[path]", "Repository path")
+        .option("--persist", "Write .agentdoctor/dna/project-dna.json", false)
+        .option("--json", "Emit JSON", false)
+        .action(async (pathArg, options) => {
+        process.exitCode = await runDnaCommand({
+            root: resolveTargetArgument(pathArg),
+            persist: Boolean(options.persist),
+            json: Boolean(options.json),
+        });
+    });
+    bindProductCommand("requirements", "Trace requirements from markdown docs (evidence-backed)", "requirements");
+    bindProductCommand("api", "Discover HTTP route patterns (regex evidence)", "api");
+    bindProductCommand("database", "Discover schema objects from migrations/SQL/Prisma", "database");
+    bindProductCommand("events", "Detect queues, workers, cron, and event markers", "events");
+    bindProductCommand("dependency", "Analyze direct dependencies and workspace duplicates", "dependency");
+    bindProductCommand("deps", "Alias for dependency", "dependency");
+    bindProductCommand("health-code", "Aggregate code health indicators with evidence", "health-code");
+    bindProductCommand("code-health", "Alias for health-code", "health-code");
+    bindProductCommand("map", "Build navigable software map from project layout", "map");
+    bindProductCommand("decisions", "Load ADR files and decision ledger", "decisions");
+    bindProductCommand("forensic", "Read-only forensic analysis (git + ledgers + brain)", "forensic");
+    bindProductCommand("twin", "Software digital twin snapshot", "twin");
+    bindProductCommand("eval-lab", "Run evaluation lab fixture checks", "eval-lab");
+    bindProductCommand("self-check", "Self-diagnosis of AgentDoctor installation", "self-check");
+    bindProductCommand("infra", "Detect Docker/K8s/Terraform/CI artifacts", "infra");
+    bindProductCommand("incident", "Build incident timeline hypotheses", "incident");
+    bindProductCommand("security-doctor", "Security heuristics: secrets, auth markers, dangerous patterns", "security-doctor");
+    bindProductCommand("test-brain", "Test Brain: test-impact plus graph file↔test mapping", "test-brain");
+    bindProductCommand("privacy-doctor", "PII-ish pattern scan (not legal compliance)", "privacy-doctor");
+    bindProductCommand("tech-debt", "Technical debt roadmap (TODO/FIXME, architecture, tests)", "tech-debt");
+    bindProductCommand("features", "Feature intelligence (flows + API links)", "features");
+    bindProductCommand("evolution", "Software evolution timeline from git + ledger", "evolution");
+    bindProductCommand("org", "Load organization model (.agentdoctor/org)", "org");
+    program
+        .command("memory")
+        .description("Query institutional memory (brain + ledgers)")
+        .argument("<query>", "Memory query")
+        .argument("[path]", "Repository path")
+        .option("--json", "Emit JSON report", false)
+        .action(async (query, pathArg, _options, command) => {
+        const options = command.optsWithGlobals();
+        process.exitCode = await runProductCommand({
+            action: "memory",
+            query,
+            root: resolveTargetArgument(pathArg),
+            json: Boolean(options.json),
+        });
+    });
+    program
+        .command("search")
+        .description("Search symbols and concepts (brain + bounded file scan)")
+        .argument("<query>", "Search query")
+        .argument("[path]", "Repository path")
+        .option("--json", "Emit JSON report", false)
+        .action(async (query, pathArg, _options, command) => {
+        const options = command.optsWithGlobals();
+        process.exitCode = await runProductCommand({
+            action: "search",
+            query,
+            root: resolveTargetArgument(pathArg),
+            json: Boolean(options.json),
+        });
+    });
+    program
+        .command("role-agent")
+        .description("Run the coding loop with a specialized agent role")
+        .argument("[path]", "Repository path")
+        .requiredOption("--role <role>", "Agent role (planner, coder, tester, reviewer, security, …)")
+        .requiredOption("--goal <text>", "Goal for the role agent")
+        .option("--approve", "Record human approval for writes", false)
+        .option("--apply", "Apply changes (requires --approve)", false)
+        .option("--json", "Emit JSON", false)
+        .action(async (pathArg, options) => {
+        process.exitCode = await runProductCommand({
+            action: "role-agent",
+            root: resolveTargetArgument(pathArg),
+            role: options.role,
+            goal: options.goal,
+            approve: Boolean(options.approve),
+            apply: Boolean(options.apply),
+            json: Boolean(options.json),
+        });
+    });
+    program
+        .command("what-if")
+        .description("Graph-backed change impact for a file or symbol")
+        .argument("<target>", "File path or symbol")
+        .argument("[path]", "Repository path")
+        .option("--json", "Emit JSON report", false)
+        .action(async (target, pathArg, _options, command) => {
+        const options = command.optsWithGlobals();
+        process.exitCode = await runProductCommand({
+            action: "what-if",
+            root: resolveTargetArgument(pathArg),
+            target,
+            json: Boolean(options.json),
+        });
+    });
     program
         .command("doctor")
         .description("Check AgentDoctor installation health")

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 = "3.0.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 = "3.0.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;
 /**