claude-dev-env 1.36.1 → 1.37.0

package/_shared/pr-loop/scripts/grant_project_claude_permissions.py

@@ -0,0 +1,130 @@
+"""Grant Edit/Write/Read permissions on the current directory's .claude tree.
+
+Run from the project root whose .claude/** you want a Claude Code session
+(including spawned subagents) to edit without prompting. Writes idempotent
+entries into the user-scope settings at ~/.claude/settings.json and prints
+the changes applied. No-op when the entries already exist.
+"""
+
+import sys
+from pathlib import Path
+
+sys.modules.pop("config", None)
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from _claude_permissions_common import (  # noqa: E402
+    append_if_missing,
+    build_permission_rules,
+    ensure_dict_section,
+    ensure_list_entry,
+    exit_with_error,
+    get_current_project_path,
+    is_valid_project_root,
+    load_settings,
+    save_settings,
+)
+from config.claude_permissions_constants import (  # noqa: E402
+    ALL_PERMISSION_ALLOW_TOOLS,
+    AUTO_MODE_ENVIRONMENT_ENTRY_TEMPLATE,
+    get_claude_user_settings_path,
+)
+from config.claude_settings_keys_constants import (  # noqa: E402
+    CLAUDE_SETTINGS_ADDITIONAL_DIRECTORIES_KEY,
+    CLAUDE_SETTINGS_ALLOW_KEY,
+    CLAUDE_SETTINGS_AUTO_MODE_KEY,
+    CLAUDE_SETTINGS_ENVIRONMENT_KEY,
+    CLAUDE_SETTINGS_PERMISSIONS_KEY,
+)
+
+
+def add_rules_to_allow_list(
+    all_settings: dict[str, object], all_rules_to_add: list[str]
+) -> int:
+    permissions_section = ensure_dict_section(
+        all_settings, CLAUDE_SETTINGS_PERMISSIONS_KEY
+    )
+    existing_allow_list = ensure_list_entry(
+        permissions_section, CLAUDE_SETTINGS_ALLOW_KEY
+    )
+    return sum(
+        1
+        for each_rule in all_rules_to_add
+        if append_if_missing(existing_allow_list, each_rule)
+    )
+
+
+def add_directory_to_additional_directories(
+    all_settings: dict[str, object], directory_path: str
+) -> int:
+    permissions_section = ensure_dict_section(
+        all_settings, CLAUDE_SETTINGS_PERMISSIONS_KEY
+    )
+    existing_directories = ensure_list_entry(
+        permissions_section, CLAUDE_SETTINGS_ADDITIONAL_DIRECTORIES_KEY
+    )
+    if append_if_missing(existing_directories, directory_path):
+        return 1
+    return 0
+
+
+def add_auto_mode_environment_entry(
+    all_settings: dict[str, object], entry_text: str
+) -> int:
+    auto_mode_section = ensure_dict_section(
+        all_settings, CLAUDE_SETTINGS_AUTO_MODE_KEY
+    )
+    existing_environment = ensure_list_entry(
+        auto_mode_section, CLAUDE_SETTINGS_ENVIRONMENT_KEY
+    )
+    if append_if_missing(existing_environment, entry_text):
+        return 1
+    return 0
+
+
+def grant_permissions_for_current_directory() -> None:
+    claude_user_settings_path: Path = get_claude_user_settings_path()
+    project_root_path = Path.cwd()
+    if not is_valid_project_root(project_root_path):
+        print(
+            f"ERROR: cwd {project_root_path} is not a project root "
+            f"(no .git or .claude). Run from a project root.",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+    project_path = get_current_project_path()
+    all_permission_rules = build_permission_rules(
+        project_path, ALL_PERMISSION_ALLOW_TOOLS
+    )
+    environment_entry = AUTO_MODE_ENVIRONMENT_ENTRY_TEMPLATE.format(
+        project_path=project_path
+    )
+    settings = load_settings(claude_user_settings_path)
+    rules_added_count = add_rules_to_allow_list(settings, all_permission_rules)
+    directories_added_count = add_directory_to_additional_directories(
+        settings, project_path
+    )
+    environment_entries_added_count = add_auto_mode_environment_entry(
+        settings, environment_entry
+    )
+    total_changes_count = (
+        rules_added_count + directories_added_count + environment_entries_added_count
+    )
+    if total_changes_count == 0:
+        print(f"Project path: {project_path}")
+        print(f"Settings file: {claude_user_settings_path}")
+        print("No changes needed; settings file left untouched.")
+        return
+    save_settings(claude_user_settings_path, settings)
+    print(f"Project path: {project_path}")
+    print(f"Settings file: {claude_user_settings_path}")
+    print(f"Allow rules added: {rules_added_count} of {len(all_permission_rules)}")
+    print(f"Additional directories added: {directories_added_count}")
+    print(f"Auto-mode environment entries added: {environment_entries_added_count}")
+
+
+if __name__ == "__main__":
+    try:
+        grant_permissions_for_current_directory()
+    except ValueError as path_error:
+        exit_with_error(str(path_error))

package/_shared/pr-loop/scripts/preflight.py

@@ -0,0 +1,449 @@
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+sys.modules.pop("config", None)
+_script_directory_resolved = Path(__file__).resolve().parent
+_script_directory_absolute = Path(__file__).absolute().parent
+
+
+def _entry_points_at_preflight_script_directory(each_path_entry: str) -> bool:
+    if each_path_entry in (
+        str(_script_directory_resolved),
+        str(_script_directory_absolute),
+    ):
+        return True
+    try:
+        candidate_path = Path(each_path_entry)
+    except (OSError, ValueError):
+        return False
+    if candidate_path.exists():
+        try:
+            return os.path.samefile(candidate_path, _script_directory_resolved)
+        except OSError:
+            return False
+    return False
+
+
+for each_index in range(len(sys.path) - 1, -1, -1):
+    if _entry_points_at_preflight_script_directory(sys.path[each_index]):
+        sys.path.pop(each_index)
+_preflight_scripts_path_entry = str(_script_directory_absolute)
+if _preflight_scripts_path_entry not in sys.path:
+    sys.path.insert(0, _preflight_scripts_path_entry)
+
+from config.fix_hookspath_constants import HOOKS_PATH_VERIFICATION_SUFFIX
+from config.preflight_constants import (
+    ALL_GIT_CONFIG_GET_CORE_HOOKS_PATH_SUBCOMMAND,
+    ALL_GIT_DIFF_NAME_ONLY_SUBCOMMAND,
+    ALL_GIT_LS_FILES_TEST_DISCOVERY_SUBCOMMAND,
+    ALL_PRE_COMMIT_RUN_ALL_FILES_COMMAND,
+    BUGTEAM_PREFLIGHT_SKIP_ENABLED_VALUE,
+    BUGTEAM_PREFLIGHT_SKIP_ENV_VAR_NAME,
+    GIT_DIRECTORY_NAME,
+    PRE_COMMIT_CONFIG_YAML_FILENAME,
+    PYPROJECT_TOML_FILENAME,
+    PYTEST_FAILED_FIRST_FLAG,
+    PYTEST_INI_FILENAME,
+    ALL_PYTEST_SCOPE_CHOICES,
+    PYTEST_NO_TESTS_COLLECTED_EXIT_CODE,
+    PYTEST_SCOPE_ALL,
+    PYTEST_SCOPE_CHANGED,
+    PYTEST_TEST_FILENAME_PREFIX,
+    PYTEST_TEST_FILENAME_SUFFIX,
+    PYTEST_TOML_TABLE_PREFIX,
+    PYTHON_FILE_SUFFIX,
+    TESTS_DIRECTORY_NAME,
+)
+
+
+def verify_git_hooks_path(repository_root: Path | None = None) -> int:
+    """Check that core.hooksPath resolves to the claude-dev-env git-hooks directory.
+
+    When *repository_root* is provided, queries the effective config for that
+    repository (``git -C <root> config --get``), which detects repo-level
+    overrides such as Husky or lefthook. Falls back to the current working
+    directory's effective config when *repository_root* is None.
+
+    Returns zero when the configured path ends with the expected hooks suffix.
+    Returns non-zero and prints a correction message when unset or pointing elsewhere.
+    """
+    expected_hooks_path_suffix = HOOKS_PATH_VERIFICATION_SUFFIX
+    enforcement_absent_message = (
+        "Git-side CODE_RULES enforcement is not active on this host.\n"
+        "Run: npx claude-dev-env .\n"
+        "Or set core.hooksPath at any scope, e.g.:\n"
+        "  git config --global core.hooksPath ~/.claude/hooks/git-hooks"
+    )
+    git_command: list[str] = ["git"]
+    if repository_root is not None:
+        git_command.extend(["-C", str(repository_root)])
+    git_command.extend(list(ALL_GIT_CONFIG_GET_CORE_HOOKS_PATH_SUBCOMMAND))
+    try:
+        query_result = subprocess.run(
+            git_command,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+        )
+    except FileNotFoundError:
+        print(
+            "bugteam_preflight: git is not installed or not available on PATH.\n"
+            f"{enforcement_absent_message}",
+            file=sys.stderr,
+        )
+        return 1
+    except OSError as os_error:
+        print(
+            f"bugteam_preflight: failed to run git: {os_error}\n"
+            f"{enforcement_absent_message}",
+            file=sys.stderr,
+        )
+        return 1
+    if query_result.returncode != 0:
+        print(
+            f"bugteam_preflight: {enforcement_absent_message}",
+            file=sys.stderr,
+        )
+        return 1
+    configured_path = query_result.stdout.strip().replace("\\", "/").rstrip("/")
+    if not configured_path.endswith(expected_hooks_path_suffix):
+        print(
+            f"bugteam_preflight: core.hooksPath is '{configured_path}' — "
+            f"expected path ending in '{expected_hooks_path_suffix}'.\n"
+            f"{enforcement_absent_message}",
+            file=sys.stderr,
+        )
+        return 1
+    return 0
+
+
+def find_repository_root(start: Path) -> Path:
+    resolved = start.resolve()
+    all_candidates = [resolved, *resolved.parents]
+    for each_candidate in all_candidates:
+        git_marker = each_candidate / GIT_DIRECTORY_NAME
+        if git_marker.is_dir() or git_marker.is_file():
+            return each_candidate
+    for each_candidate in all_candidates:
+        if (each_candidate / PYTEST_INI_FILENAME).is_file():
+            return each_candidate
+    return resolved
+
+
+def has_pytest_configuration(root: Path) -> bool:
+    if (root / PYTEST_INI_FILENAME).is_file():
+        return True
+    pyproject = root / PYPROJECT_TOML_FILENAME
+    if not pyproject.is_file():
+        return False
+    text = pyproject.read_text(encoding="utf-8", errors="replace")
+    return PYTEST_TOML_TABLE_PREFIX in text
+
+
+def has_discoverable_tests(root: Path) -> bool | None:
+    git_marker = root / GIT_DIRECTORY_NAME
+    if not (git_marker.is_dir() or git_marker.is_file()):
+        return True
+    command = ["git", "-C", str(root), *ALL_GIT_LS_FILES_TEST_DISCOVERY_SUBCOMMAND]
+    try:
+        completed = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=True,
+        )
+    except FileNotFoundError:
+        print(
+            "bugteam_preflight: git is not installed or not available on PATH.",
+            file=sys.stderr,
+        )
+        return None
+    except subprocess.CalledProcessError as error:
+        error_detail = (error.stderr or "").strip()
+        print(
+            f"bugteam_preflight: git ls-files failed (exit {error.returncode}):"
+            + (f"\n{error_detail}" if error_detail else ""),
+            file=sys.stderr,
+        )
+        return None
+    except OSError as error:
+        print(
+            f"bugteam_preflight: failed to run git ls-files: {error}",
+            file=sys.stderr,
+        )
+        return None
+    return bool(completed.stdout.strip())
+
+
+def _pytest_exit_code_no_tests_collected() -> int:
+    pytest_no_tests_collected_exit_code = PYTEST_NO_TESTS_COLLECTED_EXIT_CODE
+    return pytest_no_tests_collected_exit_code
+
+
+def run_pytest(
+    repository_root: Path,
+    verbose: bool,
+    all_test_paths: list[Path] | None = None,
+) -> int:
+    command = [sys.executable, "-m", "pytest", PYTEST_FAILED_FIRST_FLAG]
+    if not verbose:
+        command.append("-q")
+    if all_test_paths is not None:
+        command.append("--")
+        command.extend(str(each_path) for each_path in all_test_paths)
+    completed = subprocess.run(
+        command,
+        cwd=str(repository_root),
+        check=False,
+    )
+    if completed.returncode == _pytest_exit_code_no_tests_collected():
+        return 0
+    return completed.returncode
+
+
+def get_changed_files(repository_root: Path, base_ref: str) -> list[Path] | None:
+    if base_ref.startswith("-"):
+        print(
+            f"bugteam_preflight: invalid base_ref '{base_ref}' starts "
+            f"with hyphen; falling back to full suite.",
+            file=sys.stderr,
+        )
+        return None
+    command = [
+        "git",
+        *ALL_GIT_DIFF_NAME_ONLY_SUBCOMMAND,
+        f"{base_ref}...HEAD",
+    ]
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=str(repository_root),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+        )
+    except FileNotFoundError:
+        print(
+            "bugteam_preflight: git is not installed or not available on PATH.\n"
+            f"bugteam_preflight: cannot determine changed files against "
+            f"{base_ref}; falling back to full suite.",
+            file=sys.stderr,
+        )
+        return None
+    except OSError as os_error:
+        print(
+            f"bugteam_preflight: failed to run git: {os_error}\n"
+            f"bugteam_preflight: cannot determine changed files against "
+            f"{base_ref}; falling back to full suite.",
+            file=sys.stderr,
+        )
+        return None
+    if completed.returncode != 0:
+        print(
+            f"bugteam_preflight: git diff against {base_ref} failed "
+            f"(exit {completed.returncode}); falling back to full suite.\n"
+            f"{completed.stderr.strip()}",
+            file=sys.stderr,
+        )
+        return None
+    return [
+        Path(each_line.strip())
+        for each_line in completed.stdout.splitlines()
+        if each_line.strip()
+    ]
+
+
+def _find_related_test_files(changed_path: Path, repository_root: Path) -> list[Path]:
+    if changed_path.suffix != PYTHON_FILE_SUFFIX:
+        return []
+    stem = changed_path.stem
+    test_prefix = PYTEST_TEST_FILENAME_PREFIX
+    test_suffix = PYTEST_TEST_FILENAME_SUFFIX
+    if (stem.startswith(test_prefix) or stem.endswith(test_suffix)) and (
+        repository_root / changed_path
+    ).is_file():
+        return [repository_root / changed_path]
+    full_path = repository_root / changed_path
+    parent = full_path.parent
+    adjacent_tests = parent / TESTS_DIRECTORY_NAME
+    top_tests = repository_root / TESTS_DIRECTORY_NAME
+    relative_parent = changed_path.parent
+    python_suffix = PYTHON_FILE_SUFFIX
+    all_candidates = [
+        parent / f"{test_prefix}{stem}{python_suffix}",
+        parent / f"{stem}{test_suffix}{python_suffix}",
+        adjacent_tests / f"{test_prefix}{stem}{python_suffix}",
+        adjacent_tests / f"{stem}{test_suffix}{python_suffix}",
+    ]
+    if relative_parent != Path("."):
+        all_candidates.extend([
+            top_tests / relative_parent / f"{test_prefix}{stem}{python_suffix}",
+            top_tests / relative_parent / f"{stem}{test_suffix}{python_suffix}",
+        ])
+    return sorted({each_candidate for each_candidate in all_candidates if each_candidate.is_file()})
+
+
+def discover_related_tests(
+    all_changed_files: list[Path], repository_root: Path
+) -> list[Path]:
+    related: set[Path] = set()
+    for each_file in all_changed_files:
+        related.update(_find_related_test_files(each_file, repository_root))
+    return sorted(related)
+
+
+def run_pre_commit(repository_root: Path) -> int:
+    completed = subprocess.run(
+        list(ALL_PRE_COMMIT_RUN_ALL_FILES_COMMAND),
+        cwd=str(repository_root),
+        check=False,
+    )
+    return completed.returncode
+
+
+def parse_arguments(all_arguments: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Run local checks before /bugteam (pytest, optional pre-commit).",
+    )
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=None,
+        help="Repository root (default: discover from cwd).",
+    )
+    parser.add_argument(
+        "--no-pytest",
+        action="store_true",
+        help="Skip pytest.",
+    )
+    parser.add_argument(
+        "--pre-commit",
+        action="store_true",
+        help=f"Run pre-commit when {PRE_COMMIT_CONFIG_YAML_FILENAME} exists.",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Verbose pytest output.",
+    )
+    parser.add_argument(
+        "--base-ref",
+        type=str,
+        default=None,
+        help=(
+            "Git base ref for scoped test selection (e.g., origin/main). "
+            "When set, only tests related to files changed vs this ref are run."
+        ),
+    )
+    parser.add_argument(
+        "--scope",
+        type=str,
+        choices=list(ALL_PYTEST_SCOPE_CHOICES),
+        default=None,
+        help=(
+            "Test selection scope. 'all' runs the full suite. "
+            "'changed' runs only tests related to changed files (requires --base-ref). "
+            "Defaults to 'changed' when --base-ref is provided, 'all' otherwise."
+        ),
+    )
+    return parser.parse_args(all_arguments)
+
+
+def main(all_arguments: list[str]) -> int:
+    arguments = parse_arguments(all_arguments)
+    skip_env_var_name = BUGTEAM_PREFLIGHT_SKIP_ENV_VAR_NAME
+    skip_enabled_value = BUGTEAM_PREFLIGHT_SKIP_ENABLED_VALUE
+    if os.environ.get(skip_env_var_name, "").strip() == skip_enabled_value:
+        print(
+            f"bugteam_preflight: skipped ({skip_env_var_name}={skip_enabled_value}).",
+            file=sys.stderr,
+        )
+        return 0
+    start = Path.cwd()
+    repository_root = (
+        arguments.repo_root.resolve()
+        if arguments.repo_root is not None
+        else find_repository_root(start)
+    )
+    hooks_path_exit_code = verify_git_hooks_path(repository_root)
+    if hooks_path_exit_code != 0:
+        return hooks_path_exit_code
+    if not arguments.no_pytest and has_pytest_configuration(repository_root):
+        discovery_result = has_discoverable_tests(repository_root)
+        if discovery_result is None:
+            print(
+                "bugteam_preflight: test discovery failed; running full suite anyway.",
+                file=sys.stderr,
+            )
+        elif not discovery_result:
+            print(
+                "bugteam_preflight: pytest configured but no tests found; skipping pytest.",
+                file=sys.stderr,
+            )
+        if discovery_result is not False:
+            effective_scope = arguments.scope
+            if discovery_result is None:
+                effective_scope = PYTEST_SCOPE_ALL
+            if effective_scope is None:
+                effective_scope = (
+                    PYTEST_SCOPE_CHANGED
+                    if arguments.base_ref is not None
+                    else PYTEST_SCOPE_ALL
+                )
+            if effective_scope == PYTEST_SCOPE_CHANGED and arguments.base_ref is None:
+                print(
+                    "bugteam_preflight: --scope changed requires --base-ref; "
+                    "falling back to full suite.",
+                    file=sys.stderr,
+                )
+                effective_scope = PYTEST_SCOPE_ALL
+            if effective_scope == PYTEST_SCOPE_CHANGED and arguments.base_ref is not None:
+                all_changed = get_changed_files(repository_root, arguments.base_ref)
+                if all_changed is None:
+                    exit_code = run_pytest(repository_root, arguments.verbose)
+                else:
+                    all_related = discover_related_tests(all_changed, repository_root)
+                    if all_related:
+                        print(
+                            f"bugteam_preflight: running {len(all_related)} test(s) "
+                            f"related to changed files (scope=changed).",
+                            file=sys.stderr,
+                        )
+                        exit_code = run_pytest(
+                            repository_root, arguments.verbose, all_related
+                        )
+                    else:
+                        print(
+                            "bugteam_preflight: no related tests found; "
+                            "running full suite.",
+                            file=sys.stderr,
+                        )
+                        exit_code = run_pytest(repository_root, arguments.verbose)
+            else:
+                exit_code = run_pytest(repository_root, arguments.verbose)
+            if exit_code != 0:
+                return exit_code
+    elif not arguments.no_pytest:
+        print(
+            "bugteam_preflight: no pytest configuration found; skipping pytest.",
+            file=sys.stderr,
+        )
+    if arguments.pre_commit and (repository_root / PRE_COMMIT_CONFIG_YAML_FILENAME).is_file():
+        exit_code = run_pre_commit(repository_root)
+        if exit_code != 0:
+            return exit_code
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))