mcplint-cli 0.1.0__py3-none-any.whl

mcplint/models/findings.py

@@ -0,0 +1,44 @@
+"""Finding, rule metadata, and the aggregate lint report."""
+
+from __future__ import annotations
+
+from collections import Counter
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+from mcplint.models.common import ArtifactMetadata
+from mcplint.models.contracts import SourceLocation
+
+
+class Severity(StrEnum):
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+
+
+class Finding(BaseModel):
+    rule_id: str
+    severity: Severity
+    message: str
+    evidence: str
+    location: SourceLocation
+    remediation: str
+    confidence: float = Field(ge=0.0, le=1.0)
+
+
+class RuleMetadata(BaseModel):
+    id: str
+    title: str
+    description: str
+    default_severity: Severity
+    tags: list[str] = Field(default_factory=list)
+
+
+class LintReport(BaseModel):
+    metadata: ArtifactMetadata
+    server_name: str
+    findings: list[Finding]
+
+    def count_by_severity(self) -> dict[Severity, int]:
+        return dict(Counter(finding.severity for finding in self.findings))

mcplint/models/fixes.py

@@ -0,0 +1,13 @@
+"""The deterministic (or optionally LLM-assisted) rewrite suggestion model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class RewriteSuggestion(BaseModel):
+    tool_name: str
+    proposed_description: str
+    resolved_rule_ids: list[str] = Field(default_factory=list)
+    explanation: str
+    confidence: float = Field(ge=0.0, le=1.0)

mcplint/models/score.py

@@ -0,0 +1,25 @@
+"""The explainable 0-100 overall score. Not a scientifically validated metric —
+a weighted, documented heuristic meant to make regressions visible at a glance.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class ScoreDeduction(BaseModel):
+    category: str
+    points_lost: float
+    finding_count: int
+    explanation: str
+
+
+class ScoreBreakdown(BaseModel):
+    total_score: int = Field(ge=0, le=100)
+    deductions: list[ScoreDeduction] = Field(default_factory=list)
+    benchmark_accuracy: float | None = None
+    disclaimer: str = (
+        "This score is an explainable heuristic, not a scientifically validated "
+        "or universal quality metric. Use the deductions below to see exactly "
+        "why points were lost."
+    )

mcplint/models/snapshot.py

