claude-arcade 0.1.0__tar.gz

claude_arcade-0.1.0/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(pip install:*)",
+      "Bash(claude-arcade:*)",
+      "Bash(python3 -m json.tool)",
+      "Bash(python3 -c \"import json; s=json.load\\(open\\('/Users/apple/.claude/settings.json'\\)\\); print\\('hooks remaining:', s.get\\('hooks', {}\\)\\)\")",
+      "Bash(python3:*)"
+    ]
+  }
+}

claude_arcade-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: claude-arcade
+Version: 0.1.0
+Summary: Play games while Claude thinks — a collection of terminal mini-games that hook into Claude Code
+Project-URL: Homepage, https://github.com/yourusername/claude-arcade
+Project-URL: Issues, https://github.com/yourusername/claude-arcade/issues
+License: MIT
+Keywords: claude,claude-code,cli,curses,game,terminal
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Terminals
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# claude-arcade
+
+Play mini-games in your terminal while Claude thinks.
+
+Hooks into [Claude Code](https://claude.ai/code) so a game launches automatically every time Claude runs a tool — and disappears the moment it's done. Your terminal is fully restored, nothing is lost.
+
+## Install
+
+```bash
+pipx install claude-arcade
+```
+
+> `pipx` is recommended so the package gets its own isolated environment.  
+> Plain `pip install claude-arcade` works too.
+
+## Quick start
+
+```bash
+# 1. One-time setup — writes hooks into ~/.claude/settings.json
+claude-arcade setup
+
+# 2. Use Claude Code as normal
+claude
+
+# The bird game now appears automatically whenever Claude uses a tool.
+# It disappears and restores your terminal when Claude is done.
+```
+
+## Play manually
+
+```bash
+claude-arcade play        # Bird Hunt (default)
+claude-arcade play bird   # same thing
+```
+
+## Bird Hunt controls
+
+| Key | Action |
+|-----|--------|
+| Arrow keys / WASD | Move crosshair |
+| `SPACE` | Shoot |
+| `Q` | Quit |
+
+Birds fly across the screen at different speeds and are worth different points:
+
+| Bird | Points | Speed |
+|------|--------|-------|
+| `>->` | 3 | Fast |
+| `>~~>` | 1 | Normal |
+| `>°~°>` | 2 | Slow |
+
+## Remove hooks
+
+```bash
+claude-arcade unsetup
+```
+
+## How it works
+
+`claude-arcade setup` adds three hooks to `~/.claude/settings.json`:
+
+- **PreToolUse** → `claude-arcade start` — forks a background process that takes over the terminal alternate screen buffer and runs the game.
+- **PostToolUse** + **Stop** → `claude-arcade stop` — signals the game to exit and restores your terminal exactly as you left it.
+
+Because the game runs on the [alternate screen buffer](https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-The-Alternate-Screen-Buffer), all of Claude's output is preserved underneath.
+
+## Requirements
+
+- macOS or Linux
+- Python 3.9+
+- Claude Code CLI
+
+## License
+
+MIT

claude_arcade-0.1.0/README.md

@@ -0,0 +1,75 @@
+# claude-arcade
+
+Play mini-games in your terminal while Claude thinks.
+
+Hooks into [Claude Code](https://claude.ai/code) so a game launches automatically every time Claude runs a tool — and disappears the moment it's done. Your terminal is fully restored, nothing is lost.
+
+## Install
+
+```bash
+pipx install claude-arcade
+```
+
+> `pipx` is recommended so the package gets its own isolated environment.  
+> Plain `pip install claude-arcade` works too.
+
+## Quick start
+
+```bash
+# 1. One-time setup — writes hooks into ~/.claude/settings.json
+claude-arcade setup
+
+# 2. Use Claude Code as normal
+claude
+
+# The bird game now appears automatically whenever Claude uses a tool.
+# It disappears and restores your terminal when Claude is done.
+```
+
+## Play manually
+
+```bash
+claude-arcade play        # Bird Hunt (default)
+claude-arcade play bird   # same thing
+```
+
+## Bird Hunt controls
+
+| Key | Action |
+|-----|--------|
+| Arrow keys / WASD | Move crosshair |
+| `SPACE` | Shoot |
+| `Q` | Quit |
+
+Birds fly across the screen at different speeds and are worth different points:
+
+| Bird | Points | Speed |
+|------|--------|-------|
+| `>->` | 3 | Fast |
+| `>~~>` | 1 | Normal |
+| `>°~°>` | 2 | Slow |
+
+## Remove hooks
+
+```bash
+claude-arcade unsetup
+```
+
+## How it works
+
+`claude-arcade setup` adds three hooks to `~/.claude/settings.json`:
+
+- **PreToolUse** → `claude-arcade start` — forks a background process that takes over the terminal alternate screen buffer and runs the game.
+- **PostToolUse** + **Stop** → `claude-arcade stop` — signals the game to exit and restores your terminal exactly as you left it.
+
+Because the game runs on the [alternate screen buffer](https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-The-Alternate-Screen-Buffer), all of Claude's output is preserved underneath.
+
+## Requirements
+
+- macOS or Linux
+- Python 3.9+
+- Claude Code CLI
+
+## License
+
+MIT

claude_arcade-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "claude-arcade"
+version = "0.1.0"
+description = "Play games while Claude thinks — a collection of terminal mini-games that hook into Claude Code"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["claude", "terminal", "game", "cli", "curses", "claude-code"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Games/Entertainment",
+    "Topic :: Terminals",
+]
+dependencies = []
+
+[project.scripts]
+claude-arcade = "claude_arcade.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/yourusername/claude-arcade"
+Issues = "https://github.com/yourusername/claude-arcade/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/claude_arcade"]

claude_arcade-0.1.0/src/claude_arcade/__init__.py

@@ -0,0 +1,3 @@
+"""claude-arcade: Play games while Claude thinks."""
+
+__version__ = "0.1.0"

claude_arcade-0.1.0/src/claude_arcade/bird_game.py

@@ -0,0 +1,355 @@
+"""Bird Hunt — shoot ASCII birds flying across your terminal."""
+
+import curses
+import os
+import random
+import signal
+import sys
+import time
+
+PID_FILE = "/tmp/.claude-arcade.pid"
+STOP_FILE = "/tmp/.claude-arcade-stop"
+
+# ---------------------------------------------------------------------------
+# Game objects
+# ---------------------------------------------------------------------------
+
+class Bird:
+    TYPES = [
+        {"art_r": ">->",    "art_l": "<-<",    "speed": 2.0, "points": 3},
+        {"art_r": ">~~>",   "art_l": "<~~<",   "speed": 1.0, "points": 1},
+        {"art_r": ">°~°>",  "art_l": "<°~°<",  "speed": 0.6, "points": 2},
+    ]
+
+    def __init__(self, width: int, height: int) -> None:
+        t = random.choice(Bird.TYPES)
+        self.art_r  = t["art_r"]
+        self.art_l  = t["art_l"]
+        self.speed  = t["speed"]
+        self.points = t["points"]
+        self.direction = random.choice(("right", "left"))
+        self.y = random.randint(2, max(3, height - 4))
+        self._frac_x: float  # sub-pixel position for fractional speeds
+
+        if self.direction == "right":
+            self._frac_x = float(-len(self.art_r))
+        else:
+            self._frac_x = float(width)
+
+    # ---- computed properties ----
+
+    @property
+    def art(self) -> str:
+        return self.art_r if self.direction == "right" else self.art_l
+
+    @property
+    def x(self) -> int:
+        return int(self._frac_x)
+
+    # ---- logic ----
+
+    def update(self, dt: float) -> None:
+        if self.direction == "right":
+            self._frac_x += self.speed * dt * 20  # scale to ~chars/sec
+        else:
+            self._frac_x -= self.speed * dt * 20
+
+    def is_offscreen(self, width: int) -> bool:
+        if self.direction == "right":
+            return self.x > width
+        return self.x + len(self.art) < 0
+
+    def draw(self, stdscr, color: int) -> None:
+        h, w = stdscr.getmaxyx()
+        x, y = self.x, self.y
+        art   = self.art
+        if 1 <= y < h - 1 and 0 <= x < w - len(art):
+            try:
+                stdscr.addstr(y, x, art, color)
+            except curses.error:
+                pass
+
+
+class Bullet:
+    def __init__(self, x: int, y: int) -> None:
+        self.x = x
+        self.y = float(y)
+
+    def update(self, dt: float) -> None:
+        self.y -= 40 * dt  # fast upward travel
+
+    @property
+    def iy(self) -> int:
+        return int(self.y)
+
+    def is_offscreen(self) -> bool:
+        return self.iy < 1
+
+    def hits(self, bird: Bird) -> bool:
+        return bird.x <= self.x <= bird.x + len(bird.art) - 1 and self.iy == bird.y
+
+    def draw(self, stdscr, color: int) -> None:
+        h, w = stdscr.getmaxyx()
+        if 1 <= self.iy < h - 1 and 0 <= self.x < w:
+            try:
+                stdscr.addstr(self.iy, self.x, "|", color)
+            except curses.error:
+                pass
+
+
+class Explosion:
+    FRAMES = ["***", " * ", "   "]
+
+    def __init__(self, x: int, y: int) -> None:
+        self.x = x
+        self.y = y
+        self.frame = 0
+
+    def update(self) -> None:
+        self.frame += 1
+
+    @property
+    def done(self) -> bool:
+        return self.frame >= len(self.FRAMES)
+
+    def draw(self, stdscr, color: int) -> None:
+        if self.done:
+            return
+        h, w = stdscr.getmaxyx()
+        art = self.FRAMES[self.frame]
+        if 1 <= self.y < h - 1 and 0 <= self.x < w - len(art):
+            try:
+                stdscr.addstr(self.y, self.x, art, color | curses.A_BOLD)
+            except curses.error:
+                pass
+
+
+# ---------------------------------------------------------------------------
+# Main game loop
+# ---------------------------------------------------------------------------
+
+def bird_game(stdscr) -> None:
+    # Terminal setup
+    curses.curs_set(0)
+    stdscr.nodelay(True)
+    stdscr.keypad(True)
+
+    has_colors = curses.has_colors()
+    if has_colors:
+        curses.start_color()
+        curses.use_default_colors()
+        curses.init_pair(1, curses.COLOR_YELLOW,  -1)  # birds
+        curses.init_pair(2, curses.COLOR_GREEN,   -1)  # crosshair
+        curses.init_pair(3, curses.COLOR_RED,     -1)  # bullets
+        curses.init_pair(4, curses.COLOR_CYAN,    -1)  # header
+        curses.init_pair(5, curses.COLOR_BLACK, curses.COLOR_CYAN)   # status bar
+        curses.init_pair(6, curses.COLOR_MAGENTA, -1)  # explosions
+        curses.init_pair(7, curses.COLOR_WHITE,   -1)  # neutral
+
+        C_BIRD  = curses.color_pair(1)
+        C_AIM   = curses.color_pair(2) | curses.A_BOLD
+        C_SHOT  = curses.color_pair(3)
+        C_HDR   = curses.color_pair(4) | curses.A_BOLD
+        C_BAR   = curses.color_pair(5)
+        C_BOOM  = curses.color_pair(6)
+    else:
+        C_BIRD = C_AIM = C_SHOT = C_HDR = C_BAR = C_BOOM = curses.A_NORMAL
+
+    h, w = stdscr.getmaxyx()
+
+    score      = 0
+    birds: list[Bird]      = []
+    bullets: list[Bullet]  = []
+    booms: list[Explosion] = []
+
+    cx = w // 2  # crosshair column
+    cy = h // 2  # crosshair row
+
+    spawn_interval = 1.8
+    last_spawn     = time.monotonic()
+    last_tick      = time.monotonic()
+
+    running = True
+
+    def on_signal(signum, frame):  # noqa: ANN001
+        nonlocal running
+        running = False
+
+    signal.signal(signal.SIGTERM, on_signal)
+    signal.signal(signal.SIGINT,  on_signal)
+
+    while running:
+        # ---- stop-file check (set by `claude-arcade stop`) ----
+        if os.path.exists(STOP_FILE):
+            try:
+                os.unlink(STOP_FILE)
+            except OSError:
+                pass
+            break
+
+        now = time.monotonic()
+        dt  = now - last_tick
+        last_tick = now
+        h, w = stdscr.getmaxyx()
+
+        # ---- spawn ----
+        if now - last_spawn >= spawn_interval:
+            birds.append(Bird(w, h))
+            last_spawn = now
+            spawn_interval = max(0.7, spawn_interval - 0.04)
+
+        # ---- update birds ----
+        for bird in birds[:]:
+            bird.update(dt)
+            if bird.is_offscreen(w):
+                birds.remove(bird)
+
+        # ---- update bullets + collision ----
+        for blt in bullets[:]:
+            blt.update(dt)
+            if blt.is_offscreen():
+                bullets.remove(blt)
+                continue
+            hit = False
+            for bird in birds[:]:
+                if blt.hits(bird):
+                    score += bird.points
+                    booms.append(Explosion(bird.x, bird.y))
+                    birds.remove(bird)
+                    hit = True
+                    break
+            if hit and blt in bullets:
+                bullets.remove(blt)
+
+        # ---- update explosions ----
+        for b in booms[:]:
+            b.update()
+            if b.done:
+                booms.remove(b)
+
+        # ---- draw ----
+        stdscr.erase()
+
+        # header bar
+        header = f" BIRD HUNT  |  Score: {score}  |  Arrows/WASD: Aim  |  SPACE: Shoot  |  Q: Quit "
+        try:
+            stdscr.addstr(0, 0, header[: w - 1].ljust(w - 1), C_HDR)
+        except curses.error:
+            pass
+
+        for bird in birds:
+            bird.draw(stdscr, C_BIRD)
+        for blt in bullets:
+            blt.draw(stdscr, C_SHOT)
+        for boom in booms:
+            boom.draw(stdscr, C_BOOM)
+
+        # crosshair
+        for dx, ch in [(-1, "["), (0, "+"), (1, "]")]:
+            nx = cx + dx
+            if 1 <= cy < h - 1 and 0 <= nx < w:
+                try:
+                    stdscr.addstr(cy, nx, ch, C_AIM)
+                except curses.error:
+                    pass
+
+        # footer bar
+        footer = " Claude is thinking...  Hang tight and shoot some birds! "
+        try:
+            stdscr.addstr(h - 1, 0, footer[: w - 1].ljust(w - 1), C_BAR)
+        except curses.error:
+            pass
+
+        stdscr.refresh()
+
+        # ---- input ----
+        key = stdscr.getch()
+        if key in (curses.KEY_UP,    ord("w"), ord("W")) and cy > 1:
+            cy -= 1
+        elif key in (curses.KEY_DOWN,  ord("s"), ord("S")) and cy < h - 2:
+            cy += 1
+        elif key in (curses.KEY_LEFT,  ord("a"), ord("A")) and cx > 1:
+            cx -= 1
+        elif key in (curses.KEY_RIGHT, ord("d"), ord("D")) and cx < w - 2:
+            cx += 1
+        elif key == ord(" "):
+            bullets.append(Bullet(cx, cy - 1))
+        elif key in (ord("q"), ord("Q")):
+            break
+
+        time.sleep(0.033)  # ~30 fps cap
+
+
+# ---------------------------------------------------------------------------
+# Background start / stop  (called by Claude Code hooks)
+# ---------------------------------------------------------------------------
+
+def start_background() -> None:
+    """Fork a background process that runs the game on /dev/tty."""
+    # If a game is already running, skip.
+    if os.path.exists(PID_FILE):
+        try:
+            with open(PID_FILE) as fh:
+                pid = int(fh.read().strip())
+            os.kill(pid, 0)
+            return  # already alive
+        except (OSError, ValueError):
+            pass  # stale PID — continue
+
+    # Clean up any stale stop-file.
+    try:
+        os.unlink(STOP_FILE)
+    except OSError:
+        pass
+
+    pid = os.fork()
+    if pid > 0:
+        # Parent: record child PID and return immediately so the hook exits fast.
+        with open(PID_FILE, "w") as fh:
+            fh.write(str(pid))
+        sys.exit(0)
+
+    # ---- child process ----
+    try:
+        os.setsid()  # new session — detach from parent process group
+
+        # Connect fd 0/1/2 to the real terminal so curses can draw on it.
+        tty_fd = os.open("/dev/tty", os.O_RDWR)
+        for fd in (0, 1, 2):
+            os.dup2(tty_fd, fd)
+        if tty_fd > 2:
+            os.close(tty_fd)
+
+        curses.wrapper(bird_game)
+
+    except Exception:
+        pass  # silently swallow errors in background child
+    finally:
+        # Clean up PID file on any exit path.
+        try:
+            os.unlink(PID_FILE)
+        except OSError:
+            pass
+        os._exit(0)
+
+
+def stop_background() -> None:
+    """Signal the background game to exit and clean up."""
+    # Write the stop-file so the game's main loop sees it gracefully.
+    try:
+        open(STOP_FILE, "w").close()
+    except OSError:
+        pass
+
+    # Also send SIGTERM in case the process is stuck.
+    if os.path.exists(PID_FILE):
+        try:
+            with open(PID_FILE) as fh:
+                pid = int(fh.read().strip())
+            os.kill(pid, signal.SIGTERM)
+        except (OSError, ValueError):
+            pass
+        try:
+            os.unlink(PID_FILE)
+        except OSError:
+            pass

claude_arcade-0.1.0/src/claude_arcade/cli.py

@@ -0,0 +1,89 @@
+"""CLI entry point for claude-arcade."""
+
+import argparse
+import sys
+
+
+DESCRIPTION = """\
+claude-arcade — play games while Claude thinks
+
+Play a mini-game automatically every time Claude Code runs a tool,
+or launch one manually whenever you feel like it.
+"""
+
+EPILOG = """\
+examples:
+  claude-arcade setup        configure Claude Code hooks (one-time setup)
+  claude-arcade play         launch Bird Hunt right now
+  claude-arcade unsetup      remove hooks from Claude Code settings
+"""
+
+
+def main() -> None:  # noqa: C901
+    if sys.platform == "win32":
+        print(
+            "claude-arcade requires a Unix-like terminal (macOS / Linux).\n"
+            "Windows support is not available yet."
+        )
+        sys.exit(1)
+
+    parser = argparse.ArgumentParser(
+        prog="claude-arcade",
+        description=DESCRIPTION,
+        epilog=EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    sub = parser.add_subparsers(dest="cmd", metavar="<command>")
+
+    sub.add_parser("setup",   help="Configure Claude Code hooks (one-time setup)")
+    sub.add_parser("unsetup", help="Remove Claude Code hooks")
+
+    play_p = sub.add_parser("play", help="Play a game right now")
+    play_p.add_argument(
+        "game",
+        nargs="?",
+        default="bird",
+        choices=["bird"],
+        help="Which game to play  (default: bird)",
+    )
+
+    # "start" and "stop" are called internally by Claude Code hooks.
+    # They are intentionally omitted from the help listing.
+
+    # Handle internal hook commands before full arg parsing to keep them hidden.
+    if len(sys.argv) == 2 and sys.argv[1] in ("start", "stop"):
+        if sys.argv[1] == "start":
+            from .bird_game import start_background
+            start_background()
+        else:
+            from .bird_game import stop_background
+            stop_background()
+        return
+
+    args = parser.parse_args()
+
+    # ------------------------------------------------------------------ setup
+    if args.cmd == "setup":
+        from .setup_hooks import setup
+        setup()
+
+    elif args.cmd == "unsetup":
+        from .setup_hooks import unsetup
+        unsetup()
+
+    # ------------------------------------------------------------------ play
+    elif args.cmd == "play":
+        import curses
+        from .bird_game import bird_game
+        try:
+            curses.wrapper(bird_game)
+        except KeyboardInterrupt:
+            pass
+
+    # ------------------------------------------------------------------ help
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

claude_arcade-0.1.0/src/claude_arcade/setup_hooks.py

@@ -0,0 +1,115 @@
+"""Configure (and remove) Claude Code hooks for claude-arcade."""
+
+import json
+import os
+import shutil
+import sys
+
+SETTINGS_PATH = os.path.expanduser("~/.claude/settings.json")
+
+
+def _load_settings() -> dict:
+    if not os.path.exists(SETTINGS_PATH):
+        return {}
+    try:
+        with open(SETTINGS_PATH) as fh:
+            return json.load(fh)
+    except (json.JSONDecodeError, OSError) as exc:
+        print(f"Warning: could not read {SETTINGS_PATH}: {exc}")
+        return {}
+
+
+def _save_settings(settings: dict) -> None:
+    os.makedirs(os.path.dirname(SETTINGS_PATH), exist_ok=True)
+    with open(SETTINGS_PATH, "w") as fh:
+        json.dump(settings, fh, indent=2)
+        fh.write("\n")
+
+
+def _arcade_bin() -> str:
+    path = shutil.which("claude-arcade")
+    if not path:
+        print("Error: 'claude-arcade' not found in PATH.")
+        print("Install it first:  pipx install claude-arcade")
+        sys.exit(1)
+    return path
+
+
+def _has_arcade_hook(hook_list: list, bin_path: str) -> bool:
+    for entry in hook_list:
+        for h in entry.get("hooks", []):
+            if bin_path in h.get("command", ""):
+                return True
+    return False
+
+
+def setup() -> None:
+    """Write claude-arcade hooks into ~/.claude/settings.json."""
+    bin_path = _arcade_bin()
+    settings = _load_settings()
+    settings.setdefault("hooks", {})
+
+    start_entry = {
+        "matcher": "",
+        "hooks": [{"type": "command", "command": f"{bin_path} start"}],
+    }
+    stop_entry = {
+        "matcher": "",
+        "hooks": [{"type": "command", "command": f"{bin_path} stop"}],
+    }
+
+    added = []
+    for event, entry in [
+        ("PreToolUse",  start_entry),
+        ("PostToolUse", stop_entry),
+        ("Stop",        stop_entry),
+    ]:
+        settings["hooks"].setdefault(event, [])
+        if not _has_arcade_hook(settings["hooks"][event], bin_path):
+            settings["hooks"][event].append(entry)
+            added.append(event)
+
+    _save_settings(settings)
+
+    if added:
+        print(f"claude-arcade hooks added for: {', '.join(added)}")
+    else:
+        print("claude-arcade hooks were already configured — nothing changed.")
+
+    print()
+    print(f"Settings file: {SETTINGS_PATH}")
+    print()
+    print("How it works:")
+    print("  • Start Claude Code as usual:  claude")
+    print("  • Whenever Claude calls a tool the bird game launches automatically.")
+    print("  • The game closes and your terminal is restored when Claude finishes.")
+    print()
+    print("Play manually at any time:  claude-arcade play")
+    print("Remove hooks:               claude-arcade unsetup")
+
+
+def unsetup() -> None:
+    """Remove claude-arcade hooks from ~/.claude/settings.json."""
+    if not os.path.exists(SETTINGS_PATH):
+        print("No Claude Code settings file found — nothing to remove.")
+        return
+
+    bin_path = _arcade_bin()
+    settings = _load_settings()
+    removed = []
+
+    for event in ("PreToolUse", "PostToolUse", "Stop"):
+        original = settings.get("hooks", {}).get(event, [])
+        filtered = [
+            e for e in original
+            if not _has_arcade_hook([e], bin_path)
+        ]
+        if len(filtered) < len(original):
+            settings["hooks"][event] = filtered
+            removed.append(event)
+
+    if removed:
+        _save_settings(settings)
+        print(f"claude-arcade hooks removed from: {', '.join(removed)}")
+    else:
+        print("No claude-arcade hooks found — nothing to remove.")