@agentlighthouse/core 0.1.0-alpha.0

package/dist/reporters/cli.js

@@ -0,0 +1,42 @@
+import { severityOrder, titleCase } from "./shared.js";
+export { renderMarkdownReport } from "./markdown.js";
+export function renderCliReport(result, color = false) {
+    const lines = [];
+    lines.push(`AgentLighthouse Score: ${result.score}/100`);
+    lines.push(`Confidence: ${titleCase(result.scoreConfidence)} (${result.scoreConfidenceScore}/100)`);
+    lines.push(`Coverage: ${result.coverage.coveragePercent}%`);
+    lines.push(`Project: ${result.detectedProject.name} (${result.detectedProject.type})`);
+    lines.push(`Human signals: ${result.scoreInterpretation.humanReadableProjectSignals.score}/100 | Agent context: ${result.scoreInterpretation.agentSpecificContextLayer.score}/100 | Verifiability: ${result.scoreInterpretation.verifiability.score}/100`);
+    lines.push("");
+    lines.push("Subscores:");
+    for (const subscore of result.subscores) {
+        lines.push(`- ${subscore.label}: ${subscore.score}/100`);
+    }
+    lines.push("");
+    lines.push(result.summary);
+    lines.push("");
+    for (const severity of severityOrder) {
+        const findings = result.findings.filter((finding) => finding.severity === severity);
+        if (findings.length === 0) {
+            continue;
+        }
+        lines.push(`${titleCase(severity)} severity:`);
+        for (const finding of findings) {
+            const affected = finding.affectedFile ? ` (${finding.affectedFile})` : "";
+            lines.push(`- ${finding.title}${affected}`);
+            lines.push(`  ${finding.recommendation}`);
+            if (finding.agentFailureMode) {
+                lines.push(`  Agent failure mode: ${finding.agentFailureMode}`);
+            }
+        }
+        lines.push("");
+    }
+    if (result.recommendations.length > 0) {
+        lines.push("Recommended next actions:");
+        result.recommendations.forEach((action, index) => {
+            lines.push(`${index + 1}. ${action}`);
+        });
+    }
+    const report = lines.join("\n").trimEnd();
+    return color ? report : report;
+}

package/dist/reporters/comparison.d.ts

@@ -0,0 +1,13 @@
+import type { ComparisonResult } from "../schemas/types.js";
+export declare function renderComparisonJsonReport(result: ComparisonResult): string;
+export declare function renderComparisonCliReport(result: ComparisonResult): string;
+export declare function renderComparisonMarkdownReport(result: ComparisonResult, options?: {
+    status?: "passed" | "failed";
+    reasons?: string[];
+}): string;
+export declare function renderComparisonPrSummaryReport(result: ComparisonResult, options?: {
+    status?: "passed" | "failed";
+    reasons?: string[];
+    reportPaths?: string[];
+}): string;
+//# sourceMappingURL=comparison.d.ts.map

package/dist/reporters/comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.d.ts","sourceRoot":"","sources":["../../src/reporters/comparison.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG/E,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAE3E;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAmC1E;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GACjE,MAAM,CAgER;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,GACzF,MAAM,CAyCR"}

package/dist/reporters/comparison.js

