@praneeth_54/agentdoctor 1.1.1 → 2.0.0

package/dist/platform/refactor/impact.js

@@ -0,0 +1,60 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveRepoRoot } from "../../utils/path.js";
+/**
+ * Module K — Graph-aware refactoring analysis (rename impact MVP).
+ * Does not apply refactors.
+ */
+export async function analyzeRenameImpact(options) {
+    const root = resolveRepoRoot(options.root);
+    const symbol = options.symbol.trim();
+    const affected = [];
+    const depPaths = [];
+    for (const node of options.graph.nodes) {
+        if ((node.kind === "function" || node.kind === "class") && node.label === symbol && node.path) {
+            affected.push(node.path);
+        }
+    }
+    for (const node of options.graph.nodes.filter((n) => n.kind === "file" && n.path)) {
+        const rel = node.path;
+        if (!/\.(ts|tsx|js|jsx)$/i.test(rel))
+            continue;
+        try {
+            const text = await fs.readFile(path.join(root, rel), "utf8");
+            if (new RegExp(`\\b${escapeReg(symbol)}\\b`).test(text)) {
+                if (!affected.includes(rel))
+                    affected.push(rel);
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    for (const edge of options.graph.edges) {
+        const from = options.graph.nodes.find((n) => n.id === edge.from);
+        const to = options.graph.nodes.find((n) => n.id === edge.to);
+        if (from?.path && affected.includes(from.path)) {
+            depPaths.push(`${from.path} -> ${to?.label ?? edge.to}`);
+        }
+    }
+    const requiredTests = affected.map((f) => f.replace(/(\.\w+)$/, ".test$1"));
+    const risk = affected.length > 10 ? "high" : affected.length > 3 ? "medium" : "low";
+    return {
+        root,
+        symbol,
+        affectedFiles: affected.sort(),
+        dependencyPaths: depPaths.slice(0, 50),
+        risk,
+        requiredTests: [...new Set(requiredTests)].sort(),
+        breakingChangeRisk: risk === "high"
+            ? "Likely public surface impact — require review and tests"
+            : "Localized rename likely; still verify exports",
+        limitations: [
+            "Does not apply edits",
+            "Text search may include false positives for common names",
+        ],
+    };
+}
+function escapeReg(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/platform/reports/export.d.ts

@@ -0,0 +1,12 @@
+import type { PlatformFinding, PlatformSnapshot, ReadinessReport } from "../types.js";
+/**
+ * Module O — Security & compliance reporting exports.
+ * Findings are secret-redacted before any format is written.
+ */
+export declare function exportReports(options: {
+    root: string;
+    findings: PlatformFinding[];
+    readiness: ReadinessReport;
+    snapshot?: PlatformSnapshot;
+}): Promise<Record<string, string>>;
+export declare function escapeHtml(value: string): string;

package/dist/platform/reports/export.js

@@ -0,0 +1,92 @@
+import { ensurePlatformDir, writeJsonArtifact, writeTextArtifact } from "../store.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { sanitizeFindingsForExport } from "../security/redact.js";
+/**
+ * Module O — Security & compliance reporting exports.
+ * Findings are secret-redacted before any format is written.
+ */
+export async function exportReports(options) {
+    const root = resolveRepoRoot(options.root);
+    await ensurePlatformDir(root);
+    const findings = sanitizeFindingsForExport(options.findings);
+    const snapshot = options.snapshot
+        ? { ...options.snapshot, findings: sanitizeFindingsForExport(options.snapshot.findings) }
+        : null;
+    const outputs = {};
+    outputs.json = await writeJsonArtifact(root, "reports/findings.json", {
+        findings,
+        readiness: options.readiness,
+        snapshot,
+    });
+    const md = [
+        "# AgentDoctor 2.0 Report",
+        "",
+        "## Executive summary",
+        "",
+        `Findings: ${findings.length}`,
+        `Critical/High: ${findings.filter((f) => f.severity === "critical" || f.severity === "high").length}`,
+        "",
+        options.readiness.overallNote,
+        "",
+        "## Findings",
+        "",
+        ...findings.map((f) => `### ${f.title}\n- Severity: ${f.severity}\n- Module: ${f.module}\n- ${f.message}\n- Recommendation: ${f.recommendation}\n- Evidence: ${f.evidence.map((e) => e.detail).join(" | ")}\n`),
+    ].join("\n");
+    outputs.markdown = await writeTextArtifact(root, "reports/findings.md", md);
+    const csv = [
+        "id,module,severity,title,confidence,evidence",
+        ...findings.map((f) => `${csvEscape(f.id)},${csvEscape(f.module)},${f.severity},${csvEscape(f.title)},${f.confidence},${csvEscape(f.evidence.map((e) => e.detail).join("; "))}`),
+    ].join("\n");
+    outputs.csv = await writeTextArtifact(root, "reports/findings.csv", `${csv}\n`);
+    const html = `<!doctype html><html><head><meta charset="utf-8"/><title>AgentDoctor Report</title></head><body><h1>AgentDoctor 2.0</h1><pre>${escapeHtml(md)}</pre></body></html>`;
+    outputs.html = await writeTextArtifact(root, "reports/findings.html", html);
+    const sarif = {
+        $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+        version: "2.1.0",
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: "AgentDoctor",
+                        informationUri: "https://github.com/pranee54/AgentDoctor",
+                    },
+                },
+                results: findings.map((f) => ({
+                    ruleId: f.module,
+                    level: f.severity === "critical" || f.severity === "high" ? "error" : "warning",
+                    message: { text: f.message },
+                    properties: {
+                        evidence: f.evidence.map((e) => e.detail),
+                    },
+                    locations: f.evidence[0]?.path
+                        ? [
+                            {
+                                physicalLocation: {
+                                    artifactLocation: { uri: f.evidence[0].path },
+                                    ...(typeof f.evidence[0].line === "number"
+                                        ? { region: { startLine: f.evidence[0].line } }
+                                        : {}),
+                                },
+                            },
+                        ]
+                        : [],
+                })),
+            },
+        ],
+    };
+    outputs.sarif = await writeJsonArtifact(root, "reports/findings.sarif.json", sarif);
+    return outputs;
+}
+export function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+function csvEscape(value) {
+    if (/[",\n]/.test(value))
+        return `"${value.replace(/"/g, '""')}"`;
+    return value;
+}

package/dist/platform/security/redact.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Redact likely secrets from evidence / report text while preserving security context.
+ */
+export declare function redactSecrets(input: string): {
+    text: string;
+    redacted: boolean;
+    patterns: string[];
+};
+export declare function redactEvidenceDetail(detail: string, maxLen?: number): string;
+export declare function sanitizeFindingsForExport<T extends {
+    evidence: Array<{
+        detail: string;
+    }>;
+}>(findings: T[]): T[];
+export declare const SECRET_REDACTION_MARKER = "[REDACTED]";

package/dist/platform/security/redact.js

@@ -0,0 +1,87 @@
+/**
+ * Redact likely secrets from evidence / report text while preserving security context.
+ */
+const REDACTED = "[REDACTED]";
+const SECRET_PATTERNS = [
+    {
+        id: "aws-access-key",
+        re: /\b(AKIA[0-9A-Z]{16})\b/g,
+    },
+    {
+        id: "bearer-token",
+        re: /\b(Bearer\s+)[A-Za-z0-9\-._~+/]+=*/gi,
+    },
+    {
+        id: "jwt",
+        re: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g,
+    },
+    {
+        id: "private-key-block",
+        re: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g,
+    },
+    {
+        id: "connection-string",
+        re: /\b((?:postgres|postgresql|mysql|mongodb(?:\+srv)?|redis|amqp):\/\/)[^\s'"]+/gi,
+    },
+    {
+        id: "password-assignment",
+        re: /\b((?:password|passwd|pwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token)\s*[=:]\s*)(['"]?)[^\s'"]+\2/gi,
+    },
+    {
+        id: "env-export",
+        re: /\b((?:export\s+)?(?:AWS_SECRET_ACCESS_KEY|GITHUB_TOKEN|NPM_TOKEN|OPENAI_API_KEY|STRIPE_SECRET_KEY)\s*=\s*)(['"]?)[^\s'"]+\2/gi,
+    },
+    {
+        id: "generic-api-key",
+        re: /\b((?:api[_-]?key|apikey|client_secret)\s*[=:]\s*)(['"]?)[A-Za-z0-9_\-/+=]{16,}\2/gi,
+    },
+    {
+        id: "cloud-cred-json",
+        re: /("(?:private_key|client_secret|refresh_token)"\s*:\s*")[^"]+(")/gi,
+    },
+];
+export function redactSecrets(input) {
+    let text = input;
+    const patterns = [];
+    for (const pattern of SECRET_PATTERNS) {
+        const before = text;
+        if (pattern.id === "bearer-token") {
+            text = text.replace(pattern.re, `$1${REDACTED}`);
+        }
+        else if (pattern.id === "password-assignment" ||
+            pattern.id === "env-export" ||
+            pattern.id === "generic-api-key") {
+            text = text.replace(pattern.re, `$1$2${REDACTED}$2`);
+        }
+        else if (pattern.id === "connection-string") {
+            text = text.replace(pattern.re, `$1${REDACTED}`);
+        }
+        else if (pattern.id === "cloud-cred-json") {
+            text = text.replace(pattern.re, `$1${REDACTED}$2`);
+        }
+        else if (pattern.id === "private-key-block") {
+            text = text.replace(pattern.re, `-----BEGIN PRIVATE KEY-----\n${REDACTED}\n-----END PRIVATE KEY-----`);
+        }
+        else {
+            text = text.replace(pattern.re, REDACTED);
+        }
+        if (text !== before)
+            patterns.push(pattern.id);
+    }
+    return { text, redacted: patterns.length > 0, patterns: [...new Set(patterns)] };
+}
+export function redactEvidenceDetail(detail, maxLen = 160) {
+    const { text, redacted } = redactSecrets(detail);
+    const clipped = text.length > maxLen ? `${text.slice(0, maxLen)}…` : text;
+    return redacted ? `${clipped} (secrets redacted)` : clipped;
+}
+export function sanitizeFindingsForExport(findings) {
+    return findings.map((f) => ({
+        ...f,
+        evidence: f.evidence.map((e) => ({
+            ...e,
+            detail: redactEvidenceDetail(e.detail),
+        })),
+    }));
+}
+export const SECRET_REDACTION_MARKER = REDACTED;

package/dist/platform/sessions/store.d.ts

@@ -0,0 +1,32 @@
+export interface SessionEvent {
+    id: string;
+    sessionId: string;
+    timestamp: string;
+    type: "session-start" | "prompt" | "tool-call" | "tool-result" | "file-read" | "file-change" | "command" | "policy" | "approval" | "error" | "session-end";
+    summary: string;
+    detail?: Record<string, string>;
+    risk?: "none" | "low" | "medium" | "high" | "critical";
+}
+export interface AgentSession {
+    id: string;
+    root: string;
+    agentId: string;
+    userId?: string;
+    model?: string;
+    startedAt: string;
+    endedAt?: string;
+    events: SessionEvent[];
+}
+export declare function createSession(options: {
+    root: string;
+    agentId: string;
+    userId?: string;
+    model?: string;
+}): Promise<AgentSession>;
+export declare function appendSessionEvent(session: AgentSession, event: Omit<SessionEvent, "id" | "sessionId" | "timestamp"> & {
+    timestamp?: string;
+}): Promise<AgentSession>;
+export declare function endSession(session: AgentSession): Promise<AgentSession>;
+export declare function loadSession(root: string, sessionId: string): Promise<AgentSession | null>;
+export declare function listSessions(root: string): Promise<string[]>;
+export declare function exportSessionMarkdown(session: AgentSession): string;

package/dist/platform/sessions/store.js

@@ -0,0 +1,97 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { appendJsonl, ensurePlatformDir, platformDir, writeJsonArtifact } from "../store.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+export async function createSession(options) {
+    const root = resolveRepoRoot(options.root);
+    await ensurePlatformDir(root);
+    const session = {
+        id: randomUUID(),
+        root,
+        agentId: options.agentId,
+        startedAt: new Date().toISOString(),
+        events: [],
+        ...(options.userId ? { userId: options.userId } : {}),
+        ...(options.model ? { model: options.model } : {}),
+    };
+    session.events.push({
+        id: randomUUID(),
+        sessionId: session.id,
+        timestamp: session.startedAt,
+        type: "session-start",
+        summary: `Session started for agent ${options.agentId}`,
+        risk: "none",
+    });
+    await persistSession(session);
+    return session;
+}
+export async function appendSessionEvent(session, event) {
+    const full = {
+        id: randomUUID(),
+        sessionId: session.id,
+        timestamp: event.timestamp ?? new Date().toISOString(),
+        type: event.type,
+        summary: event.summary,
+        ...(event.detail ? { detail: event.detail } : {}),
+        ...(event.risk ? { risk: event.risk } : {}),
+    };
+    session.events.push(full);
+    await appendJsonl(session.root, path.join("sessions", `${session.id}.jsonl`), full);
+    await persistSession(session);
+    return session;
+}
+export async function endSession(session) {
+    session.endedAt = new Date().toISOString();
+    await appendSessionEvent(session, {
+        type: "session-end",
+        summary: "Session ended",
+        risk: "none",
+    });
+    return session;
+}
+async function persistSession(session) {
+    await writeJsonArtifact(session.root, path.join("sessions", `${session.id}.json`), session);
+}
+export async function loadSession(root, sessionId) {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(sessionId)) {
+        throw new Error("invalid session id");
+    }
+    const file = path.join(platformDir(root), "sessions", `${sessionId}.json`);
+    try {
+        return JSON.parse(await fs.readFile(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function listSessions(root) {
+    const dir = path.join(platformDir(root), "sessions");
+    try {
+        return (await fs.readdir(dir))
+            .filter((n) => n.endsWith(".json"))
+            .map((n) => n.replace(/\.json$/, ""))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export function exportSessionMarkdown(session) {
+    const lines = [
+        `# Agent session ${session.id}`,
+        "",
+        `- Agent: ${session.agentId}`,
+        `- User: ${session.userId ?? "unknown"}`,
+        `- Model: ${session.model ?? "unknown"}`,
+        `- Started: ${session.startedAt}`,
+        `- Ended: ${session.endedAt ?? "(open)"}`,
+        "",
+        "## Timeline",
+        "",
+    ];
+    for (const e of session.events) {
+        lines.push(`- ${e.timestamp} **${e.type}** ${e.summary}${e.risk ? ` _(risk=${e.risk})_` : ""}`);
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/platform/store.d.ts

@@ -0,0 +1,6 @@
+export declare function platformDir(root: string): string;
+export declare function ensurePlatformDir(root: string): Promise<string>;
+export declare function writeJsonArtifact(root: string, relativeUnderPlatform: string, value: unknown): Promise<string>;
+export declare function writeTextArtifact(root: string, relativeUnderPlatform: string, body: string): Promise<string>;
+export declare function appendJsonl(root: string, relativeUnderPlatform: string, record: unknown): Promise<void>;
+export declare function readJsonIfExists<T>(absolute: string): Promise<T | null>;

package/dist/platform/store.js

@@ -0,0 +1,57 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { atomicWriteTextFile } from "../utils/fs.js";
+import { isPathInsideRoot, resolveRepoRoot } from "../utils/path.js";
+export function platformDir(root) {
+    return path.join(resolveRepoRoot(root), ".agentdoctor", "platform");
+}
+export async function ensurePlatformDir(root) {
+    const dir = platformDir(root);
+    await fs.mkdir(path.join(dir, "sessions"), { recursive: true });
+    await fs.mkdir(path.join(dir, "provenance"), { recursive: true });
+    await fs.mkdir(path.join(dir, "reports"), { recursive: true });
+    await fs.mkdir(path.join(dir, "snapshots"), { recursive: true });
+    return dir;
+}
+function resolveSafePlatformPath(root, relativeUnderPlatform) {
+    const dir = platformDir(root);
+    if (relativeUnderPlatform.includes("\0") ||
+        path.isAbsolute(relativeUnderPlatform) ||
+        relativeUnderPlatform.split(/[/\\]/).includes("..")) {
+        throw new Error(`refusing unsafe platform path: ${relativeUnderPlatform}`);
+    }
+    const target = path.resolve(dir, relativeUnderPlatform);
+    if (!isPathInsideRoot(dir, target)) {
+        throw new Error(`platform path escapes store: ${relativeUnderPlatform}`);
+    }
+    return target;
+}
+export async function writeJsonArtifact(root, relativeUnderPlatform, value) {
+    await ensurePlatformDir(root);
+    const target = resolveSafePlatformPath(root, relativeUnderPlatform);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await atomicWriteTextFile(target, `${JSON.stringify(value, null, 2)}\n`);
+    return target;
+}
+export async function writeTextArtifact(root, relativeUnderPlatform, body) {
+    await ensurePlatformDir(root);
+    const target = resolveSafePlatformPath(root, relativeUnderPlatform);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await atomicWriteTextFile(target, body);
+    return target;
+}
+export async function appendJsonl(root, relativeUnderPlatform, record) {
+    await ensurePlatformDir(root);
+    const target = resolveSafePlatformPath(root, relativeUnderPlatform);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.appendFile(target, `${JSON.stringify(record)}\n`, "utf8");
+}
+export async function readJsonIfExists(absolute) {
+    try {
+        const raw = await fs.readFile(absolute, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/platform/test-impact/analyze.d.ts

@@ -0,0 +1,32 @@
+import type { EvidenceKind } from "../types.js";
+export interface TestImpactItem {
+    testPath: string;
+    reason: string;
+    confidence: number;
+    evidence: EvidenceKind;
+    exists: boolean;
+    relatedModules: string[];
+}
+export interface MissingTestWarning {
+    sourceFile: string;
+    message: string;
+    relatedModules: string[];
+}
+export interface TestImpactReport {
+    root: string;
+    gitAvailable: boolean;
+    changedFiles: string[];
+    recommendedTests: TestImpactItem[];
+    relatedModules: string[];
+    uncoveredAreas: string[];
+    missingTestWarnings: MissingTestWarning[];
+    skipRisk: string;
+    limitations: string[];
+}
+/**
+ * Module H — Test impact analysis (naming + path heuristics).
+ * Never claims tests passed unless actually executed elsewhere.
+ */
+export declare function analyzeTestImpact(rootInput: string): Promise<TestImpactReport>;
+export declare function persistTestImpactReport(root: string, report: TestImpactReport): Promise<string>;
+export declare function formatTestImpactHuman(report: TestImpactReport): string;

package/dist/platform/test-impact/analyze.js

@@ -0,0 +1,164 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { analyzeChanges } from "../../core/changes/analyze.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { writeJsonArtifact } from "../store.js";
+function modulesForPath(file, attributed) {
+    const mods = new Set(attributed ?? []);
+    const parts = file.split("/");
+    if (parts[0] === "src" && parts[1])
+        mods.add(parts[1]);
+    if (parts[0] === "tests" && parts[1])
+        mods.add(parts[1]);
+    const base = path.basename(file, path.extname(file));
+    if (base && !base.startsWith("."))
+        mods.add(base);
+    return [...mods].sort();
+}
+async function fileExists(root, rel) {
+    try {
+        await fs.access(path.join(root, rel));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Module H — Test impact analysis (naming + path heuristics).
+ * Never claims tests passed unless actually executed elsewhere.
+ */
+export async function analyzeTestImpact(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const changes = await analyzeChanges({ root, impact: true });
+    const changed = changes.files.map((f) => f.path);
+    const recommended = [];
+    const uncovered = [];
+    const missingTestWarnings = [];
+    const allModules = new Set();
+    if (!changes.gitAvailable) {
+        return {
+            root,
+            gitAvailable: false,
+            changedFiles: [],
+            recommendedTests: [],
+            relatedModules: [],
+            uncoveredAreas: [],
+            missingTestWarnings: [],
+            skipRisk: "Git not available — cannot infer changed files",
+            limitations: [
+                "Requires a git working tree to detect changes",
+                "Does not execute tests; never claims pass/fail",
+                ...changes.limitations,
+            ],
+        };
+    }
+    for (const fileEntry of changes.files) {
+        const file = fileEntry.path;
+        const relatedModules = modulesForPath(file, fileEntry.modules);
+        for (const m of relatedModules)
+            allModules.add(m);
+        if (/\.(test|spec)\./i.test(file) || file.includes("__tests__")) {
+            recommended.push({
+                testPath: file,
+                reason: "Changed file is itself a test",
+                confidence: 0.95,
+                evidence: "verified",
+                exists: true,
+                relatedModules,
+            });
+            continue;
+        }
+        const ext = path.extname(file);
+        const base = ext ? file.slice(0, -ext.length) : file;
+        const candidates = [
+            `${base}.test${ext || ".ts"}`,
+            `${base}.spec${ext || ".ts"}`,
+            file.replace(/\/src\//, "/tests/"),
+            file.replace(/^src\//, "tests/"),
+        ].filter((c, i, arr) => c !== file && arr.indexOf(c) === i);
+        let anyExists = false;
+        for (const c of candidates) {
+            const exists = await fileExists(root, c);
+            if (exists)
+                anyExists = true;
+            recommended.push({
+                testPath: c,
+                reason: exists
+                    ? `Existing test candidate for changed file ${file}`
+                    : `Suggested test path for changed file ${file} (file not found)`,
+                confidence: exists ? 0.7 : 0.4,
+                evidence: exists ? "verified" : "inferred",
+                exists,
+                relatedModules,
+            });
+        }
+        if (candidates.length === 0) {
+            uncovered.push(file);
+        }
+        else if (!anyExists) {
+            missingTestWarnings.push({
+                sourceFile: file,
+                message: `No co-located or tests/ counterpart found for ${file}`,
+                relatedModules,
+            });
+        }
+    }
+    for (const rel of changes.impact?.relatedPaths ?? []) {
+        for (const m of modulesForPath(rel))
+            allModules.add(m);
+    }
+    const seen = new Set();
+    const deduped = recommended.filter((r) => {
+        if (seen.has(r.testPath))
+            return false;
+        seen.add(r.testPath);
+        return true;
+    });
+    return {
+        root,
+        gitAvailable: true,
+        changedFiles: changed,
+        recommendedTests: deduped,
+        relatedModules: [...allModules].sort(),
+        uncoveredAreas: uncovered,
+        missingTestWarnings,
+        skipRisk: changed.length === 0
+            ? "No changes detected"
+            : missingTestWarnings.length > 0
+                ? "Changed source files lack matching tests — skipping tests risks regressions"
+                : "Skipping recommended tests may miss regressions in changed modules",
+        limitations: [
+            "Impact mapping is path/naming heuristic — not a full coverage DB",
+            "Does not execute tests; never claims pass/fail",
+            ...changes.limitations,
+        ],
+    };
+}
+export async function persistTestImpactReport(root, report) {
+    return writeJsonArtifact(root, "reports/test-impact.json", report);
+}
+export function formatTestImpactHuman(report) {
+    const lines = [
+        "AgentDoctor 2.0 test-impact",
+        `  git: ${report.gitAvailable ? "available" : "unavailable"}`,
+        `  changed files: ${report.changedFiles.length}`,
+        `  recommended tests: ${report.recommendedTests.length}`,
+        `  missing-test warnings: ${report.missingTestWarnings.length}`,
+        `  related modules: ${report.relatedModules.slice(0, 12).join(", ") || "(none)"}`,
+        `  skip risk: ${report.skipRisk}`,
+    ];
+    if (report.recommendedTests.length) {
+        lines.push("  affected tests:");
+        for (const t of report.recommendedTests.slice(0, 20)) {
+            lines.push(`    - ${t.testPath} (exists=${t.exists}, confidence=${t.confidence}, ${t.reason})`);
+        }
+    }
+    if (report.missingTestWarnings.length) {
+        lines.push("  missing tests:");
+        for (const w of report.missingTestWarnings.slice(0, 10)) {
+            lines.push(`    - ${w.sourceFile}: ${w.message}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/platform/time-machine/compare.d.ts

@@ -0,0 +1,17 @@
+export interface TimeMachineCompare {
+    root: string;
+    left: string;
+    right: string;
+    changedFiles: string[];
+    summary: string;
+    limitations: string[];
+}
+/**
+ * Module J — Repository time machine (git-backed).
+ */
+export declare function compareCommits(options: {
+    root: string;
+    left: string;
+    right: string;
+}): Promise<TimeMachineCompare>;
+export declare function listRecentCommits(rootInput: string, limit?: number): Promise<string[]>;