@praneeth_54/agentdoctor 2.0.0 → 2.0.1

package/dist/auth/rbac.js

@@ -0,0 +1,26 @@
+/**
+ * Role-based access control for AgentDoctor surfaces.
+ * Not enterprise SSO — roles are applied after a verified identity (local session or OIDC JWT).
+ */
+export const RBAC_ROLE_RANK = {
+    viewer: 1,
+    developer: 2,
+    reviewer: 3,
+    "policy-admin": 4,
+    admin: 5,
+};
+const PERMISSION_MIN_ROLE = {
+    "read-findings": "viewer",
+    "read-audit": "viewer",
+    "export-reports": "developer",
+    "approve-actions": "reviewer",
+    "manage-policies": "policy-admin",
+    "admin-settings": "admin",
+};
+export function hasRbacPermission(role, permission) {
+    const required = PERMISSION_MIN_ROLE[permission];
+    return (RBAC_ROLE_RANK[role] ?? 0) >= (RBAC_ROLE_RANK[required] ?? 99);
+}
+export function roleAtLeast(role, required) {
+    return (RBAC_ROLE_RANK[role] ?? 0) >= (RBAC_ROLE_RANK[required] ?? 99);
+}

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

@@ -0,0 +1,6 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runArchitectureCommand(options: {
+    action: "init" | "analyze" | "check" | "explain";
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/architecture.js

@@ -0,0 +1,109 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
+import { buildC4Views } from "../../architecture/c4.js";
+import { checkArchitectureAtRoot, explainArchitecture, initArchitecture, loadArchitectureContract, } from "../../architecture/contract.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runArchitectureCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    try {
+        switch (options.action) {
+            case "init": {
+                const written = await initArchitecture(root);
+                if (options.json)
+                    printJson({ path: written, createdOrExisting: true });
+                else
+                    process.stdout.write(`Architecture contract at ${written}\n`);
+                return EXIT_CODES.SUCCESS;
+            }
+            case "analyze": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const views = buildC4Views(graph);
+                const loaded = await loadArchitectureContract(root);
+                const check = await checkArchitectureAtRoot(root, graph);
+                const payload = {
+                    c4: {
+                        levels: views.map((v) => v.level),
+                        views,
+                        label: "Inferred/proposed from graph evidence — not approved architecture facts",
+                    },
+                    contract: loaded
+                        ? {
+                            path: loaded.path,
+                            version: loaded.contract.version,
+                            layerCount: loaded.contract.layers.length,
+                            forbiddenCount: loaded.contract.forbidden.length,
+                            allowedCount: loaded.contract.allowed.length,
+                        }
+                        : null,
+                    check: {
+                        violations: check.violations.length,
+                        importEdgesChecked: check.importEdgesChecked,
+                        limitations: check.limitations,
+                    },
+                };
+                if (options.json)
+                    printJson(payload);
+                else {
+                    process.stdout.write([
+                        "AgentDoctor architecture analyze",
+                        `  C4 views: ${views.map((v) => v.level).join(", ")} (inferred)`,
+                        loaded
+                            ? `  contract: ${loaded.path} (layers=${loaded.contract.layers.length}, forbidden=${loaded.contract.forbidden.length})`
+                            : "  contract: none (run architecture init)",
+                        `  check violations: ${check.violations.length} (edges=${check.importEdgesChecked})`,
+                    ].join("\n") + "\n");
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "check": {
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const check = await checkArchitectureAtRoot(root, graph);
+                if (options.json)
+                    printJson(check);
+                else {
+                    process.stdout.write([
+                        "AgentDoctor architecture check",
+                        `  contract: ${check.contractPath ?? "none"}`,
+                        `  import edges checked: ${check.importEdgesChecked}`,
+                        `  violations: ${check.violations.length}`,
+                        ...check.violations
+                            .slice(0, 30)
+                            .map((v) => `    - [${v.kind}] ${v.ruleId}: ${v.fromPath} → ${v.toPath} (${v.fromLayer}→${v.toLayer})`),
+                        ...check.limitations.map((l) => `  limitation: ${l}`),
+                    ].join("\n") + "\n");
+                }
+                if (check.violations.some((v) => v.kind === "forbidden")) {
+                    return EXIT_CODES.ISSUES_OR_THRESHOLD;
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            case "explain": {
+                const loaded = await loadArchitectureContract(root);
+                const graph = await buildIntelligenceGraph({ root, mode: "auto" });
+                const check = await checkArchitectureAtRoot(root, graph);
+                if (options.json) {
+                    printJson({
+                        contract: loaded?.contract ?? null,
+                        path: loaded?.path ?? null,
+                        check,
+                        explanation: explainArchitecture(loaded?.contract ?? null, check),
+                    });
+                }
+                else {
+                    process.stdout.write(explainArchitecture(loaded?.contract ?? null, check));
+                }
+                return EXIT_CODES.SUCCESS;
+            }
+            default:
+                console.error(`Error: unknown architecture 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/assurance.d.ts

@@ -0,0 +1,67 @@
+export declare function runChangeAnalyzeCommand(options: {
+    root: string;
+    since?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeVerifyCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeExplainCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    coverage?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeDiffCommand(options: {
+    root: string;
+    since?: string;
+    changeId?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runChangeStatusCommand(options: {
+    root: string;
+    changeId?: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runEvidenceInspectCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runEvidenceVerifyCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofBuildCommand(options: {
+    root: string;
+    changeId: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofInspectCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofExplainCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofVerifyCommand(options: {
+    root: string;
+    id: string;
+    json?: boolean;
+}): Promise<number>;
+export declare function runProofExportCommand(options: {
+    root: string;
+    id: string;
+    out: string;
+    json?: boolean;
+}): Promise<number>;

package/dist/cli/commands/assurance.js

@@ -0,0 +1,210 @@
+import { analyzeChange, changeStatus, diffChange, explainChange, inspectEvidence, verifyChange, verifyEvidence, } from "../../assurance/change.js";
+import { buildProofFromEvidence, explainProof, exportProof, inspectProof, verifyProof, } from "../../assurance/proof.js";
+import { EXIT_CODES } from "../../types/index.js";
+function emit(json, value, human) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(`${human}\n`);
+    }
+}
+export async function runChangeAnalyzeCommand(options) {
+    try {
+        const assessment = await analyzeChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        emit(Boolean(options.json), assessment, [
+            `Change assessment ${assessment.changeId}`,
+            `  files: ${assessment.changedFiles.length}`,
+            `  symbols: ${assessment.changedSymbols.length}`,
+            `  testImpact: ${assessment.testImpact.mode} (${assessment.testImpact.confidence})`,
+            `  verificationStatus: ${assessment.verificationStatus}`,
+            `  Next: agentdoctor change verify${options.since ? ` --since ${options.since}` : ""}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeVerifyCommand(options) {
+    try {
+        const { assessment, manifest } = await verifyChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        emit(Boolean(options.json), { assessment, manifest }, [
+            `Evidence produced for ${assessment.changeId}`,
+            `  directory: ${assessment.evidence.directory}`,
+            `  files: ${assessment.evidence.files?.join(", ") ?? ""}`,
+            `  verificationStatus: ${assessment.verificationStatus}`,
+            `  Next: agentdoctor evidence verify ${assessment.changeId}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeExplainCommand(options) {
+    try {
+        const assessment = await analyzeChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+            ...(options.coverage ? { coveragePath: options.coverage } : {}),
+        });
+        const text = explainChange(assessment);
+        emit(Boolean(options.json), { assessment, explanation: text }, text);
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeDiffCommand(options) {
+    try {
+        const diff = await diffChange({
+            root: options.root,
+            ...(options.since ? { since: options.since } : {}),
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+        });
+        emit(Boolean(options.json), diff, [
+            `Change diff${diff.changeId ? ` (${diff.changeId})` : ""}`,
+            `  base → target: ${diff.baseRevision ?? "(wt)"} → ${diff.targetRevision ?? "?"}`,
+            `  files: +${diff.summary.added} ~${diff.summary.modified} -${diff.summary.deleted} ?${diff.summary.untracked}`,
+            diff.stat ? `\n${diff.stat}` : "  (no git --stat output)",
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runChangeStatusCommand(options) {
+    try {
+        const status = await changeStatus({
+            root: options.root,
+            ...(options.changeId ? { changeId: options.changeId } : {}),
+        });
+        emit(Boolean(options.json), status, [
+            `Change status${status.changeId ? `: ${status.changeId}` : " (no evidence)"}`,
+            `  evidence: ${status.evidencePresent ? status.evidenceDirectory : "none"}`,
+            `  verificationStatus: ${status.verificationStatus}`,
+            `  proof: ${status.proofPresent ? status.proofId : "none"}`,
+            `  note: ${status.integrityNote}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runEvidenceInspectCommand(options) {
+    const result = await inspectEvidence({ root: options.root, changeId: options.changeId });
+    if (!result.ok) {
+        process.stderr.write(`Error: ${result.error ?? "evidence not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, [
+        `Evidence ${options.changeId}`,
+        `  directory: ${result.directory}`,
+        `  files: ${result.presentFiles.join(", ")}`,
+        `  manifestStatus: ${result.manifest?.verificationStatus ?? "missing"}`,
+    ].join("\n"));
+    return EXIT_CODES.SUCCESS;
+}
+export async function runEvidenceVerifyCommand(options) {
+    const result = await verifyEvidence({ root: options.root, changeId: options.changeId });
+    emit(Boolean(options.json), result, [
+        `Evidence verify ${options.changeId}`,
+        `  status: ${result.verificationStatus}`,
+        ...result.checked.map((c) => `  ${c.match ? "OK" : "FAIL"} ${c.name}`),
+    ].join("\n"));
+    if (!result.ok) {
+        return EXIT_CODES.ISSUES_OR_THRESHOLD;
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofBuildCommand(options) {
+    try {
+        const proof = await buildProofFromEvidence(options.root, options.changeId);
+        emit(Boolean(options.json), proof, [
+            `ChangeProof ${proof.proofId}`,
+            `  changeId: ${proof.changeId}`,
+            `  integrityStatus: ${proof.integrityStatus}`,
+            `  engineeringChecksStatus: ${proof.engineeringChecksStatus}`,
+            `  verificationState: ${proof.verificationState}`,
+            `  correctnessStatus: ${proof.correctnessStatus}`,
+        ].join("\n"));
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runProofInspectCommand(options) {
+    const result = await inspectProof(options.root, options.id);
+    if (!result.ok || !result.proof) {
+        process.stderr.write(`Error: ${result.error ?? "proof not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, [
+        `Proof ${result.proof.proofId}`,
+        `  changeId: ${result.proof.changeId}`,
+        `  integrityStatus: ${result.proof.integrityStatus}`,
+        `  engineeringChecksStatus: ${result.proof.engineeringChecksStatus}`,
+        `  verificationState: ${result.proof.verificationState}`,
+        `  correctnessStatus: ${result.proof.correctnessStatus}`,
+        `  path: ${result.path}`,
+    ].join("\n"));
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofExplainCommand(options) {
+    const result = await inspectProof(options.root, options.id);
+    if (!result.ok || !result.proof) {
+        process.stderr.write(`Error: ${result.error ?? "proof not found"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    const text = explainProof(result.proof);
+    emit(Boolean(options.json), { proof: result.proof, explanation: text }, text);
+    return EXIT_CODES.SUCCESS;
+}
+export async function runProofVerifyCommand(options) {
+    const result = await verifyProof(options.root, options.id);
+    emit(Boolean(options.json), result, [
+        `Proof verify ${options.id}`,
+        `  integrityStatus: ${result.integrityStatus}`,
+        `  engineeringChecksStatus: ${result.engineeringChecksStatus}`,
+        `  verificationState: ${result.verificationState}`,
+        `  correctnessStatus: ${result.correctnessStatus}`,
+        ...result.checked.map((c) => `  ${c.match ? "OK" : "FAIL"} ${c.name}`),
+    ].join("\n"));
+    return result.ok ? EXIT_CODES.SUCCESS : EXIT_CODES.ISSUES_OR_THRESHOLD;
+}
+export async function runProofExportCommand(options) {
+    const result = await exportProof(options.root, options.id, options.out);
+    if (!result.ok) {
+        process.stderr.write(`Error: ${result.error ?? "export failed"}\n`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    emit(Boolean(options.json), result, `Exported proof to ${result.path}`);
+    return EXIT_CODES.SUCCESS;
+}

package/dist/cli/commands/complete.js

@@ -183,11 +183,11 @@ export async function runV2SurfaceCommand(options) {
                 return EXIT_CODES.SUCCESS;
             }
             case "impact": {
-                const impact = await analyzeTestImpact(root);
+                const impact = await analyzeTestImpact({ root });
                 if (options.json)
                     printJson({ kind: "test-impact", contractsVersion: CONTRACTS_VERSION, impact });
                 else
-                    process.stdout.write(`impact recommendedTests=${impact.recommendedTests.length}\n`);
+                    process.stdout.write(`impact mode=${impact.mode} recommendedTests=${impact.recommendedTests.length}\n`);
                 return EXIT_CODES.SUCCESS;
             }
             case "refactor-impact": {

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

@@ -12,4 +12,6 @@ export declare function runPlatformCommand(options: {
     actionType?: string;
     sessionId?: string;
     failClosed?: boolean;
+    coverage?: string;
+    since?: string;
 }): Promise<ExitCode>;

package/dist/cli/commands/platform.js

@@ -38,7 +38,11 @@ export async function runPlatformCommand(options) {
                 return EXIT_CODES.SUCCESS;
             }
             case "test-impact": {
-                const report = await analyzeTestImpact(root);
+                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 });

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>;