@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/cli/commands/complete.js

@@ -0,0 +1,232 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { runProjectInit } from "../../core/brain-product/init.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { analyzeGitIntelligence, deadCodeCategory } from "../../intelligence/git/analyze.js";
+import { buildC4Views } from "../../architecture/c4.js";
+import { createKnowledgeRecord, listKnowledge, retrieveAuthoritative, transitionKnowledge, } from "../../knowledge/store.js";
+import { authenticateLocalDev, authorize, registerLocalDevUser } from "../../team/auth.js";
+import { runControlledCommand } from "../../enforcement/runner.js";
+import { analyzeTestImpact, analyzeRenameImpact, buildRepositoryGraph, } from "../../platform/index.js";
+import { CONTRACTS_VERSION, DEFAULT_FEATURE_FLAGS } from "../../contracts/index.js";
+import { platformFindingToContract } from "../../contracts/adapters.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runInitCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const result = await runProjectInit(root, {
+        ...(options.name ? { projectName: options.name } : {}),
+        ...(options.domain ? { businessDomain: options.domain } : {}),
+    });
+    if (options.json)
+        printJson(result);
+    else {
+        process.stdout.write(`AgentDoctor init wrote ${result.artifacts.length} PROPOSED artifacts under .agentdoctor/repository-brain/proposals/\nNone are approved facts until: agentdoctor brain review --artifact <id> --decision approved\n`);
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runV2SurfaceCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    try {
+        switch (options.action) {
+            case "graph-ast": {
+                const graph = await buildIntelligenceGraph({
+                    root,
+                    mode: options.mode ?? "auto",
+                });
+                if (options.json)
+                    printJson(graph);
+                else
+                    process.stdout.write(`graph builder=${graph.builder} nodes=${graph.nodes.length} edges=${graph.edges.length} astFiles=${graph.astFilesParsed}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "health":
+            case "git-intel": {
+                const report = await analyzeGitIntelligence(root);
+                if (options.json)
+                    printJson(report);
+                else
+                    process.stdout.write(`git-intel hotspots=${report.hotspots.length} coChanges=${report.coChanges.length} git=${report.gitAvailable}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "c4": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const views = buildC4Views(graph);
+                if (options.json)
+                    printJson({ views, featureFlag: DEFAULT_FEATURE_FLAGS.architectureC4 });
+                else
+                    process.stdout.write(`C4 views: ${views.map((v) => v.level).join(", ")}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "dead-code-demo": {
+                const sample = deadCodeCategory({
+                    exported: true,
+                    referenced: false,
+                    frameworkEntry: false,
+                    dynamicHint: false,
+                });
+                if (options.json)
+                    printJson(sample);
+                else
+                    process.stdout.write(`${sample.category} confidence=${sample.confidence}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-create": {
+                if (!options.title || !options.content) {
+                    console.error("Error: --title and --content required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const rec = await createKnowledgeRecord({
+                    root,
+                    title: options.title,
+                    content: options.content,
+                    status: "draft",
+                });
+                if (options.json)
+                    printJson(rec);
+                else
+                    process.stdout.write(`Created draft knowledge ${rec.id}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-list": {
+                const list = await listKnowledge(root);
+                if (options.json)
+                    printJson({ records: list });
+                else
+                    for (const r of list)
+                        process.stdout.write(`${r.id} [${r.status}] ${r.title}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-transition": {
+                if (!options.id || !options.decision) {
+                    console.error("Error: --id and --decision required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const rec = await transitionKnowledge({
+                    root,
+                    id: options.id,
+                    to: options.decision,
+                });
+                if (options.json)
+                    printJson(rec);
+                else
+                    process.stdout.write(`${rec.id} -> ${rec.status}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "knowledge-query": {
+                const list = await listKnowledge(root);
+                const result = retrieveAuthoritative(list, options.query ?? "");
+                if (options.json)
+                    printJson(result);
+                else
+                    process.stdout.write(result.abstain
+                        ? `ABSTAIN: ${result.reason}\n`
+                        : `AUTHORITATIVE: ${result.record?.title}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "team-register": {
+                if (!options.username || !options.password) {
+                    console.error("Error: --username and --password required (local-dev auth only)");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const user = await registerLocalDevUser({
+                    root,
+                    username: options.username,
+                    password: options.password,
+                    role: "admin",
+                });
+                if (options.json)
+                    printJson({ ...user, notice: "local-dev auth — not enterprise SSO" });
+                else
+                    process.stdout.write(`Registered local-dev user ${user.username} (${user.id})\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "team-login": {
+                if (!options.username || !options.password) {
+                    console.error("Error: --username and --password required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const session = await authenticateLocalDev({
+                    root,
+                    username: options.username,
+                    password: options.password,
+                });
+                if (options.json)
+                    printJson({ ...session, notice: "local-dev session — not enterprise SSO" });
+                else
+                    process.stdout.write(`token=${session.token} expires=${session.expiresAt}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "team-authorize": {
+                if (!options.token) {
+                    console.error("Error: --token required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const result = await authorize(root, options.token, "member");
+                if (options.json)
+                    printJson(result);
+                else
+                    process.stdout.write(`${result.ok ? "OK" : "DENIED"}: ${result.reason}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "enforce-check": {
+                if (!options.command) {
+                    console.error("Error: --command required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const result = await runControlledCommand({ root, command: options.command });
+                if (options.json)
+                    printJson(result);
+                else
+                    process.stdout.write(`enforced=${result.enforced} status=${result.decision.executionStatus} decision=${result.decision.decision}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "impact": {
+                const impact = await analyzeTestImpact({ root });
+                if (options.json)
+                    printJson({ kind: "test-impact", contractsVersion: CONTRACTS_VERSION, impact });
+                else
+                    process.stdout.write(`impact mode=${impact.mode} recommendedTests=${impact.recommendedTests.length}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "refactor-impact": {
+                if (!options.symbol) {
+                    console.error("Error: --symbol required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const graph = await buildRepositoryGraph(root);
+                const impact = await analyzeRenameImpact({ root, symbol: options.symbol, graph });
+                if (options.json)
+                    printJson(impact);
+                else
+                    process.stdout.write(`refactor ${options.symbol} affected=${impact.affectedFiles.length}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "contracts-demo": {
+                const sample = platformFindingToContract({
+                    id: "demo",
+                    module: "demo",
+                    severity: "info",
+                    title: "demo",
+                    message: "demo",
+                    recommendation: "n/a",
+                    confidence: 1,
+                    evidence: [{ kind: "verified", detail: "ok" }],
+                });
+                if (options.json)
+                    printJson({ contractsVersion: CONTRACTS_VERSION, sample });
+                else
+                    process.stdout.write(`contracts ${CONTRACTS_VERSION}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown action ${options.action}`);
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

package/dist/cli/commands/explain.js

@@ -13,7 +13,7 @@ export async function runExplainCommand(ruleId) {
     const rule = getRuleById(ruleId.trim());
     if (!rule) {
         console.error(`Error: unknown rule id "${ruleId}"`);
-        console.error("Run agentdoctor explain with a documented rule from docs/rules.md");
+        console.error("Run agentdoctor explain with a documented rule from docs/reference/rules.md");
         return EXIT_CODES.USAGE_ERROR;
     }
     const agents = rule.affectedAgents?.map((id) => AGENT_DISPLAY_NAMES[id] ?? id).join(", ") ??

package/dist/cli/commands/fix.js

@@ -1,7 +1,7 @@
 import { EXIT_CODES } from "../../types/index.js";
 import { isDirectory } from "../../utils/fs.js";
 import { resolveRepoRoot } from "../../utils/path.js";
-import { applyFixPlan, readClaudeSettings, readCodexConfig, readCursorignore, } from "../../core/fix/apply.js";
+import { applyFixPlan, readClaudeSettings, readCodexConfig, readCursorignore, readSimpleIgnore, } from "../../core/fix/apply.js";
 import { buildFixPlan } from "../../core/fix/plan.js";
 import { renderFixPlanTerminal } from "../../core/fix/render.js";
 import { runFix } from "../../core/fix/run.js";
@@ -25,14 +25,22 @@ export async function runFixCommand(options) {
             const cursorContent = await readCursorignore(plan.root);
             const claudeSettingsContent = await readClaudeSettings(plan.root);
             const codexConfigContent = await readCodexConfig(plan.root);
+            const geminiignoreContent = await readSimpleIgnore(plan.root, ".geminiignore");
+            const aiderignoreContent = await readSimpleIgnore(plan.root, ".aiderignore");
             const applyResult = await applyFixPlan(plan, { dryRun: true });
             process.stdout.write(renderFixPlanTerminal(plan, {
                 dryRun: true,
                 cursorContent,
                 claudeSettingsContent,
                 codexConfigContent,
+                geminiignoreContent,
+                aiderignoreContent,
                 applyResult,
             }));
+            if (applyResult.error) {
+                console.error(`Error: ${applyResult.error}`);
+                return EXIT_CODES.USAGE_ERROR;
+            }
             return EXIT_CODES.SUCCESS;
         }
         const { plan, applyResult, cancelled } = await runFix({
@@ -47,13 +55,23 @@ export async function runFixCommand(options) {
         const cursorContentAfter = await readCursorignore(plan.root);
         const claudeSettingsAfter = await readClaudeSettings(plan.root);
         const codexConfigAfter = await readCodexConfig(plan.root);
+        const geminiignoreAfter = await readSimpleIgnore(plan.root, ".geminiignore");
+        const aiderignoreAfter = await readSimpleIgnore(plan.root, ".aiderignore");
         process.stdout.write(renderFixPlanTerminal(plan, {
             dryRun: false,
             cursorContent: cursorContentAfter,
             claudeSettingsContent: claudeSettingsAfter,
             codexConfigContent: codexConfigAfter,
+            geminiignoreContent: geminiignoreAfter,
+            aiderignoreContent: aiderignoreAfter,
             applyResult,
         }));
+        if (applyResult.error) {
+            console.error(`Error: ${applyResult.error}`);
+            return isFixConfigOrPermissionError(applyResult.error)
+                ? EXIT_CODES.USAGE_ERROR
+                : EXIT_CODES.INTERNAL_ERROR;
+        }
         if (applyResult.writtenFiles.length > 0) {
             const after = await scan({ cwd: target });
             const remainingSafeContext = after.findings.filter((f) => f.fixability === "safe" &&
@@ -73,8 +91,10 @@ export async function runFixCommand(options) {
 }
 function isFixConfigOrPermissionError(message) {
     return (message.includes("refusing") ||
+        message.includes("not allowlisted") ||
         message.includes("not valid JSON") ||
         message.includes("EACCES") ||
         message.includes("EPERM") ||
-        message.includes("permission denied"));
+        message.includes("permission denied") ||
+        message.includes("symlink"));
 }

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

@@ -0,0 +1,8 @@
+import type { ExitCode } from "../../types/index.js";
+/**
+ * Start combined AgentDoctor MCP (Brain tools + intelligence tools) over STDIO.
+ */
+export declare function runMcpCommand(options: {
+    root: string;
+    buildIfMissing?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/mcp.js

@@ -0,0 +1,14 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { runAgentDoctorMcpStdio } from "../../mcp/agentdoctor/server.js";
+/**
+ * Start combined AgentDoctor MCP (Brain tools + intelligence tools) over STDIO.
+ */
+export async function runMcpCommand(options) {
+    const root = resolveRepoRoot(options.root);
+    await runAgentDoctorMcpStdio({
+        root,
+        buildIfMissing: options.buildIfMissing !== false,
+    });
+    return EXIT_CODES.SUCCESS;
+}

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

@@ -0,0 +1,17 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runPlatformCommand(options: {
+    action: string;
+    root?: string;
+    json?: boolean;
+    query?: string;
+    symbol?: string;
+    left?: string;
+    right?: string;
+    command?: string;
+    path?: string;
+    actionType?: string;
+    sessionId?: string;
+    failClosed?: boolean;
+    coverage?: string;
+    since?: string;
+}): Promise<ExitCode>;

package/dist/cli/commands/platform.js

@@ -0,0 +1,195 @@
+import { randomUUID } from "node:crypto";
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { analyzeRenameImpact, analyzeTestImpact, appendSessionEvent, buildProvenance, compareCommits, createSession, endSession, evaluateAgentAction, exportSessionMarkdown, formatTestImpactHuman, listSessions, loadSession, persistTestImpactReport, planContext, runPlatformScan, saveProvenance, EVALUATE_ONLY, } from "../../platform/index.js";
+import { buildRepositoryGraph } from "../../platform/graph/build.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runPlatformCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    try {
+        switch (options.action) {
+            case "scan": {
+                const result = await runPlatformScan(root);
+                if (options.json)
+                    printJson({
+                        findingCount: result.snapshot.findings.length,
+                        nodeCount: result.snapshot.graph.nodes.length,
+                        testImpact: result.snapshot.testImpact,
+                        readiness: result.snapshot.readiness.categories.map((c) => ({
+                            id: c.id,
+                            score: c.score,
+                        })),
+                        reports: result.reportPaths,
+                        limitations: result.snapshot.limitations,
+                    });
+                else {
+                    process.stdout.write(`AgentDoctor 2.0 platform scan\n  findings: ${result.snapshot.findings.length}\n  graph nodes: ${result.snapshot.graph.nodes.length}\n  test-impact recommendations: ${result.testImpact.recommendedTests.length}\n  reports: ${Object.keys(result.reportPaths).join(", ")}\n`);
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "graph": {
+                const graph = await buildRepositoryGraph(root);
+                if (options.json)
+                    printJson(graph);
+                else
+                    process.stdout.write(`Graph nodes=${graph.nodes.length} edges=${graph.edges.length}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "test-impact": {
+                const report = await analyzeTestImpact({
+                    root,
+                    ...(options.coverage ? { coveragePath: options.coverage } : {}),
+                    ...(options.since ? { since: options.since } : {}),
+                });
+                const out = await persistTestImpactReport(root, report);
+                if (options.json)
+                    printJson({ ...report, reportPath: out });
+                else {
+                    process.stdout.write(formatTestImpactHuman(report));
+                    process.stdout.write(`  wrote: ${out}\n`);
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "firewall-check":
+            case "policy-check": {
+                const verdict = await evaluateAgentAction(root, {
+                    actionId: randomUUID(),
+                    agentId: "cli",
+                    timestamp: new Date().toISOString(),
+                    type: options.actionType ?? "shell",
+                    params: {
+                        ...(options.command ? { command: options.command } : {}),
+                        ...(options.path ? { path: options.path } : {}),
+                    },
+                    repositoryRoot: root,
+                }, { failClosed: options.failClosed === true });
+                if (options.json)
+                    printJson({ ...verdict, notice: EVALUATE_ONLY });
+                else
+                    process.stdout.write(`Action Policy Evaluator\n  ${EVALUATE_ONLY}\n  decision=${verdict.decision} risk=${verdict.riskLevel} reason=${verdict.reason} executed=${verdict.executionResult}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "session-start": {
+                const session = await createSession({ root, agentId: "cli" });
+                process.stdout.write(`session ${session.id}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "session-show": {
+                if (!options.sessionId) {
+                    console.error("Error: --session <id> required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const session = await loadSession(root, options.sessionId);
+                if (!session) {
+                    console.error("Error: session not found");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                if (options.json)
+                    printJson(session);
+                else
+                    process.stdout.write(exportSessionMarkdown(session));
+                return EXIT_CODES.SUCCESS;
+            }
+            case "session-list": {
+                const ids = await listSessions(root);
+                if (options.json)
+                    printJson({ sessions: ids });
+                else
+                    process.stdout.write(ids.length ? `${ids.join("\n")}\n` : "No sessions.\n");
+                return EXIT_CODES.SUCCESS;
+            }
+            case "provenance": {
+                if (!options.path) {
+                    console.error("Error: --path <file> required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const record = buildProvenance({ root, file: options.path });
+                const out = await saveProvenance(root, record);
+                if (options.json)
+                    printJson(record);
+                else
+                    process.stdout.write(`Wrote ${out}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "context": {
+                const graph = await buildRepositoryGraph(root);
+                const plan = await planContext({
+                    root,
+                    graph,
+                    query: options.query ?? "src",
+                });
+                if (options.json)
+                    printJson(plan);
+                else
+                    process.stdout.write(`tokens=${plan.estimatedTokens}/${plan.budgetTokens} selected=${plan.selected.length}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "refactor": {
+                if (!options.symbol) {
+                    console.error("Error: --symbol required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const graph = await buildRepositoryGraph(root);
+                const impact = await analyzeRenameImpact({ root, symbol: options.symbol, graph });
+                if (options.json)
+                    printJson(impact);
+                else
+                    process.stdout.write(`symbol=${impact.symbol} affected=${impact.affectedFiles.length} risk=${impact.risk}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "time-machine": {
+                if (!options.left || !options.right) {
+                    console.error("Error: --left and --right refs required");
+                    return EXIT_CODES.USAGE_ERROR;
+                }
+                const cmp = await compareCommits({
+                    root,
+                    left: options.left,
+                    right: options.right,
+                });
+                if (options.json)
+                    printJson(cmp);
+                else
+                    process.stdout.write(`${cmp.summary}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "demo-session": {
+                const session = await createSession({ root, agentId: "demo-agent", model: "unknown" });
+                await appendSessionEvent(session, {
+                    type: "tool-call",
+                    summary: "Proposed shell: npm test",
+                    detail: { command: "npm test" },
+                    risk: "low",
+                });
+                const verdict = await evaluateAgentAction(root, {
+                    actionId: randomUUID(),
+                    agentId: "demo-agent",
+                    timestamp: new Date().toISOString(),
+                    type: "shell",
+                    params: { command: "npm test" },
+                    repositoryRoot: root,
+                });
+                await appendSessionEvent(session, {
+                    type: "policy",
+                    summary: `Action Policy Evaluator ${verdict.decision}: ${verdict.reason}`,
+                    risk: verdict.riskLevel === "critical" ? "critical" : "low",
+                });
+                await endSession(session);
+                if (options.json)
+                    printJson({ sessionId: session.id, verdict, notice: EVALUATE_ONLY });
+                else
+                    process.stdout.write(`demo session ${session.id} (${EVALUATE_ONLY})\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown platform action: ${options.action}`);
+                return EXIT_CODES.USAGE_ERROR;
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}

package/dist/cli/commands/policy-graph-run.d.ts

@@ -0,0 +1,40 @@
+export declare function runGraphSurfaceCommand(options: {
+    action: "build" | "update" | "rebuild" | "status" | "show";
+    root: string;
+    mode?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runPolicyCheckCommand(options: {
+    root: string;
+    command: string;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;
+export declare function runPolicyExplainCommand(options: {
+    root: string;
+    command: string;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;
+export declare function runPolicyEnforceCommand(options: {
+    root: string;
+    command: string;
+    execute?: boolean;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;
+export declare function runRunExplainCommand(options: {
+    root: string;
+    command: string;
+    json?: boolean;
+    failClosed?: boolean;
+    shell?: boolean;
+}): Promise<number>;
+export declare function runRunCommand(options: {
+    root: string;
+    argv: string[];
+    shell?: boolean;
+    timeoutMs?: number;
+    json?: boolean;
+    failClosed?: boolean;
+}): Promise<number>;