@@ -0,0 +1,27 @@
+"""The canonical, persistable representation of one MCP server's tool contracts."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+from mcplint.models.common import ArtifactMetadata
+from mcplint.models.contracts import ToolContract
+
+TransportKind = Literal["stdio", "http"]
+
+
+class MCPServerSnapshot(BaseModel):
+    metadata: ArtifactMetadata
+    server_name: str
+    server_version: str | None
+    transport: TransportKind
+    command: str | None
+    tools: list[ToolContract]
+
+    def get_tool(self, name: str) -> ToolContract | None:
+        for tool in self.tools:
+            if tool.name == name:
+                return tool
+        return None

mcplint/reporters/benchmark_terminal.py

@@ -0,0 +1,46 @@
+"""Render a BenchmarkResult as Rich-formatted terminal text."""
+
+from __future__ import annotations
+
+from io import StringIO
+
+from rich.console import Console
+from rich.table import Table
+
+from mcplint.models.benchmark import BenchmarkResult
+
+
+def render_benchmark_terminal(result: BenchmarkResult) -> str:
+    buffer = StringIO()
+    console = Console(file=buffer, width=140, record=True)
+
+    console.print(
+        f"[bold]{result.dataset_name}[/bold] via {result.provider}/{result.model} "
+        f"({result.runs_per_case} runs/case, {len(result.trials)} trials total)"
+    )
+
+    metrics = Table(title="Metrics")
+    metrics.add_column("Metric")
+    metrics.add_column("Value", justify="right")
+    metrics.add_row("Exact tool-selection accuracy", f"{result.exact_tool_selection_accuracy:.2%}")
+    metrics.add_row("Valid-argument rate", f"{result.valid_argument_rate:.2%}")
+    metrics.add_row("Required-argument accuracy", f"{result.required_argument_accuracy:.2%}")
+    metrics.add_row(
+        "Forbidden-tool invocation rate", f"{result.forbidden_tool_invocation_rate:.2%}"
+    )
+    metrics.add_row("No-tool rate", f"{result.no_tool_rate:.2%}")
+    metrics.add_row("Mean latency", f"{result.mean_latency_ms:.1f} ms")
+    metrics.add_row("P95 latency", f"{result.p95_latency_ms:.1f} ms")
+    if result.total_estimated_cost is not None:
+        metrics.add_row("Total estimated cost", f"${result.total_estimated_cost:.4f}")
+    console.print(metrics)
+
+    per_case = Table(title="Per-case results")
+    per_case.add_column("Case")
+    per_case.add_column("Pass rate", justify="right")
+    per_case.add_column("Stability", justify="right")
+    for case_id, pass_rate in result.per_case_pass_rate.items():
+        per_case.add_row(case_id, f"{pass_rate:.2%}", f"{result.stability.get(case_id, 0.0):.2%}")
+    console.print(per_case)
+
+    return buffer.getvalue()

mcplint/reporters/comparison_terminal.py

@@ -0,0 +1,61 @@
+"""Render a ComparisonReport as Rich-formatted terminal text."""
+
+from __future__ import annotations
+
+from io import StringIO
+
+from rich.console import Console
+
+from mcplint.models.comparison import ComparisonReport
+
+
+def render_comparison_terminal(report: ComparisonReport) -> str:
+    buffer = StringIO()
+    console = Console(file=buffer, width=140, record=True)
+
+    console.print(
+        f"[bold]{report.baseline_server_name}[/bold] -> [bold]{report.candidate_server_name}[/bold]"
+    )
+
+    if report.added_tools:
+        console.print(f"[green]Added tools:[/green] {', '.join(report.added_tools)}")
+    if report.removed_tools:
+        console.print(f"[red]Removed tools:[/red] {', '.join(report.removed_tools)}")
+    if report.description_changes:
+        console.print(f"Description changes: {len(report.description_changes)}")
+    if report.schema_changes:
+        console.print(f"Schema changes: {len(report.schema_changes)}")
+
+    console.print(
+        f"Findings: [red]{len(report.new_findings)} new[/red], "
+        f"[green]{len(report.resolved_findings)} resolved[/green]"
+    )
+
+    if report.ambiguity_score_changes:
+        console.print(f"Ambiguity score changes: {len(report.ambiguity_score_changes)}")
+        for change in report.ambiguity_score_changes:
+            direction = "up" if change.after > change.before else "down"
+            console.print(
+                f"  {change.tool_a} <-> {change.tool_b}: "
+                f"{change.before:.2f} -> {change.after:.2f} ({direction})"
+            )
+
+    if report.benchmark_dataset_name is not None:
+        console.print(f"\n[bold]Benchmark: {report.benchmark_dataset_name}[/bold]")
+        console.print(
+            f"  Accuracy: {report.baseline_accuracy:.2%} -> {report.candidate_accuracy:.2%} "
+            f"(delta {report.benchmark_accuracy_delta:+.2%})"
+        )
+        if report.regressions_by_case:
+            console.print("  [red]Regressions:[/red]")
+            for case_id, description in report.regressions_by_case.items():
+                console.print(f"    {case_id}: {description}")
+        if report.min_accuracy_delta_threshold is not None:
+            verdict = "PASS" if report.passes_ci_threshold else "FAIL"
+            style = "green" if report.passes_ci_threshold else "bold red"
+            console.print(
+                f"  CI threshold (--min-accuracy-delta "
+                f"{report.min_accuracy_delta_threshold:+.2%}): [{style}]{verdict}[/{style}]"
+            )
+
+    return buffer.getvalue()

mcplint/reporters/fix_markdown.py

@@ -0,0 +1,34 @@
+"""Render RewriteSuggestions as a Markdown patch report — never applied automatically."""
+
+from __future__ import annotations
+
+from mcplint.models.fixes import RewriteSuggestion
+
+
+def render_fix_markdown(server_name: str, suggestions: list[RewriteSuggestion]) -> str:
+    lines = [f"# MCPLint fix suggestions for `{server_name}`", ""]
+
+    if not suggestions:
+        lines.append("No actionable suggestions — nothing to fix.")
+        return "\n".join(lines) + "\n"
+
+    lines.append(
+        "These are proposed changes only. MCPLint never overwrites source files "
+        "automatically — review and apply them by hand."
+    )
+    lines.append("")
+
+    for suggestion in suggestions:
+        lines.append(f"## `{suggestion.tool_name}`")
+        lines.append("")
+        lines.append(f"**Confidence:** {suggestion.confidence:.2f}")
+        lines.append(f"**Resolves:** {', '.join(f'`{r}`' for r in suggestion.resolved_rule_ids)}")
+        lines.append("")
+        lines.append("**Proposed description:**")
+        lines.append("")
+        lines.append(f"> {suggestion.proposed_description}")
+        lines.append("")
+        lines.append(f"**Why:** {suggestion.explanation}")
+        lines.append("")
+
+    return "\n".join(lines) + "\n"

mcplint/reporters/html.py

@@ -0,0 +1,71 @@
+"""Render a standalone HTML report — no backend, embedded CSS, no external requests."""
+
+from __future__ import annotations
+
+from importlib import resources
+
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from mcplint.core.rules.ambiguity import (
+    DEFAULT_AMBIGUITY_THRESHOLD,
+    AmbiguityPairResult,
+    compute_ambiguity,
+)
+from mcplint.core.score import compute_score
+from mcplint.models.benchmark import BenchmarkResult
+from mcplint.models.comparison import ComparisonReport
+from mcplint.models.findings import LintReport
+from mcplint.models.fixes import RewriteSuggestion
+from mcplint.models.snapshot import MCPServerSnapshot
+
+
+def _score_class(total_score: int) -> str:
+    if total_score >= 80:
+        return "good"
+    if total_score >= 50:
+        return "ok"
+    return "bad"
+
+
+def _ambiguity_pairs(snapshot: MCPServerSnapshot, threshold: float) -> list[AmbiguityPairResult]:
+    pairs: list[AmbiguityPairResult] = []
+    tools = sorted(snapshot.tools, key=lambda t: t.name)
+    for index, tool_a in enumerate(tools):
+        for tool_b in tools[index + 1 :]:
+            result = compute_ambiguity(tool_a, tool_b)
+            if result.score >= threshold:
+                pairs.append(result)
+    return pairs
+
+
+def render_html_report(
+    snapshot: MCPServerSnapshot,
+    report: LintReport,
+    *,
+    benchmark_result: BenchmarkResult | None = None,
+    comparison: ComparisonReport | None = None,
+    suggestions: list[RewriteSuggestion] | None = None,
+    ambiguity_threshold: float = DEFAULT_AMBIGUITY_THRESHOLD,
+) -> str:
+    template_dir = resources.files("mcplint.reporters") / "templates"
+    env = Environment(
+        loader=FileSystemLoader(str(template_dir)),
+        autoescape=select_autoescape(enabled_extensions=("html", "j2")),
+    )
+    template = env.get_template("report.html.j2")
+
+    score = compute_score(report, benchmark_result)
+
+    return template.render(
+        server_name=snapshot.server_name,
+        generated_at=report.metadata.generated_at.isoformat(),
+        mcplint_version=report.metadata.mcplint_version,
+        score=score,
+        score_class=_score_class(score.total_score),
+        findings=report.findings,
+        tools=snapshot.tools,
+        ambiguity_pairs=_ambiguity_pairs(snapshot, ambiguity_threshold),
+        benchmark=benchmark_result,
+        comparison=comparison,
+        suggestions=suggestions or [],
+    )

mcplint/reporters/json_reporter.py

@@ -0,0 +1,9 @@
+"""Render a LintReport as JSON."""
+
+from __future__ import annotations
+
+from mcplint.models.findings import LintReport
+
+
+def render_json(report: LintReport) -> str:
+    return report.model_dump_json(indent=2)

mcplint/reporters/sarif.py

@@ -0,0 +1,77 @@
+"""Render a LintReport as SARIF 2.1.0 for GitHub code scanning / CI upload."""
+
+from __future__ import annotations
+
+import json
+
+from mcplint.__about__ import __version__ as MCPLINT_VERSION
+from mcplint.core.registry import RuleRegistry
+from mcplint.models.findings import Finding, LintReport, Severity
+
+SARIF_SCHEMA_URI = (
+    "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json"
+)
+SARIF_VERSION = "2.1.0"
+MCPLINT_INFORMATION_URI = "https://github.com/mcplint/mcplint"
+
+_LEVEL_BY_SEVERITY = {Severity.ERROR: "error", Severity.WARNING: "warning", Severity.INFO: "note"}
+
+
+def _rule_descriptors() -> list[dict[str, object]]:
+    registry = RuleRegistry.with_builtin_rules()
+    descriptors: list[dict[str, object]] = []
+    for rule in registry.all():
+        metadata = rule.metadata()
+        descriptors.append(
+            {
+                "id": metadata.id,
+                "name": metadata.id,
+                "shortDescription": {"text": metadata.title},
+                "fullDescription": {"text": metadata.description},
+                "defaultConfiguration": {"level": _LEVEL_BY_SEVERITY[metadata.default_severity]},
+                "properties": {"tags": list(metadata.tags)},
+            }
+        )
+    return descriptors
+
+
+def _result(finding: Finding) -> dict[str, object]:
+    return {
+        "ruleId": finding.rule_id,
+        "level": _LEVEL_BY_SEVERITY[finding.severity],
+        "message": {"text": finding.message},
+        "properties": {
+            "evidence": finding.evidence,
+            "remediation": finding.remediation,
+            "confidence": finding.confidence,
+        },
+        "locations": [
+            {
+                "physicalLocation": {
+                    "artifactLocation": {"uri": f"mcp-tool:{finding.location.tool_name}"},
+                },
+                "logicalLocations": [{"fullyQualifiedName": finding.location.json_path}],
+            }
+        ],
+    }
+
+
+def render_sarif(report: LintReport) -> str:
+    sarif_log = {
+        "$schema": SARIF_SCHEMA_URI,
+        "version": SARIF_VERSION,
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "mcplint",
+                        "informationUri": MCPLINT_INFORMATION_URI,
+                        "version": MCPLINT_VERSION,
+                        "rules": _rule_descriptors(),
+                    }
+                },
+                "results": [_result(finding) for finding in report.findings],
+            }
+        ],
+    }
+    return json.dumps(sarif_log, indent=2)

mcplint/reporters/templates/report.html.j2

@@ -0,0 +1,176 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>MCPLint report — {{ server_name }}</title>
+<style>
+  :root { color-scheme: light dark; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    max-width: 960px;
+    margin: 2rem auto;
+    padding: 0 1.5rem;
+    line-height: 1.5;
+    color: #1a1a1a;
+    background: #ffffff;
+  }
+  @media (prefers-color-scheme: dark) {
+    body { color: #e6e6e6; background: #14161a; }
+    table { border-color: #333 !important; }
+    th, td { border-color: #333 !important; }
+    .card { background: #1c1f24 !important; border-color: #333 !important; }
+    code { background: #262a30 !important; }
+  }
+  h1 { font-size: 1.6rem; margin-bottom: 0.25rem; }
+  h2 { font-size: 1.2rem; margin-top: 2.5rem; border-bottom: 2px solid currentColor; padding-bottom: 0.25rem; }
+  .meta { opacity: 0.7; font-size: 0.9rem; margin-bottom: 1.5rem; }
+  .score {
+    display: inline-block;
+    font-size: 2.5rem;
+    font-weight: 700;
+    border-radius: 0.5rem;
+    padding: 0.5rem 1.25rem;
+    margin: 0.5rem 0;
+  }
+  .score.good { background: #d4f4dd; color: #1a7431; }
+  .score.ok { background: #fff2cc; color: #8a6d00; }
+  .score.bad { background: #fbdcdc; color: #a3231f; }
+  .disclaimer { font-size: 0.85rem; opacity: 0.7; font-style: italic; }
+  table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
+  th, td { border: 1px solid #ddd; padding: 0.5rem 0.75rem; text-align: left; font-size: 0.92rem; }
+  th { background: rgba(127,127,127,0.1); }
+  .sev-error { color: #a3231f; font-weight: 600; }
+  .sev-warning { color: #8a6d00; font-weight: 600; }
+  .sev-info { color: #2563a8; font-weight: 600; }
+  .card { background: #f7f7f8; border: 1px solid #e2e2e2; border-radius: 0.5rem; padding: 1rem; margin: 0.75rem 0; }
+  code { background: rgba(127,127,127,0.15); padding: 0.1rem 0.3rem; border-radius: 0.25rem; }
+  .empty { opacity: 0.6; font-style: italic; }
+</style>
+</head>
+<body>
+
+<h1>MCPLint report</h1>
+<div class="meta">
+  Server: <code>{{ server_name }}</code> &middot;
+  Generated: {{ generated_at }} &middot;
+  mcplint {{ mcplint_version }}
+</div>
+
+<div class="score {{ score_class }}">{{ score.total_score }}/100</div>
+<p class="disclaimer">{{ score.disclaimer }}</p>
+
+{% if score.deductions %}
+<table>
+  <tr><th>Category</th><th>Points lost</th><th>Why</th></tr>
+  {% for d in score.deductions %}
+  <tr><td>{{ d.category }}</td><td>-{{ "%.1f"|format(d.points_lost) }}</td><td>{{ d.explanation }}</td></tr>
+  {% endfor %}
+</table>
+{% endif %}
+
+<h2>Findings by severity ({{ findings|length }} total)</h2>
+{% if findings %}
+<table>
+  <tr><th>Severity</th><th>Rule</th><th>Tool</th><th>Message</th><th>Confidence</th></tr>
+  {% for f in findings %}
+  <tr>
+    <td class="sev-{{ f.severity }}">{{ f.severity }}</td>
+    <td><code>{{ f.rule_id }}</code></td>
+    <td>{{ f.location.tool_name }}</td>
+    <td>{{ f.message }}</td>
+    <td>{{ "%.2f"|format(f.confidence) }}</td>
+  </tr>
+  {% endfor %}
+</table>
+{% else %}
+<p class="empty">No findings.</p>
+{% endif %}
+
+<h2>Tool inventory ({{ tools|length }} tools)</h2>
+<table>
+  <tr><th>Name</th><th>Description</th><th>Params</th><th>Destructive</th><th>Read-only</th></tr>
+  {% for t in tools %}
+  <tr>
+    <td><code>{{ t.name }}</code></td>
+    <td>{{ t.description or "—" }}</td>
+    <td>{{ t.parameters|length }}</td>
+    <td>{{ "yes" if t.annotations.destructive_hint else "" }}</td>
+    <td>{{ "yes" if t.annotations.read_only_hint else "" }}</td>
+  </tr>
+  {% endfor %}
+</table>
+
+<h2>Ambiguity pairs ({{ ambiguity_pairs|length }})</h2>
+{% if ambiguity_pairs %}
+<table>
+  <tr><th>Tool A</th><th>Tool B</th><th>Score</th><th>Evidence</th></tr>
+  {% for pair in ambiguity_pairs %}
+  <tr>
+    <td>{{ pair.tool_a }}</td>
+    <td>{{ pair.tool_b }}</td>
+    <td>{{ "%.2f"|format(pair.score) }}</td>
+    <td>
+      {% if pair.evidence.shared_verbs %}shared verbs: {{ pair.evidence.shared_verbs|join(", ") }}<br>{% endif %}
+      {% if pair.evidence.overlapping_parameters %}overlapping params: {{ pair.evidence.overlapping_parameters|join(", ") }}<br>{% endif %}
+      {% if pair.evidence.absent_exact_vs_search_distinction %}missing exact-vs-search distinction<br>{% endif %}
+      {% if pair.evidence.absent_one_vs_many_distinction %}missing one-vs-many distinction<br>{% endif %}
+      {% if pair.evidence.absent_read_vs_write_distinction %}missing read-vs-write distinction{% endif %}
+    </td>
+  </tr>
+  {% endfor %}
+</table>
+{% else %}
+<p class="empty">No ambiguous pairs above the threshold.</p>
+{% endif %}
+
+{% if benchmark %}
+<h2>Benchmark: {{ benchmark.dataset_name }}</h2>
+<div class="card">
+  <p>{{ benchmark.provider }}/{{ benchmark.model }} &middot; {{ benchmark.runs_per_case }} runs/case &middot; {{ benchmark.trials|length }} trials</p>
+  <table>
+    <tr><th>Metric</th><th>Value</th></tr>
+    <tr><td>Exact tool-selection accuracy</td><td>{{ "%.1f"|format(benchmark.exact_tool_selection_accuracy * 100) }}%</td></tr>
+    <tr><td>Valid-argument rate</td><td>{{ "%.1f"|format(benchmark.valid_argument_rate * 100) }}%</td></tr>
+    <tr><td>Required-argument accuracy</td><td>{{ "%.1f"|format(benchmark.required_argument_accuracy * 100) }}%</td></tr>
+    <tr><td>Forbidden-tool invocation rate</td><td>{{ "%.1f"|format(benchmark.forbidden_tool_invocation_rate * 100) }}%</td></tr>
+    <tr><td>No-tool rate</td><td>{{ "%.1f"|format(benchmark.no_tool_rate * 100) }}%</td></tr>
+    <tr><td>Mean / P95 latency</td><td>{{ "%.0f"|format(benchmark.mean_latency_ms) }} / {{ "%.0f"|format(benchmark.p95_latency_ms) }} ms</td></tr>
+    {% if benchmark.total_estimated_cost is not none %}
+    <tr><td>Total estimated cost</td><td>${{ "%.4f"|format(benchmark.total_estimated_cost) }}</td></tr>
+    {% endif %}
+  </table>
+</div>
+{% endif %}
+
+{% if comparison %}
+<h2>Before &amp; after: {{ comparison.baseline_server_name }} &rarr; {{ comparison.candidate_server_name }}</h2>
+<div class="card">
+  <p>
+    Added tools: {{ comparison.added_tools|join(", ") if comparison.added_tools else "none" }}<br>
+    Removed tools: {{ comparison.removed_tools|join(", ") if comparison.removed_tools else "none" }}<br>
+    Findings: {{ comparison.new_findings|length }} new, {{ comparison.resolved_findings|length }} resolved
+  </p>
+  {% if comparison.benchmark_dataset_name %}
+  <p>
+    Benchmark accuracy: {{ "%.1f"|format((comparison.baseline_accuracy or 0) * 100) }}% &rarr;
+    {{ "%.1f"|format((comparison.candidate_accuracy or 0) * 100) }}%
+    (delta {{ "%+.1f"|format((comparison.benchmark_accuracy_delta or 0) * 100) }}%)
+  </p>
+  {% endif %}
+</div>
+{% endif %}
+
+{% if suggestions %}
+<h2>Remediation suggestions ({{ suggestions|length }})</h2>
+{% for s in suggestions %}
+<div class="card">
+  <strong><code>{{ s.tool_name }}</code></strong> — confidence {{ "%.2f"|format(s.confidence) }}<br>
+  Resolves: {{ s.resolved_rule_ids|join(", ") }}<br>
+  <blockquote>{{ s.proposed_description }}</blockquote>
+  <em>{{ s.explanation }}</em>
+</div>
+{% endfor %}
+{% endif %}
+
+</body>
+</html>

mcplint/reporters/terminal.py

@@ -0,0 +1,52 @@
+"""Render a LintReport as Rich-formatted terminal text."""
+
+from __future__ import annotations
+
+from io import StringIO
+
+from rich.console import Console
+from rich.table import Table
+
+from mcplint.core.score import compute_score
+from mcplint.models.findings import LintReport, Severity
+
+_SEVERITY_STYLE = {Severity.ERROR: "bold red", Severity.WARNING: "yellow", Severity.INFO: "cyan"}
+
+
+def render_terminal(report: LintReport) -> str:
+    buffer = StringIO()
+    console = Console(file=buffer, width=120, record=True)
+
+    counts = report.count_by_severity()
+    score = compute_score(report)
+    console.print(
+        f"[bold]{report.server_name}[/bold] — "
+        f"{len(report.findings)} finding(s) "
+        f"({counts.get(Severity.ERROR, 0)} error, "
+        f"{counts.get(Severity.WARNING, 0)} warning, "
+        f"{counts.get(Severity.INFO, 0)} info) — "
+        f"score: [bold]{score.total_score}/100[/bold]"
+    )
+    if score.deductions:
+        for deduction in score.deductions:
+            console.print(f"  -{deduction.points_lost:.1f} {deduction.explanation}")
+
+    if report.findings:
+        table = Table()
+        table.add_column("Rule")
+        table.add_column("Severity")
+        table.add_column("Tool")
+        table.add_column("Message")
+        table.add_column("Confidence", justify="right")
+        for finding in report.findings:
+            style = _SEVERITY_STYLE[finding.severity]
+            table.add_row(
+                finding.rule_id,
+                f"[{style}]{finding.severity.value}[/{style}]",
+                finding.location.tool_name,
+                finding.message,
+                f"{finding.confidence:.2f}",
+            )
+        console.print(table)
+
+    return buffer.getvalue()