claude-dev-env 1.30.1 → 1.32.0

package/skills/bugteam/scripts/bugteam_fix_hookspath.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _expected_hooks_path_suffix() -> str:
+    return "hooks/git-hooks"
+
+
+def _canonical_hooks_directory_components() -> tuple[str, ...]:
+    return (".claude", "hooks", "git-hooks")
+
+
+def _home_env_var_names() -> tuple[str, ...]:
+    return ("HOME", "USERPROFILE")
+
+
+def resolve_canonical_hooks_directory(
+    environment_overrides: dict[str, str] | None,
+) -> Path:
+    components = _canonical_hooks_directory_components()
+    if environment_overrides is not None:
+        for each_env_var_name in _home_env_var_names():
+            home_value = environment_overrides.get(each_env_var_name)
+            if home_value:
+                return Path(home_value).joinpath(*components)
+    return Path.home().joinpath(*components)
+
+
+def list_local_core_hooks_path_values(
+    repository_root: Path,
+    environment_overrides: dict[str, str] | None,
+) -> list[str]:
+    git_command = [
+        "git",
+        "-C",
+        str(repository_root),
+        "config",
+        "--local",
+        "--get-all",
+        "core.hooksPath",
+    ]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+        env=environment_overrides,
+    )
+    if completed_process.returncode != 0:
+        return []
+    return [
+        each_line.strip()
+        for each_line in completed_process.stdout.splitlines()
+        if each_line.strip()
+    ]
+
+
+def read_global_core_hooks_path(
+    environment_overrides: dict[str, str] | None,
+) -> str:
+    git_command = ["git", "config", "--global", "--get", "core.hooksPath"]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+        env=environment_overrides,
+    )
+    if completed_process.returncode != 0:
+        return ""
+    return completed_process.stdout.strip()
+
+
+def unset_local_core_hooks_path(
+    repository_root: Path,
+    environment_overrides: dict[str, str] | None,
+) -> None:
+    git_command = [
+        "git",
+        "-C",
+        str(repository_root),
+        "config",
+        "--local",
+        "--unset-all",
+        "core.hooksPath",
+    ]
+    subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment_overrides,
+    )
+
+
+def set_global_core_hooks_path(
+    target_value: str,
+    environment_overrides: dict[str, str] | None,
+) -> int:
+    git_command = ["git", "config", "--global", "core.hooksPath", target_value]
+    completed_process = subprocess.run(
+        git_command,
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment_overrides,
+    )
+    return completed_process.returncode
+
+
+def normalize_hooks_path(raw_value: str) -> str:
+    return raw_value.replace("\\", "/").rstrip("/")
+
+
+def is_canonical_hooks_path(raw_value: str) -> bool:
+    if not raw_value:
+        return False
+    return normalize_hooks_path(raw_value).endswith(_expected_hooks_path_suffix())
+
+
+def find_repository_root(start: Path) -> Path:
+    resolved_start = start.resolve()
+    candidate_paths = [resolved_start, *resolved_start.parents]
+    for each_candidate in candidate_paths:
+        marker = each_candidate / ".git"
+        if marker.is_dir() or marker.is_file():
+            return each_candidate
+    return resolved_start
+
+
+def rerun_preflight(
+    repository_root: Path,
+    environment_overrides: dict[str, str] | None,
+) -> int:
+    preflight_script_path = Path(__file__).resolve().parent / "bugteam_preflight.py"
+    rerun_command = [
+        sys.executable,
+        str(preflight_script_path),
+        "--no-pytest",
+        "--repo-root",
+        str(repository_root),
+    ]
+    completed_process = subprocess.run(
+        rerun_command,
+        check=False,
+        env=environment_overrides,
+    )
+    return completed_process.returncode
+
+
+def parse_arguments(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Auto-fix core.hooksPath when bugteam preflight detects a stale override. "
+            "Removes a local-scope override and ensures global core.hooksPath points "
+            "at the canonical claude-dev-env git-hooks directory."
+        ),
+    )
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=None,
+        help="Repository root (default: discover from cwd).",
+    )
+    return parser.parse_args(argv)
+
+
+def main(
+    argv: list[str] | None = None,
+    *,
+    environment_overrides: dict[str, str] | None = None,
+) -> int:
+    arguments = parse_arguments(sys.argv[1:] if argv is None else argv)
+    start_directory = Path.cwd()
+    repository_root = (
+        arguments.repo_root.resolve()
+        if arguments.repo_root is not None
+        else find_repository_root(start_directory)
+    )
+    canonical_hooks_directory = resolve_canonical_hooks_directory(environment_overrides)
+    expected_suffix = _expected_hooks_path_suffix()
+    if not canonical_hooks_directory.is_dir():
+        print(
+            "bugteam_fix_hookspath: canonical hooks directory does not exist: "
+            f"{canonical_hooks_directory}\n"
+            "Run: npx claude-dev-env .\n"
+            "Then re-run /bugteam. The directory must end in "
+            f"'{expected_suffix}' and contain the claude-dev-env git hook shims.",
+            file=sys.stderr,
+        )
+        return 1
+    local_hooks_path_values = list_local_core_hooks_path_values(
+        repository_root,
+        environment_overrides,
+    )
+    has_non_canonical_local_override = any(
+        not is_canonical_hooks_path(each_value)
+        for each_value in local_hooks_path_values
+    )
+    if has_non_canonical_local_override:
+        unset_local_core_hooks_path(repository_root, environment_overrides)
+        print(
+            "bugteam_fix_hookspath: removed stale local core.hooksPath override on "
+            f"{repository_root}",
+            file=sys.stderr,
+        )
+    current_global_value = read_global_core_hooks_path(environment_overrides)
+    if not is_canonical_hooks_path(current_global_value):
+        canonical_target_value = str(canonical_hooks_directory).replace("\\", "/")
+        global_set_exit_code = set_global_core_hooks_path(
+            canonical_target_value,
+            environment_overrides,
+        )
+        if global_set_exit_code != 0:
+            print(
+                "bugteam_fix_hookspath: failed to set global core.hooksPath to "
+                f"{canonical_target_value} (git exit {global_set_exit_code}).",
+                file=sys.stderr,
+            )
+            return 1
+        print(
+            "bugteam_fix_hookspath: set global core.hooksPath to "
+            f"{canonical_target_value}",
+            file=sys.stderr,
+        )
+    return rerun_preflight(repository_root, environment_overrides)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/bugteam/scripts/test_bugteam_fix_hookspath.py