@@ -0,0 +1,227 @@
+import { severityOrder, severityRank, titleCase } from "./shared.js";
+export function renderComparisonJsonReport(result) {
+    return JSON.stringify(result, null, 2);
+}
+export function renderComparisonCliReport(result) {
+    const lines = [];
+    lines.push(`AgentLighthouse PR Delta: ${titleCase(result.summary.verdict)}`);
+    lines.push(`Score: ${result.baseline.score} -> ${result.current.score} (${formatDelta(result.deltas.scoreDelta)})`);
+    lines.push(`Confidence: ${result.baseline.confidence} -> ${result.current.confidence} (${formatDelta(result.deltas.confidenceDelta)})`);
+    lines.push(`Coverage: ${result.baseline.coverage}% -> ${result.current.coverage}% (${formatDelta(result.deltas.coverageDelta)}%)`);
+    lines.push("");
+    lines.push(`New findings: ${result.findings.new.length}`);
+    lines.push(`Resolved findings: ${result.findings.resolved.length}`);
+    lines.push(`Worsened findings: ${result.findings.worsened.length}`);
+    lines.push(`Improved findings: ${result.findings.improved.length}`);
+    lines.push(`Unchanged findings: ${result.findings.unchanged.length}`);
+    if (result.summary.recommendedActions.length > 0) {
+        lines.push("");
+        lines.push("Recommended actions:");
+        result.summary.recommendedActions.forEach((action, index) => {
+            lines.push(`${index + 1}. ${action}`);
+        });
+    }
+    if (result.summary.caveats.length > 0) {
+        lines.push("");
+        lines.push("Caveats:");
+        result.summary.caveats.forEach((caveat) => lines.push(`- ${caveat}`));
+    }
+    if (result.prImpact) {
+        lines.push("");
+        lines.push(`PR impact: ${result.prImpact.summary}`);
+    }
+    return lines.join("\n");
+}
+export function renderComparisonMarkdownReport(result, options = {}) {
+    return `# AgentLighthouse Comparison Report
+
+Verdict: **${titleCase(result.summary.verdict)}**
+
+AgentLighthouse compares **agent-readiness**, not general software quality. A score regression means agents have less usable context, weaker verifiability, or new semantic risk under the selected profile.
+
+## Delta Summary
+
+| Metric | Baseline | Current | Delta |
+| --- | ---: | ---: | ---: |
+| Score | ${result.baseline.score} | ${result.current.score} | ${formatDelta(result.deltas.scoreDelta)} |
+| Confidence score | ${result.baseline.confidenceScore} | ${result.current.confidenceScore} | ${formatDelta(result.deltas.confidenceDelta)} |
+| Coverage | ${result.baseline.coverage}% | ${result.current.coverage}% | ${formatDelta(result.deltas.coverageDelta)}% |
+| Findings | ${totalFindings(result, "baseline")} | ${totalFindings(result, "current")} | ${formatDelta(result.deltas.findingCountDelta)} |
+
+${renderPrImpactMarkdown(result)}
+
+## Gate Status
+
+${renderGateStatus(options)}
+
+## Severity Count Deltas
+
+| Severity | Delta |
+| --- | ---: |
+${severityOrder.map((severity) => `| ${severity} | ${formatDelta(result.deltas.severityCountDeltas[severity] ?? 0)} |`).join("\n")}
+
+## New Findings
+
+${renderFindingList(result.findings.new)}
+
+## Resolved Findings
+
+${renderFindingList(result.findings.resolved)}
+
+## Worsened Findings
+
+${renderFindingList(result.findings.worsened)}
+
+## Improved Findings
+
+${renderFindingList(result.findings.improved)}
+
+## Unchanged
+
+${result.findings.unchanged.length} finding(s) remained unchanged.
+
+## Recommended Actions
+
+${result.summary.recommendedActions.map((action, index) => `${index + 1}. ${action}`).join("\n") || "No comparison-specific actions."}
+
+## Caveats
+
+${result.summary.caveats.map((caveat) => `- ${caveat}`).join("\n") || "No caveats."}
+
+## Metadata
+
+- Baseline scan: \`${result.baseline.scanId}\` (${result.baseline.completedAt})
+- Current scan: \`${result.current.scanId}\` (${result.current.completedAt})
+- Baseline profile: \`${result.baseline.profile}\`
+- Current profile: \`${result.current.profile}\`
+- Comparison model: \`${result.metadata.comparisonModelVersion}\`
+`;
+}
+export function renderComparisonPrSummaryReport(result, options = {}) {
+    const newHighRisk = result.findings.new.filter((finding) => severityRank(finding.severity) >= severityRank("high"));
+    const impact = result.prImpact;
+    return `## AgentLighthouse PR Delta: ${titleCase(result.summary.verdict)}
+
+**Status:** ${options.status === "failed" ? "Failed" : "Passed"}
+
+Score: **${result.baseline.score} -> ${result.current.score}** (${formatDelta(result.deltas.scoreDelta)})
+Confidence: **${result.baseline.confidence} -> ${result.current.confidence}** (${formatDelta(result.deltas.confidenceDelta)})
+Coverage: **${result.baseline.coverage}% -> ${result.current.coverage}%** (${formatDelta(result.deltas.coverageDelta)}%)
+${impact ? `Changed files analyzed: **${impact.changedFileCount}**\n` : ""}
+
+${options.reasons && options.reasons.length > 0 ? `### Gate Result\n\n${options.reasons.map((reason) => `- ${reason}`).join("\n")}\n` : ""}
+${impact ? `### New Findings On Changed Files\n\n${renderFindingList(impact.newFindingsOnChangedFiles.slice(0, 5))}\n\n### Resolved Findings On Changed Files\n\n${renderFindingList(impact.resolvedFindingsOnChangedFiles.slice(0, 5))}\n\n### New Global Findings\n\n${renderFindingList(impact.globalNewFindings.slice(0, 5))}\n` : ""}
+### New High-Severity Findings
+
+${renderFindingList(newHighRisk.slice(0, 5))}
+
+### Top New Findings
+
+${renderFindingList(result.findings.new.slice(0, 5))}
+
+### Top Resolved Findings
+
+${renderFindingList(result.findings.resolved.slice(0, 5))}
+
+### Recommended Actions
+
+${result.summary.recommendedActions
+        .slice(0, 5)
+        .map((action, index) => `${index + 1}. ${action}`)
+        .join("\n") || "No comparison-specific actions."}
+
+### Reports
+
+${options.reportPaths?.map((reportPath) => `- ${reportPath}`).join("\n") || "No comparison report artifact path was provided."}
+`;
+}
+function renderPrImpactMarkdown(result) {
+    const impact = result.prImpact;
+    if (!impact) {
+        return "";
+    }
+    return `## PR Impact Summary
+
+${impact.summary}
+
+| Bucket | Count |
+| --- | ---: |
+| Changed files | ${impact.changedFileCount} |
+| New findings on changed files | ${impact.newFindingsOnChangedFiles.length} |
+| Resolved findings on changed files | ${impact.resolvedFindingsOnChangedFiles.length} |
+| New global findings | ${impact.globalNewFindings.length} |
+| Unknown-location findings | ${impact.unknownLocationFindings.length} |
+| Unrelated existing findings | ${impact.unrelatedExistingFindings.length} |
+
+## Changed Files
+
+${impact.changedFiles.map((file) => `- ${file.status}: ${file.oldPath ? `${file.oldPath} -> ` : ""}${file.path}`).join("\n") || "None."}
+
+## New Findings On Changed Files
+
+${renderFindingList(impact.newFindingsOnChangedFiles)}
+
+## Resolved Findings On Changed Files
+
+${renderFindingList(impact.resolvedFindingsOnChangedFiles)}
+
+## New Global Findings
+
+${renderFindingList(impact.globalNewFindings)}
+
+## Unknown-Location Findings
+
+${renderFindingList(impact.unknownLocationFindings)}
+
+## Unrelated Existing Findings Summary
+
+${impact.unrelatedExistingFindings.length} unchanged finding(s) are outside the changed-file set.`;
+}
+function renderGateStatus(options) {
+    if (!options.status) {
+        return "No comparison gate status was provided.";
+    }
+    const status = options.status === "failed" ? "Failed" : "Passed";
+    const reasons = options.reasons && options.reasons.length > 0
+        ? `\n\n${options.reasons.map((reason) => `- ${reason}`).join("\n")}`
+        : "";
+    return `**${status}**${reasons}`;
+}
+function renderFindingList(findings) {
+    if (findings.length === 0) {
+        return "None.";
+    }
+    return findings
+        .map((finding, index) => {
+        const severityChange = finding.previousSeverity && finding.currentSeverity
+            ? ` (${finding.previousSeverity} -> ${finding.currentSeverity})`
+            : "";
+        return `${index + 1}. **${finding.severity}** \`${finding.ruleId}\`: ${finding.title}${severityChange}${formatFindingLocation(finding)}`;
+    })
+        .join("\n");
+}
+function formatFindingLocation(finding) {
+    const file = finding.location?.file ?? finding.affectedFile;
+    if (!file)
+        return "";
+    const line = finding.location?.startLine ? `:${finding.location.startLine}` : "";
+    const subject = finding.subject ?? finding.location?.subject;
+    return ` (${file}${line}${subject ? `, ${subject}` : ""})`;
+}
+function formatDelta(value) {
+    if (value > 0)
+        return `+${value}`;
+    return String(value);
+}
+function totalFindings(result, side) {
+    if (side === "baseline") {
+        return (result.findings.resolved.length +
+            result.findings.unchanged.length +
+            result.findings.worsened.length +
+            result.findings.improved.length);
+    }
+    return (result.findings.new.length +
+        result.findings.unchanged.length +
+        result.findings.worsened.length +
+        result.findings.improved.length);
+}

