agentrepocoach 0.2.0__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentrepocoach
-Version: 0.2.0
+Version: 0.3.1
 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
 ```
@@ -197,6 +203,3 @@ are safe to publish as CI artifacts.
 ## License
 
 Apache 2.0. See [LICENSE](LICENSE).
-
-Built using the [GSD](https://github.com/gsd-build/get-shit-done) workflow
-methodology (MIT).

{agentrepocoach-0.2.0 → agentrepocoach-0.3.1}/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
 ```
@@ -163,6 +169,3 @@ are safe to publish as CI artifacts.
 ## License
 
 Apache 2.0. See [LICENSE](LICENSE).
-
-Built using the [GSD](https://github.com/gsd-build/get-shit-done) workflow
-methodology (MIT).

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentrepocoach"
-version = "0.2.0"
+version = "0.3.1"
 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.1}/src/agentrepocoach/__init__.py

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

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

@@ -32,22 +32,62 @@ def get_adapter_by_name(name: str) -> LanguageAdapter:
     return _REGISTRY[name]()
 
 
-def detect_primary(repo_path: Path) -> LanguageAdapter:
-    """Try every adapter and return the one with the highest detect() confidence."""
+def _collect_candidates(repo_path: Path) -> list[tuple[float, LanguageAdapter]]:
+    """Collect all adapters with confidence > 0.0, sorted descending by (confidence, file_count)."""
     candidates: list[tuple[float, LanguageAdapter]] = []
     for cls in _REGISTRY.values():
         adapter = cls()
         confidence = adapter.detect(repo_path)
         if confidence > 0.0:
             candidates.append((confidence, adapter))
