mumucc 0.4.4 → 0.4.10

package/defaults/plugin-seed/marketplaces/claude-code-workflows/plugins/plugin-eval/src/plugin_eval/parser.py

@@ -0,0 +1,198 @@
+"""Parse Claude Code plugin structure: skills, agents, plugin.json."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+
+@dataclass
+class ParsedSkill:
+    path: Path
+    name: str
+    description: str
+    line_count: int
+    h2_count: int
+    h3_count: int
+    code_block_count: int
+    code_block_languages: list[str]
+    has_examples: bool
+    has_troubleshooting: bool
+    has_references: bool
+    has_assets: bool
+    reference_files: list[str]
+    asset_files: list[str]
+    total_content_lines: int
+    must_never_always_count: int
+    cross_references: list[str]
+    raw_content: str
+    frontmatter: dict
+
+
+@dataclass
+class ParsedAgent:
+    path: Path
+    name: str
+    description: str
+    model: str | None
+    has_tools_restriction: bool
+    tools: list[str]
+    has_proactive_trigger: bool
+    skill_references: list[str]
+    raw_content: str
+    frontmatter: dict
+
+
+@dataclass
+class ParsedPlugin:
+    path: Path
+    name: str
+    skills: list[ParsedSkill] = field(default_factory=list)
+    agents: list[ParsedAgent] = field(default_factory=list)
+    plugin_json: dict = field(default_factory=dict)
+
+
+def parse_skill(skill_dir: Path) -> ParsedSkill:
+    """Parse a skill directory into structured data."""
+    skill_md = skill_dir / "SKILL.md"
+    if not skill_md.exists():
+        raise FileNotFoundError(f"No SKILL.md found in {skill_dir}")
+
+    content = skill_md.read_text(encoding="utf-8")
+    frontmatter, body = _split_frontmatter(content)
+    lines = body.strip().split("\n")
+
+    h2_count = sum(1 for line in lines if re.match(r"^## ", line))
+    h3_count = sum(1 for line in lines if re.match(r"^### ", line))
+
+    code_blocks = re.findall(r"```(\w*)", content)
+    code_block_languages = [lang for lang in code_blocks if lang]
+
+    lower_body = body.lower()
+    has_examples = bool(re.search(r"(## example|### example|## usage)", lower_body))
+    has_troubleshooting = bool(re.search(r"(## troubleshoot|## common issue|## faq)", lower_body))
+
+    refs_dir = skill_dir / "references"
+    assets_dir = skill_dir / "assets"
+    reference_files = (
+        [f.name for f in refs_dir.iterdir() if f.is_file()] if refs_dir.exists() else []
+    )
+    asset_files = (
+        [f.name for f in assets_dir.iterdir() if f.is_file()] if assets_dir.exists() else []
+    )
+
+    total_lines = len(content.split("\n"))
+    for ref_file in reference_files:
+        ref_path = refs_dir / ref_file
+        total_lines += len(ref_path.read_text(encoding="utf-8").split("\n"))
+
+    must_pattern = re.compile(r"\b(MUST|NEVER|ALWAYS)\b")
+    must_count = len(must_pattern.findall(content))
+
+    cross_refs = re.findall(r"(?:skill|skills)/([a-z0-9-]+)", body)
+
+    return ParsedSkill(
+        path=skill_dir,
+        name=frontmatter.get("name", skill_dir.name),
+        description=frontmatter.get("description", ""),
+        line_count=len(content.split("\n")),
+        h2_count=h2_count,
+        h3_count=h3_count,
+        code_block_count=len(code_blocks),
+        code_block_languages=code_block_languages,
+        has_examples=has_examples,
+        has_troubleshooting=has_troubleshooting,
+        has_references=refs_dir.exists(),
+        has_assets=assets_dir.exists(),
+        reference_files=reference_files,
+        asset_files=asset_files,
+        total_content_lines=total_lines,
+        must_never_always_count=must_count,
+        cross_references=cross_refs,
+        raw_content=content,
+        frontmatter=frontmatter,
+    )
+
+
+def parse_agent(agent_path: Path) -> ParsedAgent:
+    """Parse an agent markdown file."""
+    content = agent_path.read_text(encoding="utf-8")
+    frontmatter, body = _split_frontmatter(content)
+
+    tools_raw = frontmatter.get("tools", "")
+    if isinstance(tools_raw, list):
+        tools = [str(t).strip() for t in tools_raw]
+    elif isinstance(tools_raw, str) and tools_raw:
+        tools = [t.strip() for t in tools_raw.split(",")]
+    else:
+        tools = []
+
+    description = frontmatter.get("description", "")
+    has_proactive = bool(re.search(r"use proactively", description, re.IGNORECASE))
+
+    skill_refs = re.findall(r"(?:skill|skills)/([a-z0-9-]+)", body)
+
+    return ParsedAgent(
+        path=agent_path,
+        name=frontmatter.get("name", agent_path.stem),
+        description=description,
+        model=frontmatter.get("model"),
+        has_tools_restriction=bool(tools),
+        tools=tools,
+        has_proactive_trigger=has_proactive,
+        skill_references=skill_refs,
+        raw_content=content,
+        frontmatter=frontmatter,
+    )
+
+
+def parse_plugin(plugin_dir: Path) -> ParsedPlugin:
+    """Parse an entire plugin directory."""
+    plugin_json_path = plugin_dir / ".claude-plugin" / "plugin.json"
+    plugin_json = {}
+    if plugin_json_path.exists():
+        plugin_json = json.loads(plugin_json_path.read_text(encoding="utf-8"))
+
+    name = plugin_json.get("name", plugin_dir.name)
+
+    skills = []
+    skills_dir = plugin_dir / "skills"
+    if skills_dir.exists():
+        for skill_dir in sorted(skills_dir.iterdir()):
+            if skill_dir.is_dir() and (skill_dir / "SKILL.md").exists():
+                skills.append(parse_skill(skill_dir))
+
+    agents = []
+    agents_dir = plugin_dir / "agents"
+    if agents_dir.exists():
+        for agent_file in sorted(agents_dir.glob("*.md")):
+            agents.append(parse_agent(agent_file))
+
+    return ParsedPlugin(
+        path=plugin_dir,
+        name=name,
+        skills=skills,
+        agents=agents,
+        plugin_json=plugin_json,
+    )
+
+
+def _split_frontmatter(content: str) -> tuple[dict, str]:
+    """Split YAML frontmatter from markdown body."""
+    if not content.startswith("---"):
+        return {}, content
+
+    parts = content.split("---", 2)
+    if len(parts) < 3:
+        return {}, content
+
+    try:
+        frontmatter = yaml.safe_load(parts[1]) or {}
+    except yaml.YAMLError:
+        frontmatter = {}
+
+    return frontmatter, parts[2]

package/defaults/plugin-seed/marketplaces/claude-code-workflows/plugins/plugin-eval/src/plugin_eval/reporter.py

@@ -0,0 +1,184 @@
+"""Reporter — formats PluginEvalResult into JSON, Markdown, or HTML."""
+
+from __future__ import annotations
+
+from plugin_eval.models import PluginEvalResult
+
+
+class Reporter:
+    """Converts a PluginEvalResult into various output formats."""
+
+    # ------------------------------------------------------------------
+    # JSON
+    # ------------------------------------------------------------------
+
+    def to_json(self, result: PluginEvalResult) -> str:
+        """Return a pretty-printed JSON string of the full result."""
+        return result.model_dump_json(indent=2)
+
+    # ------------------------------------------------------------------
+    # Markdown
+    # ------------------------------------------------------------------
+
+    def to_markdown(self, result: PluginEvalResult) -> str:
+        lines: list[str] = []
+
+        lines.append("# PluginEval Report")
+        lines.append("")
+        lines.append(f"**Path:** `{result.plugin_path}`")
+        lines.append(f"**Timestamp:** {result.timestamp}")
+        lines.append(f"**Depth:** {result.config.depth}")
+        lines.append("")
+
+        # Overall Score
+        lines.append("## Overall Score")
+        lines.append("")
+        if result.composite:
+            c = result.composite
+            score_str = f"{c.score:.1f}/100"
+            badge_str = c.badge.value.replace("_", " ").title()
+            lines.append("| Metric | Value |")
+            lines.append("|--------|-------|")
+            lines.append(f"| Score | **{score_str}** |")
+            lines.append(f"| Confidence | {c.confidence_label} |")
+            lines.append(f"| Badge | {badge_str} |")
+            if c.ci_lower is not None and c.ci_upper is not None:
+                lines.append(f"| 95% CI | [{c.ci_lower:.1f}, {c.ci_upper:.1f}] |")
+            if c.anti_pattern_penalty < 1.0:
+                penalty_pct = (1.0 - c.anti_pattern_penalty) * 100
+                lines.append(f"| Anti-Pattern Penalty | -{penalty_pct:.0f}% |")
+        else:
+            lines.append("_No composite score available._")
+        lines.append("")
+
+        # Elo Rating (if present)
+        if result.elo:
+            elo = result.elo
+            lines.append("## Elo Rating")
+            lines.append("")
+            lines.append("| Metric | Value |")
+            lines.append("|--------|-------|")
+            lines.append(f"| Rating | {elo.rating:.0f} |")
+            if elo.ci_lower is not None and elo.ci_upper is not None:
+                lines.append(f"| 95% CI | [{elo.ci_lower:.0f}, {elo.ci_upper:.0f}] |")
+            if elo.corpus_percentile is not None:
+                lines.append(f"| Corpus Percentile | {elo.corpus_percentile:.1f}% |")
+            if elo.closest_comparable:
+                lines.append(f"| Closest Comparable | {elo.closest_comparable} |")
+            lines.append("")
+
+        # Layer Breakdown
+        lines.append("## Layer Breakdown")
+        lines.append("")
+        lines.append("| Layer | Score | Anti-Patterns |")
+        lines.append("|-------|-------|---------------|")
+        for layer in result.layers:
+            ap_count = len(layer.anti_patterns)
+            lines.append(f"| {layer.layer} | {layer.score:.3f} | {ap_count} |")
+        lines.append("")
+
+        # Dimension Scores
+        if result.composite and result.composite.dimensions:
+            lines.append("## Dimension Scores")
+            lines.append("")
+            lines.append("| Dimension | Weight | Score | Grade |")
+            lines.append("|-----------|--------|-------|-------|")
+            for dim in result.composite.dimensions:
+                name = dim.name.replace("_", " ").title()
+                grade = dim.grade or "—"
+                lines.append(f"| {name} | {dim.weight:.0%} | {dim.score:.3f} | {grade} |")
+            lines.append("")
+
+        # Elo Matchups (if present)
+        if result.elo and result.elo.matches:
+            lines.append("## Elo Matchups")
+            lines.append("")
+            lines.append("| Opponent | Elo | Result | Score |")
+            lines.append("|----------|-----|--------|-------|")
+            for m in result.elo.matches:
+                lines.append(
+                    f"| {m.opponent} | {m.opponent_elo:.0f} | {m.result} | {m.score:.3f} |"
+                )
+            lines.append("")
+
+        # Anti-Patterns Detected
+        all_anti_patterns = [ap for layer in result.layers for ap in layer.anti_patterns]
+        lines.append("## Anti-Patterns Detected")
+        lines.append("")
+        if all_anti_patterns:
+            lines.append("| Flag | Description | Severity |")
+            lines.append("|------|-------------|----------|")
+            for ap in all_anti_patterns:
+                lines.append(f"| `{ap.flag}` | {ap.description} | {ap.severity:.0%} |")
+        else:
+            lines.append("_No anti-patterns detected._")
+        lines.append("")
+
+        # Model Usage
+        lines.append("## Model Usage")
+        lines.append("")
+        if result.model_usage:
+            lines.append("| Model | Tokens |")
+            lines.append("|-------|--------|")
+            for model, tokens in result.model_usage.items():
+                lines.append(f"| {model} | {tokens:,} |")
+        else:
+            lines.append("_No model usage (static-only evaluation)._")
+        lines.append("")
+
+        return "\n".join(lines)
+
+    # ------------------------------------------------------------------
+    # HTML
+    # ------------------------------------------------------------------
+
+    def to_html(self, result: PluginEvalResult) -> str:
+        """Wrap the markdown report in a dark-themed HTML page."""
+        md_content = self.to_markdown(result)
+        # Escape for inclusion in a <pre> block isn't ideal; use a simple
+        # markdown-to-HTML approach with basic replacements.
+        escaped = md_content.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+        return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>PluginEval Report</title>
+  <style>
+    :root {{
+      --bg: #0d1117;
+      --surface: #161b22;
+      --border: #30363d;
+      --text: #c9d1d9;
+      --muted: #8b949e;
+      --accent: #58a6ff;
+      --green: #3fb950;
+      --red: #f85149;
+    }}
+    * {{ box-sizing: border-box; margin: 0; padding: 0; }}
+    body {{
+      background: var(--bg);
+      color: var(--text);
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, monospace;
+      padding: 2rem;
+      line-height: 1.6;
+    }}
+    pre {{
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 1.5rem;
+      overflow-x: auto;
+      white-space: pre-wrap;
+      font-size: 0.875rem;
+      font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace;
+    }}
+    h1 {{ color: var(--accent); margin-bottom: 1rem; font-size: 1.5rem; }}
+  </style>
+</head>
+<body>
+  <pre>{escaped}</pre>
+</body>
+</html>
+"""

