@praneeth_54/agentdoctor 1.1.1 → 2.0.0

package/dist/cli/commands/platform.js

@@ -0,0 +1,191 @@
+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);
+                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/v2.d.ts

@@ -0,0 +1,55 @@
+import { type ExitCode } from "../../types/index.js";
+export declare function runChangesCommand(options: {
+    root?: string;
+    since?: string;
+    impact?: boolean;
+    json?: boolean;
+}): Promise<ExitCode>;
+export declare function runContextHealthCommand(options: {
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;
+export declare function runSecretsCommand(options: {
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;
+export declare function runFixUndoCommand(options: {
+    root?: string;
+    auditId: string;
+}): Promise<ExitCode>;
+export declare function runFixHistoryCommand(options: {
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;
+export declare function runBaselineCommand(options: {
+    action: "save" | "list" | "diff" | "delete" | "trends";
+    name?: string;
+    root?: string;
+    json?: boolean;
+}): Promise<ExitCode>;
+export declare function runPackagesCommand(options: {
+    root?: string;
+    json?: boolean;
+    scan?: boolean;
+}): Promise<ExitCode>;
+export declare function runPrReviewCommand(options: {
+    root?: string;
+    base?: string;
+    json?: boolean;
+}): Promise<ExitCode>;
+export declare function runDashboardCommand(options: {
+    root?: string;
+    host?: string;
+    port?: number;
+    allowNonLoopback?: boolean;
+}): Promise<ExitCode>;
+export declare function runPluginsCommand(options: {
+    root?: string;
+    json?: boolean;
+    run?: boolean;
+}): Promise<ExitCode>;
+export declare function runLocalAiCommand(options: {
+    provider?: string;
+    prompt?: string;
+    json?: boolean;
+}): Promise<ExitCode>;

package/dist/cli/commands/v2.js

@@ -0,0 +1,278 @@
+import { EXIT_CODES } from "../../types/index.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { analyzeChanges } from "../../core/changes/analyze.js";
+import { analyzeContextHealth } from "../../core/context-health/analyze.js";
+import { scanSecrets } from "../../core/secrets/scan.js";
+import { listFixAudits, undoFix } from "../../core/fix/backup.js";
+import { baselineFromScan, compareToBaseline, computeBaselineTrends, deleteNamedBaseline, listNamedBaselines, loadNamedBaseline, saveNamedBaseline, } from "../../core/baseline/store.js";
+import { detectMonorepo } from "../../core/monorepo/detect.js";
+import { analyzePullRequest } from "../../integrations/github/pr-analyze.js";
+import { startDashboardServer } from "../../dashboard/server.js";
+import { discoverPlugins } from "../../plugins/sdk.js";
+import { runPluginAnalyzers } from "../../plugins/runtime.js";
+import { createLocalAiProvider, } from "../../integrations/local-ai/provider.js";
+import { scan } from "../../core/scanner/scan.js";
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export async function runChangesCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const report = await analyzeChanges({
+        root,
+        ...(options.since ? { since: options.since } : {}),
+        impact: options.impact === true,
+    });
+    if (options.json) {
+        printJson(report);
+    }
+    else {
+        process.stdout.write(`Changes (${report.gitAvailable ? "git" : "no-git"})\n  files: ${report.files.length}\n  added: ${report.summary.added} modified: ${report.summary.modified} deleted: ${report.summary.deleted}\n`);
+        for (const f of report.files.slice(0, 40)) {
+            const mods = f.modules?.length ? `  modules=${f.modules.join(",")}` : "";
+            process.stdout.write(`  ${f.staged ? "S" : " "} ${f.kind.padEnd(10)} ${f.path}${mods}\n`);
+        }
+        if (report.impact) {
+            process.stdout.write(`Impact: ${report.impact.status} — ${report.impact.reason}\n  edges: ${report.impact.edges.length}\n`);
+        }
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runContextHealthCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const report = await analyzeContextHealth(root);
+    if (options.json)
+        printJson(report);
+    else {
+        process.stdout.write(`Context health\n  instruction files: ${report.instructionFiles.length}\n  conflicts: ${report.conflicts.length}\n`);
+        for (const c of report.conflicts) {
+            process.stdout.write(`  [${c.severity}] ${c.kind}: ${c.message}\n`);
+        }
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runSecretsCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const report = await scanSecrets({ root, enabled: true });
+    if (options.json)
+        printJson(report);
+    else {
+        process.stdout.write(`Secret scan (opt-in)\n  files: ${report.filesScanned}\n  findings: ${report.findings.length}\n`);
+        for (const f of report.findings.slice(0, 30)) {
+            process.stdout.write(`  [${f.severity}] ${f.ruleId} ${f.file}:${f.line} ${f.redactedSnippet}\n`);
+        }
+    }
+    return report.findings.some((f) => f.severity === "critical")
+        ? EXIT_CODES.ISSUES_OR_THRESHOLD
+        : EXIT_CODES.SUCCESS;
+}
+export async function runFixUndoCommand(options) {
+    try {
+        const record = await undoFix({
+            root: resolveRepoRoot(options.root ?? process.cwd()),
+            auditId: options.auditId,
+        });
+        process.stdout.write(`Undid Safe Fix audit ${options.auditId} → undo audit ${record.id}\n`);
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.INTERNAL_ERROR;
+    }
+}
+export async function runFixHistoryCommand(options) {
+    const audits = await listFixAudits(resolveRepoRoot(options.root ?? process.cwd()));
+    if (options.json)
+        printJson({ audits });
+    else if (audits.length === 0)
+        process.stdout.write("No Safe Fix audits yet.\n");
+    else {
+        for (const a of audits) {
+            process.stdout.write(`${a.id}  ${a.mode}  ${a.createdAt}  entries=${a.entries.length}\n`);
+        }
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runBaselineCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    try {
+        if (options.action === "list") {
+            const names = await listNamedBaselines(root);
+            if (options.json)
+                printJson({ baselines: names });
+            else
+                process.stdout.write(names.length ? `${names.join("\n")}\n` : "No named baselines.\n");
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.action === "trends") {
+            const trends = await computeBaselineTrends(root);
+            if (options.json)
+                printJson(trends);
+            else if (trends.points.length === 0) {
+                process.stdout.write("No baselines for trends.\n");
+            }
+            else {
+                for (const p of trends.points) {
+                    process.stdout.write(`${p.createdAt}  ${p.name}  total=${p.counts.total} critical=${p.counts.critical}\n`);
+                }
+                for (const d of trends.deltas) {
+                    process.stdout.write(`  Δ ${d.from}→${d.to}: total ${d.totalDelta >= 0 ? "+" : ""}${d.totalDelta}, critical ${d.criticalDelta >= 0 ? "+" : ""}${d.criticalDelta}\n`);
+                }
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.action === "save") {
+            if (!options.name) {
+                console.error("Error: --name required");
+                return EXIT_CODES.USAGE_ERROR;
+            }
+            const result = await scan({ cwd: root });
+            const baseline = baselineFromScan(options.name, result);
+            const file = await saveNamedBaseline(root, baseline);
+            process.stdout.write(`Saved baseline ${options.name} → ${file}\n`);
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.action === "delete") {
+            if (!options.name) {
+                console.error("Error: --name required");
+                return EXIT_CODES.USAGE_ERROR;
+            }
+            await deleteNamedBaseline(root, options.name);
+            process.stdout.write(`Deleted baseline ${options.name}\n`);
+            return EXIT_CODES.SUCCESS;
+        }
+        if (options.action === "diff") {
+            if (!options.name) {
+                console.error("Error: --name required");
+                return EXIT_CODES.USAGE_ERROR;
+            }
+            const baseline = await loadNamedBaseline(root, options.name);
+            if (!baseline) {
+                console.error(`Error: baseline not found: ${options.name}`);
+                return EXIT_CODES.USAGE_ERROR;
+            }
+            const result = await scan({ cwd: root });
+            const diff = compareToBaseline(baseline, result.findings);
+            if (options.json)
+                printJson(diff);
+            else {
+                process.stdout.write(`Baseline ${diff.name}\n  added: ${diff.added.length}\n  removed: ${diff.removed.length}\n  recurring: ${diff.recurring.length}\n  unchanged: ${diff.unchanged}\n`);
+            }
+            return EXIT_CODES.SUCCESS;
+        }
+        return EXIT_CODES.USAGE_ERROR;
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+}
+export async function runPackagesCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const mono = await detectMonorepo(root);
+    if (!options.scan) {
+        if (options.json)
+            printJson(mono);
+        else {
+            process.stdout.write(`Monorepo: ${mono.isMonorepo ? "yes" : "no"} (${mono.tool})\n  packages: ${mono.packages.length}\n`);
+            for (const p of mono.packages) {
+                process.stdout.write(`  - ${p.name} (${p.relativePath})\n`);
+            }
+        }
+        return EXIT_CODES.SUCCESS;
+    }
+    const packageScans = [];
+    for (const pkg of mono.packages) {
+        const result = await scan({ cwd: pkg.absolutePath });
+        packageScans.push({
+            name: pkg.name,
+            path: pkg.relativePath,
+            summary: result.summary,
+            overall: result.scores?.overall ?? null,
+        });
+    }
+    if (options.json)
+        printJson({ monorepo: mono, packageScans });
+    else {
+        for (const p of packageScans) {
+            process.stdout.write(`${p.name}: score=${p.overall} findings=${p.summary.total} (c=${p.summary.critical} w=${p.summary.warning})\n`);
+        }
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runPrReviewCommand(options) {
+    const report = await analyzePullRequest({
+        root: resolveRepoRoot(options.root ?? process.cwd()),
+        dryRun: true,
+        ...(options.base ? { baseRef: options.base } : {}),
+    });
+    if (options.json)
+        printJson(report);
+    else {
+        process.stdout.write(report.commentMarkdown);
+        process.stdout.write("\n(posted=false; local dry-run only)\n");
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runDashboardCommand(options) {
+    try {
+        const server = await startDashboardServer({
+            root: resolveRepoRoot(options.root ?? process.cwd()),
+            host: options.host ?? "127.0.0.1",
+            port: options.port ?? 8787,
+            readOnly: true,
+            allowNonLoopback: options.allowNonLoopback === true,
+        });
+        if (options.allowNonLoopback) {
+            process.stderr.write("WARNING: dashboard bound outside loopback with --allow-non-loopback. Local ?user= roles are not authentication.\n");
+        }
+        process.stdout.write(`AgentDoctor dashboard (read-only) at http://${server.host}:${server.port}/\nLocal ?user= is not authentication. Press Ctrl+C to stop.\n`);
+        await new Promise(() => {
+            /* keep process alive until signal */
+        });
+        return EXIT_CODES.SUCCESS;
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
+}
+export async function runPluginsCommand(options) {
+    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const plugins = await discoverPlugins(root);
+    const analyzerResults = options.run ? await runPluginAnalyzers(root) : undefined;
+    if (options.json) {
+        printJson({ plugins, ...(analyzerResults ? { analyzerResults } : {}) });
+    }
+    else if (plugins.length === 0) {
+        process.stdout.write("No plugins discovered under .agentdoctor/plugins/\n");
+    }
+    else {
+        for (const p of plugins) {
+            process.stdout.write(`${p.ok ? "ok" : "ERR"}  ${p.manifest.id}@${p.manifest.version}  caps=${p.manifest.capabilities.join(",")}\n`);
+            for (const e of p.errors)
+                process.stdout.write(`    ${e}\n`);
+        }
+        if (analyzerResults) {
+            for (const r of analyzerResults) {
+                process.stdout.write(`run ${r.ok ? "ok" : "ERR"}  ${r.pluginId}  notes=${r.notes.length}${r.error ? `  ${r.error}` : ""}\n`);
+            }
+        }
+    }
+    return EXIT_CODES.SUCCESS;
+}
+export async function runLocalAiCommand(options) {
+    const id = (options.provider ?? "none");
+    const provider = createLocalAiProvider(id === "mock" || id === "ollama" || id === "none" ? id : "none");
+    const response = await provider.generate({
+        prompt: options.prompt ?? "Summarize repository agent readiness.",
+        context: [],
+        maxTokens: 128,
+        timeoutMs: 3000,
+    });
+    if (options.json)
+        printJson(response);
+    else {
+        process.stdout.write(`provider=${response.provider} aiGenerated=${response.aiGenerated}\n${response.text || response.error || "(empty)"}\n`);
+    }
+    return EXIT_CODES.SUCCESS;
+}