claude-dev-env 1.93.0 → 1.94.0

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

@@ -1,261 +0,0 @@
-"""Group hook-block records by a normalized signature and rank the clusters.
-
-Two failures can read differently only because one names line 12 and the other
-line 348. They are the same failure. This script strips the varying parts down
-to one signature, so it counts how often each real failure recurs. It ranks the
-loudest first and weights recent blocks over stale ones. It also reads timing
-samples for one operation and flags that operation when its recent runs have
-grown slower than its earlier runs.
-
-Reads the JSON record list collect_log_window prints, on stdin.
-
-Usage:
-    collect_log_window.py --hours 24 | cluster_recurrences.py
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import sys
-from collections import defaultdict
-from dataclasses import dataclass
-from datetime import datetime
-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.cluster_recurrences_constants import (  # noqa: E402
-    DIGIT_PATTERN,
-    HASH_PATTERN,
-    MIN_TIMING_SAMPLES_PER_HALF,
-    PATH_PATTERN,
-    RECENCY_DECAY_BASE,
-    RECENCY_HALF_LIFE_HOURS,
-    SAMPLE_HALVES,
-    SECONDS_PER_HOUR,
-    SIGNATURE_PLACEHOLDER,
-    TIMING_REGRESSION_RATIO,
-)
-from log_audit_constants.collect_log_window_constants import (  # noqa: E402
-    RECORD_LEVEL_KEY,
-    RECORD_MESSAGE_KEY,
-    RECORD_SOURCE_KEY,
-    RECORD_TIMESTAMP_KEY,
-)
-
-from collect_log_window import LogRecord  # noqa: E402
-
-
-@dataclass(frozen=True)
-class SignatureCluster:
-    """A group of records that share one normalized message signature.
-
-    Attributes:
-        signature: The normalized message the grouped records share.
-        count: How many records fell into the cluster.
-        latest_timestamp: The most recent record's timestamp in the cluster.
-        score: The recency-weighted sum of the cluster's records.
-    """
-
-    signature: str
-    count: int
-    latest_timestamp: datetime
-    score: float
-
-
-@dataclass(frozen=True)
-class TimingSample:
-    """One measured run of a repeated operation.
-
-    Attributes:
-        operation: The operation's name.
-        timestamp: When the run happened.
-        duration_ms: How long the run took, in milliseconds.
-    """
-
-    operation: str
-    timestamp: datetime
-    duration_ms: float
-
-
-@dataclass(frozen=True)
-class TimingRegression:
-    """A repeated operation whose recent runs have grown slower.
-
-    Attributes:
-        operation: The operation's name.
-        baseline_ms: The mean duration of the earliest runs.
-        recent_ms: The mean duration of the latest runs.
-        ratio: The recent mean divided by the baseline mean.
-    """
-
-    operation: str
-    baseline_ms: float
-    recent_ms: float
-    ratio: float
-
-
-def normalize_signature(message: str) -> str:
-    """Reduce a message to a signature shared by its recurring variants.
-
-    Args:
-        message: A raw block-reason message.
-
-    Returns:
-        The message with paths, hashes, and numbers replaced by a placeholder
-        and runs of whitespace collapsed to single spaces.
-    """
-    without_paths = re.sub(PATH_PATTERN, SIGNATURE_PLACEHOLDER, message)
-    without_hashes = re.sub(HASH_PATTERN, SIGNATURE_PLACEHOLDER, without_paths)
-    without_numbers = re.sub(DIGIT_PATTERN, SIGNATURE_PLACEHOLDER, without_hashes)
-    return re.sub(r"\s+", " ", without_numbers).strip()
-
-
-def recency_weight(record_timestamp: datetime, now: datetime) -> float:
-    """Weight a record by how recent it is, halving each half-life of age.
-
-    Args:
-        record_timestamp: When the record was written.
-        now: The current time age is measured against.
-
-    Returns:
-        A weight near one for a fresh record, falling toward zero as it ages.
-    """
-    age_hours = (now - record_timestamp).total_seconds() / SECONDS_PER_HOUR
-    non_negative_age_hours = max(age_hours, 0.0)
-    return RECENCY_DECAY_BASE ** (non_negative_age_hours / RECENCY_HALF_LIFE_HOURS)
-
-
-def rank_signature_clusters(
-    all_records: list[LogRecord], now: datetime
-) -> list[SignatureCluster]:
-    """Group records by signature and rank them by recency-weighted count.
-
-    Args:
-        all_records: The block records to group.
-        now: The current time used to weight each record.
-
-    Returns:
-        One cluster per distinct signature, highest score first.
-    """
-    records_by_signature: dict[str, list[LogRecord]] = defaultdict(list)
-    for each_record in all_records:
-        records_by_signature[normalize_signature(each_record.message)].append(
-            each_record
-        )
-    clusters: list[SignatureCluster] = []
-    for each_signature, each_signature_records in records_by_signature.items():
-        score = sum(
-            recency_weight(each_grouped.timestamp, now)
-            for each_grouped in each_signature_records
-        )
-        latest_timestamp = max(
-            each_grouped.timestamp for each_grouped in each_signature_records
-        )
-        clusters.append(
-            SignatureCluster(
-                signature=each_signature,
-                count=len(each_signature_records),
-                latest_timestamp=latest_timestamp,
-                score=score,
-            )
-        )
-    return sorted(
-        clusters,
-        key=lambda cluster: (cluster.score, cluster.count),
-        reverse=True,
-    )
-
-
-def _mean_duration(all_samples: list[TimingSample]) -> float:
-    """Return the mean duration in milliseconds of the given samples."""
-    return sum(each_sample.duration_ms for each_sample in all_samples) / len(
-        all_samples
-    )
-
-
-def detect_timing_regressions(
-    all_samples: list[TimingSample],
-) -> list[TimingRegression]:
-    """Flag operations whose recent runs are slower than their earliest runs.
-
-    Args:
-        all_samples: Timing samples across one or more operations.
-
-    Returns:
-        One regression per operation whose recent-to-baseline duration ratio
-        reaches the regression threshold, highest ratio first.
-    """
-    samples_by_operation: dict[str, list[TimingSample]] = defaultdict(list)
-    for each_sample in all_samples:
-        samples_by_operation[each_sample.operation].append(each_sample)
-    regressions: list[TimingRegression] = []
-    for each_operation, each_operation_samples in samples_by_operation.items():
-        if len(each_operation_samples) < MIN_TIMING_SAMPLES_PER_HALF * SAMPLE_HALVES:
-            continue
-        ordered_samples = sorted(
-            each_operation_samples, key=lambda sample: sample.timestamp
-        )
-        baseline_ms = _mean_duration(ordered_samples[:MIN_TIMING_SAMPLES_PER_HALF])
-        recent_ms = _mean_duration(ordered_samples[-MIN_TIMING_SAMPLES_PER_HALF:])
-        if baseline_ms <= 0:
-            continue
-        ratio = recent_ms / baseline_ms
-        if ratio >= TIMING_REGRESSION_RATIO:
-            regressions.append(
-                TimingRegression(
-                    operation=each_operation,
-                    baseline_ms=baseline_ms,
-                    recent_ms=recent_ms,
-                    ratio=ratio,
-                )
-            )
-    return sorted(regressions, key=lambda regression: regression.ratio, reverse=True)
-
-
-def _record_from_json_dict(all_record_fields: dict[str, str]) -> LogRecord:
-    """Rebuild a LogRecord from one collect_log_window JSON dict."""
-    return LogRecord(
-        timestamp=datetime.fromisoformat(all_record_fields[RECORD_TIMESTAMP_KEY]),
-        source=all_record_fields[RECORD_SOURCE_KEY],
-        level=all_record_fields[RECORD_LEVEL_KEY],
-        message=all_record_fields[RECORD_MESSAGE_KEY],
-    )
-
-
-def main() -> int:
-    """Read records on stdin and print ranked signature clusters.
-
-    Returns:
-        The process exit code; zero on success, one when stdin is not a JSON
-        list of well-formed records.
-    """
-    try:
-        records_payload = json.load(sys.stdin)
-    except json.JSONDecodeError as decode_error:
-        print(f"cluster_recurrences: stdin is not valid JSON: {decode_error}", file=sys.stderr)
-        return 1
-    if not isinstance(records_payload, list):
-        print("cluster_recurrences: stdin JSON must be a list of records", file=sys.stderr)
-        return 1
-    try:
-        records = [
-            _record_from_json_dict(each_record_fields)
-            for each_record_fields in records_payload
-        ]
-    except (KeyError, TypeError, ValueError) as record_error:
-        print(f"cluster_recurrences: malformed record in stdin: {record_error}", file=sys.stderr)
-        return 1
-    clusters = rank_signature_clusters(records, datetime.now())
-    for each_cluster in clusters:
-        print(
-            f"{each_cluster.count}\t{each_cluster.score:.2f}\t{each_cluster.signature}"
-        )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

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

@@ -1,199 +0,0 @@
-"""Read the recent window of the hook block log into structured records.
-
-Tails the JSON-lines hook block log every blocking hook appends to, and hands
-back the block events inside a time window as plain records. Picture the audit
-agent waking up: it asks this script for the last few hours of blocks, and gets
-one record per block carrying when it happened, which hook fired, and why. Those
-records feed cluster_recurrences, which groups them by a normalized signature.
-
-Usage:
-    collect_log_window.py --hours 24
-    collect_log_window.py --hours 6 --log-path /path/to/hook-blocks.log
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from collections.abc import Iterable
-from dataclasses import dataclass
-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 log_audit_constants.collect_log_window_constants import (  # noqa: E402
-    BLOCK_LEVEL_LABEL,
-    DEFAULT_WINDOW_HOURS,
-    HOOK_BLOCKS_LOG_RELATIVE_PATH,
-    LOG_HOOK_KEY,
-    LOG_REASON_KEY,
-    LOG_TIMESTAMP_KEY,
-    RECORD_LEVEL_KEY,
-    RECORD_MESSAGE_KEY,
-    RECORD_SOURCE_KEY,
-    RECORD_TIMESTAMP_KEY,
-)
-
-
-@dataclass(frozen=True)
-class LogRecord:
-    """One block event read from the hook block log.
-
-    Attributes:
-        timestamp: When the block happened, parsed from the record's ISO string.
-        source: The hook that blocked, taken from the record's hook field.
-        level: The severity label; every hook-block record reads as a block.
-        message: The human-readable block reason.
-    """
-
-    timestamp: datetime
-    source: str
-    level: str
-    message: str
-
-
-def parse_log_line(raw_line: str) -> LogRecord | None:
-    """Parse one hook-block-log line into a LogRecord.
-
-    Args:
-        raw_line: A single line of the JSON-lines hook block log.
-
-    Returns:
-        The parsed record, or None when the line is blank, is not a JSON object,
-        or omits the timestamp, hook, or reason field, or carries a timestamp
-        that does not parse as an ISO datetime.
-    """
-    stripped_line = raw_line.strip()
-    if not stripped_line:
-        return None
-    try:
-        record_fields = json.loads(stripped_line)
-    except json.JSONDecodeError:
-        return None
-    if not isinstance(record_fields, dict):
-        return None
-    timestamp_text = record_fields.get(LOG_TIMESTAMP_KEY)
-    source_text = record_fields.get(LOG_HOOK_KEY)
-    message_text = record_fields.get(LOG_REASON_KEY)
-    if not isinstance(timestamp_text, str):
-        return None
-    if not isinstance(source_text, str) or not isinstance(message_text, str):
-        return None
-    try:
-        parsed_timestamp = datetime.fromisoformat(timestamp_text)
-    except ValueError:
-        return None
-    return LogRecord(
-        timestamp=parsed_timestamp,
-        source=source_text,
-        level=BLOCK_LEVEL_LABEL,
-        message=message_text,
-    )
-
-
-def _records_within_window(
-    all_lines: Iterable[str], window_start: datetime
-) -> list[LogRecord]:
-    """Parse each line and keep the records at or after the window start.
-
-    Args:
-        all_lines: The hook-block-log lines to parse, in file order.
-        window_start: The earliest timestamp a kept record may carry.
-
-    Returns:
-        The in-window records in the order their lines appear.
-    """
-    kept_records: list[LogRecord] = []
-    for each_line in all_lines:
-        parsed_record = parse_log_line(each_line)
-        if parsed_record is None:
-            continue
-        if parsed_record.timestamp >= window_start:
-            kept_records.append(parsed_record)
-    return kept_records
-
-
-def collect_records(log_text: str, window_start: datetime) -> list[LogRecord]:
-    """Parse log text and keep records at or after the window start.
-
-    Args:
-        log_text: The full text of the hook block log.
-        window_start: The earliest timestamp a kept record may carry.
-
-    Returns:
-        The in-window records in the order they appear in the log.
-    """
-    return _records_within_window(log_text.splitlines(), window_start)
-
-
-def read_log_window(
-    log_path: Path, window_hours: int, now: datetime
-) -> list[LogRecord]:
-    """Read the hook block log and return records within the window.
-
-    Args:
-        log_path: Path to the JSON-lines hook block log.
-        window_hours: How many hours back from now to keep.
-        now: The current time the window is measured back from.
-
-    Returns:
-        The in-window records, or an empty list when the log file is absent.
-    """
-    window_start = now - timedelta(hours=window_hours)
-    try:
-        with log_path.open(encoding="utf-8") as log_file:
-            return _records_within_window(log_file, window_start)
-    except FileNotFoundError:
-        return []
-
-
-def _default_log_path() -> Path:
-    """Return the home-relative path of the hook block log."""
-    return Path.home() / HOOK_BLOCKS_LOG_RELATIVE_PATH
-
-
-def _record_as_json_dict(record: LogRecord) -> dict[str, str]:
-    """Render a record as a JSON-ready dict with an ISO timestamp string.
-
-    Args:
-        record: The record to render.
-
-    Returns:
-        A dict of string values keyed by the record's field names.
-    """
-    return {
-        RECORD_TIMESTAMP_KEY: record.timestamp.isoformat(),
-        RECORD_SOURCE_KEY: record.source,
-        RECORD_LEVEL_KEY: record.level,
-        RECORD_MESSAGE_KEY: record.message,
-    }
-
-
-def main() -> int:
-    """Print the recent hook-block records as JSON to stdout.
-
-    Returns:
-        The process exit code; zero on success.
-    """
-    parser = argparse.ArgumentParser(description="Tail the hook block log window.")
-    parser.add_argument("--hours", type=int, default=DEFAULT_WINDOW_HOURS)
-    parser.add_argument("--log-path", type=str, default=None)
-    parsed_arguments = parser.parse_args()
-    log_path = (
-        Path(parsed_arguments.log_path).expanduser().resolve()
-        if parsed_arguments.log_path is not None
-        else _default_log_path()
-    )
-    records = read_log_window(log_path, parsed_arguments.hours, datetime.now())
-    json.dump(
-        [_record_as_json_dict(each_record) for each_record in records], sys.stdout
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/skills/log-audit/scripts/log_audit_constants/CLAUDE.md

@@ -1,12 +0,0 @@
-# log-audit/scripts/log_audit_constants
-
-Named constants imported by the `log-audit` scripts. Each module holds the tunables for one script, keeping magic values out of the scripts.
-
-## Files
-
-| File | What it holds |
-|---|---|
-| `__init__.py` | Package marker. |
-| `collect_log_window_constants.py` | The hook-block-log path, default window, block level label, and the input and output record key names for `collect_log_window.py`. |
-| `cluster_recurrences_constants.py` | The signature-stripping regexes, recency decay, and timing-regression thresholds for `cluster_recurrences.py`. |
-| `mine_copilot_findings_constants.py` | The reviewer-bot logins, the recent-pulls and per-pull comments endpoint templates, the recent-pull count, and the defect-class keyword and proposal maps for `mine_copilot_findings.py`. |

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

@@ -1,23 +0,0 @@
-"""Constants for the cluster_recurrences script.
-
-PATH_PATTERN, HASH_PATTERN, DIGIT_PATTERN: regexes stripped from a message, in this
-    order, so records that differ only in a path, hash, or number share one signature.
-SIGNATURE_PLACEHOLDER: the token each stripped span collapses to.
-SECONDS_PER_HOUR: seconds in one hour, dividing a record's age into hours.
-RECENCY_DECAY_BASE: the weight a record carries once it is one half-life old.
-RECENCY_HALF_LIFE_HOURS: age in hours at which a record's weight reaches the decay base.
-TIMING_REGRESSION_RATIO: recent-over-baseline duration ratio that flags a regression.
-MIN_TIMING_SAMPLES_PER_HALF: samples required in the baseline half and the recent half.
-SAMPLE_HALVES: the number of halves a timing series splits into before it can be judged.
-"""
-
-PATH_PATTERN = r"(?:[A-Za-z]:)?(?:[\\/][\w.\-]+)+"
-HASH_PATTERN = r"\b[0-9a-f]{7,40}\b"
-DIGIT_PATTERN = r"\d+"
-SIGNATURE_PLACEHOLDER = "*"
-SECONDS_PER_HOUR = 3600
-RECENCY_DECAY_BASE = 0.5
-RECENCY_HALF_LIFE_HOURS = 24.0
-TIMING_REGRESSION_RATIO = 1.5
-MIN_TIMING_SAMPLES_PER_HALF = 3
-SAMPLE_HALVES = 2

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

@@ -1,24 +0,0 @@
-"""Constants for the collect_log_window script.
-
-HOOK_BLOCKS_LOG_RELATIVE_PATH: home-relative path of the JSON-lines hook block log.
-DEFAULT_WINDOW_HOURS: how many hours back a collection reads when no window is given.
-BLOCK_LEVEL_LABEL: the level stamped on every record read from the hook block log.
-LOG_TIMESTAMP_KEY: hook-block-log JSON key holding the ISO-8601 block time.
-LOG_HOOK_KEY: hook-block-log JSON key holding the blocking hook's name.
-LOG_REASON_KEY: hook-block-log JSON key holding the human-readable block reason.
-RECORD_TIMESTAMP_KEY: output-record key holding the ISO-8601 block time.
-RECORD_SOURCE_KEY: output-record key holding the blocking hook's name.
-RECORD_LEVEL_KEY: output-record key holding the severity label.
-RECORD_MESSAGE_KEY: output-record key holding the block reason.
-"""
-
-HOOK_BLOCKS_LOG_RELATIVE_PATH = ".claude/logs/hook-blocks.log"
-DEFAULT_WINDOW_HOURS = 24
-BLOCK_LEVEL_LABEL = "block"
-LOG_TIMESTAMP_KEY = "timestamp"
-LOG_HOOK_KEY = "hook"
-LOG_REASON_KEY = "reason"
-RECORD_TIMESTAMP_KEY = "timestamp"
-RECORD_SOURCE_KEY = "source"
-RECORD_LEVEL_KEY = "level"
-RECORD_MESSAGE_KEY = "message"

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

@@ -1,49 +0,0 @@
-"""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."
-    ),
-}