package/dist/reporters/github-summary.d.ts

@@ -0,0 +1,4 @@
+import type { ScanResult } from "../schemas/types.js";
+import { type PrSummaryOptions } from "./pr-summary.js";
+export declare function renderGithubStepSummary(result: ScanResult, options?: PrSummaryOptions): string;
+//# sourceMappingURL=github-summary.d.ts.map

package/dist/reporters/github-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-summary.d.ts","sourceRoot":"","sources":["../../src/reporters/github-summary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAyB,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE/E,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAER"}

package/dist/reporters/github-summary.js

@@ -0,0 +1,4 @@
+import { renderPrSummaryReport } from "./pr-summary.js";
+export function renderGithubStepSummary(result, options = {}) {
+    return renderPrSummaryReport(result, options);
+}

package/dist/reporters/json.d.ts

@@ -0,0 +1,3 @@
+import type { ScanResult } from "../schemas/types.js";
+export declare function renderJsonReport(result: ScanResult): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/reporters/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/reporters/json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE3D"}

package/dist/reporters/json.js

@@ -0,0 +1,3 @@
+export function renderJsonReport(result) {
+    return JSON.stringify(result, null, 2);
+}

package/dist/reporters/markdown.d.ts

@@ -0,0 +1,3 @@
+import type { ScanResult } from "../schemas/types.js";
+export declare function renderMarkdownReport(result: ScanResult): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/reporters/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/reporters/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAyJ/D"}