package/defaults/plugin-seed/marketplaces/claude-code-workflows/plugins/plugin-eval/src/plugin_eval/stats.py

@@ -0,0 +1,183 @@
+"""Statistical methods for PluginEval confidence intervals and reliability metrics."""
+
+from __future__ import annotations
+
+import math
+import random
+from collections import Counter
+
+
+def wilson_score_ci(
+    successes: int,
+    trials: int,
+    confidence: float = 0.95,
+) -> tuple[float, float]:
+    """Wilson score interval for binomial proportion."""
+    if trials == 0:
+        raise ValueError("trials must be > 0")
+    if successes > trials:
+        raise ValueError(f"successes ({successes}) cannot exceed trials ({trials})")
+
+    z = _z_score(confidence)
+    n = trials
+    p_hat = successes / n
+
+    denominator = 1 + z**2 / n
+    center = (p_hat + z**2 / (2 * n)) / denominator
+    margin = (z / denominator) * math.sqrt(p_hat * (1 - p_hat) / n + z**2 / (4 * n**2))
+
+    lower = max(0.0, center - margin)
+    upper = min(1.0, center + margin)
+    return lower, upper
+
+
+def bootstrap_ci(
+    data: list[float],
+    confidence: float = 0.95,
+    n_resamples: int = 1000,
+    seed: int | None = None,
+) -> tuple[float, float]:
+    """Bootstrap confidence interval via percentile method."""
+    if len(data) == 0:
+        raise ValueError("data must not be empty")
+    if len(data) == 1:
+        return data[0], data[0]
+
+    rng = random.Random(seed)
+    n = len(data)
+    means = []
+    for _ in range(n_resamples):
+        sample = [rng.choice(data) for _ in range(n)]
+        means.append(sum(sample) / n)
+
+    means.sort()
+    alpha = 1 - confidence
+    lower_idx = int(math.floor(alpha / 2 * n_resamples))
+    upper_idx = int(math.ceil((1 - alpha / 2) * n_resamples)) - 1
+
+    lower_idx = max(0, min(lower_idx, n_resamples - 1))
+    upper_idx = max(0, min(upper_idx, n_resamples - 1))
+
+    return means[lower_idx], means[upper_idx]
+
+
+def clopper_pearson_ci(
+    failures: int,
+    trials: int,
+    confidence: float = 0.95,
+) -> tuple[float, float]:
+    """Clopper-Pearson exact confidence interval for failure rate."""
+    if trials == 0:
+        raise ValueError("trials must be > 0")
+    if failures > trials:
+        raise ValueError(f"failures ({failures}) cannot exceed trials ({trials})")
+
+    alpha = 1 - confidence
+
+    lower = 0.0 if failures == 0 else _beta_ppf(alpha / 2, failures, trials - failures + 1)
+    upper = 1.0 if failures == trials else _beta_ppf(1 - alpha / 2, failures + 1, trials - failures)
+
+    return lower, upper
+
+
+def coefficient_of_variation(data: list[float]) -> float:
+    """Coefficient of variation (std / mean). Lower = more consistent."""
+    if len(data) == 0:
+        raise ValueError("data must not be empty")
+    mean = sum(data) / len(data)
+    if mean == 0:
+        return 0.0
+    variance = sum((x - mean) ** 2 for x in data) / len(data)
+    return math.sqrt(variance) / abs(mean)
+
+
+def cohens_kappa(rater1: list[int], rater2: list[int]) -> float:
+    """Cohen's kappa for inter-rater agreement."""
+    if len(rater1) != len(rater2):
+        raise ValueError("Rater lists must have the same length")
+
+    n = len(rater1)
+    categories = set(rater1) | set(rater2)
+
+    observed_agreement = sum(a == b for a, b in zip(rater1, rater2, strict=True)) / n
+
+    counts1 = Counter(rater1)
+    counts2 = Counter(rater2)
+    expected_agreement = sum((counts1.get(c, 0) / n) * (counts2.get(c, 0) / n) for c in categories)
+
+    if expected_agreement == 1.0:
+        return 1.0
+
+    return (observed_agreement - expected_agreement) / (1 - expected_agreement)
+
+
+def _z_score(confidence: float) -> float:
+    """Approximate z-score for common confidence levels."""
+    z_table = {0.90: 1.645, 0.95: 1.960, 0.99: 2.576}
+    if confidence in z_table:
+        return z_table[confidence]
+    p = (1 + confidence) / 2
+    t = math.sqrt(-2 * math.log(1 - p))
+    c0, c1, c2 = 2.515517, 0.802853, 0.010328
+    d1, d2, d3 = 1.432788, 0.189269, 0.001308
+    return t - (c0 + c1 * t + c2 * t**2) / (1 + d1 * t + d2 * t**2 + d3 * t**3)
+
+
+def _beta_ppf(p: float, a: float, b: float) -> float:
+    """Approximate beta distribution percent point function via Newton's method."""
+    if p <= 0:
+        return 0.0
+    if p >= 1:
+        return 1.0
+
+    mu = a / (a + b)
+    sigma = math.sqrt(a * b / ((a + b) ** 2 * (a + b + 1)))
+    z = _z_score(2 * p - 1) if p > 0.5 else -_z_score(2 * (1 - p) - 1)
+    x = max(0.001, min(0.999, mu + sigma * z))
+
+    for _ in range(50):
+        cdf = _beta_cdf(x, a, b)
+        pdf = _beta_pdf(x, a, b)
+        if pdf < 1e-12:
+            break
+        x_new = x - (cdf - p) / pdf
+        x_new = max(0.001, min(0.999, x_new))
+        if abs(x_new - x) < 1e-10:
+            break
+        x = x_new
+
+    return x
+
+
+def _beta_pdf(x: float, a: float, b: float) -> float:
+    """Beta distribution probability density function."""
+    if x <= 0 or x >= 1:
+        return 0.0
+    log_pdf = (a - 1) * math.log(x) + (b - 1) * math.log(1 - x) - _log_beta(a, b)
+    return math.exp(log_pdf)
+
+
+def _beta_cdf(x: float, a: float, b: float, steps: int = 200) -> float:
+    """Beta CDF via numerical integration (Simpson's rule)."""
+    if x <= 0:
+        return 0.0
+    if x >= 1:
+        return 1.0
+
+    h = x / steps
+    # Endpoints: f(0) is 0 for a>=1, divergent for a<1 — use 0.0 safely
+    f_0 = 0.0 if a <= 1 else _beta_pdf(h / 2, a, b)
+    total = f_0 + _beta_pdf(x, a, b)
+    for i in range(1, steps):
+        xi = i * h
+        if xi <= 0 or xi >= 1:
+            continue
+        weight = 4 if i % 2 == 1 else 2
+        total += weight * _beta_pdf(xi, a, b)
+
+    return total * h / 3
+
+
+def _log_beta(a: float, b: float) -> float:
+    """Log of the beta function."""
+    return math.lgamma(a) + math.lgamma(b) - math.lgamma(a + b)

