claude-dev-env 4.3.0 → 7.1.0

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

@@ -1,172 +0,0 @@
-"""Remove git worktrees and run temp directories for a bugteam run.
-
-Usage:
-  python scripts/teardown_worktrees.py --run-temp-dir <PATH> --all-pr-jsons <JSON>
-
-The JSON array must contain objects with keys: number, owner, repo.
-Tolerates already-removed worktrees and missing directories.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import shutil
-import stat
-import subprocess
-import sys
-from collections.abc import Callable
-from pathlib import Path
-
-_self_dir = Path(__file__).resolve().parent
-if str(_self_dir) not in sys.path:
-    sys.path.insert(0, str(_self_dir))
-
-from _path_resolver import per_pr_workspace
-from skills_pr_loop_constants.path_resolver_constants import ALL_PYTHON_ONEXC_VERSION
-
-
-def _remove_readonly_attribute(
-    removal_function: Callable[[str], None],
-    target_path: str,
-    *_exc_info: object,
-) -> None:
-    """Windows-safe handler: strip ReadOnly attribute and retry the syscall.
-
-    Args:
-        removal_function: The syscall that failed (os.unlink or os.rmdir).
-        target_path: Path to the file or directory that triggered the error.
-        *_exc_info: Exception information (collapses onerror/onexc signature difference).
-    """
-    try:
-        os.chmod(target_path, stat.S_IWRITE)
-        removal_function(target_path)
-    except OSError:
-        pass
-
-
-def force_rmtree(target_path: str) -> None:
-    """Remove a directory tree, handling Windows ReadOnly attribute.
-
-    Args:
-        target_path: Path to the directory tree to remove.
-    """
-    handler_kw: dict[str, object] = (
-        {"onexc": _remove_readonly_attribute}
-        if sys.version_info >= ALL_PYTHON_ONEXC_VERSION
-        else {"onerror": _remove_readonly_attribute}
-    )
-    try:
-        shutil.rmtree(target_path, **handler_kw)
-    except OSError:
-        pass
-
-
-def remove_worktree(worktree_path: Path) -> bool:
-    """Remove a single git worktree via `git worktree remove`.
-
-    Args:
-        worktree_path: Path to the worktree directory.
-
-    Returns:
-        True when the worktree was registered and removed, False when
-        it was already absent or unregistered.
-    """
-    if not worktree_path.exists():
-        return False
-    completed_process = subprocess.run(
-        ["git", "worktree", "remove", str(worktree_path)],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        check=False,
-    )
-    if completed_process.returncode != 0:
-        stderr_text = completed_process.stderr or ""
-        if "not a working tree" in stderr_text.lower():
-            force_rmtree(str(worktree_path))
-            return False
-        print(
-            f"git worktree remove failed for {worktree_path}: {stderr_text}",
-            file=sys.stderr,
-        )
-        return False
-    return True
-
-
-def teardown_run(
-    *,
-    run_temp_dir: Path,
-    all_pr_entries: list[dict[str, object]],
-) -> int:
-    """Remove all worktrees and the run temp directory.
-
-    Args:
-        run_temp_dir: Path to the run's temp directory.
-        all_pr_entries: List of dicts with number, owner, and repo keys.
-
-    Returns:
-        Count of worktrees successfully removed via git.
-    """
-    removed_count = 0
-    for each_entry in all_pr_entries:
-        pr_number = each_entry.get("number")
-        owner = each_entry.get("owner", "")
-        repo = each_entry.get("repo", "")
-        if not isinstance(pr_number, int):
-            continue
-        workspace = per_pr_workspace(run_temp_dir, str(owner), str(repo), pr_number)
-        if remove_worktree(workspace.worktree):
-            removed_count += 1
-
-    force_rmtree(str(run_temp_dir))
-    return removed_count
-
-
-def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
-    """Parse command-line arguments.
-
-    Args:
-        all_argv: Command-line argument list.
-
-    Returns:
-        Parsed namespace with run_temp_dir and all_pr_jsons.
-    """
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--run-temp-dir", type=Path, required=True)
-    parser.add_argument("--all-pr-jsons", required=True)
-    return parser.parse_args(all_argv)
-
-
-def main(all_arguments: list[str]) -> int:
-    """Entry point: remove worktrees and temp directory.
-
-    Args:
-        all_arguments: Command-line arguments.
-
-    Returns:
-        0 on success, 1 on JSON parse failure.
-    """
-    arguments = parse_arguments(all_arguments)
-    run_temp_dir = getattr(arguments, "run_temp_dir")
-    try:
-        all_pr_entries = json.loads(getattr(arguments, "all_pr_jsons"))
-    except json.JSONDecodeError as exc:
-        print(f"Invalid JSON for --all-pr-jsons: {exc}", file=sys.stderr)
-        return 1
-    if not isinstance(all_pr_entries, list):
-        print("--all-pr-jsons must be a JSON array", file=sys.stderr)
-        return 1
-
-    removed_count = teardown_run(
-        run_temp_dir=run_temp_dir,
-        all_pr_entries=all_pr_entries,
-    )
-    print(f"Removed {removed_count} worktree(s), cleaned {run_temp_dir.as_posix()}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))

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

@@ -1,106 +0,0 @@
-"""Tests for _path_resolver.per_pr_workspace typed structure."""
-
-from __future__ import annotations
-
-import dataclasses
-import importlib.util
-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_path_resolver() -> ModuleType:
-    module_path = _SCRIPTS_DIR / "_path_resolver.py"
-    spec = importlib.util.spec_from_file_location("_path_resolver", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["_path_resolver"] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-path_resolver = _load_path_resolver()
-
-
-def test_per_pr_workspace_returns_typed_structure_with_concrete_fields() -> None:
-    run_temp_dir = Path("/tmp/bugteam-pr-422")
-    workspace = path_resolver.per_pr_workspace(
-        run_temp_dir, "jl-cmd", "claude-dev-env", 422
-    )
-    assert isinstance(workspace, path_resolver.PerPrWorkspace)
-    assert isinstance(workspace.worktree, Path)
-    assert workspace.worktree == run_temp_dir / "pr-422" / "worktree"
-    assert isinstance(workspace.diff_patch_template, str)
-    assert isinstance(workspace.outcome_xml_template, str)
-    assert isinstance(workspace.fix_outcome_xml_template, str)
-
-
-def test_per_pr_workspace_diff_patch_template_carries_loop_placeholder() -> None:
-    run_temp_dir = Path("/tmp/bugteam-pr-7")
-    workspace = path_resolver.per_pr_workspace(run_temp_dir, "owner", "repo", 7)
-    rendered = workspace.diff_patch_template.format(loop=3)
-    assert rendered.endswith("loop-3.patch")
-    assert "owner-repo-pr-7" in rendered
-
-
-def test_per_pr_workspace_diff_patch_template_uses_forward_slashes() -> None:
-    run_temp_dir = Path("C:/Users/example/AppData/Local/Temp/bugteam-pr-376")
-    workspace = path_resolver.per_pr_workspace(run_temp_dir, "owner", "repo", 376)
-    assert "\\" not in workspace.diff_patch_template
-    assert workspace.diff_patch_template == (
-        "C:/Users/example/AppData/Local/Temp/bugteam-pr-376/"
-        "pr-376/owner-repo-pr-376/loop-{loop}.patch"
-    )
-
-
-def test_per_pr_workspace_is_frozen() -> None:
-    run_temp_dir = Path("/tmp/bugteam-pr-9")
-    workspace = path_resolver.per_pr_workspace(run_temp_dir, "owner", "repo", 9)
-    with pytest.raises(dataclasses.FrozenInstanceError):
-        workspace.worktree = Path("/tmp/other")
-
-
-def test_sanitize_branch_name_replaces_filesystem_unsafe_characters() -> None:
-    assert path_resolver.sanitize_branch_name("feat/my-branch") == "feat-my-branch"
-
-
-def test_build_run_name_uses_pr_number_for_single_pr() -> None:
-    assert path_resolver.build_run_name(422, "feat/x", is_multi_pr=False) == "bugteam-pr-422"
-
-
-def test_build_run_name_uses_sanitized_branch_for_multi_pr() -> None:
-    assert path_resolver.build_run_name(422, "feat/x", is_multi_pr=True) == "bugteam-feat-x"
-
-
-def test_slugify_pr_identity_joins_owner_repo_and_number() -> None:
-    assert (
-        path_resolver.slugify_pr_identity("jl-cmd", "claude-dev-env", 422)
-        == "jl-cmd-claude-dev-env-pr-422"
-    )
-
-
-def test_outcome_xml_path_embeds_pr_and_loop() -> None:
-    worktree_path = Path("/tmp/worktree")
-    outcome_path = path_resolver.outcome_xml_path(worktree_path, 422, 3)
-    assert outcome_path == worktree_path / ".bugteam-pr422-loop3.outcomes.xml"
-
-
-def test_fix_outcome_xml_path_embeds_pr_and_loop() -> None:
-    worktree_path = Path("/tmp/worktree")
-    fix_outcome_path = path_resolver.fix_outcome_xml_path(worktree_path, 422, 3)
-    assert fix_outcome_path == worktree_path / ".bugteam-pr422-loop3.fix-outcomes.xml"
-
-
-def test_diff_patch_path_joins_slug_and_loop_filename() -> None:
-    run_temp_dir = Path("/tmp/run")
-    patch_path = path_resolver.diff_patch_path(
-        run_temp_dir, "owner", "repo", 7, 2
-    )
-    assert patch_path == run_temp_dir / "owner-repo-pr-7" / "loop-2.patch"

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

@@ -1,94 +0,0 @@
-"""Parity tests for the A-Q audit-category schema and projections."""
-
-from __future__ import annotations
-
-import importlib.util
-import json
-import sys
-from pathlib import Path
-from types import ModuleType
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from skills_pr_loop_constants.audit_category_schema_constants import (
-    CATEGORY_SLUG_KEY,
-    CATEGORY_SUB_BUCKETS_KEY,
-    PROMPTS_DIRECTORY,
-    SCHEMA_CATEGORIES_KEY,
-    SKELETON_PLACEHOLDER_FRAGMENT,
-    SKELETON_SEPARATOR_LINE,
-    UTF8_ENCODING,
-)
-from skills_pr_loop_constants.path_resolver_constants import ALL_AUDIT_CATEGORY_ENTRIES
-
-
-def _load_audit_category_schema() -> ModuleType:
-    module_path = _SCRIPTS_DIR / "audit_category_schema.py"
-    spec = importlib.util.spec_from_file_location("audit_category_schema", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["audit_category_schema"] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-audit_category_schema = _load_audit_category_schema()
-
-
-def test_schema_lists_a_through_q_in_order() -> None:
-    schema = audit_category_schema.load_audit_category_schema()
-    all_ids = [each_category["id"] for each_category in schema["categories"]]
-    assert all_ids == list("ABCDEFGHIJKLMNOPQ")
-
-
-def test_schema_entries_match_constant_export() -> None:
-    assert (
-        audit_category_schema.category_id_title_entries()
-        == list(ALL_AUDIT_CATEGORY_ENTRIES)
-    )
-
-
-def test_validate_projections_matches_rubrics_and_prompts() -> None:
-    all_findings = audit_category_schema.validate_projections()
-    assert all_findings == [], all_findings
-
-
-def test_skeleton_projection_is_byte_stable() -> None:
-    schema = audit_category_schema.load_audit_category_schema()
-    first_render = audit_category_schema.render_skeleton_projections(schema)
-    second_render = audit_category_schema.render_skeleton_projections(
-        json.loads(json.dumps(schema))
-    )
-    assert first_render == second_render
-    assert "A1" in first_render["A"]
-    assert first_render["A"].count("\n") >= 1
-
-
-def test_schema_omits_worked_example_prose() -> None:
-    schema_path = audit_category_schema.audit_category_schema_path()
-    schema_text = schema_path.read_text(encoding="utf-8")
-    assert "Examples of Category" not in schema_text
-    assert "Sample prompt" not in schema_text
-
-
-def test_no_prompt_skeleton_uses_placeholder_count() -> None:
-    """Migrated prompts state a numeric sub-bucket count, never [N]."""
-    schema = audit_category_schema.load_audit_category_schema()
-    all_findings = audit_category_schema.validate_projections()
-    assert all_findings == [], all_findings
-    for each_category in schema[SCHEMA_CATEGORIES_KEY]:
-        slug = each_category[CATEGORY_SLUG_KEY]
-        assert isinstance(slug, str)
-        prompt_path = PROMPTS_DIRECTORY / f"{slug}.md"
-        all_skeleton_lines: list[str] = []
-        for each_line in prompt_path.read_text(encoding=UTF8_ENCODING).splitlines():
-            if each_line == SKELETON_SEPARATOR_LINE:
-                break
-            all_skeleton_lines.append(each_line)
-        skeleton_text = "\n".join(all_skeleton_lines)
-        assert SKELETON_PLACEHOLDER_FRAGMENT not in skeleton_text, slug
-        sub_bucket_count = len(each_category[CATEGORY_SUB_BUCKETS_KEY])
-        assert f"decomposed into {sub_bucket_count} sub-buckets" in skeleton_text, slug