claude-dev-env 8.11.0 → 8.12.0

package/.agents/skills/e-code-review/scripts/test_finding_pipeline.py

@@ -1,197 +0,0 @@
-"""Red fixtures: low-severity findings survive collection; filter is separate."""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-import pytest
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from e_code_review_scripts_constants.finding_pipeline_constants import (
-    ALL_COLLECTION_SEVERITIES,
-    COLLECTION_STAGE_NAME,
-    FILTER_STAGE_NAME,
-    FINDING_FIELD_CATEGORY,
-    FINDING_FIELD_EVIDENCE,
-    FINDING_FIELD_FILE,
-    FINDING_FIELD_LINE,
-    FINDING_FIELD_SEVERITY,
-    REPORT_EVERY_FINDING_INSTRUCTION,
-    SEVERITY_BLOCKER,
-    SEVERITY_HIGH,
-    SEVERITY_LOW,
-    SEVERITY_MEDIUM,
-    SEVERITY_NIT,
-)
-from finding_pipeline import (
-    CollectedFinding,
-    FindingCollection,
-    collect_findings,
-    filter_findings_by_severity,
-)
-
-
-def _seeded_findings() -> list[CollectedFinding]:
-    return [
-        CollectedFinding(
-            file_path="pkg/a.py",
-            line_number=10,
-            severity=SEVERITY_BLOCKER,
-            category="correctness",
-            evidence="raises on empty input",
-        ),
-        CollectedFinding(
-            file_path="pkg/b.py",
-            line_number=20,
-            severity=SEVERITY_HIGH,
-            category="security",
-            evidence="shell=True with user text",
-        ),
-        CollectedFinding(
-            file_path="pkg/c.py",
-            line_number=30,
-            severity=SEVERITY_MEDIUM,
-            category="api-contracts",
-            evidence="return type narrowed",
-        ),
-        CollectedFinding(
-            file_path="pkg/d.py",
-            line_number=40,
-            severity=SEVERITY_LOW,
-            category="simplification",
-            evidence="duplicated helper body",
-        ),
-        CollectedFinding(
-            file_path="pkg/e.py",
-            line_number=50,
-            severity=SEVERITY_NIT,
-            category="conventions",
-            evidence="typo in comment",
-        ),
-    ]
-
-
-def test_collection_retains_every_seeded_severity_including_low_and_nit() -> None:
-    all_seeded = _seeded_findings()
-    collection = collect_findings(all_seeded)
-
-    assert collection.stage_name == COLLECTION_STAGE_NAME
-    all_severities = {
-        each.severity for each in collection.all_findings
-    }
-    assert all_severities == set(ALL_COLLECTION_SEVERITIES)
-    assert len(collection.all_findings) == len(all_seeded)
-    low_finding = next(
-        each for each in collection.all_findings if each.severity == SEVERITY_LOW
-    )
-    assert low_finding.file_path == "pkg/d.py"
-    assert low_finding.line_number == 40
-    assert low_finding.evidence == "duplicated helper body"
-    assert low_finding.category == "simplification"
-
-
-def test_each_collected_finding_keeps_file_line_evidence_and_category() -> None:
-    collection = collect_findings(_seeded_findings())
-    for each_finding in collection.all_findings:
-        as_mapping = each_finding.as_mapping()
-        assert as_mapping[FINDING_FIELD_FILE]
-        assert as_mapping[FINDING_FIELD_LINE] > 0
-        assert as_mapping[FINDING_FIELD_EVIDENCE]
-        assert as_mapping[FINDING_FIELD_CATEGORY]
-        assert as_mapping[FINDING_FIELD_SEVERITY] in ALL_COLLECTION_SEVERITIES
-
-
-def test_filter_is_explicit_later_stage_and_does_not_mutate_collection() -> None:
-    collection = collect_findings(_seeded_findings())
-    collected_snapshot = [
-        (
-            each.file_path,
-            each.line_number,
-            each.severity,
-            each.category,
-            each.evidence,
-        )
-        for each in collection.all_findings
-    ]
-
-    filtered = filter_findings_by_severity(
-        collection,
-        minimum_severity=SEVERITY_MEDIUM,
-    )
-
-    assert filtered.stage_name == FILTER_STAGE_NAME
-    all_filtered_severities = {each.severity for each in filtered.all_findings}
-    assert SEVERITY_LOW not in all_filtered_severities
-    assert SEVERITY_NIT not in all_filtered_severities
-    assert SEVERITY_MEDIUM in all_filtered_severities
-    assert SEVERITY_BLOCKER in all_filtered_severities
-
-    after_filter_snapshot = [
-        (
-            each.file_path,
-            each.line_number,
-            each.severity,
-            each.category,
-            each.evidence,
-        )
-        for each in collection.all_findings
-    ]
-    assert after_filter_snapshot == collected_snapshot
-    assert len(collection.all_findings) == 5
-
-
-def test_filter_rejects_unknown_minimum_severity() -> None:
-    collection = collect_findings(_seeded_findings())
-    with pytest.raises(ValueError, match="unknown minimum severity"):
-        filter_findings_by_severity(collection, minimum_severity="P1")
-
-
-def test_filter_rejects_unknown_finding_severity_with_value_error() -> None:
-    collection = FindingCollection(
-        stage_name=COLLECTION_STAGE_NAME,
-        all_findings=(
-            CollectedFinding(
-                file_path="pkg/x.py",
-                line_number=1,
-                severity="P0",
-                category="correctness",
-                evidence="bypass collect",
-            ),
-        ),
-    )
-    with pytest.raises(ValueError, match="unknown collection severity"):
-        filter_findings_by_severity(collection, minimum_severity=SEVERITY_LOW)
-
-
-def test_collect_rejects_finding_missing_required_fields() -> None:
-    with pytest.raises(ValueError, match="file"):
-        collect_findings(
-            [
-                CollectedFinding(
-                    file_path="",
-                    line_number=1,
-                    severity=SEVERITY_LOW,
-                    category="correctness",
-                    evidence="x",
-                )
-            ]
-        )
-
-
-def test_report_every_finding_instruction_names_all_severities() -> None:
-    for each_severity in ALL_COLLECTION_SEVERITIES:
-        assert each_severity in REPORT_EVERY_FINDING_INSTRUCTION
-    assert "consumer stage" in REPORT_EVERY_FINDING_INSTRUCTION
-    assert "Do not drop findings by severity during collection" in (
-        REPORT_EVERY_FINDING_INSTRUCTION
-    )
-
-
-def test_collection_record_type_is_immutable() -> None:
-    collection = collect_findings(_seeded_findings())
-    assert isinstance(collection, FindingCollection)
-    assert collection.stage_name == COLLECTION_STAGE_NAME

