claude-dev-env 8.72.2 → 8.73.0

package/scripts/tests/test_context_budget_check.py

@@ -0,0 +1,270 @@
+"""The context budget command checks explicit files against HEAD and keeps the list generated."""
+
+from __future__ import annotations
+
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import context_budget_check
+import pytest
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[4]
+SKILL_RELATIVE_PATH = "skills/example/SKILL.md"
+
+
+def _git(repository_root: Path, *all_arguments: str) -> None:
+    subprocess.run(
+        [
+            "git",
+            "-c",
+            "user.name=Test",
+            "-c",
+            "user.email=test@example.com",
+            *all_arguments,
+        ],
+        cwd=repository_root,
+        check=True,
+        capture_output=True,
+    )
+
+
+def _section(heading: str, detail_count: int) -> str:
+    return f"## {heading}\n" + "".join(
+        f"Detail line {each}.\n" for each in range(detail_count)
+    )
+
+
+@pytest.fixture
+def repository_root(tmp_path: Path) -> Path:
+    policy = {
+        "section_detail_line_limit": 6,
+        "kinds": [
+            {
+                "name": "skill entry",
+                "patterns": ["**/SKILL.md"],
+                "line_limit": 10,
+                "section_rule": True,
+            }
+        ],
+        "hooks": [],
+        "baseline": {
+            "files": {SKILL_RELATIVE_PATH: {"lines": 20, "sections": ["Plan"]}},
+            "hooks": {},
+        },
+    }
+    (tmp_path / ".claude").mkdir()
+    (tmp_path / ".claude" / "context-budget.json").write_text(
+        json.dumps(policy), encoding="utf-8"
+    )
+    skill_path = tmp_path / SKILL_RELATIVE_PATH
+    skill_path.parent.mkdir(parents=True)
+    skill_path.write_text(_section("Plan", 7) + "\n" * 12, encoding="utf-8")
+    _git(tmp_path, "init", "-q")
+    _git(tmp_path, "add", ".")
+    _git(tmp_path, "commit", "-q", "-m", "seed")
+    return tmp_path
+
+
+def _run(repository_root: Path, *all_arguments: str) -> tuple[int, str]:
+    stdout = io.StringIO()
+    exit_code = context_budget_check.main(list(all_arguments), repository_root, stdout)
+    return exit_code, stdout.getvalue()
+
+
+def test_an_unchanged_listed_file_is_ok(repository_root: Path) -> None:
+    exit_code, report_text = _run(
+        repository_root, str(repository_root / SKILL_RELATIVE_PATH)
+    )
+
+    assert exit_code == 0
+    assert "context-budget: OK (1 checked)" in report_text
+
+
+def test_head_is_the_prior_state_so_a_shrunk_listed_file_must_lower_its_entry(
+    repository_root: Path,
+) -> None:
+    (repository_root / SKILL_RELATIVE_PATH).write_text(
+        _section("Plan", 7) + "\n" * 4, encoding="utf-8"
+    )
+
+    exit_code, report_text = _run(
+        repository_root, str(repository_root / SKILL_RELATIVE_PATH)
+    )
+
+    assert exit_code == 1
+    assert '{"lines": 12, "sections": ["Plan"]}' in report_text
+
+
+def test_a_new_unpointed_section_is_reported(repository_root: Path) -> None:
+    skill_path = repository_root / SKILL_RELATIVE_PATH
+    skill_path.write_text(_section("Plan", 7) + _section("Steps", 7), encoding="utf-8")
+
+    exit_code, report_text = _run(repository_root, str(skill_path))
+
+    assert exit_code == 1
+    assert 'section "Steps" has 7 detail lines' in report_text
+
+
+def test_write_baseline_records_the_tree(repository_root: Path) -> None:
+    (repository_root / SKILL_RELATIVE_PATH).write_text(
+        _section("Plan", 7) + "\n" * 4, encoding="utf-8"
+    )
+
+    exit_code, report_text = _run(repository_root, "--write-baseline")
+
+    written = json.loads(
+        (repository_root / ".claude" / "context-budget.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert exit_code == 0 and "1 files" in report_text
+    assert written["baseline"]["files"] == {
+        SKILL_RELATIVE_PATH: {"lines": 12, "sections": ["Plan"]}
+    }
+
+
+def test_the_committed_baseline_matches_what_the_generator_builds_today() -> None:
+    policy = context_budget_check.read_policy_file(REPOSITORY_ROOT)
+    assert policy is not None
+    committed = json.loads(
+        (REPOSITORY_ROOT / ".claude" / "context-budget.json").read_text(
+            encoding="utf-8"
+        )
+    )
+
+    regenerated = context_budget_check.current_baseline(policy, REPOSITORY_ROOT)
+
+    assert regenerated == committed["baseline"]
+
+
+def _hook_policy(repository_root: Path, all_hook_specs: list[tuple[str, str]]) -> Path:
+    all_hooks = []
+    for index, (name, source_text) in enumerate(all_hook_specs):
+        hook_path = repository_root / f"fixture_hook_{index}.py"
+        hook_path.write_text(source_text, encoding="utf-8")
+        all_hooks.append(
+            {
+                "name": name,
+                "command": [sys.executable, str(hook_path)],
+                "stdin": {},
+                "char_limit": 1500,
+            }
+        )
+    policy_path = repository_root / ".claude" / "context-budget.json"
+    policy_path.write_text(
+        json.dumps(
+            {
+                "kinds": [],
+                "hooks": all_hooks,
+                "baseline": {"files": {}, "hooks": {"sample": 2200}},
+            }
+        ),
+        encoding="utf-8",
+    )
+    return policy_path
+
+
+def _hook_cli(repository_root: Path, action: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, context_budget_check.__file__, action],
+        cwd=repository_root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+@pytest.mark.parametrize("action", ["--hooks", "--write-baseline"])
+def test_duplicate_hook_names_fail_without_replacing_the_policy(
+    repository_root: Path,
+    action: str,
+) -> None:
+    policy_path = _hook_policy(
+        repository_root,
+        [
+            ("sample", "print('x' * 2100)\n"),
+            ("sample", "print('x')\n"),
+        ],
+    )
+    prior_text = policy_path.read_bytes()
+
+    completed = _hook_cli(repository_root, action)
+
+    assert completed.returncode == 1
+    assert "hook names must be unique" in completed.stdout
+    assert policy_path.read_bytes() == prior_text
+
+
+@pytest.mark.parametrize("action", ["--hooks", "--write-baseline"])
+@pytest.mark.parametrize(
+    "source_text",
+    [
+        "raise RuntimeError('fixture failure')\n",
+        "print('partial output')\nraise RuntimeError('fixture failure')\n",
+    ],
+)
+def test_failed_hook_measurement_fails_without_replacing_the_policy(
+    repository_root: Path,
+    action: str,
+    source_text: str,
+) -> None:
+    policy_path = _hook_policy(repository_root, [("sample", source_text)])
+    prior_text = policy_path.read_bytes()
+
+    completed = _hook_cli(repository_root, action)
+
+    assert completed.returncode == 1
+    assert 'hook "sample" exited with status 1' in completed.stdout
+    assert "fixture failure" in completed.stdout
+    assert policy_path.read_bytes() == prior_text
+
+
+def test_unique_hook_measurements_keep_each_count(repository_root: Path) -> None:
+    _hook_policy(
+        repository_root, [("sample", "print('x' * 2100)\n"), ("short", "print('x')\n")]
+    )
+
+    completed = _hook_cli(repository_root, "--hooks")
+
+    assert completed.returncode == 0
+    assert "sample: 2101 characters" in completed.stdout
+    assert "short: 2 characters" in completed.stdout
+
+
+def test_successful_empty_hook_can_remove_its_baseline(repository_root: Path) -> None:
+    policy_path = _hook_policy(repository_root, [("sample", "")])
+
+    completed = _hook_cli(repository_root, "--write-baseline")
+
+    assert completed.returncode == 0
+    assert (
+        json.loads(policy_path.read_text(encoding="utf-8"))["baseline"]["hooks"] == {}
+    )
+
+
+def test_successful_hook_baseline_preserves_its_count(repository_root: Path) -> None:
+    policy_path = _hook_policy(repository_root, [("sample", "print('x' * 2100)\n")])
+
+    completed = _hook_cli(repository_root, "--write-baseline")
+
+    assert completed.returncode == 0
+    assert json.loads(policy_path.read_text(encoding="utf-8"))["baseline"]["hooks"] == {
+        "sample": 2101
+    }
+
+
+def test_a_unique_unlisted_long_hook_still_exceeds_its_limit(
+    repository_root: Path,
+) -> None:
+    policy_path = _hook_policy(repository_root, [("sample", "print('x' * 2100)\n")])
+    raw_policy = json.loads(policy_path.read_text(encoding="utf-8"))
+    raw_policy["baseline"]["hooks"] = {}
+    policy_path.write_text(json.dumps(raw_policy), encoding="utf-8")
+
+    completed = _hook_cli(repository_root, "--hooks")
+
+    assert completed.returncode == 1
+    assert "injects 2101 characters (limit 1500)" in completed.stdout

package/scripts/tests/test_policy_lint_rules_context_budget.py

@@ -0,0 +1,218 @@
+"""The context-budget rules reach context Markdown and the policy file through the registry."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path, PurePosixPath
+
+import pytest
+
+from policy_lint import adapters, registry
+from policy_lint.engine import lint
+from policy_lint.model import ContentOrigin, Document, DocumentRule, LintRequest
+
+_SKILL_PATH = "tools/example/SKILL.md"
+_POLICY_PATH = ".claude/context-budget.json"
+
+
+def _policy(baseline_files: dict | None = None, line_limit: int = 200) -> dict:
+    return {
+        "section_detail_line_limit": 6,
+        "kinds": [
+            {
+                "name": "skill entry",
+                "patterns": ["**/SKILL.md"],
+                "line_limit": line_limit,
+                "section_rule": True,
+            }
+        ],
+        "hooks": [],
+        "baseline": {"files": baseline_files or {}, "hooks": {}},
+    }
+
+
+def _write_policy(repository_root: Path, raw_policy: dict) -> None:
+    (repository_root / ".claude").mkdir(exist_ok=True)
+    (repository_root / _POLICY_PATH).write_text(
+        json.dumps(raw_policy), encoding="utf-8"
+    )
+
+
+def _document(path: str, text: str, prior_text: str | None = None) -> Document:
+    return Document(PurePosixPath(path), text, prior_text, None, ContentOrigin.WORKTREE)
+
+
+def _section(heading: str, detail_count: int) -> str:
+    all_lines = [
+        f"## {heading}",
+        *(f"Detail line {each}." for each in range(detail_count)),
+    ]
+    return "\n".join(all_lines) + "\n"
+
+
+def _registered_rule(rule_id: str) -> DocumentRule:
+    for each_rule in registry.default_registry():
+        if each_rule.rule_id == rule_id and isinstance(each_rule, DocumentRule):
+            return each_rule
+    raise AssertionError(rule_id)
+
+
+def test_both_rules_are_registered_for_changed_and_repository_selections() -> None:
+    for each_rule_id in ("context-budget", "context-budget-policy"):
+        assert _registered_rule(each_rule_id).rule_sets == frozenset(
+            {"changed", "repository"}
+        )
+    assert _registered_rule("context-budget").accepts(_document(_SKILL_PATH, ""))
+    assert _registered_rule("context-budget-policy").accepts(
+        _document(_POLICY_PATH, "{}")
+    )
+    assert not _registered_rule("context-budget-policy").accepts(
+        _document("a/b.json", "{}")
+    )
+
+
+def test_an_unpointed_long_section_reports_with_its_fix(tmp_path: Path) -> None:
+    _write_policy(tmp_path, _policy())
+
+    all_diagnostics = adapters.context_budget_diagnostics(
+        _document(_SKILL_PATH, _section("Plan", 7)), tmp_path
+    )
+
+    assert [each.rule_id for each in all_diagnostics] == ["context-budget"]
+    assert (
+        'section "Plan" has 7 detail lines and no pointer (limit 6)'
+        in all_diagnostics[0].message
+    )
+    assert "reference/plan.md" in all_diagnostics[0].message
+
+
+def test_a_repository_without_a_policy_file_is_not_checked(tmp_path: Path) -> None:
+    assert (
+        adapters.context_budget_diagnostics(
+            _document(_SKILL_PATH, _section("Plan", 9)), tmp_path
+        )
+        == ()
+    )
+
+
+def test_a_changed_listed_file_below_its_record_must_lower_its_entry(
+    tmp_path: Path,
+) -> None:
+    prior_text = _section("Plan", 7) + "\n" * 10
+    _write_policy(
+        tmp_path, _policy({_SKILL_PATH: {"lines": 18, "sections": ["Plan"]}}, 10)
+    )
+
+    all_diagnostics = adapters.context_budget_diagnostics(
+        _document(_SKILL_PATH, _section("Plan", 7) + "\n" * 5, prior_text), tmp_path
+    )
+
+    assert len(all_diagnostics) == 1
+    assert '{"lines": 13, "sections": ["Plan"]}' in all_diagnostics[0].message
+
+
+def test_raising_a_baseline_entry_is_a_shrink_only_finding(tmp_path: Path) -> None:
+    prior_text = json.dumps(_policy({_SKILL_PATH: {"lines": 300, "sections": []}}))
+    current_text = json.dumps(_policy({_SKILL_PATH: {"lines": 310, "sections": []}}))
+
+    all_diagnostics = adapters.context_budget_policy_diagnostics(
+        _document(_POLICY_PATH, current_text, prior_text), tmp_path
+    )
+
+    assert [each.rule_id for each in all_diagnostics] == ["context-budget-policy"]
+    assert "the over-budget list may only shrink" in all_diagnostics[0].message
+
+
+def test_a_new_or_shrunk_policy_file_passes_and_a_malformed_one_reports(
+    tmp_path: Path,
+) -> None:
+    prior_text = json.dumps(_policy({_SKILL_PATH: {"lines": 300, "sections": []}}))
+    shrunk_text = json.dumps(_policy())
+
+    assert (
+        adapters.context_budget_policy_diagnostics(
+            _document(_POLICY_PATH, shrunk_text, prior_text), tmp_path
+        )
+        == ()
+    )
+    assert (
+        adapters.context_budget_policy_diagnostics(
+            _document(_POLICY_PATH, shrunk_text), tmp_path
+        )
+        == ()
+    )
+    malformed = adapters.context_budget_policy_diagnostics(
+        _document(_POLICY_PATH, "{broken"), tmp_path
+    )
+    assert "does not parse" in malformed[0].message
+
+
+def _git(repository_root: Path, *arguments: str) -> None:
+    environment = {
+        variable_name: variable_text
+        for variable_name, variable_text in os.environ.items()
+        if not variable_name.upper().startswith("GIT_")
+    }
+    subprocess.run(
+        ["git", "-c", "core.hooksPath=.git/fixture-hooks", *arguments],
+        cwd=repository_root, env=environment,
+        check=True, capture_output=True, text=True,
+    )
+
+
+def test_a_section_added_below_line_one_reports_in_a_base_selection(
+    tmp_path: Path,
+) -> None:
+    """A base selection keeps only diagnostics on changed lines, so a finding
+    pinned to an unchanged line 1 vanished from the pull request check."""
+    _git(tmp_path, "init", "--quiet", "-b", "main")
+    _git(tmp_path, "config", "user.name", "Budget Tests")
+    _git(tmp_path, "config", "user.email", "budget@example.invalid")
+    _git(tmp_path, "config", "commit.gpgsign", "false")
+    _write_policy(tmp_path, _policy())
+    skill_path = tmp_path / _SKILL_PATH
+    skill_path.parent.mkdir(parents=True)
+    skill_path.write_text("# Example\n\nShort map.\n", encoding="utf-8")
+    _git(tmp_path, "add", ".")
+    _git(tmp_path, "commit", "--quiet", "-m", "fixture")
+    with skill_path.open("a", encoding="utf-8") as skill_file:
+        skill_file.write("\n" + _section("Oversee", 9))
+    _git(tmp_path, "commit", "--quiet", "-am", "inline a long section")
+
+    report = lint(LintRequest.base(tmp_path, "HEAD~1"))
+
+    assert [
+        each.rule_id for each in report.diagnostics if each.rule_id == "context-budget"
+    ] == ["context-budget"]
+
+
+@pytest.mark.parametrize("selection", ["staged", "base"])
+@pytest.mark.parametrize("operation", ["delete", "rename"])
+def test_removing_the_policy_is_rejected_by_git_selection(
+    tmp_path: Path, selection: str, operation: str
+) -> None:
+    _git(tmp_path, "init", "--quiet", "-b", "main")
+    _git(tmp_path, "config", "user.name", "Budget Tests")
+    _git(tmp_path, "config", "user.email", "budget@example.invalid")
+    _git(tmp_path, "config", "commit.gpgsign", "false")
+    _write_policy(tmp_path, _policy())
+    _git(tmp_path, "add", ".")
+    _git(tmp_path, "commit", "--quiet", "-m", "fixture")
+    if operation == "delete":
+        _git(tmp_path, "rm", _POLICY_PATH)
+    else:
+        _git(tmp_path, "mv", _POLICY_PATH, ".claude/renamed-budget.json")
+    request = (
+        LintRequest.staged(tmp_path)
+        if selection == "staged"
+        else LintRequest.base(tmp_path, "HEAD")
+    )
+
+    report = lint(request)
+
+    findings = [each for each in report.diagnostics if each.rule_id == "context-budget-policy"]
+    assert len(findings) == 1
+    assert "policy file is removed" in findings[0].message
+    assert not report.failed_rules

package/scripts/tests/test_policy_lint_rules_pairing.py

@@ -594,3 +594,29 @@ def test_pairing_rejects_comment_rules_module_without_any_approved_suite(
 ) -> None:
     all_paths = _diagnostic_paths(tmp_path, _body_change_at(_COMMENT_RULES_PRODUCTION_PATH))
     assert all_paths == (_COMMENT_RULES_PRODUCTION_PATH,)
+
+
+def test_pairing_treats_test_support_modules_as_test_files(tmp_path: Path) -> None:
+    all_test_support_paths = (
+        PurePosixPath("packages/claude-dev-env/scripts/_code_review_test_support.py"),
+        PurePosixPath("packages/claude-dev-env/scripts/codec_forwarding_test_support.py"),
+    )
+    all_paths = _diagnostic_paths(
+        tmp_path,
+        *(_body_change_at(each_path) for each_path in all_test_support_paths),
+    )
+    assert all_paths == ()
+
+
+def test_pairing_rejects_a_module_beside_only_its_changed_test_support(
+    tmp_path: Path,
+) -> None:
+    production_path = PurePosixPath("packages/claude-dev-env/scripts/codec_forwarding.py")
+    all_paths = _diagnostic_paths(
+        tmp_path,
+        _body_change_at(production_path),
+        _body_change_at(
+            PurePosixPath("packages/claude-dev-env/scripts/codec_forwarding_test_support.py")
+        ),
+    )
+    assert all_paths == (production_path,)