package/defaults/plugin-seed/marketplaces/claude-code-workflows/plugins/plugin-eval/tests/conftest.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def fixtures_dir() -> Path:
+    return Path(__file__).parent / "fixtures"
+
+
+@pytest.fixture
+def sample_skill_dir(tmp_path: Path) -> Path:
+    """Create a minimal valid skill directory."""
+    skill_dir = tmp_path / "test-skill"
+    skill_dir.mkdir()
+    skill_md = skill_dir / "SKILL.md"
+    skill_md.write_text(
+        "---\n"
+        "name: test-skill\n"
+        'description: "Test skill for evaluation. Use when testing plugin-eval."\n'
+        "---\n\n"
+        "# Test Skill\n\n"
+        "## Overview\n\n"
+        "This is a test skill for evaluation purposes.\n\n"
+        "## Usage\n\n"
+        "```python\nprint('hello')\n```\n\n"
+        "## Troubleshooting\n\n"
+        "Check the logs.\n"
+    )
+    refs_dir = skill_dir / "references"
+    refs_dir.mkdir()
+    (refs_dir / "guide.md").write_text("# Guide\n\nDetailed reference content.\n")
+    return skill_dir
+
+
+@pytest.fixture
+def sample_plugin_dir(tmp_path: Path, sample_skill_dir: Path) -> Path:
+    """Create a minimal valid plugin directory."""
+    plugin_dir = tmp_path / "test-plugin"
+    plugin_dir.mkdir()
+    claude_dir = plugin_dir / ".claude-plugin"
+    claude_dir.mkdir()
+    (claude_dir / "plugin.json").write_text('{"name": "test-plugin"}')
+
+    skills_dir = plugin_dir / "skills"
+    skills_dir.mkdir()
+    import shutil
+    dest = skills_dir / "test-skill"
+    shutil.copytree(sample_skill_dir, dest)
+
+    agents_dir = plugin_dir / "agents"
+    agents_dir.mkdir()
+    (agents_dir / "test-agent.md").write_text(
+        "---\n"
+        "name: test-agent\n"
+        'description: "Test agent. Use PROACTIVELY for testing."\n'
+        "model: sonnet\n"
+        "tools: Read, Grep, Glob\n"
+        "---\n\n"
+        "You are a test agent.\n"
+    )
+    return plugin_dir
+
+
+@pytest.fixture
+def poor_skill_dir(tmp_path: Path) -> Path:
+    """Create a skill with multiple anti-patterns."""
+    skill_dir = tmp_path / "poor-skill"
+    skill_dir.mkdir()
+    skill_md = skill_dir / "SKILL.md"
+    lines = ["---\n", "name: poor-skill\n", 'description: "A skill."\n', "---\n\n"]
+    lines.append("# Poor Skill\n\n")
+    for i in range(100):
+        lines.append(f"You MUST follow rule {i}. You ALWAYS do this. NEVER skip.\n")
+    skill_md.write_text("".join(lines))
+    refs = skill_dir / "references"
+    refs.mkdir()
+    (refs / "orphan.md").write_text("# Orphan\n\nNot referenced from SKILL.md.\n")
+    return skill_dir

package/defaults/plugin-seed/marketplaces/claude-code-workflows/plugins/plugin-eval/tests/test_cli.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from plugin_eval.cli import app
+
+runner = CliRunner()
+
+
+class TestCLI:
+    def test_score_quick(self, sample_skill_dir: Path):
+        result = runner.invoke(app, ["score", str(sample_skill_dir), "--depth", "quick"])
+        assert result.exit_code == 0
+
+    def test_score_json_output(self, sample_skill_dir: Path):
+        result = runner.invoke(
+            app, ["score", str(sample_skill_dir), "--depth", "quick", "--output", "json"]
+        )
+        assert result.exit_code == 0
+        assert '"composite"' in result.stdout
+
+    def test_score_markdown_output(self, sample_skill_dir: Path):
+        result = runner.invoke(
+            app, ["score", str(sample_skill_dir), "--depth", "quick", "--output", "markdown"]
+        )
+        assert result.exit_code == 0
+        assert "PluginEval Report" in result.stdout
+
+    def test_score_nonexistent_path(self, tmp_path: Path):
+        result = runner.invoke(app, ["score", str(tmp_path / "nonexistent")])
+        assert result.exit_code == 2