agentrepocoach 0.2.0__tar.gz → 0.3.0__tar.gz

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentrepocoach
-Version: 0.2.0
+Version: 0.3.0
 Summary: Score your codebase on how ready it is for AI agents — and coach you through the fixes.
 Author: WouterDeBot
 License: Apache-2.0
@@ -38,7 +38,7 @@ Dynamic: license-file
 
 [![PyPI version](https://img.shields.io/pypi/v/agentrepocoach.svg)](https://pypi.org/project/agentrepocoach/)
 [![License](https://img.shields.io/github/license/WouterDeBot/agentrepocoach.svg)](./LICENSE)
-[![CI](https://github.com/WouterDeBot/agentrepocoach/workflows/dogfood/badge.svg)](https://github.com/WouterDeBot/agentrepocoach/actions)
+[![CI](https://github.com/WouterDeBot/agentrepocoach/actions/workflows/ci.yml/badge.svg)](https://github.com/WouterDeBot/agentrepocoach/actions/workflows/ci.yml)
 [![Python versions](https://img.shields.io/pypi/pyversions/agentrepocoach.svg)](https://pypi.org/project/agentrepocoach/)
 
 AgentRepoCoach computes the **Codebase Agent Health (CAH)** score: a single 0-100
@@ -123,6 +123,12 @@ python -m agentrepocoach.cli --repo . --format json --output ./report.json
 # Per-sub-component breakdown
 python -m agentrepocoach.cli --repo . --verbose
 
+# Compare against a baseline report (inline delta)
+python -m agentrepocoach.cli --repo . --format json --output ./pr.json --compare ./baseline.json
+
+# Compare two saved score files
+python -m agentrepocoach.cli compare ./baseline.json ./pr.json
+
 # Show the installed version
 python -m agentrepocoach.cli --version
 ```

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/README.md

@@ -4,7 +4,7 @@
 
 [![PyPI version](https://img.shields.io/pypi/v/agentrepocoach.svg)](https://pypi.org/project/agentrepocoach/)
 [![License](https://img.shields.io/github/license/WouterDeBot/agentrepocoach.svg)](./LICENSE)
-[![CI](https://github.com/WouterDeBot/agentrepocoach/workflows/dogfood/badge.svg)](https://github.com/WouterDeBot/agentrepocoach/actions)
+[![CI](https://github.com/WouterDeBot/agentrepocoach/actions/workflows/ci.yml/badge.svg)](https://github.com/WouterDeBot/agentrepocoach/actions/workflows/ci.yml)
 [![Python versions](https://img.shields.io/pypi/pyversions/agentrepocoach.svg)](https://pypi.org/project/agentrepocoach/)
 
 AgentRepoCoach computes the **Codebase Agent Health (CAH)** score: a single 0-100
@@ -89,6 +89,12 @@ python -m agentrepocoach.cli --repo . --format json --output ./report.json
 # Per-sub-component breakdown
 python -m agentrepocoach.cli --repo . --verbose
 
+# Compare against a baseline report (inline delta)
+python -m agentrepocoach.cli --repo . --format json --output ./pr.json --compare ./baseline.json
+
+# Compare two saved score files
+python -m agentrepocoach.cli compare ./baseline.json ./pr.json
+
 # Show the installed version
 python -m agentrepocoach.cli --version
 ```

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentrepocoach"
-version = "0.2.0"
+version = "0.3.0"
 description = "Score your codebase on how ready it is for AI agents — and coach you through the fixes."
 readme = "README.md"
 license = { text = "Apache-2.0" }

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/__init__.py

@@ -9,6 +9,6 @@ from __future__ import annotations
 
 from .compute import compute_cah
 
-VERSION = "0.2.0"
+VERSION = "0.3.0"
 
 __all__ = ["compute_cah", "VERSION"]

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/adapters/__init__.py

@@ -33,7 +33,12 @@ def get_adapter_by_name(name: str) -> LanguageAdapter:
 
 
 def detect_primary(repo_path: Path) -> LanguageAdapter:
-    """Try every adapter and return the one with the highest detect() confidence."""
+    """Try every adapter and return the one with the highest detect() confidence.
+
+    When multiple adapters tie on confidence, the adapter whose
+    ``find_production_files`` returns more files wins — a repo with 20 .py
+    files and a single .sln fixture is almost certainly a Python project.
+    """
     candidates: list[tuple[float, LanguageAdapter]] = []
     for cls in _REGISTRY.values():
         adapter = cls()
@@ -44,7 +49,12 @@ def detect_primary(repo_path: Path) -> LanguageAdapter:
         supported = ", ".join(sorted(_REGISTRY))
         msg = f"No supported language detected in {repo_path}. Supported: {supported}."
         raise NoAdapterError(f"{msg} Try using --language to force an adapter, or check that the repo contains a recognized project file.")
-    candidates.sort(key=lambda pair: pair[0], reverse=True)
+    # Sort by confidence (desc), then by production file count (desc) to
+    # break ties deterministically in favour of the dominant language.
+    candidates.sort(
+        key=lambda pair: (pair[0], len(pair[1].find_production_files(repo_path))),
+        reverse=True,
+    )
     return candidates[0][1]
 
 

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/adapters/csharp.py

@@ -116,10 +116,14 @@ class CSharpAdapter(LanguageAdapter):
     # ------------------------------------------------------------------
 
     def detect(self, repo_path: Path) -> float:
-        """1.0 if any *.sln, 0.8 if any *.csproj, else 0.0."""
-        if any(repo_path.rglob("*.sln")):
+        """1.0 if any *.sln, 0.8 if any *.csproj, else 0.0.
+
+        Only checks the repo root and one level deep to avoid false
+        positives from test fixtures or vendored dependencies.
+        """
+        if any(repo_path.glob("*.sln")) or any(repo_path.glob("*/*.sln")):
             return 1.0
-        if any(repo_path.rglob("*.csproj")):
+        if any(repo_path.glob("*.csproj")) or any(repo_path.glob("*/*.csproj")):
             return 0.8
         return 0.0
 

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/adapters/go.py

@@ -72,7 +72,9 @@ class GoAdapter(LanguageAdapter):
     def detect(self, repo_path: Path) -> float:
         if (repo_path / "go.mod").is_file():
             return 1.0
-        if any(repo_path.rglob("*.go")):
+        # Shallow search (root + one level) to avoid false positives from
+        # test fixtures or vendored dependencies.
+        if any(repo_path.glob("*.go")) or any(repo_path.glob("*/*.go")):
             return 0.5
         return 0.0
 

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/adapters/rust.py

@@ -72,7 +72,9 @@ class RustAdapter(LanguageAdapter):
     def detect(self, repo_path: Path) -> float:
         if (repo_path / "Cargo.toml").is_file():
             return 1.0
-        if any(repo_path.rglob("*.rs")):
+        # Shallow search (root + one level) to avoid false positives from
+        # test fixtures or vendored dependencies.
+        if any(repo_path.glob("*.rs")) or any(repo_path.glob("*/*.rs")):
             return 0.5
         return 0.0
 

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/cli.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import argparse
+import json as _json
 import sys
 from pathlib import Path
 
@@ -10,12 +11,17 @@ from .adapters import NoAdapterError
 from .compute import compute_cah
 from .config import ConfigError, load_config
 from .output import (
+    format_comparison,
+    format_comparison_markdown,
     format_summary,
     format_verbose,
+    render_json,
+    render_markdown_comment,
     write_json,
     write_markdown_comment,
     write_prometheus,
 )
+from .pr_bot import compare_scores, format_pr_comment, parse_score_output
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -49,9 +55,10 @@ def build_parser() -> argparse.ArgumentParser:
         "--format",
         choices=["json", "markdown", "both"],
         default=None,
-        help="Output format when using --output. 'json' writes the full report, "
-             "'markdown' writes a PR-comment summary, 'both' writes both (markdown "
-             "path derived from --output by swapping the extension to .md).",
+        help="Output format. 'json' prints the full report (to stdout or --output), "
+             "'markdown' prints a PR-comment summary (to stdout or --output), "
+             "'both' writes both to --output (markdown path derived by swapping "
+             "the extension to .md; requires --output).",
     )
     parser.add_argument(
         "--output",
@@ -59,17 +66,88 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="Output path for --format. Ignored if --format is not set.",
     )
+    parser.add_argument(
+        "--compare",
+        type=Path,
+        default=None,
+        help="Path to a baseline JSON report. Prints a delta comparison instead of "
+             "the normal summary.",
+    )
     parser.add_argument("--verbose", action="store_true", help="Print per-sub-component breakdown.")
     parser.add_argument("--quiet", action="store_true", help="Print only the total score.")
     parser.add_argument("--version", action="version", version=f"agentrepocoach {VERSION}")
+
+    # Subcommands
+    subparsers = parser.add_subparsers(dest="subcommand")
+
+    # compare subcommand
+    compare_parser = subparsers.add_parser(
+        "compare",
+        help="Compare two JSON score files and display deltas.",
+    )
+    compare_parser.add_argument(
+        "base_file",
+        type=Path,
+        help="Path to the base (target branch) JSON score file.",
+    )
+    compare_parser.add_argument(
+        "pr_file",
+        type=Path,
+        help="Path to the PR (source branch) JSON score file.",
+    )
+    compare_parser.add_argument(
+        "--json",
+        action="store_true",
+        dest="json_output",
+        help="Output raw comparison dict as JSON instead of markdown.",
+    )
+
     return parser
 
 
+def _run_compare(args: argparse.Namespace) -> int:
+    """Execute the ``compare`` subcommand."""
+    base_path = args.base_file.resolve()
+    pr_path = args.pr_file.resolve()
+
+    if not base_path.is_file():
+        print(f"error: base file does not exist: {base_path}", file=sys.stderr)
+        return 2
+    if not pr_path.is_file():
+        print(f"error: pr file does not exist: {pr_path}", file=sys.stderr)
+        return 2
+
+    try:
+        base_scores = parse_score_output(base_path.read_text())
+    except ValueError as exc:
+        print(f"error: failed to parse base file: {exc}", file=sys.stderr)
+        return 2
+
+    try:
+        pr_scores = parse_score_output(pr_path.read_text())
+    except ValueError as exc:
+        print(f"error: failed to parse pr file: {exc}", file=sys.stderr)
+        return 2
+
+    comparison = compare_scores(base_scores, pr_scores)
+
+    if args.json_output:
+        print(_json.dumps(comparison, indent=2))
+    else:
+        print(format_pr_comment(comparison))
+
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     """Run the CLI, parse arguments, compute the CAH score, and write outputs."""
     parser = build_parser()
     args = parser.parse_args(argv)
 
+    # Dispatch subcommands
+    if args.subcommand == "compare":
+        return _run_compare(args)
+
     repo_root = args.repo.resolve()
     if not repo_root.is_dir():
         print(f"error: repo path is not a directory: {repo_root}", file=sys.stderr)
@@ -92,7 +170,25 @@ def main(argv: list[str] | None = None) -> int:
         print(f"error: {exc}", file=sys.stderr)
         return 2
 
-    if args.quiet:
+    # When --format is used without --output, the formatted content replaces
+    # the default terminal summary on stdout.
+    stdout_replaced_by_format = args.format and not args.output
+
+    if args.compare:
+        baseline_path = args.compare.resolve()
+        if not baseline_path.is_file():
+            print(f"error: baseline report not found: {baseline_path}", file=sys.stderr)
+            return 2
+        import json as _json
+        baseline = _json.loads(baseline_path.read_text())
+        if args.quiet:
+            delta = result["total"] - baseline["total"]
+            print(f"{delta:+.2f}")
+        else:
+            print(format_comparison(result, baseline))
+    elif stdout_replaced_by_format:
+        pass  # handled below in the --format block
+    elif args.quiet:
         print(f"{result['total']:.2f}")
     elif args.verbose:
         print(format_verbose(result))
@@ -117,12 +213,22 @@ def main(argv: list[str] | None = None) -> int:
     if args.format and args.output:
         _write_formatted(result, args.format, args.output, quiet=args.quiet)
     elif args.format and not args.output:
-        print("error: --format requires --output", file=sys.stderr)
-        return 2
+        if args.format == "both":
+            print("error: --format both requires --output", file=sys.stderr)
+            return 2
+        _print_formatted(result, args.format)
 
     return 0
 
 
+def _print_formatted(result: dict, fmt: str) -> None:
+    """Print formatted output to stdout when --output is not provided."""
+    if fmt == "json":
+        print(render_json(result))
+    elif fmt == "markdown":
+        print(render_markdown_comment(result))
+
+
 def _write_formatted(
     result: dict,
     fmt: str,

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/components/decision_queryability.py

@@ -14,11 +14,13 @@ inline_ref_resolution 30 -> 40. Total still sums to 100.
 from __future__ import annotations
 
 import re
+import warnings
 from pathlib import Path
 from typing import Any
 
 from ..adapters import LanguageAdapter
 from ..config import Config
+from ..regex_safety import safe_compile_pattern
 from ..scoring import scale_linear
 
 _ADR_COUNT_WEIGHT = 60
@@ -139,9 +141,13 @@ def _compile_inline_ref_patterns(patterns: tuple[str, ...]) -> list[re.Pattern[s
         # Wrap in word boundaries if the user did not already supply them.
         anchored = raw if raw.startswith("\\b") else rf"\b{raw}\b"
         try:
-            compiled.append(re.compile(anchored, re.IGNORECASE))
-        except re.error:
-            # Malformed regex -> skip silently; the user sees it in --verbose.
+            compiled.append(safe_compile_pattern(anchored, flags=re.IGNORECASE))
+        except ValueError as exc:
+            warnings.warn(
+                f"Skipping inline_ref_pattern {raw!r}: {exc}",
+                UserWarning,
+                stacklevel=2,
+            )
             continue
     return compiled
 

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/components/test_quality.py

@@ -14,12 +14,14 @@ full credit unless the user opts in by listing project-specific patterns.
 from __future__ import annotations
 
 import re
+import warnings
 from pathlib import Path
 from typing import Any
 
 from ..adapters import LanguageAdapter
 from ..adapters.base import iter_source_files
 from ..config import Config
+from ..regex_safety import safe_compile_pattern
 from ..scoring import scale_linear
 
 _NAMING_WEIGHT = 40
@@ -153,8 +155,13 @@ def _score_fixture_duplication(
     compiled: list[re.Pattern[str]] = []
     for raw in patterns:
         try:
-            compiled.append(re.compile(raw))
-        except re.error:
+            compiled.append(safe_compile_pattern(raw))
+        except ValueError as exc:
+            warnings.warn(
+                f"Skipping fixture_duplication_pattern {raw!r}: {exc}",
+                UserWarning,
+                stacklevel=2,
+            )
             continue
 
     total = 0

{agentrepocoach-0.2.0 → agentrepocoach-0.3.0}/src/agentrepocoach/output.py

@@ -21,14 +21,19 @@ _METRIC_HELP = "AgentRepoCoach composite codebase agent health score (0-100)."
 _METRIC_NAME = "agentrepocoach_codebase_health_score"
 
 
+def render_json(result: dict[str, Any]) -> str:
+    """Return the full score breakdown as a JSON string."""
+    return json.dumps(result, indent=2, default=str)
+
+
 def write_json(result: dict[str, Any], path: Path) -> None:
     """Write the full score breakdown as JSON."""
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(result, indent=2, default=str) + "\n")
+    path.write_text(render_json(result) + "\n")
 
 
-def write_prometheus(result: dict[str, Any], path: Path) -> None:
-    """Write the score in Prometheus exposition format."""
+def render_prometheus(result: dict[str, Any]) -> str:
+    """Return the score in Prometheus exposition format as a string."""
     lines = [
         f"# HELP {_METRIC_NAME} {_METRIC_HELP}",
         f"# TYPE {_METRIC_NAME} gauge",
@@ -37,8 +42,36 @@ def write_prometheus(result: dict[str, Any], path: Path) -> None:
     for name, component in result.get("components", {}).items():
         score = component.get("score", 0)
         lines.append(f'{_METRIC_NAME}{{component="{name}"}} {score}')
+    return "\n".join(lines)
+
+
+def write_prometheus(result: dict[str, Any], path: Path) -> None:
+    """Write the score in Prometheus exposition format."""
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text("\n".join(lines) + "\n")
+    path.write_text(render_prometheus(result) + "\n")
+
+
+def render_markdown_comment(result: dict[str, Any]) -> str:
+    """Return a short summary suitable for a GitHub PR comment as a string."""
+    lines = [
+        "### AgentRepoCoach — Codebase Agent Health",
+        "",
+        f"**Total score:** {result['total']:.2f} / 100",
+        f"**Language:** `{result.get('language', 'unknown')}`",
+        "",
+        "| Component | Score | Weight |",
+        "|---|---:|---:|",
+    ]
+    weights = result.get("weights", {})
+    for name, component in result.get("components", {}).items():
+        weight = weights.get(name, 0.0)
+        lines.append(f"| {name} | {component['score']:.2f} / 100 | {weight:.2f} |")
+    tips = generate_coaching(result)
+    coaching = format_coaching_markdown(tips)
+    if coaching:
+        lines.append(coaching)
+    lines.append("<!-- agentrepocoach -->")
+    return "\n".join(lines)
 
 
 def write_markdown_comment(result: dict[str, Any], path: Path) -> None:
@@ -254,6 +287,72 @@ def format_summary(result: dict[str, Any]) -> str:
     return "\n".join(lines)
 
 
+def format_comparison(current: dict[str, Any], baseline: dict[str, Any]) -> str:
+    """Return a terminal-friendly delta table comparing *current* against *baseline*."""
+    cur_total = current["total"]
+    base_total = baseline["total"]
+    delta_total = cur_total - base_total
+
+    lines = [
+        "AgentRepoCoach — Score Comparison",
+        "=================================",
+        f"Total: {base_total:.2f} -> {cur_total:.2f} ({delta_total:+.2f})",
+        "",
+        f"  {'Component':25s} {'Baseline':>10s} {'Current':>10s} {'Delta':>10s}",
+        f"  {'-' * 25} {'-' * 10} {'-' * 10} {'-' * 10}",
+    ]
+
+    base_components = baseline.get("components", {})
+    cur_components = current.get("components", {})
+    all_names = list(dict.fromkeys(list(base_components) + list(cur_components)))
+
+    for name in all_names:
+        base_score = base_components.get(name, {}).get("score", 0.0)
+        cur_score = cur_components.get(name, {}).get("score", 0.0)
+        delta = cur_score - base_score
+        lines.append(
+            f"  {name:25s} {base_score:10.2f} {cur_score:10.2f} {delta:+10.2f}"
+        )
+
+    return "\n".join(lines)
+
+
+def format_comparison_markdown(current: dict[str, Any], baseline: dict[str, Any]) -> str:
+    """Return a markdown delta table suitable for a GitHub PR comment."""
+    cur_total = current["total"]
+    base_total = baseline["total"]
+    delta_total = cur_total - base_total
+
+    lines = [
+        "### AgentRepoCoach — Score Comparison",
+        "",
+        f"**Total score:** {base_total:.2f} -> {cur_total:.2f} ({delta_total:+.2f})",
+        "",
+        "| Component | Baseline | Current | Delta |",
+        "|---|---:|---:|---:|",
+    ]
+
+    base_components = baseline.get("components", {})
+    cur_components = current.get("components", {})
+    all_names = list(dict.fromkeys(list(base_components) + list(cur_components)))
+
+    for name in all_names:
+        base_score = base_components.get(name, {}).get("score", 0.0)
+        cur_score = cur_components.get(name, {}).get("score", 0.0)
+        delta = cur_score - base_score
+        lines.append(f"| {name} | {base_score:.2f} | {cur_score:.2f} | {delta:+.2f} |")
+
+    # Append coaching tips from the current result
+    tips = generate_coaching(current)
+    coaching = format_coaching_markdown(tips)
+    if coaching:
+        lines.append(coaching)
+
+    lines.append("<!-- agentrepocoach -->")
+
+    return "\n".join(lines)
+
+
 def format_verbose(result: dict[str, Any]) -> str:
     """Return the summary plus a per-sub-component breakdown."""
     lines = [format_summary(result), "", "Sub-component breakdown:"]