+    candidates.sort(
+        key=lambda pair: (pair[0], len(pair[1].find_production_files(repo_path))),
+        reverse=True,
+    )
+    return candidates
+
+
+def detect_primary(repo_path: Path) -> LanguageAdapter:
+    """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 = _collect_candidates(repo_path)
     if not candidates:
         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)
     return candidates[0][1]
 
 
+def detect_all(repo_path: Path) -> list[tuple[float, LanguageAdapter]]:
+    """Return all adapters that meet the detection threshold.
+
+    An adapter is included when ``confidence >= 0.5`` AND it has
+    ``file_count >= 3`` production files under ``repo_path``.  This filters
+    out repos where a language appears only as tooling sprinkles (e.g. a
+    single Makefile helper script in an otherwise Go repo).
+
+    Returns:
+        A list of ``(confidence, adapter)`` tuples, sorted descending by
+        ``(confidence, file_count)``.  Returns an empty list when no adapter
+        meets the threshold.
+    """
+    _CONFIDENCE_FLOOR = 0.5
+    _FILE_COUNT_FLOOR = 3
+
+    result: list[tuple[float, LanguageAdapter]] = []
+    for confidence, adapter in _collect_candidates(repo_path):
+        if confidence < _CONFIDENCE_FLOOR:
+            continue
+        if len(adapter.find_production_files(repo_path)) < _FILE_COUNT_FLOOR:
+            continue
+        result.append((confidence, adapter))
+    return result
+
+
 __all__ = [
     "CSharpAdapter",
     "Declaration",
@@ -59,6 +99,7 @@ __all__ = [
     "RustAdapter",
     "ThrowSite",
     "TypeScriptAdapter",
+    "detect_all",
     "detect_primary",
     "get_adapter_by_name",
 ]

{agentrepocoach-0.2.0 → agentrepocoach-0.3.1}/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.1}/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.1}/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.3.1/src/agentrepocoach/cli.py

@@ -0,0 +1,346 @@
+"""AgentRepoCoach CLI entry point."""
+from __future__ import annotations
+
+import argparse
+import json as _json
+import sys
+from pathlib import Path
+
+from . import VERSION
+from .adapters import NoAdapterError, _REGISTRY
+from .compute import compute_cah, compute_cah_all
+from .config import Config, 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:
+    """Build the argument parser for the ``agentrepocoach`` CLI."""
+    parser = argparse.ArgumentParser(
+        prog="agentrepocoach",
+        description="Compute the Codebase Agent Health (CAH) composite score for a repository.",
+    )
+    parser.add_argument(
+        "--repo",
+        type=Path,
+        default=None,
+        help="Path to the repository to score (default: current directory). "
+             "You may also pass the path as a positional argument: agentrepocoach [PATH].",
+    )
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=None,
+        help="Explicit config file path (default: <repo>/.agentrepocoach.toml).",
+    )
+    _adapter_names = "|".join(sorted(_REGISTRY)) + "|auto"
+    lang_group = parser.add_mutually_exclusive_group()
+    lang_group.add_argument(
+        "--language",
+        type=str,
+        default=None,
+        help=f"Override language detection ({_adapter_names}). Mutually exclusive with --all-languages.",
+    )
+    lang_group.add_argument(
+        "--all-languages",
+        action="store_true",
+        default=False,
+        dest="all_languages",
+        help="Score every detected language above threshold. Mutually exclusive with --language.",
+    )
+    parser.add_argument("--json", type=Path, help="Write full JSON result to this path.")
+    parser.add_argument("--prometheus", type=Path, help="Write Prometheus metrics to this path.")
+    parser.add_argument("--comment", type=Path, help="Write a PR-comment markdown file to this path.")
+    parser.add_argument(
+        "--format",
+        choices=["json", "markdown", "both"],
+        default=None,
+        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",
+        type=Path,
+        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()
+
+    # Pre-process argv to support positional path: `agentrepocoach .`
+    # If the first non-option argument is not a known subcommand and looks like
+    # a path (not starting with '-'), inject it as `--repo` so argparse handles
+    # the rest normally. This preserves full backward-compat with `--repo` and
+    # with subcommands like `compare`.
+    _argv = list(argv) if argv is not None else sys.argv[1:]
+    _known_subcommands = {"compare"}
+    _positional_path: Path | None = None
+    if _argv and not _argv[0].startswith("-") and _argv[0] not in _known_subcommands:
+        _positional_path = Path(_argv[0])
+        _argv = _argv[1:]
+
+    args = parser.parse_args(_argv)
+
+    # Dispatch subcommands
+    if args.subcommand == "compare":
+        return _run_compare(args)
+
+    # Resolve repo path: --repo wins over positional; default is cwd.
+    if args.repo is not None and _positional_path is not None:
+        print(
+            "notice: both --repo and positional PATH given; --repo takes precedence.",
+            file=sys.stderr,
+        )
+        resolved_repo = args.repo
+    elif args.repo is not None:
+        resolved_repo = args.repo
+    elif _positional_path is not None:
+        resolved_repo = _positional_path
+    else:
+        resolved_repo = Path.cwd()
+
+    repo_root = resolved_repo.resolve()
+    if not repo_root.is_dir():
+        print(f"error: repo path is not a directory: {repo_root}", file=sys.stderr)
+        return 2
+
+    try:
+        config = load_config(repo_root, config_path=args.config)
+    except ConfigError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    if args.language:
+        # Replace the config's language field. Dataclass is frozen -> rebuild.
+        from dataclasses import replace as _replace
+        config = _replace(config, language=args.language)
+
+    if args.all_languages:
+        return _run_all_languages(repo_root, config, args)
+
+    try:
+        result = compute_cah(repo_root, config=config)
+    except NoAdapterError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    # 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))
+    else:
+        print(format_summary(result))
+
+    if args.json:
+        write_json(result, args.json)
+        if not args.quiet:
+            print(f"\nJSON report written to {args.json}")
+
+    if args.prometheus:
+        write_prometheus(result, args.prometheus)
+        if not args.quiet:
+            print(f"Prometheus metrics written to {args.prometheus}")
+
+    if args.comment:
+        write_markdown_comment(result, args.comment)
+        if not args.quiet:
+            print(f"PR comment written to {args.comment}")
+
+    if args.format and args.output:
+        _write_formatted(result, args.format, args.output, quiet=args.quiet)
+    elif args.format and not args.output:
+        if args.format == "both":
+            print("error: --format both requires --output", file=sys.stderr)
+            return 2
+        _print_formatted(result, args.format)
+
+    return 0
+
+
+def _run_all_languages(
+    repo_root: Path,
+    config: Config,
+    args: argparse.Namespace,
+) -> int:
+    """Handle the --all-languages code path."""
+    try:
+        result = compute_cah_all(repo_root, config=config)
+    except (NoAdapterError, RuntimeError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    languages: dict = result.get("languages", {})
+
+    if not languages:
+        print("No language met the detection threshold (confidence >= 0.5, file count >= 3).", file=sys.stderr)
+        return 2
+
+    # Text output: one summary block per language, separated by a header line.
+    if not args.quiet:
+        first = True
+        for lang_name, lang_result in languages.items():
+            if not first:
+                print()
+            print(f"=== Language: {lang_name} ===")
+            print(format_summary(lang_result))
+            first = False
+
+    # JSON file output: write the nested multi-language shape.
+    if args.json:
+        write_json(result, args.json)
+        if not args.quiet:
+            print(f"\nJSON report written to {args.json}")
+
+    # --format json to stdout.
+    if args.format == "json" and not args.output:
+        print(render_json(result))
+    elif args.format == "json" and args.output:
+        write_json(result, args.output)
+        if not args.quiet:
+            print(f"\nJSON report written to {args.output}")
+
+    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,
+    output: Path,
+    *,
+    quiet: bool,
+) -> None:
+    """Dispatch --format/--output combinations to the underlying writers."""
+    if fmt == "json":
+        write_json(result, output)
+        if not quiet:
+            print(f"\nJSON report written to {output}")
+        return
+    if fmt == "markdown":
+        write_markdown_comment(result, output)
+        if not quiet:
+            print(f"\nMarkdown report written to {output}")
+        return
+    # fmt == "both"
+    json_path = output
+    markdown_path = output.with_suffix(".md")
+    write_json(result, json_path)
+    write_markdown_comment(result, markdown_path)
+    if not quiet:
+        print(f"\nJSON report written to {json_path}")
+        print(f"Markdown report written to {markdown_path}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{agentrepocoach-0.2.0 → agentrepocoach-0.3.1}/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.1}/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.1}/src/agentrepocoach/compute.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
-from .adapters import LanguageAdapter, detect_primary, get_adapter_by_name
+from .adapters import LanguageAdapter, detect_all, detect_primary, get_adapter_by_name
 from .components import (
     compute_decision_queryability,
     compute_error_quality,
@@ -82,3 +82,59 @@ def _pick_adapter(repo_root: Path, config: Config) -> LanguageAdapter:
     if config.language and config.language != "auto":
         return get_adapter_by_name(config.language)
     return detect_primary(repo_root)
+
+
+# Schema version for the multi-language output shape.
+_MULTI_LANGUAGE_SCHEMA_VERSION = 2
+
+
+def compute_cah_all(repo_root: Path, config: Config | None = None) -> dict[str, Any]:
+    """Compute CAH scores for every language that meets the detection threshold.
+
+    Uses ``detect_all()`` to find adapters with ``confidence >= 0.5`` AND
+    ``file_count >= 3``, then calls ``compute_cah()`` once per adapter.
+
+    The returned dict uses a nested shape distinct from the single-language
+    shape so downstream consumers can distinguish the two without ambiguity:
+
+    .. code-block:: json
+
+        {
+            "schema_version": 2,
+            "generator": "agentrepocoach <version>",
+            "languages": {
+                "python": {"total": 72.4, "components": {...}, "language": "python"},
+                "typescript": {"total": 61.2, "components": {...}, "language": "typescript"}
+            }
+        }
+
+    Note: the top-level ``"total"`` and ``"language"`` keys are intentionally
+    **absent** — use the per-language sub-dicts for those values.
+
+    Args:
+        repo_root: Path to the repository to score.
+        config: Optional explicit config. If None, loads from
+            ``<repo_root>/.agentrepocoach.toml`` with defaults.
+
+    Returns:
+        Multi-language result dict as described above.  ``"languages"`` is
+        empty when no adapter meets the threshold.
+    """
+    from . import VERSION  # local import to avoid circular reference
+
+    repo_root = repo_root.resolve()
+    if config is None:
+        config = load_config(repo_root)
+
+    adapters = detect_all(repo_root)
+
+    per_language: dict[str, Any] = {}
+    for _confidence, adapter in adapters:
+        lang_result = compute_cah(repo_root, config=config, adapter=adapter)
+        per_language[adapter.name] = lang_result
+
+    return {
+        "schema_version": _MULTI_LANGUAGE_SCHEMA_VERSION,
+        "generator": f"{_GENERATOR_NAME} {VERSION}",
+        "languages": per_language,
+    }