@@ -0,0 +1,267 @@
+"""Tests for bugteam_fix_hookspath auto-remediation.
+
+Covers:
+- removes a local-scope core.hooksPath override and re-runs preflight
+- sets global core.hooksPath when missing
+- idempotent: second invocation produces the same final state with no errors
+- no-op when no override exists and global is already canonical
+- exits non-zero with a clear message when canonical hooks dir is missing
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import subprocess
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+
+def _load_fix_module() -> ModuleType:
+    module_path = Path(__file__).parent / "bugteam_fix_hookspath.py"
+    spec = importlib.util.spec_from_file_location("bugteam_fix_hookspath", 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
+
+
+bugteam_fix_hookspath = _load_fix_module()
+
+
+def _make_isolated_git_environment(home_directory: Path) -> dict[str, str]:
+    """Build an env dict that pins git's HOME and XDG paths into a tmp directory.
+
+    Without this, real `git config --global` reads/writes hit the developer's
+    actual ~/.gitconfig — which would corrupt the host machine and make tests
+    depend on global state. Pointing HOME, USERPROFILE, XDG_CONFIG_HOME, and
+    GIT_CONFIG_GLOBAL at a temp directory isolates the test fully.
+    """
+    isolated_environment = os.environ.copy()
+    isolated_environment["HOME"] = str(home_directory)
+    isolated_environment["USERPROFILE"] = str(home_directory)
+    isolated_environment["XDG_CONFIG_HOME"] = str(home_directory / ".config")
+    isolated_environment["GIT_CONFIG_GLOBAL"] = str(home_directory / ".gitconfig")
+    isolated_environment["GIT_CONFIG_NOSYSTEM"] = "1"
+    return isolated_environment
+
+
+def _initialize_repository(repository_path: Path, environment: dict[str, str]) -> None:
+    repository_path.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        ["git", "init", "--quiet", str(repository_path)],
+        check=True,
+        env=environment,
+    )
+
+
+def _set_local_hooks_path(
+    repository_path: Path,
+    hooks_path_value: str,
+    environment: dict[str, str],
+) -> None:
+    subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "config",
+            "--local",
+            "core.hooksPath",
+            hooks_path_value,
+        ],
+        check=True,
+        env=environment,
+    )
+
+
+def _set_global_hooks_path(hooks_path_value: str, environment: dict[str, str]) -> None:
+    subprocess.run(
+        ["git", "config", "--global", "core.hooksPath", hooks_path_value],
+        check=True,
+        env=environment,
+    )
+
+
+def _read_local_hooks_path(repository_path: Path, environment: dict[str, str]) -> str:
+    completed_process = subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "config",
+            "--local",
+            "--get",
+            "core.hooksPath",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment,
+    )
+    return completed_process.stdout.strip()
+
+
+def _read_global_hooks_path(environment: dict[str, str]) -> str:
+    completed_process = subprocess.run(
+        ["git", "config", "--global", "--get", "core.hooksPath"],
+        capture_output=True,
+        text=True,
+        check=False,
+        env=environment,
+    )
+    return completed_process.stdout.strip()
+
+
+def _create_canonical_hooks_directory(home_directory: Path) -> Path:
+    canonical_hooks_directory = home_directory / ".claude" / "hooks" / "git-hooks"
+    canonical_hooks_directory.mkdir(parents=True)
+    return canonical_hooks_directory
+
+
+def test_should_remove_local_override_and_pass_preflight(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0, (
+        "fix script must succeed when canonical global hooks dir exists"
+    )
+    assert _read_local_hooks_path(repository_path, environment) == "", (
+        "local core.hooksPath override must be removed"
+    )
+
+
+def test_should_set_global_hooks_path_when_missing(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    global_value_after_fix = _read_global_hooks_path(environment)
+    assert (
+        global_value_after_fix.replace("\\", "/")
+        .rstrip("/")
+        .endswith("hooks/git-hooks")
+    ), (
+        "fix script must set canonical global core.hooksPath when missing; "
+        f"got '{global_value_after_fix}'"
+    )
+
+
+def test_should_be_idempotent(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    first_exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+    second_exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert first_exit_code == 0
+    assert second_exit_code == 0, "second invocation must succeed without errors"
+    assert _read_local_hooks_path(repository_path, environment) == ""
+
+
+def test_should_no_op_when_already_clean(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    assert _read_local_hooks_path(repository_path, environment) == ""
+    assert (
+        _read_global_hooks_path(environment)
+        .replace("\\", "/")
+        .rstrip("/")
+        .endswith("hooks/git-hooks")
+    )
+
+
+def test_should_exit_nonzero_when_canonical_hooks_directory_missing(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    home_directory = tmp_path / "home"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    repository_path = tmp_path / "synthetic-repo"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code != 0, (
+        "fix script must fail clearly when ~/.claude/hooks/git-hooks does not exist "
+        "so the user knows to run `npx claude-dev-env .`"
+    )
+    captured_streams = capsys.readouterr()
+    assert "hooks/git-hooks" in captured_streams.err.replace("\\", "/")
+
+
+def test_should_handle_paths_with_spaces(tmp_path: Path) -> None:
+    home_directory = tmp_path / "home with space"
+    home_directory.mkdir()
+    environment = _make_isolated_git_environment(home_directory)
+    canonical_hooks_directory = _create_canonical_hooks_directory(home_directory)
+    _set_global_hooks_path(str(canonical_hooks_directory), environment)
+    repository_path = tmp_path / "repo with space"
+    _initialize_repository(repository_path, environment)
+    stale_local_value = str(repository_path / ".git" / "hooks")
+    _set_local_hooks_path(repository_path, stale_local_value, environment)
+
+    exit_code = bugteam_fix_hookspath.main(
+        ["--repo-root", str(repository_path)],
+        environment_overrides=environment,
+    )
+
+    assert exit_code == 0
+    assert _read_local_hooks_path(repository_path, environment) == ""

package/skills/logifix/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: logifix
+description: Restore the Logitech Gaming Software (LCore) tray icon when it disappears on Windows. Calls a PowerShell script that reproduces the verified Session 2 recovery procedure from 2026-04-25. Triggers on "logifix", "/logifix", "logitech tray icon missing", "LCore tray gone", "logitech is not loaded".
+---
+
+# logifix
+
+## Overview
+
+Restore the Logitech Gaming Software (LCore) tray icon by reproducing the verified recovery procedure documented in `sessions/System Support/2. Logitech Tray Icon Fix Recurrence.md`.
+
+**Announce at start:** "Running /logifix to restore the LCore tray icon."
+
+## What the script does
+
+`scripts/logifix.ps1` runs this sequence (verified during Session 2 on 2026-04-25):
+
+1. **State snapshot.** Explorer instances per session, Logitech services state, LCore process state.
+2. **Stop LCore in user context.** `Stop-Process -Name LCore -Force`.
+3. **Single elevated UAC step:**
+   - `Start-Service -Name LogiRegistryService` (handles the recurrence case where the service is Stopped).
+   - `Stop-Process -Name explorer -Force`.
+   - **Does NOT** call `Start-Process explorer` from inside the elevated block. Windows shell auto-respawn handles the user-session explorer cleanly. Skipping this line is the operative fix discovered in Session 2 — including it created a duplicate admin-context `explorer.exe` (no resolvable owner, parent = the admin pwsh) that blocked LCore tray registration.
+4. **Wait for Windows shell auto-respawn** (default 5 seconds).
+5. **Verify exactly one explorer in the user's session.**
+6. **Perform `LCoreRelaunchAttemptCount` full stop-then-launch cycles of `LCore.exe /minimized`** (default 2). The full count always runs — a responsive LCore on the first attempt does NOT imply the tray icon registered. Per Session 2 gotcha #2, the first relaunch can leave LCore responsive with no tray icon; only a second stop+launch reliably triggers `Shell_NotifyIcon` registration.
+7. **Final state snapshot.**
+
+## Invocation
+
+From Claude Code:
+
+```
+/logifix
+```
+
+Direct PowerShell:
+
+```
+pwsh -File "$HOME\.claude\skills\logifix\scripts\logifix.ps1"
+```
+
+Optional parameters (all have safe defaults):
+
+- `-ExplorerAutoRespawnWaitSeconds <int>` — wait after the elevated kill (default 5).
+- `-LCoreInitializationWaitSeconds <int>` — wait after each LCore relaunch before checking responsiveness (default 5).
+- `-LCoreRelaunchAttemptCount <int>` — number of LCore stop+launch cycles to perform (default 2). Always runs the full count.
+
+## When to use
+
+- LCore tray icon missing (also confirmed absent from the overflow `^` chevron).
+- LCore process is running but the tray icon never appears.
+- After resume from sleep, system restart, or a Logitech service crash that leaves LCore in a half-loaded state.
+
+## Fallback (if the script does not restore the icon)
+
+If `/logifix` reports that UAC was canceled, or LCore is still not responding after both relaunch cycles:
+
+1. **Ctrl+Shift+Esc** → Task Manager.
+2. Find **Windows Explorer** → right-click → **Restart**.
+3. Re-run `/logifix`.
+
+The Task Manager restart path is guaranteed to hit the correct interactive session and elevation context regardless of how the calling shell was launched. In Session 2, elevated calls from Claude Code's PowerShell tool could not be confirmed to reach the user's interactive Session 1 — Task Manager bypasses that ambiguity.
+
+## Source
+
+Procedure verified during Session 2 (Logitech Tray Icon Fix Recurrence), 2026-04-25. The session log lists the verified command set, the gotcha catalog, and the final process/service state.
+
+The "always run the full relaunch count" behavior was added on 2026-04-26 after `/logifix` reported success on the first responsive attempt but the tray icon never appeared — the original early-break optimization conflicted with documented Session 2 gotcha #2 (responsive LCore, no tray icon).