claude-dev-env 2.31.0 → 2.32.0

package/scripts/shared_tree_paths.py

@@ -0,0 +1,104 @@
+"""Resolve a scripts directory inside the installed shared tree.
+
+An install can place a managed directory behind a directory junction. Path
+resolution walks that link, so a parent computed from the resolved path
+names the link target's parent, where the shared tree does not sit.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+
+from dev_env_scripts_constants.shared_tree_constants import (
+    CLAUDE_CONFIG_DIR_ENV_VAR,
+    PROCESS_TREE_DIRECTORY_NAME,
+    PROCESS_TREE_KILL_MODULE_FILENAME,
+    SCRIPTS_DIRECTORY_NAME,
+    SHARED_PACKAGE_DIRECTORY_NAME,
+)
+
+
+def _shared_scripts_directory(from_root: Path, shared_subpackage_name: str) -> Path:
+    """Return the scripts directory one named sub-package holds under a root."""
+    return (
+        from_root
+        / SHARED_PACKAGE_DIRECTORY_NAME
+        / shared_subpackage_name
+        / SCRIPTS_DIRECTORY_NAME
+    )
+
+
+def resolve_shared_scripts_directory(
+    module_file: str | Path,
+    all_environment: Mapping[str, str],
+    shared_subpackage_name: str,
+    marker_filename: str,
+    anchor_depth: int,
+) -> Path:
+    """Return the first shared scripts directory that holds the marker file.
+
+    ::
+
+        the managed scripts directory is a junction
+        ok:   an un-resolved parent keeps the link side, where _shared sits
+        flag: a resolved parent walks the link and misses _shared entirely
+
+    Tries the un-resolved parent first, then the configured managed root,
+    then the resolved parent. When none holds the marker, returns the
+    un-resolved candidate, so an import failure names a readable path.
+
+    Args:
+        module_file: Path of the importing module (``__file__``).
+        all_environment: Mapping that may hold ``CLAUDE_CONFIG_DIR``.
+        shared_subpackage_name: Directory under ``_shared`` to resolve.
+        marker_filename: File whose presence marks the right directory.
+        anchor_depth: Parent levels above the module to treat as the root.
+
+    Returns:
+        Directory that should hold the marker file.
+    """
+    module_path = Path(module_file)
+    un_resolved_candidate = _shared_scripts_directory(
+        module_path.absolute().parents[anchor_depth], shared_subpackage_name
+    )
+    all_candidates = [un_resolved_candidate]
+    configured_root_text = all_environment.get(CLAUDE_CONFIG_DIR_ENV_VAR, "").strip()
+    if configured_root_text:
+        all_candidates.append(
+            _shared_scripts_directory(Path(configured_root_text), shared_subpackage_name)
+        )
+    all_candidates.append(
+        _shared_scripts_directory(
+            module_path.resolve().parents[anchor_depth], shared_subpackage_name
+        )
+    )
+    for each_candidate in all_candidates:
+        if (each_candidate / marker_filename).is_file():
+            return each_candidate
+    return un_resolved_candidate
+
+
+def resolve_shared_process_tree_scripts_directory(
+    module_file: str | Path,
+    all_environment: Mapping[str, str],
+) -> Path:
+    """Return the process-tree scripts directory that holds the kill helper.
+
+    Names the process-tree sub-package for a caller sitting one level under
+    the installed root, such as a script in the managed ``scripts`` directory.
+
+    Args:
+        module_file: Path of the importing module (``__file__``).
+        all_environment: Mapping that may hold ``CLAUDE_CONFIG_DIR``.
+
+    Returns:
+        Directory that should hold ``process_tree_kill.py``.
+    """
+    return resolve_shared_scripts_directory(
+        module_file,
+        all_environment,
+        PROCESS_TREE_DIRECTORY_NAME,
+        PROCESS_TREE_KILL_MODULE_FILENAME,
+        1,
+    )

package/scripts/test_shared_tree_paths.py

@@ -0,0 +1,173 @@
+"""Behavioral tests for shared-tree directory resolution."""
+
+from __future__ import annotations
+
+import importlib
+import os
+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 shared_tree_paths  # noqa: E402
+from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
+    CLAUDE_CONFIG_DIR_ENV_VAR,
+    PROCESS_TREE_DIRECTORY_NAME,
+    PROCESS_TREE_KILL_MODULE_FILENAME,
+    SCRIPTS_DIRECTORY_NAME,
+    SHARED_PACKAGE_DIRECTORY_NAME,
+)
+
+
+def _create_directory_link(*, from_link: Path, to_target: Path) -> None:
+    if sys.platform.startswith("win32"):
+        importlib.import_module("_winapi").CreateJunction(
+            str(to_target), str(from_link)
+        )
+        return
+    try:
+        os.symlink(to_target, from_link, target_is_directory=True)
+    except OSError:
+        pytest.skip("directory symlink creation is not available")
+
+
+def _build_junction_scripts_layout(tmp_path: Path) -> Path:
+    real_scripts_directory = tmp_path / "real" / SCRIPTS_DIRECTORY_NAME
+    real_scripts_directory.mkdir(parents=True)
+    (real_scripts_directory / "runner.py").write_text("", encoding="utf-8")
+    managed_root = tmp_path / "root"
+    managed_root.mkdir()
+    _create_directory_link(
+        from_link=managed_root / SCRIPTS_DIRECTORY_NAME,
+        to_target=real_scripts_directory,
+    )
+    return managed_root / SCRIPTS_DIRECTORY_NAME / "runner.py"
+
+
+def _write_process_tree_kill_stub(from_root: Path) -> Path:
+    scripts_directory = (
+        from_root
+        / SHARED_PACKAGE_DIRECTORY_NAME
+        / PROCESS_TREE_DIRECTORY_NAME
+        / SCRIPTS_DIRECTORY_NAME
+    )
+    scripts_directory.mkdir(parents=True)
+    (scripts_directory / PROCESS_TREE_KILL_MODULE_FILENAME).write_text(
+        "", encoding="utf-8"
+    )
+    return scripts_directory
+
+
+def test_junction_scripts_dir_finds_shared_tree_on_unresolved_parent(
+    tmp_path: Path,
+) -> None:
+    module_file = _build_junction_scripts_layout(tmp_path)
+    expected_scripts_directory = _write_process_tree_kill_stub(tmp_path / "root")
+    resolved_scripts_directory = (
+        shared_tree_paths.resolve_shared_process_tree_scripts_directory(
+            module_file, all_environment={}
+        )
+    )
+    assert resolved_scripts_directory == expected_scripts_directory
+
+
+def test_resolved_parent_is_used_when_link_side_has_no_shared_tree(
+    tmp_path: Path,
+) -> None:
+    module_file = _build_junction_scripts_layout(tmp_path)
+    expected_scripts_directory = _write_process_tree_kill_stub(tmp_path / "real")
+    resolved_scripts_directory = (
+        shared_tree_paths.resolve_shared_process_tree_scripts_directory(
+            module_file, all_environment={}
+        )
+    )
+    assert resolved_scripts_directory == expected_scripts_directory
+
+
+def test_configured_root_is_used_when_neither_parent_holds_the_module(
+    tmp_path: Path,
+) -> None:
+    module_file = _build_junction_scripts_layout(tmp_path)
+    configured_root = tmp_path / "configured"
+    expected_scripts_directory = _write_process_tree_kill_stub(configured_root)
+    resolved_scripts_directory = (
+        shared_tree_paths.resolve_shared_process_tree_scripts_directory(
+            module_file,
+            all_environment={
+                CLAUDE_CONFIG_DIR_ENV_VAR: str(configured_root)
+            },
+        )
+    )
+    assert resolved_scripts_directory == expected_scripts_directory
+
+
+def test_unresolved_parent_wins_when_configured_root_also_holds_the_module(
+    tmp_path: Path,
+) -> None:
+    module_file = _build_junction_scripts_layout(tmp_path)
+    expected_scripts_directory = _write_process_tree_kill_stub(tmp_path / "root")
+    configured_root = tmp_path / "configured"
+    _write_process_tree_kill_stub(configured_root)
+    resolved_scripts_directory = (
+        shared_tree_paths.resolve_shared_process_tree_scripts_directory(
+            module_file,
+            all_environment={
+                CLAUDE_CONFIG_DIR_ENV_VAR: str(configured_root)
+            },
+        )
+    )
+    assert resolved_scripts_directory == expected_scripts_directory
+
+
+def test_missing_module_returns_unresolved_candidate(tmp_path: Path) -> None:
+    module_file = _build_junction_scripts_layout(tmp_path)
+    expected_scripts_directory = (
+        tmp_path
+        / "root"
+        / SHARED_PACKAGE_DIRECTORY_NAME
+        / PROCESS_TREE_DIRECTORY_NAME
+        / SCRIPTS_DIRECTORY_NAME
+    )
+    resolved_scripts_directory = (
+        shared_tree_paths.resolve_shared_process_tree_scripts_directory(
+            module_file, all_environment={}
+        )
+    )
+    assert resolved_scripts_directory == expected_scripts_directory
+    assert not (
+        expected_scripts_directory / PROCESS_TREE_KILL_MODULE_FILENAME
+    ).is_file()
+
+
+def test_generalized_resolver_serves_a_deeper_anchor(tmp_path: Path) -> None:
+    """A caller three levels under the root resolves its own sub-package.
+
+    This is the shape the pr-loop and codex-review scripts carry, which the
+    process-tree wrapper's own anchor of one level cannot reach.
+    """
+    installed_root = tmp_path / "root"
+    module_directory = installed_root / "_shared" / "pr-loop" / "scripts"
+    module_directory.mkdir(parents=True)
+    module_file = str(module_directory / "run_codex_review.py")
+    expected_scripts_directory = (
+        installed_root
+        / SHARED_PACKAGE_DIRECTORY_NAME
+        / PROCESS_TREE_DIRECTORY_NAME
+        / SCRIPTS_DIRECTORY_NAME
+    )
+    expected_scripts_directory.mkdir(parents=True)
+    (expected_scripts_directory / PROCESS_TREE_KILL_MODULE_FILENAME).write_text(
+        "", encoding="utf-8"
+    )
+    resolved_scripts_directory = shared_tree_paths.resolve_shared_scripts_directory(
+        module_file,
+        {},
+        PROCESS_TREE_DIRECTORY_NAME,
+        PROCESS_TREE_KILL_MODULE_FILENAME,
+        3,
+    )
+    assert resolved_scripts_directory == expected_scripts_directory