agentrepocoach 0.3.0__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentrepocoach
-Version: 0.3.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
@@ -203,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.3.0 → agentrepocoach-0.3.1}/README.md

@@ -169,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.3.0 → agentrepocoach-0.3.1}/pyproject.toml

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

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

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

@@ -32,6 +32,21 @@ def get_adapter_by_name(name: str) -> LanguageAdapter:
     return _REGISTRY[name]()
 
 
+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.
 
@@ -39,25 +54,40 @@ def detect_primary(repo_path: Path) -> LanguageAdapter:
     ``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()
-        confidence = adapter.detect(repo_path)
-        if confidence > 0.0:
-            candidates.append((confidence, adapter))
+    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.")
-    # 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]
 
 
+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",
@@ -69,6 +99,7 @@ __all__ = [
     "RustAdapter",
     "ThrowSite",
     "TypeScriptAdapter",
+    "detect_all",
     "detect_primary",
     "get_adapter_by_name",
 ]

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

@@ -7,9 +7,9 @@ import sys
 from pathlib import Path
 
 from . import VERSION
-from .adapters import NoAdapterError
-from .compute import compute_cah
-from .config import ConfigError, load_config
+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,
@@ -33,8 +33,9 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--repo",
         type=Path,
-        default=Path.cwd(),
-        help="Path to the repository to score (default: current directory).",
+        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",
@@ -42,11 +43,20 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="Explicit config file path (default: <repo>/.agentrepocoach.toml).",
     )
-    parser.add_argument(
+    _adapter_names = "|".join(sorted(_REGISTRY)) + "|auto"
+    lang_group = parser.add_mutually_exclusive_group()
+    lang_group.add_argument(
         "--language",
         type=str,
         default=None,
-        help="Override language detection (csharp|python|auto).",
+        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.")
@@ -142,13 +152,40 @@ def _run_compare(args: argparse.Namespace) -> int:
 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)
+
+    # 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)
 
-    repo_root = args.repo.resolve()
+    # 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
@@ -164,6 +201,9 @@ def main(argv: list[str] | None = None) -> int:
         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:
@@ -221,6 +261,51 @@ def main(argv: list[str] | None = None) -> int:
     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":

{agentrepocoach-0.3.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,
+    }

{agentrepocoach-0.3.0 → agentrepocoach-0.3.1}/src/agentrepocoach.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentrepocoach
-Version: 0.3.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
@@ -203,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.3.0 → agentrepocoach-0.3.1}/src/agentrepocoach.egg-info/SOURCES.txt

@@ -30,9 +30,11 @@ src/agentrepocoach/components/error_quality.py
 src/agentrepocoach/components/module_hygiene.py
 src/agentrepocoach/components/test_quality.py
 tests/test_adapters.py
+tests/test_cli.py
 tests/test_cli_compare.py
 tests/test_components.py
 tests/test_config.py
+tests/test_multi_language.py
 tests/test_output.py
 tests/test_pr_bot.py
 tests/test_regex_safety.py

agentrepocoach-0.3.1/tests/test_cli.py