package/.agents/skills/e-code-review/scripts/test_grok_code_review.py

@@ -1,289 +0,0 @@
-"""Behavioral tests for Grok medium-review discovery and verification."""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-import pytest
-
-_SCRIPTS = Path(__file__).resolve().parent
-if str(_SCRIPTS) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS))
-
-from e_code_review_scripts_constants.grok_code_review_constants import (  # noqa: E402
-    ALL_MEDIUM_FINDER_ANGLES,
-    MEDIUM_REVIEW_FINDER_COUNT,
-    VERDICT_CONFIRMED,
-    VERDICT_PLAUSIBLE,
-    VERDICT_REFUTED,
-)
-from grok_code_review import (  # noqa: E402
-    FinderCandidate,
-    deduplicate_candidates,
-    require_exact_finder_set,
-    retain_verified_findings,
-    run_medium_review,
-)
-
-
-def _candidate(
-    angle: str,
-    *,
-    file_path: str = "a.py",
-    line_number: int = 1,
-    mechanism: str = "m",
-    scenario: str = "short",
-    suffix: str = "",
-    head: str = "head1",
-) -> FinderCandidate:
-    token = suffix or angle
-    return FinderCandidate(
-        angle=angle,
-        file_path=file_path,
-        line_number=line_number,
-        mechanism=mechanism,
-        scenario=scenario,
-        worktree_path=f"/wt/{token}",
-        leader_socket=f"sock-{token}",
-        advisor_session_id=f"adv-{token}",
-        reviewed_head=head,
-    )
-
-
-def test_require_exact_finder_set_accepts_all_angles() -> None:
-    require_exact_finder_set(ALL_MEDIUM_FINDER_ANGLES)
-    with pytest.raises(ValueError):
-        require_exact_finder_set(ALL_MEDIUM_FINDER_ANGLES[:-1])
-
-
-def test_deduplicate_keeps_most_concrete_scenario() -> None:
-    short = _candidate("correctness", scenario="short")
-    long = _candidate("security", scenario="much more concrete failure path")
-    # same key different angles - force same file/line/mech
-    short = FinderCandidate(
-        angle="correctness",
-        file_path="a.py",
-        line_number=3,
-        mechanism="null",
-        scenario="x",
-        worktree_path="/wt/a",
-        leader_socket="s1",
-        advisor_session_id="a1",
-        reviewed_head="h",
-    )
-    long = FinderCandidate(
-        angle="security",
-        file_path="a.py",
-        line_number=3,
-        mechanism="null",
-        scenario="concrete long scenario",
-        worktree_path="/wt/b",
-        leader_socket="s2",
-        advisor_session_id="a2",
-        reviewed_head="h",
-    )
-    kept = deduplicate_candidates([short, long])
-    assert len(kept) == 1
-    assert kept[0].scenario == "concrete long scenario"
-
-
-def test_run_medium_review_happy_path() -> None:
-    head = "abc123"
-    all_finders = [
-        _candidate(each_angle, head=head, suffix=each_angle)
-        for each_angle in ALL_MEDIUM_FINDER_ANGLES
-    ]
-    # make unique keys per angle
-    all_finders = [
-        FinderCandidate(
-            angle=each_angle,
-            file_path=f"{each_angle}.py",
-            line_number=1,
-            mechanism="m",
-            scenario=f"scenario {each_angle}",
-            worktree_path=f"/wt/{each_angle}",
-            leader_socket=f"sock-{each_angle}",
-            advisor_session_id=f"adv-{each_angle}",
-            reviewed_head=head,
-        )
-        for each_angle in ALL_MEDIUM_FINDER_ANGLES
-    ]
-    verdicts = {
-        (f"{each}.py", 1, "m"): VERDICT_CONFIRMED
-        for each in ALL_MEDIUM_FINDER_ANGLES
-    }
-    severities = {
-        (f"{each}.py", 1, "m"): "medium" for each in ALL_MEDIUM_FINDER_ANGLES
-    }
-    # refute one
-    first = ALL_MEDIUM_FINDER_ANGLES[0]
-    verdicts[(f"{first}.py", 1, "m")] = VERDICT_REFUTED
-    batch = run_medium_review(
-        target_head=head,
-        diff_base="base",
-        all_finder_candidates=all_finders,
-        verdict_by_key=verdicts,
-        severity_by_key=severities,
-        live_head=head,
-    )
-    assert batch.is_rejected is False
-    assert len(batch.all_finder_angles) == MEDIUM_REVIEW_FINDER_COUNT
-    assert all(each.reviewed_head == head for each in batch.all_retained_findings)
-    assert all(each.verdict in {VERDICT_CONFIRMED, VERDICT_PLAUSIBLE} for each in batch.all_retained_findings)
-    assert len(batch.all_retained_findings) == MEDIUM_REVIEW_FINDER_COUNT - 1
-
-
-def _one_candidate_per_angle(head: str) -> list[FinderCandidate]:
-    return [
-        FinderCandidate(
-            angle=each_angle,
-            file_path=f"{each_angle}.py",
-            line_number=1,
-            mechanism="m",
-            scenario=f"scenario {each_angle}",
-            worktree_path=f"/wt/{each_angle}",
-            leader_socket=f"sock-{each_angle}",
-            advisor_session_id=f"adv-{each_angle}",
-            reviewed_head=head,
-        )
-        for each_angle in ALL_MEDIUM_FINDER_ANGLES
-    ]
-
-
-def test_a_finder_reporting_several_candidates_is_not_a_identity_clash() -> None:
-    head = "abc123"
-    all_finders = _one_candidate_per_angle(head)
-    first = all_finders[0]
-    second_from_first_finder = FinderCandidate(
-        angle=first.angle,
-        file_path="second.py",
-        line_number=9,
-        mechanism="m",
-        scenario="a second finding from the same finder",
-        worktree_path=first.worktree_path,
-        leader_socket=first.leader_socket,
-        advisor_session_id=first.advisor_session_id,
-        reviewed_head=head,
-    )
-    all_finders.append(second_from_first_finder)
-    all_keys = [
-        (each.file_path, each.line_number, each.mechanism) for each in all_finders
-    ]
-    batch = run_medium_review(
-        target_head=head,
-        diff_base="base",
-        all_finder_candidates=all_finders,
-        verdict_by_key={each_key: VERDICT_CONFIRMED for each_key in all_keys},
-        severity_by_key={each_key: "medium" for each_key in all_keys},
-        live_head=head,
-    )
-    assert batch.is_rejected is False
-    assert batch.rejection_reason is None
-    assert len(batch.all_retained_findings) == len(all_finders)
-
-
-def test_two_finders_sharing_one_socket_reject_the_batch() -> None:
-    head = "abc123"
-    all_finders = _one_candidate_per_angle(head)
-    first = all_finders[0]
-    second = all_finders[1]
-    all_finders[1] = FinderCandidate(
-        angle=second.angle,
-        file_path=second.file_path,
-        line_number=second.line_number,
-        mechanism=second.mechanism,
-        scenario=second.scenario,
-        worktree_path=second.worktree_path,
-        leader_socket=first.leader_socket,
-        advisor_session_id=second.advisor_session_id,
-        reviewed_head=head,
-    )
-    batch = run_medium_review(
-        target_head=head,
-        diff_base="base",
-        all_finder_candidates=all_finders,
-        verdict_by_key={},
-        severity_by_key={},
-        live_head=head,
-    )
-    assert batch.is_rejected is True
-    assert batch.rejection_reason == "non_unique_finder_identity"
-
-
-def test_head_drift_rejects_batch() -> None:
-    head = "h1"
-    all_finders = [
-        FinderCandidate(
-            angle=each_angle,
-            file_path=f"{each_angle}.py",
-            line_number=1,
-            mechanism="m",
-            scenario="s",
-            worktree_path=f"/wt/{each_angle}",
-            leader_socket=f"sock-{each_angle}",
-            advisor_session_id=f"adv-{each_angle}",
-            reviewed_head=head,
-        )
-        for each_angle in ALL_MEDIUM_FINDER_ANGLES
-    ]
-    batch = run_medium_review(
-        target_head=head,
-        diff_base="b",
-        all_finder_candidates=all_finders,
-        verdict_by_key={},
-        severity_by_key={},
-        live_head="other",
-    )
-    assert batch.is_rejected is True
-    assert batch.rejection_reason == "head_drift"
-
-
-def test_advisor_blocked_rejects_batch() -> None:
-    head = "h1"
-    all_finders = [
-        FinderCandidate(
-            angle=each_angle,
-            file_path=f"{each_angle}.py",
-            line_number=1,
-            mechanism="m",
-            scenario="s",
-            worktree_path=f"/wt/{each_angle}",
-            leader_socket=f"sock-{each_angle}",
-            advisor_session_id=f"adv-{each_angle}",
-            reviewed_head=head,
-        )
-        for each_angle in ALL_MEDIUM_FINDER_ANGLES
-    ]
-    batch = run_medium_review(
-        target_head=head,
-        diff_base="b",
-        all_finder_candidates=all_finders,
-        verdict_by_key={},
-        severity_by_key={},
-        live_head=head,
-        is_any_advisor_blocked=True,
-    )
-    assert batch.is_rejected is True
-    assert batch.rejection_reason == "advisor_blocked"
-
-
-def test_retain_verified_findings_keeps_confirmed() -> None:
-    candidate = FinderCandidate(
-        angle="correctness",
-        file_path="a.py",
-        line_number=2,
-        mechanism="null",
-        scenario="boom",
-        worktree_path="/wt/x",
-        leader_socket="s",
-        advisor_session_id="a",
-        reviewed_head="h",
-    )
-    kept = retain_verified_findings(
-        all_candidates=[candidate],
-        verdict_by_key={("a.py", 2, "null"): VERDICT_CONFIRMED},
-        severity_by_key={("a.py", 2, "null"): "high"},
-    )
-    assert len(kept) == 1
-    assert kept[0].verdict == VERDICT_CONFIRMED