claude-dev-env 1.82.0 → 1.84.0

package/skills/log-audit/scripts/log_audit_constants/mine_copilot_findings_constants.py

@@ -0,0 +1,49 @@
+"""Constants for the mine_copilot_findings script.
+
+ALL_REVIEWER_BOT_LOGINS: the GitHub logins whose review comments count as defects.
+RECENT_PULLS_ENDPOINT_TEMPLATE: the gh api path for a repo's most recent pulls.
+PULL_COMMENTS_ENDPOINT_TEMPLATE: the gh api path for one pull request's comments.
+RECENT_PULL_COUNT: how many recent pull requests a mining run reads.
+MAX_EXAMPLES_PER_CLUSTER: example comment bodies kept per defect class.
+KEYWORDS_BY_DEFECT_CLASS: lowercased substrings that sort a comment into a defect class.
+PROPOSAL_BY_DEFECT_CLASS: the concrete skill-definition edit proposed for each class.
+"""
+
+ALL_REVIEWER_BOT_LOGINS = ("copilot-pull-request-reviewer[bot]", "cursor[bot]")
+RECENT_PULLS_ENDPOINT_TEMPLATE = (
+    "repos/{repo}/pulls?state=all&sort=updated&direction=desc&per_page={pull_count}"
+)
+PULL_COMMENTS_ENDPOINT_TEMPLATE = (
+    "repos/{repo}/pulls/{pull_number}/comments?per_page=100"
+)
+RECENT_PULL_COUNT = 20
+MAX_EXAMPLES_PER_CLUSTER = 3
+KEYWORDS_BY_DEFECT_CLASS = {
+    "missing-type-hint": ("type hint", "missing annotation", "untyped", "no return type"),
+    "broad-except": ("broad except", "bare except", "except exception", "catch-all except"),
+    "magic-value": ("magic number", "magic value", "hardcoded", "hard-coded"),
+    "unclear-name": ("abbreviation", "unclear name", "rename this", "single-letter"),
+    "missing-docstring": ("missing docstring", "no docstring", "undocumented"),
+}
+PROPOSAL_BY_DEFECT_CLASS = {
+    "missing-type-hint": (
+        "Tighten the code skill's type-hint rule to flag the untyped shape this "
+        "class keeps hitting."
+    ),
+    "broad-except": (
+        "Extend the no-broad-except enforcer pattern to the except shape this "
+        "class keeps hitting."
+    ),
+    "magic-value": (
+        "Extend the magic-value enforcer to the literal shape this class keeps "
+        "hitting."
+    ),
+    "unclear-name": (
+        "Add the abbreviation this class keeps flagging to the banned-identifier "
+        "list."
+    ),
+    "missing-docstring": (
+        "Tighten the public-docstring rule to the surface this class keeps "
+        "hitting."
+    ),
+}

package/skills/log-audit/scripts/mine_copilot_findings.py

