claude-dev-env 4.2.0 → 7.0.0

package/.agents/skills/_shared/pr-loop/scripts/test_write_handoff.py

@@ -1,201 +0,0 @@
-"""Tests for write_handoff: the durable per-run handoff writer."""
-
-from __future__ import annotations
-
-import importlib.util
-import json
-import sys
-from pathlib import Path
-from types import ModuleType
-
-import pytest
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-
-def _load_write_handoff_module() -> ModuleType:
-    module_path = _SCRIPTS_DIR / "write_handoff.py"
-    spec = importlib.util.spec_from_file_location("write_handoff", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-write_handoff = _load_write_handoff_module()
-
-
-_FROZEN_TIMESTAMP = "2026-07-03T12:00:00+00:00"
-
-
-def _point_base_dir_at(monkeypatch: pytest.MonkeyPatch, base: Path) -> None:
-    monkeypatch.setattr(write_handoff, "_handoff_base_dir", lambda: base)
-    monkeypatch.setattr(write_handoff, "_now_iso", lambda: _FROZEN_TIMESTAMP)
-
-
-def test_resolve_handoff_dir_joins_run_name_under_base(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """resolve_handoff_dir places the run's directory under the durable base."""
-    _point_base_dir_at(monkeypatch, tmp_path)
-    resolved = write_handoff.resolve_handoff_dir("bugteam-pr-4")
-    assert resolved == tmp_path / "bugteam-pr-4"
-
-
-def test_handoff_base_dir_lives_under_home_runtime_pr_loop(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """The durable base sits under the user home, not the OS temp directory."""
-    monkeypatch.setenv("USERPROFILE", str(tmp_path))
-    monkeypatch.setenv("HOME", str(tmp_path))
-    base = write_handoff._handoff_base_dir()
-    assert base == tmp_path / ".claude" / "runtime" / "pr-loop"
-
-
-def test_write_handoff_records_resume_command_and_phase(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """write_handoff writes handoff.json and HANDOFF.md carrying the resume
-    command, phase, run id, completed steps, and a timestamp."""
-    _point_base_dir_at(monkeypatch, tmp_path)
-    handoff_dir = write_handoff.write_handoff(
-        pr_number=4,
-        head_ref="feat/pr-loop-durable-handoff",
-        phase="tick",
-        resume_command="claude --resume /pr-converge",
-        run_id="wf_abc123",
-        all_completed_steps=["preflight", "audit"],
-        note="Copilot wait-gate still open.",
-    )
-    assert handoff_dir == tmp_path / "bugteam-pr-4"
-
-    payload = json.loads((handoff_dir / "handoff.json").read_text(encoding="utf-8"))
-    assert payload["resume_command"] == "claude --resume /pr-converge"
-    assert payload["phase"] == "tick"
-    assert payload["run_id"] == "wf_abc123"
-    assert payload["completed_steps"] == ["preflight", "audit"]
-    assert payload["timestamp"] == _FROZEN_TIMESTAMP
-
-    markdown = (handoff_dir / "HANDOFF.md").read_text(encoding="utf-8")
-    assert "claude --resume /pr-converge" in markdown
-    assert "preflight" in markdown
-    assert "Copilot wait-gate still open." in markdown
-
-
-def test_write_handoff_copies_state_file_when_given(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """A supplied --state-file is copied to state-copy.json and the copy path is
-    recorded in handoff.json."""
-    _point_base_dir_at(monkeypatch, tmp_path)
-    source_state = tmp_path / "loop-state.json"
-    source_state.write_text('{"loop_count": 3}', encoding="utf-8")
-
-    handoff_dir = write_handoff.write_handoff(
-        pr_number=4,
-        head_ref="feat/branch",
-        phase="teardown",
-        resume_command="claude --resume /autoconverge",
-        state_file=source_state,
-    )
-
-    state_copy = handoff_dir / "state-copy.json"
-    assert json.loads(state_copy.read_text(encoding="utf-8")) == {"loop_count": 3}
-    payload = json.loads((handoff_dir / "handoff.json").read_text(encoding="utf-8"))
-    assert payload["state_file"] == state_copy.as_posix()
-
-
-def test_write_handoff_omits_state_copy_when_absent(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """With no --state-file, no state-copy.json is written and state_file is null."""
-    _point_base_dir_at(monkeypatch, tmp_path)
-    handoff_dir = write_handoff.write_handoff(
-        pr_number=4,
-        head_ref="feat/branch",
-        phase="tick",
-        resume_command="claude --resume /pr-converge",
-    )
-    assert not (handoff_dir / "state-copy.json").exists()
-    payload = json.loads((handoff_dir / "handoff.json").read_text(encoding="utf-8"))
-    assert payload["state_file"] is None
-
-
-def test_parse_arguments_reads_completed_steps_value() -> None:
-    """The CLI captures the raw comma-separated --completed-steps value."""
-    arguments = write_handoff.parse_arguments(
-        [
-            "--pr-number",
-            "4",
-            "--head-ref",
-            "feat/branch",
-            "--phase",
-            "tick",
-            "--resume-command",
-            "claude --resume /pr-converge",
-            "--completed-steps",
-            "preflight,audit,fix",
-        ]
-    )
-    assert arguments.completed_steps == "preflight,audit,fix"
-
-
-def test_main_writes_handoff_and_prints_dir(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """main writes the handoff files and prints the durable directory path."""
-    _point_base_dir_at(monkeypatch, tmp_path)
-    exit_code = write_handoff.main(
-        [
-            "--pr-number",
-            "4",
-            "--head-ref",
-            "feat/branch",
-            "--phase",
-            "tick",
-            "--resume-command",
-            "claude --resume /pr-converge",
-            "--completed-steps",
-            "preflight,audit",
-        ]
-    )
-    assert exit_code == 0
-    printed = capsys.readouterr().out.strip()
-    assert "\\" not in printed
-    assert printed.endswith("bugteam-pr-4")
-    payload = json.loads(
-        (tmp_path / "bugteam-pr-4" / "handoff.json").read_text(encoding="utf-8")
-    )
-    assert payload["completed_steps"] == ["preflight", "audit"]
-
-
-def test_main_returns_one_on_non_utf8_state_file(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """main exits 1 rather than crashing when --state-file holds non-UTF-8 bytes."""
-    _point_base_dir_at(monkeypatch, tmp_path)
-    bad_state = tmp_path / "loop-state.json"
-    bad_state.write_bytes(b"\xff\xfe not valid utf-8")
-    exit_code = write_handoff.main(
-        [
-            "--pr-number",
-            "4",
-            "--head-ref",
-            "feat/branch",
-            "--phase",
-            "teardown",
-            "--resume-command",
-            "claude --resume /autoconverge",
-            "--state-file",
-            str(bad_state),
-        ]
-    )
-    assert exit_code == 1
-    assert "write_handoff failed" in capsys.readouterr().err

package/.agents/skills/_shared/pr-loop/scripts/write_audit_outcomes.py

@@ -1,182 +0,0 @@
-"""Validate Shape A/B contract and write <bugteam_audit> XML at the canonical path.
-
-Usage:
-  python scripts/write_audit_outcomes.py --pr-number 422 --loop 3 --review-url <URL> --findings-json <PATH> --worktree-path <PATH>
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-from xml.etree.ElementTree import Element, SubElement
-
-_self_dir = Path(__file__).resolve().parent
-if str(_self_dir) not in sys.path:
-    sys.path.insert(0, str(_self_dir))
-
-from _cli_utils import require_file
-from _path_resolver import outcome_xml_path
-from _xml_utils import emit_pretty_xml
-from skills_pr_loop_constants.path_resolver_constants import ALL_FINDING_BODY_ELEMENT_KEYS
-
-
-def build_audit_xml(
-    *,
-    pr_number: int,
-    loop: int,
-    review_url: str,
-    findings_json_path: Path,
-) -> Element:
-    """Build the <bugteam_audit> XML element from findings data.
-
-    Args:
-        pr_number: Pull request number.
-        loop: Loop iteration number.
-        review_url: URL of the GitHub review.
-        findings_json_path: Path to the findings JSON file.
-
-    Returns:
-        Root <bugteam_audit> element.
-
-    Raises:
-        SystemExit: When findings-json is not a JSON array of objects.
-    """
-    findings_data = json.loads(findings_json_path.read_text(encoding="utf-8"))
-    if not isinstance(findings_data, list):
-        print("findings-json must contain a JSON array", file=sys.stderr)
-        raise SystemExit(1)
-    for each_index, each_finding in enumerate(findings_data):
-        if not isinstance(each_finding, dict):
-            print(
-                f"findings-json[{each_index}]: each entry must be a JSON object",
-                file=sys.stderr,
-            )
-            raise SystemExit(1)
-    root = Element("bugteam_audit", {
-        "pr": str(pr_number),
-        "loop": str(loop),
-        "review_url": review_url,
-    })
-
-    findings_elem = SubElement(root, "findings")
-    _populate_findings(findings_elem, findings_data)
-    return root
-
-
-def _populate_findings(parent: Element, findings_data: list[dict[str, object]]) -> None:
-    """Populate <finding> elements from a validated list of finding dicts.
-
-    Scalar finding fields become XML attributes on `<finding>`; the
-    body fields named in `ALL_FINDING_BODY_ELEMENT_KEYS` (defined in
-    `packages/claude-dev-env/.agents/skills/_shared/pr-loop/scripts/skills_pr_loop_constants/path_resolver_constants.py`
-    and currently `("title", "excerpt", "description")`) become child elements.
-    Nested dicts or lists in scalar slots are flattened to string form
-    so attribute serialization stays well-defined.
-
-    Args:
-        parent: Parent XML element (typically `<findings>`).
-        findings_data: Validated list of finding dicts (caller must have
-            confirmed each entry is a dict via the build_audit_xml gate).
-    """
-    all_finding_body_element_keys = ALL_FINDING_BODY_ELEMENT_KEYS
-    for each_finding in findings_data:
-        finding_elem = SubElement(parent, "finding")
-        for each_key, each_field_detail in each_finding.items():
-            field_text = (
-                str(each_field_detail) if each_field_detail is not None else ""
-            )
-            if each_key in all_finding_body_element_keys:
-                child = SubElement(finding_elem, each_key)
-                child.text = field_text
-            else:
-                finding_elem.set(each_key, field_text)
-
-
-def write_audit_xml(
-    *,
-    pr_number: int,
-    loop: int,
-    review_url: str,
-    findings_json_path: Path,
-    worktree_path: Path,
-) -> Path:
-    """Write the <bugteam_audit> XML to the canonical outcome path.
-
-    Args:
-        pr_number: Pull request number.
-        loop: Loop iteration number.
-        review_url: URL of the GitHub review.
-        findings_json_path: Path to the findings JSON file.
-        worktree_path: Path to the git worktree.
-
-    Returns:
-        Path to the written XML file.
-    """
-    root = build_audit_xml(
-        pr_number=pr_number,
-        loop=loop,
-        review_url=review_url,
-        findings_json_path=findings_json_path,
-    )
-    xml_string = emit_pretty_xml(root)
-
-    output_path = outcome_xml_path(worktree_path, pr_number, loop)
-    output_path.write_text(xml_string, encoding="utf-8")
-    return output_path
-
-
-def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
-    """Parse command-line arguments.
-
-    Args:
-        all_argv: Command-line argument list.
-
-    Returns:
-        Parsed namespace with pr_number, loop, review_url, findings_json, and worktree_path.
-    """
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--pr-number", type=int, required=True)
-    parser.add_argument("--loop", type=int, required=True)
-    parser.add_argument("--review-url", required=True)
-    parser.add_argument("--findings-json", type=Path, required=True)
-    parser.add_argument("--worktree-path", type=Path, required=True)
-    return parser.parse_args(all_argv)
-
-
-def main(all_arguments: list[str]) -> int:
-    """Entry point: write <bugteam_audit> XML at the canonical path.
-
-    Args:
-        all_arguments: Command-line arguments.
-
-    Returns:
-        0 on success, 1 on validation or write failure.
-    """
-    arguments = parse_arguments(all_arguments)
-    findings_path = getattr(arguments, "findings_json")
-
-    early_exit = require_file(findings_path, "findings-json")
-    if early_exit is not None:
-        return early_exit
-
-    try:
-        output_path = write_audit_xml(
-            pr_number=getattr(arguments, "pr_number"),
-            loop=arguments.loop,
-            review_url=getattr(arguments, "review_url"),
-            findings_json_path=findings_path,
-            worktree_path=getattr(arguments, "worktree_path"),
-        )
-    except SystemExit:
-        return 1
-    except (json.JSONDecodeError, OSError) as exc:
-        print(f"write_audit_xml failed: {exc}", file=sys.stderr)
-        return 1
-    print(output_path)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))

package/.agents/skills/_shared/pr-loop/scripts/write_fix_outcomes.py

@@ -1,206 +0,0 @@
-"""Validate status enum values and write <bugteam_fix> XML at the canonical path.
-
-Status enum (canonical source: `ALL_VALID_FIX_STATUSES` in
-`packages/claude-dev-env/.agents/skills/_shared/pr-loop/scripts/skills_pr_loop_constants/path_resolver_constants.py`):
-fixed | could_not_address | hook_blocked | unverified_fixed.
-
-Each outcome's scalar fields become XML attributes on `<outcome>`; the
-body fields named in `ALL_FIX_OUTCOME_BODY_ELEMENT_KEYS` (currently
-`("reason", "hook_output")`) become child elements.
-
-Usage:
-  python scripts/write_fix_outcomes.py --pr-number 422 --loop 3 --commit-sha abc1234 --outcomes-json <PATH> --worktree-path <PATH>
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-from xml.etree.ElementTree import Element, SubElement
-
-_self_dir = Path(__file__).resolve().parent
-if str(_self_dir) not in sys.path:
-    sys.path.insert(0, str(_self_dir))
-
-from _cli_utils import require_file
-from _path_resolver import fix_outcome_xml_path
-from _xml_utils import emit_pretty_xml
-from skills_pr_loop_constants.path_resolver_constants import (
-    ALL_FIX_OUTCOME_BODY_ELEMENT_KEYS,
-    ALL_VALID_FIX_STATUSES,
-)
-
-
-def validate_fix_statuses(all_outcomes: list[dict[str, object]]) -> list[str]:
-    """Validate that every outcome entry has a recognized status.
-
-    Args:
-        all_outcomes: List of outcome dicts, each expected to have a 'status' key.
-
-    Returns:
-        List of validation error messages (empty when valid).
-    """
-    valid_statuses = ALL_VALID_FIX_STATUSES
-    errors: list[str] = []
-    for each_index, each_outcome in enumerate(all_outcomes):
-        status = each_outcome.get("status")
-        if not isinstance(status, str):
-            errors.append(f"outcome[{each_index}]: status missing or not a string")
-            continue
-        if status not in valid_statuses:
-            errors.append(
-                f"outcome[{each_index}]: invalid status '{status}' "
-                f"(expected one of {sorted(valid_statuses)})"
-            )
-    return errors
-
-
-def build_fix_xml(
-    *,
-    pr_number: int,
-    loop: int,
-    commit_sha: str,
-    outcomes_json_path: Path,
-) -> Element:
-    """Build the <bugteam_fix> XML element from outcomes data.
-
-    Args:
-        pr_number: Pull request number.
-        loop: Loop iteration number.
-        commit_sha: Commit SHA of the fix commit.
-        outcomes_json_path: Path to the outcomes JSON file.
-
-    Returns:
-        Root <bugteam_fix> element.
-
-    Raises:
-        SystemExit: When outcomes-json is not a JSON array of objects, or
-            when status validation fails.
-    """
-    outcomes_data = json.loads(outcomes_json_path.read_text(encoding="utf-8"))
-    if not isinstance(outcomes_data, list):
-        print("outcomes-json must contain a JSON array", file=sys.stderr)
-        raise SystemExit(1)
-    for each_index, each_entry in enumerate(outcomes_data):
-        if not isinstance(each_entry, dict):
-            print(
-                f"outcomes-json[{each_index}]: each entry must be a JSON object",
-                file=sys.stderr,
-            )
-            raise SystemExit(1)
-    errors = validate_fix_statuses(outcomes_data)
-    if errors:
-        for each_error in errors:
-            print(each_error, file=sys.stderr)
-        raise SystemExit(1)
-
-    root = Element("bugteam_fix", {
-        "pr": str(pr_number),
-        "loop": str(loop),
-        "commit_sha": commit_sha,
-    })
-
-    all_fix_outcome_body_element_keys = ALL_FIX_OUTCOME_BODY_ELEMENT_KEYS
-    outcomes_elem = SubElement(root, "outcomes")
-    for each_outcome in outcomes_data:
-        outcome_elem = SubElement(outcomes_elem, "outcome")
-        for each_key, each_field_detail in each_outcome.items():
-            field_text = (
-                str(each_field_detail) if each_field_detail is not None else ""
-            )
-            if each_key in all_fix_outcome_body_element_keys:
-                child = SubElement(outcome_elem, each_key)
-                child.text = field_text
-            else:
-                outcome_elem.set(each_key, field_text)
-    return root
-
-
-def write_fix_xml(
-    *,
-    pr_number: int,
-    loop: int,
-    commit_sha: str,
-    outcomes_json_path: Path,
-    worktree_path: Path,
-) -> Path:
-    """Write the <bugteam_fix> XML to the canonical outcome path.
-
-    Args:
-        pr_number: Pull request number.
-        loop: Loop iteration number.
-        commit_sha: Commit SHA of the fix commit.
-        outcomes_json_path: Path to the outcomes JSON file.
-        worktree_path: Path to the git worktree.
-
-    Returns:
-        Path to the written XML file.
-    """
-    root = build_fix_xml(
-        pr_number=pr_number,
-        loop=loop,
-        commit_sha=commit_sha,
-        outcomes_json_path=outcomes_json_path,
-    )
-    xml_string = emit_pretty_xml(root)
-
-    output_path = fix_outcome_xml_path(worktree_path, pr_number, loop)
-    output_path.write_text(xml_string, encoding="utf-8")
-    return output_path
-
-
-def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
-    """Parse command-line arguments.
-
-    Args:
-        all_argv: Command-line argument list.
-
-    Returns:
-        Parsed namespace with pr_number, loop, commit_sha, outcomes_json, and worktree_path.
-    """
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--pr-number", type=int, required=True)
-    parser.add_argument("--loop", type=int, required=True)
-    parser.add_argument("--commit-sha", required=True)
-    parser.add_argument("--outcomes-json", type=Path, required=True)
-    parser.add_argument("--worktree-path", type=Path, required=True)
-    return parser.parse_args(all_argv)
-
-
-def main(all_arguments: list[str]) -> int:
-    """Entry point: write <bugteam_fix> XML at the canonical path.
-
-    Args:
-        all_arguments: Command-line arguments.
-
-    Returns:
-        0 on success, 1 on validation or write failure.
-    """
-    arguments = parse_arguments(all_arguments)
-    outcomes_path = getattr(arguments, "outcomes_json")
-
-    early_exit = require_file(outcomes_path, "outcomes-json")
-    if early_exit is not None:
-        return early_exit
-
-    try:
-        output_path = write_fix_xml(
-            pr_number=getattr(arguments, "pr_number"),
-            loop=arguments.loop,
-            commit_sha=getattr(arguments, "commit_sha"),
-            outcomes_json_path=outcomes_path,
-            worktree_path=getattr(arguments, "worktree_path"),
-        )
-    except SystemExit:
-        return 1
-    except (json.JSONDecodeError, OSError) as exc:
-        print(f"write_fix_xml failed: {exc}", file=sys.stderr)
-        return 1
-    print(output_path)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))