package/dist/reporters/markdown.js

@@ -0,0 +1,146 @@
+import { severityOrder, titleCase, topActionableFindings } from "./shared.js";
+export function renderMarkdownReport(result) {
+    const topFindings = topActionableFindings(result.findings, 5)
+        .map((finding) => `- **${finding.severity}**: ${finding.title}${finding.affectedFile ? ` (${finding.affectedFile})` : ""}`)
+        .join("\n");
+    const groupedFindings = severityOrder
+        .map((severity) => {
+        const findings = result.findings.filter((finding) => finding.severity === severity);
+        if (findings.length === 0) {
+            return "";
+        }
+        return `### ${titleCase(severity)}
+
+${findings
+            .map((finding) => `#### ${finding.title}
+
+- Rule ID: \`${finding.ruleId}\`
+- Severity: ${finding.severity}
+- Category: ${finding.category}
+- Affected file: ${finding.affectedFile ?? "n/a"}
+- Recommendation: ${finding.recommendation}
+- Agent failure mode: ${finding.agentFailureMode ?? "n/a"}
+- Fix example: ${finding.fixExample ?? "n/a"}
+- Evidence: ${finding.evidence.join("; ")}
+`)
+            .join("\n")}`;
+    })
+        .filter(Boolean)
+        .join("\n\n");
+    const artifactTable = result.detectedArtifacts
+        .map((artifact) => `| ${artifact.path} | ${artifact.exists ? "yes" : "no"} | ${artifact.kind} | ${artifact.quality} | ${artifact.role} |`)
+        .join("\n");
+    return `# AgentLighthouse Report: ${result.projectName}
+
+AgentLighthouse measures **agent-readiness**, not general software quality. A mature human-friendly project can score lower when it lacks agent-specific context, verifiable workflows, or machine-readable API/tool guidance.
+
+Score: **${result.score}/100**
+
+${result.summary}
+
+Confidence: **${titleCase(result.scoreConfidence)}** (${result.scoreConfidenceScore}/100)
+
+Coverage: **${result.coverage.coveragePercent}%**
+
+## Project Detection
+
+- Type: \`${result.detectedProject.type}\`
+- Profile: \`${result.profile}\`
+- Confidence: ${Math.round(result.detectedProject.confidence * 100)}%
+- Package manager: \`${result.detectedProject.packageManager}\`
+- Frameworks: ${result.detectedProject.frameworks.length > 0 ? result.detectedProject.frameworks.join(", ") : "none detected"}
+- Evidence: ${result.detectedProject.evidence.join("; ")}
+
+## Score Interpretation
+
+- Agent-Readiness Score: ${result.scoreInterpretation.agentReadinessScore}/100
+- Human-readable project signals: ${result.scoreInterpretation.humanReadableProjectSignals.score}/100 - ${result.scoreInterpretation.humanReadableProjectSignals.signals.join(", ") || "none detected"}
+- Agent-specific context layer: ${result.scoreInterpretation.agentSpecificContextLayer.score}/100 - ${result.scoreInterpretation.agentSpecificContextLayer.signals.join(", ") || "none detected"}
+- Verifiability: ${result.scoreInterpretation.verifiability.score}/100 - ${result.scoreInterpretation.verifiability.signals.join(", ") || "none detected"}
+
+## CI Interpretation
+
+- This score should be used as an agent-readiness gate, not as a judgment of overall engineering quality.
+- Low scores usually mean agents need more context files, clearer examples, verifiable commands, or safer API/MCP descriptions.
+- Command execution probes are opt-in; static analysis remains the default.
+
+## Subscores
+
+${result.subscores.map((subscore) => `- ${subscore.label}: ${subscore.score}/100`).join("\n")}
+
+## API Analysis
+
+- Spec files: ${result.apiAnalysis.specFiles.join(", ") || "none"}
+- Operations: ${result.apiAnalysis.operationCount}
+- Operations with examples: ${result.apiAnalysis.operationsWithExamples}
+- Operations missing descriptions: ${result.apiAnalysis.operationsMissingDescriptions}
+- Auth schemes: ${result.apiAnalysis.authSchemes.join(", ") || "none"}
+- Destructive operations: ${result.apiAnalysis.destructiveOperations.join("; ") || "none"}
+- Weak operations: ${result.apiAnalysis.weakOperations.slice(0, 8).join("; ") || "none"}
+
+## MCP Analysis
+
+- Detected: ${result.mcpAnalysis.detected ? "yes" : "no"}
+- Files: ${result.mcpAnalysis.files.join(", ") || "none"}
+- Tools: ${result.mcpAnalysis.toolCount}
+- Tools with schemas: ${result.mcpAnalysis.toolsWithSchemas}
+- Tools with examples: ${result.mcpAnalysis.toolsWithExamples}
+- Ambiguous tools: ${result.mcpAnalysis.ambiguousTools.join("; ") || "none"}
+- Destructive tools: ${result.mcpAnalysis.destructiveTools.join("; ") || "none"}
+- Weak tools: ${result.mcpAnalysis.weakTools.slice(0, 8).join("; ") || "none"}
+
+## Command Probes
+
+- Enabled: ${result.commandProbes.enabled ? "yes" : "no"}
+- Attempted: ${result.commandProbes.attempted}
+- Passed: ${result.commandProbes.passed}
+- Failed: ${result.commandProbes.failed}
+- Timed out: ${result.commandProbes.timedOut}
+- Skipped: ${result.commandProbes.skipped}
+
+## Coverage
+
+- Evaluated checks: ${result.coverage.evaluatedChecks}
+- Skipped checks: ${result.coverage.skippedChecks}
+- Not applicable checks: ${result.coverage.notApplicableChecks}
+- Not evaluated checks: ${result.coverage.notEvaluatedChecks}
+- Evaluated categories: ${result.coverage.evaluatedCategories.join(", ") || "none"}
+- Missing categories: ${result.coverage.missingCategories.join(", ") || "none"}
+
+## Scoring Caps
+
+${result.scoringCaps.map((cap) => `- ${cap.id}: max ${cap.maxScore}. ${cap.reason}`).join("\n") || "No scoring caps applied."}
+
+## Top Findings
+
+${topFindings || "No non-informational findings."}
+
+## Recommended Actions
+
+${result.recommendations.map((action, index) => `${index + 1}. ${action}`).join("\n") || "No prioritized actions."}
+
+## Detected Artifacts
+
+| Path | Exists | Kind | Quality | Role |
+| --- | --- | --- | --- | --- |
+${artifactTable}
+
+## Scan Metadata
+
+- Scan ID: \`${result.scanId}\`
+- AgentLighthouse version: \`${result.agentLighthouseVersion}\`
+- Scoring model: \`${result.scoringModelVersion}\`
+- Started: ${result.startedAt}
+- Completed: ${result.completedAt}
+- Duration: ${result.durationMs}ms
+- Files scanned: ${result.scanStats.filesScanned}
+- Text files read: ${result.scanStats.textFilesRead}
+- Ignored paths observed: ${result.ignoredPaths.length}
+- Warnings: ${result.warnings.length}
+- Errors: ${result.errors.length}
+
+## Findings
+
+${groupedFindings || "No findings."}
+`;
+}