@@ -0,0 +1,302 @@
+"""Turn the defects reviewers keep catching into upstream skill-edit proposals.
+
+Copilot and Bugbot flag the same kinds of defect over and over — an untyped
+return here, a broad except there. Each catch is a defect that reached review
+because nothing blocked it at write time. This script reads recent reviewer
+comments, sorts them into defect classes, and for each class names a concrete
+skill or rule edit that would block that class upstream. The proposals are for a
+human to apply through review, not for the agent to commit on its own.
+
+Usage:
+    mine_copilot_findings.py --repo owner/name
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+
+_script_directory = str(Path(__file__).resolve().parent)
+if _script_directory not in sys.path:
+    sys.path.insert(0, _script_directory)
+
+from log_audit_constants.mine_copilot_findings_constants import (  # noqa: E402
+    ALL_REVIEWER_BOT_LOGINS,
+    KEYWORDS_BY_DEFECT_CLASS,
+    MAX_EXAMPLES_PER_CLUSTER,
+    PROPOSAL_BY_DEFECT_CLASS,
+    PULL_COMMENTS_ENDPOINT_TEMPLATE,
+    RECENT_PULL_COUNT,
+    RECENT_PULLS_ENDPOINT_TEMPLATE,
+)
+
+
+class GitHubCommandError(RuntimeError):
+    """Raised when a gh api call fails or returns output that is not JSON."""
+
+
+@dataclass(frozen=True)
+class ReviewerComment:
+    """One review comment left by a reviewer bot.
+
+    Attributes:
+        pull_number: The pull request the comment was left on.
+        author: The reviewer bot's login.
+        body: The comment text.
+    """
+
+    pull_number: int
+    author: str
+    body: str
+
+
+@dataclass(frozen=True)
+class DefectCluster:
+    """The reviewer comments that fall into one defect class.
+
+    Attributes:
+        defect_class: The class name the comments were sorted into.
+        count: How many comments fell into the class.
+        example_bodies: A capped sample of the comment bodies in the class.
+    """
+
+    defect_class: str
+    count: int
+    example_bodies: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class SkillProposal:
+    """A proposed skill-definition edit that blocks one defect class upstream.
+
+    Attributes:
+        defect_class: The defect class the edit would block.
+        proposal: The concrete edit to make.
+    """
+
+    defect_class: str
+    proposal: str
+
+
+def classify_defect(comment_body: str) -> str | None:
+    """Sort a review comment into a defect class by its keywords.
+
+    Args:
+        comment_body: The review comment text.
+
+    Returns:
+        The first defect class whose keywords appear in the comment, or None
+        when no class matches.
+    """
+    lowered_body = comment_body.lower()
+    for each_defect_class, each_keywords in KEYWORDS_BY_DEFECT_CLASS.items():
+        if any(each_keyword in lowered_body for each_keyword in each_keywords):
+            return each_defect_class
+    return None
+
+
+def cluster_defects(all_comments: list[ReviewerComment]) -> list[DefectCluster]:
+    """Group review comments by defect class and rank by how often each recurs.
+
+    Args:
+        all_comments: The reviewer comments to sort.
+
+    Returns:
+        One cluster per defect class present, most frequent first, each with a
+        capped sample of its comment bodies.
+    """
+    bodies_by_class: dict[str, list[str]] = defaultdict(list)
+    for each_comment in all_comments:
+        defect_class = classify_defect(each_comment.body)
+        if defect_class is None:
+            continue
+        bodies_by_class[defect_class].append(each_comment.body)
+    clusters: list[DefectCluster] = []
+    for each_defect_class, each_bodies in bodies_by_class.items():
+        clusters.append(
+            DefectCluster(
+                defect_class=each_defect_class,
+                count=len(each_bodies),
+                example_bodies=tuple(each_bodies[:MAX_EXAMPLES_PER_CLUSTER]),
+            )
+        )
+    return sorted(clusters, key=lambda cluster: cluster.count, reverse=True)
+
+
+def proposal_for_defect_class(defect_class: str) -> SkillProposal:
+    """Return the skill-edit proposal that blocks a defect class upstream.
+
+    Args:
+        defect_class: The defect class to propose an edit for.
+
+    Returns:
+        The proposal mapped to the class.
+    """
+    return SkillProposal(
+        defect_class=defect_class, proposal=PROPOSAL_BY_DEFECT_CLASS[defect_class]
+    )
+
+
+def _pull_number_from_url(pull_request_url: str) -> int | None:
+    """Read the trailing pull number from a GitHub pull-request URL."""
+    last_segment = pull_request_url.rsplit("/", 1)[-1]
+    try:
+        return int(last_segment)
+    except ValueError:
+        return None
+
+
+def _reviewer_comment_from_payload(payload: object) -> ReviewerComment | None:
+    """Build a ReviewerComment from one gh comment payload, or None to skip it."""
+    if not isinstance(payload, dict):
+        return None
+    user_field = payload.get("user")
+    login = user_field.get("login") if isinstance(user_field, dict) else None
+    body = payload.get("body")
+    pull_request_url = payload.get("pull_request_url")
+    if not isinstance(login, str) or login not in ALL_REVIEWER_BOT_LOGINS:
+        return None
+    if not isinstance(body, str) or not isinstance(pull_request_url, str):
+        return None
+    pull_number = _pull_number_from_url(pull_request_url)
+    if pull_number is None:
+        return None
+    return ReviewerComment(pull_number=pull_number, author=login, body=body)
+
+
+def _flatten_pages(slurped_payload: object) -> list[object]:
+    """Flatten the per-page arrays a gh --slurp response holds into one list.
+
+    Args:
+        slurped_payload: The parsed output of a ``gh api --paginate --slurp``
+            call: a list whose entries are the individual page responses.
+
+    Returns:
+        Every entry across the pages in page order. A page that is itself a list
+        contributes its entries; any other page contributes itself.
+    """
+    flattened_entries: list[object] = []
+    if isinstance(slurped_payload, list):
+        for each_page in slurped_payload:
+            if isinstance(each_page, list):
+                flattened_entries.extend(each_page)
+            else:
+                flattened_entries.append(each_page)
+    return flattened_entries
+
+
+def _run_gh_json(endpoint: str, *, should_paginate: bool = False) -> object:
+    """Run one gh api call for an endpoint and return its parsed JSON payload.
+
+    Args:
+        endpoint: The gh api endpoint path to request.
+        should_paginate: When True, follow pagination with ``--paginate
+            --slurp`` and flatten the per-page arrays into one list, so a list
+            endpoint with more than one page returns every entry rather than
+            only the first page.
+
+    Returns:
+        The parsed JSON payload: the flattened entry list when should_paginate
+        is True, otherwise the single response parsed as-is.
+
+    Raises:
+        GitHubCommandError: When gh is not installed, the gh api call fails, or
+            its output is not JSON.
+    """
+    gh_command = ["gh", "api", endpoint]
+    if should_paginate:
+        gh_command += ["--paginate", "--slurp"]
+    try:
+        completed_process = subprocess.run(
+            gh_command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except FileNotFoundError as missing_gh_error:
+        raise GitHubCommandError(
+            "gh command not found; install the GitHub CLI to mine reviewer comments"
+        ) from missing_gh_error
+    except subprocess.CalledProcessError as gh_failure_error:
+        raise GitHubCommandError(
+            f"gh api {endpoint} failed: {gh_failure_error.stderr.strip()}"
+        ) from gh_failure_error
+    try:
+        parsed_payload = json.loads(completed_process.stdout)
+    except json.JSONDecodeError as decode_error:
+        raise GitHubCommandError(
+            f"gh api {endpoint} returned output that is not JSON"
+        ) from decode_error
+    if should_paginate:
+        return _flatten_pages(parsed_payload)
+    return parsed_payload
+
+
+def _fetch_recent_pull_numbers(repo: str, pull_count: int) -> list[int]:
+    """Fetch the most recently updated pull numbers, capped at pull_count."""
+    pulls_payload = _run_gh_json(
+        RECENT_PULLS_ENDPOINT_TEMPLATE.format(repo=repo, pull_count=pull_count)
+    )
+    recent_pull_numbers: list[int] = []
+    if isinstance(pulls_payload, list):
+        for each_pull in pulls_payload:
+            if isinstance(each_pull, dict):
+                pull_number = each_pull.get("number")
+                if isinstance(pull_number, int):
+                    recent_pull_numbers.append(pull_number)
+    return recent_pull_numbers
+
+
+def _fetch_pull_comments(repo: str, pull_number: int) -> list[object]:
+    """Fetch one pull request's review comments through gh."""
+    comments_payload = _run_gh_json(
+        PULL_COMMENTS_ENDPOINT_TEMPLATE.format(repo=repo, pull_number=pull_number),
+        should_paginate=True,
+    )
+    if isinstance(comments_payload, list):
+        return list(comments_payload)
+    return []
+
+
+def _fetch_reviewer_comments(repo: str) -> list[ReviewerComment]:
+    """Fetch reviewer-bot comments from the repo's most recent pull requests."""
+    recent_pull_numbers = _fetch_recent_pull_numbers(repo, RECENT_PULL_COUNT)
+    reviewer_comments: list[ReviewerComment] = []
+    for each_pull_number in recent_pull_numbers:
+        for each_payload in _fetch_pull_comments(repo, each_pull_number):
+            parsed_comment = _reviewer_comment_from_payload(each_payload)
+            if parsed_comment is not None:
+                reviewer_comments.append(parsed_comment)
+    return reviewer_comments
+
+
+def main() -> int:
+    """Print one skill-edit proposal per recurring reviewer defect class.
+
+    Returns:
+        The process exit code; zero on success.
+    """
+    parser = argparse.ArgumentParser(
+        description="Mine reviewer defect patterns into skill-edit proposals."
+    )
+    parser.add_argument("--repo", required=True)
+    parsed_arguments = parser.parse_args()
+    try:
+        comments = _fetch_reviewer_comments(parsed_arguments.repo)
+    except GitHubCommandError as gh_error:
+        print(str(gh_error), file=sys.stderr)
+        return 1
+    clusters = cluster_defects(comments)
+    for each_cluster in clusters:
+        proposal = proposal_for_defect_class(each_cluster.defect_class)
+        print(f"{each_cluster.count}\t{each_cluster.defect_class}\t{proposal.proposal}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/log-audit/scripts/test_cluster_recurrences.py

@@ -0,0 +1,160 @@
+"""Tests for cluster_recurrences — signature grouping and timing regressions."""
+
+import io
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pytest
+
+_script_directory = str(Path(__file__).resolve().parent)
+if _script_directory not in sys.path:
+    sys.path.insert(0, _script_directory)
+
+from cluster_recurrences import (  # noqa: E402
+    TimingSample,
+    detect_timing_regressions,
+    main,
+    normalize_signature,
+    recency_weight,
+    rank_signature_clusters,
+)
+from collect_log_window import LogRecord  # noqa: E402
+
+
+def _record(timestamp: datetime, message: str) -> LogRecord:
+    return LogRecord(
+        timestamp=timestamp, source="a_hook", level="block", message=message
+    )
+
+
+class TestNormalizeSignature:
+    def test_two_messages_differing_only_in_numbers_share_a_signature(self) -> None:
+        first = normalize_signature("blocked at line 12 with 3 issues")
+        second = normalize_signature("blocked at line 348 with 9 issues")
+        assert first == second
+
+    def test_messages_differing_only_in_a_path_share_a_signature(self) -> None:
+        first = normalize_signature(r"cannot read C:\a\b\one.py right now")
+        second = normalize_signature(r"cannot read C:\x\y\two.py right now")
+        assert first == second
+
+    def test_messages_differing_only_in_a_hash_share_a_signature(self) -> None:
+        first = normalize_signature("commit a1b2c3d failed to apply")
+        second = normalize_signature("commit deadbeef failed to apply")
+        assert first == second
+
+    def test_distinct_messages_keep_distinct_signatures(self) -> None:
+        assert normalize_signature("heavy word detected") != normalize_signature(
+            "missing type hint"
+        )
+
+
+class TestRecencyWeight:
+    def test_a_fresh_record_weighs_about_one(self) -> None:
+        now = datetime(2026, 7, 3, 12, 0, 0)
+        weight = recency_weight(now, now)
+        assert abs(weight - 1.0) < 0.001
+
+    def test_a_record_one_half_life_old_weighs_about_the_decay_base(self) -> None:
+        now = datetime(2026, 7, 3, 12, 0, 0)
+        one_half_life_ago = now - timedelta(hours=24)
+        weight = recency_weight(one_half_life_ago, now)
+        assert abs(weight - 0.5) < 0.001
+
+    def test_a_future_record_is_clamped_to_at_most_one(self) -> None:
+        now = datetime(2026, 7, 3, 12, 0, 0)
+        one_hour_ahead = now + timedelta(hours=1)
+        weight = recency_weight(one_hour_ahead, now)
+        assert abs(weight - 1.0) < 0.001
+
+
+class TestRankSignatureClusters:
+    def test_the_most_frequent_recent_signature_ranks_first(self) -> None:
+        now = datetime(2026, 7, 3, 12, 0, 0)
+        records = [
+            _record(now - timedelta(hours=1), "blocked at line 1"),
+            _record(now - timedelta(hours=2), "blocked at line 2"),
+            _record(now - timedelta(hours=1), "blocked at line 3"),
+            _record(now - timedelta(hours=200), "a rare stale failure"),
+        ]
+        clusters = rank_signature_clusters(records, now)
+        assert clusters[0].count == 3
+        assert clusters[0].signature == normalize_signature("blocked at line 1")
+
+    def test_each_distinct_signature_becomes_one_cluster(self) -> None:
+        now = datetime(2026, 7, 3, 12, 0, 0)
+        records = [
+            _record(now, "heavy word here"),
+            _record(now, "missing type hint"),
+        ]
+        clusters = rank_signature_clusters(records, now)
+        assert len(clusters) == 2
+
+
+class TestDetectTimingRegressions:
+    def test_flags_an_operation_whose_recent_runs_are_slower(self) -> None:
+        base = datetime(2026, 7, 3, 0, 0, 0)
+        samples = [
+            TimingSample("extract", base + timedelta(minutes=1), 100.0),
+            TimingSample("extract", base + timedelta(minutes=2), 110.0),
+            TimingSample("extract", base + timedelta(minutes=3), 105.0),
+            TimingSample("extract", base + timedelta(minutes=40), 300.0),
+            TimingSample("extract", base + timedelta(minutes=41), 320.0),
+            TimingSample("extract", base + timedelta(minutes=42), 310.0),
+        ]
+        regressions = detect_timing_regressions(samples)
+        assert len(regressions) == 1
+        assert regressions[0].operation == "extract"
+        assert regressions[0].ratio > 1.5
+
+    def test_ignores_a_steady_operation(self) -> None:
+        base = datetime(2026, 7, 3, 0, 0, 0)
+        samples = [
+            TimingSample("steady", base + timedelta(minutes=each_minute_offset), 100.0)
+            for each_minute_offset in range(6)
+        ]
+        assert detect_timing_regressions(samples) == []
+
+    def test_ignores_an_operation_with_too_few_samples(self) -> None:
+        base = datetime(2026, 7, 3, 0, 0, 0)
+        samples = [
+            TimingSample("sparse", base + timedelta(minutes=1), 100.0),
+            TimingSample("sparse", base + timedelta(minutes=2), 900.0),
+        ]
+        assert detect_timing_regressions(samples) == []
+
+
+class TestMain:
+    def test_rejects_non_json_stdin(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        monkeypatch.setattr(sys, "stdin", io.StringIO("not json"))
+        exit_code = main()
+        captured = capsys.readouterr()
+        assert exit_code == 1
+        assert "not valid JSON" in captured.err
+
+    def test_rejects_a_non_list_payload(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        monkeypatch.setattr(sys, "stdin", io.StringIO('{"not": "a list"}'))
+        exit_code = main()
+        captured = capsys.readouterr()
+        assert exit_code == 1
+        assert "must be a list" in captured.err
+
+    def test_rejects_a_malformed_record(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        monkeypatch.setattr(sys, "stdin", io.StringIO('[{"missing": "fields"}]'))
+        exit_code = main()
+        captured = capsys.readouterr()
+        assert exit_code == 1
+        assert "malformed record" in captured.err

package/skills/log-audit/scripts/test_collect_log_window.py

@@ -0,0 +1,111 @@
+"""Tests for collect_log_window — parsing and windowing hook-block records."""
+
+import json
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+_script_directory = str(Path(__file__).resolve().parent)
+if _script_directory not in sys.path:
+    sys.path.insert(0, _script_directory)
+
+from collect_log_window import (  # noqa: E402
+    LogRecord,
+    collect_records,
+    parse_log_line,
+    read_log_window,
+)
+
+
+def _block_line(timestamp_text: str, hook_name: str, reason_text: str) -> str:
+    return json.dumps(
+        {
+            "timestamp": timestamp_text,
+            "hook": hook_name,
+            "event": "PreToolUse",
+            "reason": reason_text,
+        }
+    )
+
+
+class TestParseLogLine:
+    def test_parses_a_well_formed_block_record(self) -> None:
+        line = _block_line(
+            "2026-07-03T09:00:00", "plain_language_blocker", "Heavy word"
+        )
+        record = parse_log_line(line)
+        assert record == LogRecord(
+            timestamp=datetime(2026, 7, 3, 9, 0, 0),
+            source="plain_language_blocker",
+            level="block",
+            message="Heavy word",
+        )
+
+    def test_returns_none_for_a_blank_line(self) -> None:
+        assert parse_log_line("   ") is None
+
+    def test_returns_none_for_non_json(self) -> None:
+        assert parse_log_line("not json at all") is None
+
+    def test_returns_none_when_reason_is_missing(self) -> None:
+        line = json.dumps({"timestamp": "2026-07-03T09:00:00", "hook": "x"})
+        assert parse_log_line(line) is None
+
+    def test_returns_none_for_an_unparseable_timestamp(self) -> None:
+        line = _block_line("not-a-timestamp", "x", "y")
+        assert parse_log_line(line) is None
+
+
+class TestCollectRecords:
+    def test_keeps_only_records_at_or_after_the_window_start(self) -> None:
+        window_start = datetime(2026, 7, 3, 8, 0, 0)
+        log_text = "\n".join(
+            [
+                _block_line("2026-07-03T07:59:59", "old_hook", "before window"),
+                _block_line("2026-07-03T08:00:00", "edge_hook", "on the boundary"),
+                _block_line("2026-07-03T09:30:00", "new_hook", "inside window"),
+            ]
+        )
+        records = collect_records(log_text, window_start)
+        assert [each_record.source for each_record in records] == [
+            "edge_hook",
+            "new_hook",
+        ]
+
+    def test_skips_malformed_lines(self) -> None:
+        window_start = datetime(2026, 7, 3, 0, 0, 0)
+        log_text = "\n".join(
+            [
+                "garbage",
+                _block_line("2026-07-03T09:00:00", "good_hook", "kept"),
+                "",
+            ]
+        )
+        records = collect_records(log_text, window_start)
+        assert len(records) == 1
+        assert records[0].source == "good_hook"
+
+
+class TestReadLogWindow:
+    def test_returns_empty_list_when_the_log_is_absent(self, tmp_path: Path) -> None:
+        missing_path = tmp_path / "hook-blocks.log"
+        assert read_log_window(missing_path, 24, datetime(2026, 7, 3, 12, 0, 0)) == []
+
+    def test_reads_records_inside_the_window_from_a_real_file(
+        self, tmp_path: Path
+    ) -> None:
+        now = datetime(2026, 7, 3, 12, 0, 0)
+        recent_time = (now - timedelta(hours=1)).isoformat()
+        stale_time = (now - timedelta(hours=48)).isoformat()
+        log_path = tmp_path / "hook-blocks.log"
+        log_path.write_text(
+            "\n".join(
+                [
+                    _block_line(stale_time, "stale_hook", "too old"),
+                    _block_line(recent_time, "recent_hook", "in window"),
+                ]
+            ),
+            encoding="utf-8",
+        )
+        records = read_log_window(log_path, 24, now)
+        assert [each_record.source for each_record in records] == ["recent_hook"]