claude-dev-env 4.2.0 → 7.0.0

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

@@ -1,287 +0,0 @@
-"""Tests for preflight_worktree against real git working trees."""
-
-from __future__ import annotations
-
-import importlib.util
-import subprocess
-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_preflight() -> ModuleType:
-    module_path = _SCRIPTS_DIR / "preflight_worktree.py"
-    spec = importlib.util.spec_from_file_location("preflight_worktree", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["preflight_worktree"] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-preflight = _load_preflight()
-
-GIT_TIMEOUT = 30
-CLAUDE_REMOTE = "https://github.com/jl-cmd/claude-dev-env.git"
-GIT_CEILING_DIRECTORIES = "GIT_CEILING_DIRECTORIES"
-
-
-@pytest.fixture(autouse=True)
-def _isolate_git_from_ancestor_repos(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    monkeypatch.setenv(GIT_CEILING_DIRECTORIES, str(tmp_path))
-
-
-def _git(repo_dir: Path, *args: str) -> None:
-    subprocess.run(
-        ["git", "-C", str(repo_dir), *args],
-        check=True,
-        capture_output=True,
-        text=True,
-        timeout=GIT_TIMEOUT,
-    )
-
-
-def _init_repo(repo_dir: Path, origin_url: str | None) -> Path:
-    repo_dir.mkdir(parents=True, exist_ok=True)
-    subprocess.run(
-        ["git", "init", "-q", str(repo_dir)],
-        check=True,
-        capture_output=True,
-        text=True,
-        timeout=GIT_TIMEOUT,
-    )
-    if origin_url is not None:
-        _git(repo_dir, "remote", "add", "origin", origin_url)
-    return repo_dir
-
-
-@pytest.mark.parametrize(
-    ("remote_url", "expected_owner", "expected_repo"),
-    [
-        (
-            "https://github.com/jl-cmd/claude-dev-env.git",
-            "jl-cmd",
-            "claude-dev-env",
-        ),
-        (
-            "https://github.com/jl-cmd/claude-dev-env",
-            "jl-cmd",
-            "claude-dev-env",
-        ),
-        ("git@github.com:Example/llm-settings.git", "example", "llm-settings"),
-        (
-            "ssh://git@github.com/jl-cmd/Claude-Dev-Env",
-            "jl-cmd",
-            "claude-dev-env",
-        ),
-        ("https://github.com/jl-cmd/repo/", "jl-cmd", "repo"),
-    ],
-)
-def test_parse_repo_identity_accepts_every_github_remote_form(
-    remote_url: str, expected_owner: str, expected_repo: str
-) -> None:
-    identity = preflight.parse_repo_identity(remote_url)
-    assert identity is not None
-    assert identity.owner == expected_owner
-    assert identity.repo == expected_repo
-
-
-@pytest.mark.parametrize(
-    "remote_url",
-    ["https://gitlab.com/foo/bar.git", "", "not-a-url"],
-)
-def test_parse_repo_identity_rejects_non_github_remotes(remote_url: str) -> None:
-    assert preflight.parse_repo_identity(remote_url) is None
-
-
-def test_is_inside_work_tree_true_in_git_repo(tmp_path: Path) -> None:
-    repo_dir = _init_repo(tmp_path / "session", None)
-    assert preflight.is_inside_work_tree(repo_dir) is True
-
-
-def test_is_inside_work_tree_false_in_plain_directory(tmp_path: Path) -> None:
-    plain_dir = tmp_path / "home"
-    plain_dir.mkdir()
-    assert preflight.is_inside_work_tree(plain_dir) is False
-
-
-def test_worktree_machinery_is_healthy_true_in_git_repo(tmp_path: Path) -> None:
-    repo_dir = _init_repo(tmp_path / "session", None)
-    assert preflight.worktree_machinery_is_healthy(repo_dir) is True
-
-
-def test_worktree_machinery_is_healthy_false_in_plain_directory(
-    tmp_path: Path,
-) -> None:
-    plain_dir = tmp_path / "home"
-    plain_dir.mkdir()
-    assert preflight.worktree_machinery_is_healthy(plain_dir) is False
-
-
-def test_classify_same_repo_when_origin_matches_pr(tmp_path: Path) -> None:
-    repo_dir = _init_repo(tmp_path / "session", CLAUDE_REMOTE)
-    pr_identity = preflight.RepoIdentity("jl-cmd", "claude-dev-env")
-    verdict = preflight.classify_environment(repo_dir, pr_identity)
-    assert verdict.outcome == preflight.OUTCOME_SAME_REPO
-    assert verdict.cwd_identity == pr_identity
-    assert verdict.has_healthy_worktree_machinery is True
-
-
-def test_classify_different_repo_when_origin_is_another_github_repo(
-    tmp_path: Path,
-) -> None:
-    repo_dir = _init_repo(
-        tmp_path / "session", "https://github.com/example/llm-settings.git"
-    )
-    pr_identity = preflight.RepoIdentity("jl-cmd", "claude-dev-env")
-    verdict = preflight.classify_environment(repo_dir, pr_identity)
-    assert verdict.outcome == preflight.OUTCOME_DIFFERENT_REPO
-    assert verdict.cwd_identity == preflight.RepoIdentity("example", "llm-settings")
-
-
-def test_classify_different_repo_when_origin_is_non_github(tmp_path: Path) -> None:
-    repo_dir = _init_repo(tmp_path / "session", "https://gitlab.com/foo/bar.git")
-    pr_identity = preflight.RepoIdentity("jl-cmd", "claude-dev-env")
-    verdict = preflight.classify_environment(repo_dir, pr_identity)
-    assert verdict.outcome == preflight.OUTCOME_DIFFERENT_REPO
-    assert verdict.cwd_identity is None
-
-
-def test_classify_re_rooted_when_origin_is_absent(tmp_path: Path) -> None:
-    repo_dir = _init_repo(tmp_path / "session", None)
-    pr_identity = preflight.RepoIdentity("jl-cmd", "claude-dev-env")
-    verdict = preflight.classify_environment(repo_dir, pr_identity)
-    assert verdict.outcome == preflight.OUTCOME_RE_ROOTED
-
-
-def test_classify_re_rooted_when_directory_is_not_a_work_tree(
-    tmp_path: Path,
-) -> None:
-    plain_dir = tmp_path / "home"
-    plain_dir.mkdir()
-    pr_identity = preflight.RepoIdentity("jl-cmd", "claude-dev-env")
-    verdict = preflight.classify_environment(plain_dir, pr_identity)
-    assert verdict.outcome == preflight.OUTCOME_RE_ROOTED
-    assert verdict.has_healthy_worktree_machinery is False
-
-
-@pytest.mark.parametrize(
-    ("outcome", "is_healthy", "mode", "expected_exit"),
-    [
-        ("same_repo", True, "strict", 0),
-        ("same_repo", True, "classify", 0),
-        ("same_repo", False, "strict", 1),
-        ("same_repo", False, "classify", 1),
-        ("different_repo", True, "strict", 1),
-        ("different_repo", True, "classify", 0),
-        ("re_rooted", False, "strict", 1),
-        ("re_rooted", False, "classify", 1),
-    ],
-)
-def test_decide_exit_code_matrix(
-    outcome: str, is_healthy: bool, mode: str, expected_exit: int
-) -> None:
-    verdict = preflight.PreflightVerdict(
-        outcome=outcome,
-        cwd_identity=None,
-        has_healthy_worktree_machinery=is_healthy,
-    )
-    assert preflight.decide_exit_code(verdict, mode) == expected_exit
-
-
-def test_build_report_lines_marks_outcome_and_routes_cross_repo() -> None:
-    verdict = preflight.PreflightVerdict(
-        outcome=preflight.OUTCOME_DIFFERENT_REPO,
-        cwd_identity=preflight.RepoIdentity("example", "llm-settings"),
-        has_healthy_worktree_machinery=True,
-    )
-    pr_identity = preflight.RepoIdentity("jl-cmd", "claude-dev-env")
-    classify_lines = preflight.build_report_lines(
-        verdict, "classify", Path("/tmp/x"), pr_identity
-    )
-    assert classify_lines[0] == "PREFLIGHT_OUTCOME=different_repo"
-    assert any("ROUTE" in line for line in classify_lines)
-    strict_lines = preflight.build_report_lines(
-        verdict, "strict", Path("/tmp/x"), pr_identity
-    )
-    assert any("ABORT" in line for line in strict_lines)
-
-
-def test_build_report_lines_aborts_on_broken_worktree_machinery() -> None:
-    verdict = preflight.PreflightVerdict(
-        outcome=preflight.OUTCOME_SAME_REPO,
-        cwd_identity=preflight.RepoIdentity("jl-cmd", "claude-dev-env"),
-        has_healthy_worktree_machinery=False,
-    )
-    pr_identity = preflight.RepoIdentity("jl-cmd", "claude-dev-env")
-    lines = preflight.build_report_lines(verdict, "strict", Path("/tmp/x"), pr_identity)
-    assert lines[0] == "PREFLIGHT_OUTCOME=same_repo"
-    assert any("git worktree prune" in line for line in lines)
-
-
-def test_main_strict_passes_in_matching_repo(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    repo_dir = _init_repo(tmp_path / "session", CLAUDE_REMOTE)
-    monkeypatch.chdir(repo_dir)
-    exit_code = preflight.main(
-        ["--owner", "jl-cmd", "--repo", "claude-dev-env", "--mode", "strict"]
-    )
-    captured = capsys.readouterr()
-    assert exit_code == preflight.EXIT_PREFLIGHT_OK
-    assert "PREFLIGHT_OUTCOME=same_repo" in captured.out
-
-
-def test_main_strict_aborts_when_session_rooted_in_other_repo(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    repo_dir = _init_repo(
-        tmp_path / "session", "https://github.com/example/llm-settings.git"
-    )
-    monkeypatch.chdir(repo_dir)
-    exit_code = preflight.main(
-        ["--owner", "jl-cmd", "--repo", "claude-dev-env", "--mode", "strict"]
-    )
-    captured = capsys.readouterr()
-    assert exit_code == preflight.EXIT_PREFLIGHT_ABORT
-    assert "PREFLIGHT_OUTCOME=different_repo" in captured.out
-    assert "ABORT" in captured.out
-
-
-def test_main_classify_routes_cross_repo_without_abort(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    repo_dir = _init_repo(
-        tmp_path / "session", "https://github.com/example/llm-settings.git"
-    )
-    monkeypatch.chdir(repo_dir)
-    exit_code = preflight.main(
-        ["--owner", "jl-cmd", "--repo", "claude-dev-env", "--mode", "classify"]
-    )
-    captured = capsys.readouterr()
-    assert exit_code == preflight.EXIT_PREFLIGHT_OK
-    assert "PREFLIGHT_OUTCOME=different_repo" in captured.out
-    assert "ROUTE" in captured.out
-
-
-def test_main_classify_aborts_when_re_rooted(
-    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    plain_dir = tmp_path / "home"
-    plain_dir.mkdir()
-    monkeypatch.chdir(plain_dir)
-    exit_code = preflight.main(
-        ["--owner", "jl-cmd", "--repo", "claude-dev-env", "--mode", "classify"]
-    )
-    captured = capsys.readouterr()
-    assert exit_code == preflight.EXIT_PREFLIGHT_ABORT
-    assert "PREFLIGHT_OUTCOME=re_rooted" in captured.out

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

@@ -1,207 +0,0 @@
-"""Tests for select_converge_pacer — host tool surface → pacer mapping."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-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))
-
-import select_converge_pacer as pacer_module  # noqa: E402
-from skills_pr_loop_constants.pacer_constants import (  # noqa: E402
-    CLI_HAS_SCHEDULE_WAKEUP_FLAG,
-    CLI_HAS_WORKFLOW_FLAG,
-    CLI_SKILL_FLAG,
-    ENTRY_SKILL_AUTOCONVERGE,
-    ENTRY_SKILL_PR_CONVERGE,
-    EXIT_SUCCESS,
-    EXIT_USAGE_ERROR,
-    PACER_PORTABLE,
-    PACER_SCHEDULE_WAKEUP,
-    PACER_WORKFLOW,
-    RESULT_KEY_ENTRY_SKILL,
-    RESULT_KEY_HAS_SCHEDULE_WAKEUP,
-    RESULT_KEY_HAS_WORKFLOW,
-    RESULT_KEY_PACER,
-)
-
-SCRIPT_PATH = _SCRIPTS_DIR / "select_converge_pacer.py"
-
-
-def test_autoconverge_with_workflow_selects_workflow() -> None:
-    selection = pacer_module.select_converge_pacer(
-        entry_skill=ENTRY_SKILL_AUTOCONVERGE,
-        has_workflow=True,
-        has_schedule_wakeup=False,
-    )
-    assert selection.pacer == PACER_WORKFLOW
-    assert selection.entry_skill == ENTRY_SKILL_AUTOCONVERGE
-
-
-def test_autoconverge_without_workflow_selects_portable() -> None:
-    selection = pacer_module.select_converge_pacer(
-        entry_skill=ENTRY_SKILL_AUTOCONVERGE,
-        has_workflow=False,
-        has_schedule_wakeup=True,
-    )
-    assert selection.pacer == PACER_PORTABLE
-
-
-def test_pr_converge_with_schedule_wakeup_selects_schedule_wakeup() -> None:
-    selection = pacer_module.select_converge_pacer(
-        entry_skill=ENTRY_SKILL_PR_CONVERGE,
-        has_workflow=False,
-        has_schedule_wakeup=True,
-    )
-    assert selection.pacer == PACER_SCHEDULE_WAKEUP
-    assert selection.entry_skill == ENTRY_SKILL_PR_CONVERGE
-
-
-def test_pr_converge_without_schedule_wakeup_selects_portable() -> None:
-    selection = pacer_module.select_converge_pacer(
-        entry_skill=ENTRY_SKILL_PR_CONVERGE,
-        has_workflow=True,
-        has_schedule_wakeup=False,
-    )
-    assert selection.pacer == PACER_PORTABLE
-
-
-def test_third_party_surface_selects_portable_for_both_entries() -> None:
-    for each_skill in (ENTRY_SKILL_AUTOCONVERGE, ENTRY_SKILL_PR_CONVERGE):
-        selection = pacer_module.select_converge_pacer(
-            entry_skill=each_skill,
-            has_workflow=False,
-            has_schedule_wakeup=False,
-        )
-        assert selection.pacer == PACER_PORTABLE, each_skill
-
-
-def test_unknown_entry_skill_raises() -> None:
-    with pytest.raises(ValueError, match="entry skill must be one of"):
-        pacer_module.select_converge_pacer(
-            entry_skill="bugteam",
-            has_workflow=False,
-            has_schedule_wakeup=False,
-        )
-
-
-def test_parse_bool_flag_accepts_common_tokens() -> None:
-    assert pacer_module.parse_bool_flag("1") is True
-    assert pacer_module.parse_bool_flag("true") is True
-    assert pacer_module.parse_bool_flag("YES") is True
-    assert pacer_module.parse_bool_flag("0") is False
-    assert pacer_module.parse_bool_flag("false") is False
-    assert pacer_module.parse_bool_flag("OFF") is False
-
-
-def test_parse_bool_flag_rejects_unknown_token() -> None:
-    with pytest.raises(ValueError, match="boolean token"):
-        pacer_module.parse_bool_flag("maybe")
-
-
-def test_selection_as_json_dict_uses_stable_keys() -> None:
-    selection = pacer_module.select_converge_pacer(
-        entry_skill=ENTRY_SKILL_PR_CONVERGE,
-        has_workflow=False,
-        has_schedule_wakeup=False,
-    )
-    payload = pacer_module.selection_as_json_dict(selection)
-    assert payload[RESULT_KEY_PACER] == PACER_PORTABLE
-    assert payload[RESULT_KEY_ENTRY_SKILL] == ENTRY_SKILL_PR_CONVERGE
-    assert payload[RESULT_KEY_HAS_WORKFLOW] is False
-    assert payload[RESULT_KEY_HAS_SCHEDULE_WAKEUP] is False
-
-
-def test_cli_prints_json_and_exits_zero() -> None:
-    completed = subprocess.run(
-        [
-            sys.executable,
-            str(SCRIPT_PATH),
-            "--skill",
-            ENTRY_SKILL_AUTOCONVERGE,
-            "--has-workflow",
-            "0",
-            "--has-schedule-wakeup",
-            "0",
-        ],
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-    assert completed.returncode == EXIT_SUCCESS, completed.stderr
-    payload = json.loads(completed.stdout)
-    assert payload[RESULT_KEY_PACER] == PACER_PORTABLE
-    assert payload[RESULT_KEY_ENTRY_SKILL] == ENTRY_SKILL_AUTOCONVERGE
-
-
-def test_cli_rejects_bad_bool_with_usage_exit() -> None:
-    completed = subprocess.run(
-        [
-            sys.executable,
-            str(SCRIPT_PATH),
-            "--skill",
-            ENTRY_SKILL_PR_CONVERGE,
-            "--has-workflow",
-            "nope",
-            "--has-schedule-wakeup",
-            "0",
-        ],
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-    assert completed.returncode == EXIT_USAGE_ERROR
-    assert "boolean token" in completed.stderr
-
-
-def test_main_returns_usage_error_on_value_error(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    def raise_value_error(**_kwargs: object) -> object:
-        raise ValueError("entry skill must be one of")
-
-    monkeypatch.setattr(
-        pacer_module, "select_converge_pacer", raise_value_error
-    )
-    exit_code = pacer_module.main(
-        [
-            "--skill",
-            ENTRY_SKILL_PR_CONVERGE,
-            "--has-workflow",
-            "0",
-            "--has-schedule-wakeup",
-            "0",
-        ]
-    )
-    assert exit_code == EXIT_USAGE_ERROR
-
-
-def test_build_argument_parser_requires_skill_and_host_flags() -> None:
-    parser = pacer_module.build_argument_parser()
-    all_option_strings = {
-        each_option
-        for each_action in parser._actions
-        for each_option in each_action.option_strings
-    }
-    assert CLI_SKILL_FLAG in all_option_strings
-    assert CLI_HAS_WORKFLOW_FLAG in all_option_strings
-    assert CLI_HAS_SCHEDULE_WAKEUP_FLAG in all_option_strings
-    parsed_namespace = parser.parse_args(
-        [
-            CLI_SKILL_FLAG,
-            ENTRY_SKILL_AUTOCONVERGE,
-            CLI_HAS_WORKFLOW_FLAG,
-            "1",
-            CLI_HAS_SCHEDULE_WAKEUP_FLAG,
-            "0",
-        ]
-    )
-    assert parsed_namespace.skill == ENTRY_SKILL_AUTOCONVERGE
-    assert parsed_namespace.has_workflow == "1"
-    assert parsed_namespace.has_schedule_wakeup == "0"

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

@@ -1,59 +0,0 @@
-"""Tests for teardown_worktrees.teardown_run consuming the typed workspace."""
-
-from __future__ import annotations
-
-import importlib.util
-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))
-
-
-def _load_teardown_module() -> ModuleType:
-    module_path = _SCRIPTS_DIR / "teardown_worktrees.py"
-    spec = importlib.util.spec_from_file_location("teardown_worktrees", 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
-
-
-teardown_worktrees = _load_teardown_module()
-
-
-def test_teardown_run_returns_zero_when_no_worktrees_exist(tmp_path: Path) -> None:
-    """With absent worktrees, teardown_run removes nothing and reports zero,
-    reading each worktree path from the typed PerPrWorkspace.worktree attribute
-    rather than a dict lookup."""
-    run_temp_dir = tmp_path / "run"
-    run_temp_dir.mkdir()
-    all_pr_entries: list[dict[str, object]] = [
-        {"number": 7, "owner": "owner", "repo": "repo"},
-    ]
-    removed_count = teardown_worktrees.teardown_run(
-        run_temp_dir=run_temp_dir,
-        all_pr_entries=all_pr_entries,
-    )
-    assert removed_count == 0
-    assert not run_temp_dir.exists()
-
-
-def test_teardown_run_skips_entries_without_integer_number(tmp_path: Path) -> None:
-    """A PR entry whose number is not an integer is skipped before any workspace
-    resolution, so teardown_run reports zero removals and still clears the run
-    temp directory."""
-    run_temp_dir = tmp_path / "run"
-    run_temp_dir.mkdir()
-    all_pr_entries: list[dict[str, object]] = [
-        {"number": "not-an-int", "owner": "owner", "repo": "repo"},
-    ]
-    removed_count = teardown_worktrees.teardown_run(
-        run_temp_dir=run_temp_dir,
-        all_pr_entries=all_pr_entries,
-    )
-    assert removed_count == 0
-    assert not run_temp_dir.exists()