@@ -0,0 +1,108 @@
+"""Tests for v0.3.1 release-integrity fixes.
+
+AC-01: --all-languages flag exists in --help output
+AC-02: --language help text lists all registered adapters
+AC-03: agentrepocoach <positional-path> works without --repo
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from agentrepocoach.cli import main
+
+
+FIXTURES_ROOT = Path(__file__).parent / "fixtures"
+
+
+class TestAllLanguagesFlagExists:
+    """AC-01: --all-languages flag must appear in --help output."""
+
+    def test_all_languages_flag_exists(self) -> None:
+        """Invoke --help via subprocess and assert --all-languages is listed."""
+        result = subprocess.run(
+            [sys.executable, "-m", "agentrepocoach", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "--all-languages" in result.stdout
+
+
+class TestLanguageHelpListsAllAdapters:
+    """AC-02: --language help text must list all registered adapter names."""
+
+    def test_language_help_lists_all_adapters(self) -> None:
+        """Invoke --help, assert each adapter name appears in --language help text."""
+        result = subprocess.run(
+            [sys.executable, "-m", "agentrepocoach", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        stdout = result.stdout
+        # All five adapter names must appear in the help output
+        for adapter_name in ("csharp", "go", "python", "rust", "typescript"):
+            assert adapter_name in stdout, (
+                f"Adapter '{adapter_name}' missing from --help output. "
+                f"Full stdout:\n{stdout}"
+            )
+
+
+class TestPositionalPathArgument:
+    """AC-03: agentrepocoach <path> (positional) must succeed and produce a score."""
+
+    def test_positional_path_argument(self, capsys: pytest.CaptureFixture[str]) -> None:
+        """Invoke main with positional path (no --repo), assert exit 0 and score produced."""
+        python_repo = FIXTURES_ROOT / "sample-python-repo"
+        mock_result = {
+            "total": 72.00,
+            "language": "python",
+            "weights": {"navigability": 0.20},
+            "components": {
+                "navigability": {"score": 72.0, "breakdown": {}},
+            },
+        }
+        with patch("agentrepocoach.cli.compute_cah", return_value=mock_result):
+            rc = main([str(python_repo)])
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "72.00" in out
+
+    def test_positional_path_dot_uses_cwd(self, capsys: pytest.CaptureFixture[str]) -> None:
+        """agentrepocoach . should resolve to cwd without error."""
+        mock_result = {
+            "total": 65.00,
+            "language": "python",
+            "weights": {"navigability": 0.20},
+            "components": {
+                "navigability": {"score": 65.0, "breakdown": {}},
+            },
+        }
+        with patch("agentrepocoach.cli.compute_cah", return_value=mock_result):
+            rc = main(["."])
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "65.00" in out
+
+    def test_repo_flag_wins_over_positional(self, capsys: pytest.CaptureFixture[str]) -> None:
+        """When both --repo and positional are given, --repo wins and a notice is printed."""
+        python_repo = FIXTURES_ROOT / "sample-python-repo"
+        mock_result = {
+            "total": 80.00,
+            "language": "python",
+            "weights": {"navigability": 0.20},
+            "components": {
+                "navigability": {"score": 80.0, "breakdown": {}},
+            },
+        }
+        with patch("agentrepocoach.cli.compute_cah", return_value=mock_result):
+            rc = main([str(python_repo), "--repo", str(python_repo)])
+        assert rc == 0
+        captured = capsys.readouterr()
+        # --repo takes precedence; notice on stderr
+        assert "takes precedence" in captured.err or "notice" in captured.err

agentrepocoach-0.3.1/tests/test_multi_language.py

@@ -0,0 +1,197 @@
+"""Tests for multi-language scoring (detect_all, compute_cah_all, --all-languages flag).
+
+Coverage maps to XPL-003-MVP acceptance criteria:
+- AC-1: Threshold logic edge cases (confidence and file_count boundaries)
+- AC-2: detect_all() positive — mixed-language fixture
+- AC-3: detect_all() empty — nothing meets threshold
+- AC-4: compute_cah_all() JSON shape contract
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Generator
+from unittest.mock import patch
+
+import pytest
+
+from agentrepocoach.adapters import LanguageAdapter, PythonAdapter, detect_all
+from agentrepocoach.compute import compute_cah_all, _MULTI_LANGUAGE_SCHEMA_VERSION
+
+
+# ---------------------------------------------------------------------------
+# Helpers / mini-fixtures
+# ---------------------------------------------------------------------------
+
+
+def _make_python_repo(root: Path, file_count: int) -> Path:
+    """Scaffold a minimal Python repo with ``file_count`` .py source files."""
+    src = root / "src"
+    src.mkdir(parents=True)
+    (root / "pyproject.toml").write_text("[project]\nname = 'test'\n")
+    for i in range(file_count):
+        (src / f"module_{i}.py").write_text(f"def func_{i}(): pass\n")
+    return root
+
+
+# ---------------------------------------------------------------------------
+# AC-1: Threshold logic edge cases
+# ---------------------------------------------------------------------------
+
+
+class TestDetectAllThresholdEdgeCases:
+    """Confidence and file_count boundary conditions (AC-1)."""
+
+    def test_confidence_below_floor_excluded(self, tmp_path: Path) -> None:
+        """Adapter with confidence=0.49 must be excluded."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=5)
+        adapter = PythonAdapter()
+        with patch.object(type(adapter), "detect", return_value=0.49):
+            with patch("agentrepocoach.adapters._REGISTRY", {"python": lambda: adapter}):
+                result = detect_all(repo)
+        assert result == []
+
+    def test_confidence_at_floor_included(self, tmp_path: Path) -> None:
+        """Adapter with confidence=0.50 and file_count>=3 must be included."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=5)
+        adapter = PythonAdapter()
+        with patch.object(type(adapter), "detect", return_value=0.50):
+            with patch("agentrepocoach.adapters._REGISTRY", {"python": lambda: adapter}):
+                result = detect_all(repo)
+        assert len(result) == 1
+        assert result[0][0] == pytest.approx(0.50)
+
+    def test_file_count_below_floor_excluded(self, tmp_path: Path) -> None:
+        """Adapter with file_count=2 (< 3) must be excluded even at confidence=1.0."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=2)
+        # PythonAdapter.detect() will return 1.0 (pyproject.toml present)
+        # but only 2 production files exist → excluded
+        result = detect_all(repo)
+        assert result == []
+
+    def test_file_count_at_floor_included(self, tmp_path: Path) -> None:
+        """Adapter with file_count=3 and confidence>=0.5 must be included."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=3)
+        result = detect_all(repo)
+        assert len(result) == 1
+        assert result[0][1].name == "python"
+
+
+# ---------------------------------------------------------------------------
+# AC-2: detect_all() positive — multiple languages above threshold
+# ---------------------------------------------------------------------------
+
+
+class TestDetectAllPositive:
+    """detect_all() returns multiple adapters when the repo is multi-language (AC-2)."""
+
+    def test_detect_all_returns_multiple_adapters(self, tmp_path: Path) -> None:
+        """A repo with Python AND Go source files above threshold returns both adapters.
+
+        PythonAdapter.find_production_files() looks in ``src/`` or ``lib/`` dirs.
+        GoAdapter.find_production_files() looks for ``*.go`` files.
+        """
+        repo = tmp_path / "mixed"
+        repo.mkdir()
+
+        # Python side: pyproject.toml + 3 .py files under src/
+        (repo / "pyproject.toml").write_text("[project]\nname = 'mixed'\n")
+        py_src = repo / "src"
+        py_src.mkdir()
+        for i in range(3):
+            (py_src / f"module_{i}.py").write_text(f"def func_{i}(): pass\n")
+
+        # Go side: go.mod + 3 .go files
+        (repo / "go.mod").write_text("module example.com/mixed\ngo 1.21\n")
+        go_src = repo / "go_src"
+        go_src.mkdir()
+        for i in range(3):
+            (go_src / f"pkg{i}.go").write_text(f"package main\nfunc F{i}() {{}}\n")
+
+        result = detect_all(repo)
+        adapter_names = {adapter.name for _, adapter in result}
+        assert "python" in adapter_names
+        assert "go" in adapter_names
+
+    def test_detect_all_sorted_by_confidence_descending(self, tmp_path: Path) -> None:
+        """Results are sorted confidence-descending."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=5)
+        result = detect_all(repo)
+        # At least one result (python) must be present
+        assert result
+        confidences = [c for c, _ in result]
+        assert confidences == sorted(confidences, reverse=True)
+
+
+# ---------------------------------------------------------------------------
+# AC-3: detect_all() empty — no language meets threshold
+# ---------------------------------------------------------------------------
+
+
+class TestDetectAllEmpty:
+    """detect_all() returns [] when nothing meets the detection threshold (AC-3)."""
+
+    def test_empty_repo_returns_empty_list(self, tmp_path: Path) -> None:
+        """A repo with no recognised language files returns []."""
+        empty = tmp_path / "empty"
+        empty.mkdir()
+        result = detect_all(empty)
+        assert result == []
+
+    def test_below_file_count_threshold_returns_empty_list(self, tmp_path: Path) -> None:
+        """A Python repo with only 2 production files (< 3) returns []."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=2)
+        result = detect_all(repo)
+        assert result == []
+
+
+# ---------------------------------------------------------------------------
+# AC-4: compute_cah_all() JSON shape contract
+# ---------------------------------------------------------------------------
+
+
+class TestComputeCahAllShape:
+    """compute_cah_all() output shape: no top-level total/language, nested languages dict (AC-4)."""
+
+    def test_no_top_level_total(self, tmp_path: Path) -> None:
+        """Top-level 'total' key must be absent from multi-language output."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=3)
+        result = compute_cah_all(repo)
+        assert "total" not in result
+
+    def test_no_top_level_language(self, tmp_path: Path) -> None:
+        """Top-level 'language' key must be absent from multi-language output."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=3)
+        result = compute_cah_all(repo)
+        assert "language" not in result
+
+    def test_languages_dict_present(self, tmp_path: Path) -> None:
+        """Top-level 'languages' dict is present and non-empty for a qualifying repo."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=3)
+        result = compute_cah_all(repo)
+        assert "languages" in result
+        assert isinstance(result["languages"], dict)
+        assert len(result["languages"]) >= 1
+
+    def test_languages_sub_shape(self, tmp_path: Path) -> None:
+        """Each language entry has 'total' and 'language' sub-keys."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=3)
+        result = compute_cah_all(repo)
+        for lang_name, lang_result in result["languages"].items():
+            assert "total" in lang_result, f"{lang_name} missing 'total'"
+            assert "language" in lang_result, f"{lang_name} missing 'language'"
+            assert lang_result["language"] == lang_name
+
+    def test_schema_version_is_bumped(self, tmp_path: Path) -> None:
+        """schema_version must be the multi-language version (2), not the v0.3 value (1)."""
+        repo = _make_python_repo(tmp_path / "repo", file_count=3)
+        result = compute_cah_all(repo)
+        assert result["schema_version"] == _MULTI_LANGUAGE_SCHEMA_VERSION
+        assert result["schema_version"] == 2
+
+    def test_empty_repo_returns_empty_languages(self, tmp_path: Path) -> None:
+        """When no language meets threshold, 'languages' is an empty dict."""
+        empty = tmp_path / "empty"
+        empty.mkdir()
+        result = compute_cah_all(empty)
+        assert result["languages"] == {}
+        assert "total" not in result