package/dist/reporters/pr-summary.d.ts

@@ -0,0 +1,8 @@
+import type { ScanResult } from "../schemas/types.js";
+export interface PrSummaryOptions {
+    status?: "passed" | "failed";
+    reasons?: string[];
+    reportPaths?: string[];
+}
+export declare function renderPrSummaryReport(result: ScanResult, options?: PrSummaryOptions): string;
+//# sourceMappingURL=pr-summary.d.ts.map

package/dist/reporters/pr-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pr-summary.d.ts","sourceRoot":"","sources":["../../src/reporters/pr-summary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,gBAAqB,GAAG,MAAM,CAsChG"}

package/dist/reporters/pr-summary.js

@@ -0,0 +1,38 @@
+import { titleCase, topActionableFindings } from "./shared.js";
+export function renderPrSummaryReport(result, options = {}) {
+    const status = options.status ?? "passed";
+    const findings = topActionableFindings(result.findings, 5);
+    const reportPaths = options.reportPaths ?? [];
+    return `## AgentLighthouse PR Summary
+
+**Status:** ${status === "passed" ? "Passed" : "Failed"}
+
+AgentLighthouse measures **agent-readiness**, not general software quality. It checks whether AI coding agents have enough context, examples, API/tool semantics, and verifiable workflows to use this project safely.
+
+- Score: **${result.score}/100**
+- Confidence: **${titleCase(result.scoreConfidence)}** (${result.scoreConfidenceScore}/100)
+- Coverage: **${result.coverage.coveragePercent}%**
+- Profile: \`${result.profile}\`
+- Project type: \`${result.detectedProject.type}\`
+
+${options.reasons && options.reasons.length > 0 ? `### Gate Result\n\n${options.reasons.map((reason) => `- ${reason}`).join("\n")}\n` : ""}
+### Top Findings
+
+${findings.map((finding) => `- **${finding.severity}** \`${finding.ruleId}\`: ${finding.title}${finding.affectedFile ? ` (${finding.affectedFile})` : ""}`).join("\n") || "No non-informational findings."}
+
+### Recommended Next Actions
+
+${result.recommendations
+        .slice(0, 5)
+        .map((action, index) => `${index + 1}. ${action}`)
+        .join("\n") || "No prioritized actions."}
+
+### Reports
+
+${reportPaths.map((reportPath) => `- ${reportPath}`).join("\n") || "No external report artifact path was provided."}
+
+### What Changed
+
+Diff comparison is planned for a future baseline mode. For now, compare this summary with the saved baseline report or previous CI artifact.
+`;
+}

package/dist/reporters/sarif.d.ts

@@ -0,0 +1,3 @@
+import type { ScanResult } from "../schemas/types.js";
+export declare function renderSarifReport(result: ScanResult): string;
+//# sourceMappingURL=sarif.d.ts.map

package/dist/reporters/sarif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sarif.d.ts","sourceRoot":"","sources":["../../src/reporters/sarif.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,UAAU,EAAY,MAAM,qBAAqB,CAAC;AAmEzE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAoB5D"}

package/dist/reporters/sarif.js

@@ -0,0 +1,119 @@
+export function renderSarifReport(result) {
+    const rules = uniqueRules(result.findings);
+    const sarif = {
+        version: "2.1.0",
+        $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: "AgentLighthouse",
+                        semanticVersion: result.agentLighthouseVersion,
+                        informationUri: "https://github.com/PainDeMie64/agentlighthouse",
+                        rules
+                    }
+                },
+                results: result.findings.map((finding) => findingToResult(finding, result))
+            }
+        ]
+    };
+    return JSON.stringify(sarif, null, 2);
+}
+function uniqueRules(findings) {
+    const byRule = new Map();
+    for (const finding of findings) {
+        if (!byRule.has(finding.ruleId)) {
+            byRule.set(finding.ruleId, finding);
+        }
+    }
+    return [...byRule.values()].map((finding) => ({
+        id: finding.ruleId,
+        name: finding.title,
+        shortDescription: { text: finding.title },
+        fullDescription: { text: finding.description },
+        help: {
+            text: finding.recommendation,
+            markdown: [
+                finding.recommendation,
+                finding.agentFailureMode ? `Agent failure mode: ${finding.agentFailureMode}` : undefined,
+                finding.fixExample ? `Fix example: ${finding.fixExample}` : undefined
+            ]
+                .filter((line) => Boolean(line))
+                .join("\n\n")
+        },
+        defaultConfiguration: { level: severityToSarifLevel(finding.severity) },
+        properties: {
+            category: finding.category,
+            severity: finding.severity,
+            tags: ["agent-readiness", finding.category, finding.severity]
+        }
+    }));
+}
+function findingToResult(finding, result) {
+    return {
+        ruleId: finding.ruleId,
+        level: severityToSarifLevel(finding.severity),
+        message: {
+            text: `${finding.title}: ${finding.recommendation}`
+        },
+        ...(finding.location?.file || finding.affectedFile
+            ? {
+                locations: [
+                    {
+                        physicalLocation: {
+                            artifactLocation: { uri: finding.location?.file ?? finding.affectedFile },
+                            region: sarifRegion(finding)
+                        }
+                    }
+                ]
+            }
+            : {}),
+        partialFingerprints: {
+            agentLighthouseFinding: stableFingerprint(finding)
+        },
+        properties: {
+            category: finding.category,
+            severity: finding.severity,
+            ...(finding.agentFailureMode ? { agentFailureMode: finding.agentFailureMode } : {}),
+            recommendation: finding.recommendation,
+            ...(finding.fixExample ? { fixExample: finding.fixExample } : {}),
+            confidence: result.scoreConfidence,
+            ...(finding.subject || finding.location?.subject
+                ? { subject: finding.subject ?? finding.location?.subject }
+                : {}),
+            ...(finding.locationKey || finding.location?.locationKey
+                ? { locationKey: finding.locationKey ?? finding.location?.locationKey }
+                : {}),
+            ...(finding.location?.sourceKind ? { sourceKind: finding.location.sourceKind } : {})
+        }
+    };
+}
+function sarifRegion(finding) {
+    return {
+        startLine: finding.location?.startLine ?? 1,
+        ...(finding.location?.startColumn ? { startColumn: finding.location.startColumn } : {}),
+        ...(finding.location?.endLine ? { endLine: finding.location.endLine } : {}),
+        ...(finding.location?.endColumn ? { endColumn: finding.location.endColumn } : {})
+    };
+}
+function severityToSarifLevel(severity) {
+    if (severity === "critical" || severity === "high") {
+        return "error";
+    }
+    if (severity === "medium") {
+        return "warning";
+    }
+    return "note";
+}
+function stableFingerprint(finding) {
+    if (finding.fingerprint) {
+        return finding.fingerprint;
+    }
+    const input = `${finding.ruleId}:${finding.affectedFile ?? ""}:${finding.evidence.join("|")}`;
+    let hash = 2166136261;
+    for (const character of input) {
+        hash ^= character.charCodeAt(0);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}

package/dist/reporters/shared.d.ts

@@ -0,0 +1,8 @@
+import type { Finding, Severity } from "../schemas/types.js";
+export declare const severityOrder: Severity[];
+export declare function titleCase(value: string): string;
+export declare function topActionableFindings(findings: Finding[], limit: number): Finding[];
+export declare function findingLocation(finding: Finding): string;
+export declare function severityRank(severity: Severity): number;
+export declare function confidenceRank(confidence: "low" | "medium" | "high"): number;
+//# sourceMappingURL=shared.d.ts.map

package/dist/reporters/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/reporters/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE7D,eAAO,MAAM,aAAa,EAAE,QAAQ,EAAkD,CAAC;AAEvF,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,CAEnF;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAExD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAQvD;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAM5E"}