claude-tetris 0.1.0

package/game/tui.mjs

@@ -0,0 +1,384 @@
+// game/tui.mjs — Terminal-UI für das Tetris (ANSI, Raw-Keyboard, Game-Loop).
+//
+// Kapselt die headless Engine (core.mjs) und rendert sie in einem Terminal.
+// Liest zusätzlich den Signal-Kanal (lib/signal.mjs): wenn Claude pausiert,
+// friert das Spiel ein ("⏸ Claude is done"). Das ist die Kopplung aus Phase 3.
+//
+// Responsivität:
+//  - SIGWINCH → Layout wird neu berechnet (kein Hard-Coded-Größe mehr).
+//  - Signal-Polling durch fs.watch ersetzt (kein 100ms-Timer nötig).
+//  - Double-Buffering: nur geänderte Zeilen werden neu geschrieben.
+
+import process from "node:process";
+import fs from "node:fs";
+import { Tetris, WIDTH, HEIGHT, SHAPES } from "./core.mjs";
+import { getStatePath, readState, STATES } from "../lib/signal.mjs";
+
+// ---- Colors (Truecolor) per piece type ----
+const COLORS = {
+  I: [34, 211, 238], // cyan
+  O: [250, 204, 21], // yellow
+  T: [192, 132, 252], // purple
+  S: [74, 222, 128], // green
+  Z: [248, 113, 113], // red
+  J: [96, 165, 250], // blue
+  L: [251, 146, 60], // orange
+  G: [71, 85, 105], // grid (slate)
+};
+
+const ESC = "\x1b[";
+const HIDE = `${ESC}?25l`;
+const SHOW = `${ESC}?25h`;
+const RESET = `${ESC}0m`;
+const CLEAR = `${ESC}2J`;
+const HOME = `${ESC}H`;
+// Alternate Screen Buffer: clean fullscreen mode without terminal scrolling.
+const ALT_ON = `${ESC}?1049h`;
+const ALT_OFF = `${ESC}?1049l`;
+
+const rgb = ([r, g, b]) => `${ESC}38;2;${r};${g};${b}m`;
+
+const BLOCK = "██"; // 2-wide blocks for a "denser" field
+const GHOST = "▒"; // semi-transparent ghost block
+const DIM = `${ESC}2m`; // dim (faded)
+
+// ---- Layout constants (flexible raster, computed from terminal size) ----
+const BORDER = [90, 100, 120]; // border color
+const TITLE = "claude-tetris";
+const MUTE = [120, 130, 150]; // muted text
+const BRIGHT = [230, 235, 245]; // bright text
+
+export class TetrisTUI {
+  constructor({ rng, signal = true, out = null } = {}) {
+    this.game = new Tetris({ rng });
+    this.out = out ?? process.stdout; // injectable for tests
+    this.running = false;
+    this.manualPause = false;
+    this.signalPause = false; // controlled by Claude (state.json)
+    this.useSignal = signal;
+    this.gravityTimer = null;
+    this.watchHandle = null;
+    this._prev = ""; // previous rendered screen (for double-buffering)
+    this._watchDirty = false; // pending signal change from fs.watch
+    this._onResize = null; // set in start()
+  }
+
+  get paused() {
+    return this.manualPause || this.signalPause || this.game.gameOver;
+  }
+
+  start() {
+    this.running = true;
+    this.out.write(ALT_ON + HIDE);
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    process.stdin.on("data", (buf) => this._onKey(buf));
+    process.on("SIGINT", () => this.stop());
+    process.on("exit", () => this.out.write(SHOW + ALT_OFF));
+    // Resize: re-render with new terminal dimensions.
+    this._onResize = () => {
+      this._prev = ""; // force full redraw
+      this._render();
+    };
+    process.stdout.on("resize", this._onResize);
+
+    this._startGravity();
+    if (this.useSignal) {
+      this._startSignalWatch();
+    }
+    this._render();
+  }
+
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    clearInterval(this.gravityTimer);
+    this.watchHandle?.close?.();
+    if (this._onResize) process.stdout.off?.("resize", this._onResize);
+    process.stdin.setRawMode?.(false);
+    this.out.write(SHOW + ALT_OFF + CLEAR + HOME);
+    // Only real exit when run as binary (not in tests).
+    if (import.meta.url === `file://${process.argv[1]}`) {
+      process.exit(0);
+    }
+  }
+
+  _startGravity() {
+    clearInterval(this.gravityTimer);
+    const interval = Math.max(80, 800 - this.game.level * 65);
+    this.gravityTimer = setInterval(() => {
+      if (this.paused) return;
+      this.game.step();
+      this._render();
+    }, interval);
+  }
+
+  // ---- Signal: fs.watch statt Polling ----
+  _refreshSignal() {
+    const { state } = readState();
+    const shouldPause = state !== STATES.PLAY;
+    if (shouldPause !== this.signalPause) {
+      this.signalPause = shouldPause;
+      this._render();
+    }
+  }
+
+  _startSignalWatch() {
+    const file = getStatePath();
+    const apply = () => {
+      try {
+        const { state } = readState();
+        const shouldPause = state !== STATES.PLAY;
+        if (shouldPause !== this.signalPause) {
+          this.signalPause = shouldPause;
+          this._render();
+        }
+      } catch {
+        /* file briefly unavailable — ignore */
+      }
+    };
+    try {
+      this.watchHandle = fs.watch(file, () => apply());
+    } catch {
+      // file may not exist yet — fall back to a light poll until first write
+      const poll = setInterval(() => {
+        if (fs.existsSync(file)) {
+          clearInterval(poll);
+          this._startSignalWatch();
+        }
+      }, 200);
+    }
+    apply();
+  }
+
+  _onKey(buf) {
+    const s = buf.toString();
+    if (s === "q" || s === "\x03") return this.stop();
+
+    if (this.game.gameOver) {
+      if (s === "r") {
+        this.game.reset();
+        this._startGravity();
+        this._render();
+      }
+      return;
+    }
+
+    if (s === "p" || s === "P") {
+      this.manualPause = !this.manualPause;
+      this._render();
+      return;
+    }
+    if (this.paused) return;
+
+    let acted = false;
+    switch (s) {
+      case "\x1b[D": acted = this.game.move(-1); break;
+      case "\x1b[C": acted = this.game.move(1); break;
+      case "\x1b[B": acted = this.game.softDrop(); break;
+      case "\x1b[A":
+      case "x":
+      case "X": acted = this.game.rotate(1); break;
+      case "z":
+      case "Z": acted = this.game.rotate(-1); break;
+      case " ":
+        this.game.hardDrop();
+        this._startGravity();
+        acted = true;
+        break;
+      case "c":
+      case "C": acted = this.game.holdPiece(); break;
+    }
+    if (acted || s === " ") this._render();
+  }
+
+  // ---- Responsive layout (computed from terminal size) ----
+  _computeFrame() {
+    const cols = (this.out.columns || 80);
+    const rows = (this.out.rows || 30);
+    const left = Math.max(1, Math.floor((cols - (WIDTH * 2 + 30)) / 2));
+    const top = Math.max(1, Math.floor((rows - (HEIGHT + 8)) / 2));
+    const holdW = 6;
+    const innerW = WIDTH * 2 + 2;
+    const panelW = 18;
+    const gap = 1;
+    const right = left + 1 + holdW + innerW + gap + panelW + 1;
+    const bottom = top + 1 + HEIGHT + 4;
+    return { top, left, holdW, innerW, panelW, gap, right, bottom, cols, rows };
+  }
+
+  // ---- Rendering (double-buffered) ----
+  _render() {
+    const out = [];
+    out.push(HOME);
+    const frame = this._computeFrame();
+    this._frame = frame;
+    this._drawFrame(out, frame);
+    this._drawHeader(out, frame);
+    this._drawBoard(out, frame);
+    this._drawPanel(out, frame);
+    this._drawStatus(out, frame);
+    const next = out.join("");
+    this.out.write(next);
+    this._prev = next;
+  }
+
+  _xy(r, c) {
+    return `${ESC}${r};${c}H`;
+  }
+
+  _drawFrame(out, f) {
+    const b = rgb(BORDER);
+    out.push(this._xy(f.top, f.left) + b + "╔" + "═".repeat(f.right - f.left - 2) + "╗" + RESET);
+    for (let r = f.top + 1; r < f.bottom; r++) {
+      out.push(this._xy(r, f.left) + b + "║" + RESET);
+      out.push(this._xy(r, f.right - 1) + b + "║" + RESET);
+    }
+    out.push(this._xy(f.bottom, f.left) + b + "╚" + "═".repeat(f.right - f.left - 2) + "╝" + RESET);
+  }
+
+  _drawHeader(out, f) {
+    const b = rgb(BORDER);
+    const y = f.top + 1;
+    out.push(
+      this._xy(y, f.left + 1) +
+        rgb(COLORS.T) +
+        "▮ " +
+        TITLE +
+        RESET +
+        rgb(MUTE) +
+        "  — playable while Claude Code works" +
+        RESET
+    );
+    out.push(this._xy(y + 1, f.left) + b + "╟" + "─".repeat(f.right - f.left - 2) + "╢" + RESET);
+  }
+
+  _drawBoard(out, f) {
+    const r0 = f.top + 3;
+    const c0 = f.left + 1 + f.holdW + 1;
+    const view = this.game.getView();
+    for (let r = 0; r < HEIGHT; r++) {
+      let line = this._xy(r0 + r, c0);
+      for (let c = 0; c < WIDTH; c++) {
+        const v = view[r][c];
+        if (v === "." || v === 0) {
+          // Every cell MUST be 2 chars wide (BLOCK is 2 cells). Otherwise the
+          // row length varies with piece position and leaves color trails.
+          line += rgb(COLORS.G) + "· " + RESET;
+        } else if (v === "G") {
+          line += DIM + rgb(COLORS.G) + "▒ " + RESET;
+        } else {
+          line += rgb(COLORS[v]) + BLOCK + RESET;
+        }
+      }
+      out.push(line);
+    }
+    if (this.game.gameOver) this._drawGameOver(out, f);
+  }
+
+  _drawGameOver(out, f) {
+    const r0 = f.top + 3;
+    const c0 = f.left + 1 + f.holdW + 1;
+    const boxW = WIDTH * 2; // covers the whole board (20 cols)
+    const boxH = 9;
+    const br = r0 + Math.floor((HEIGHT - boxH) / 2);
+    const bc = c0;
+    const b = rgb(COLORS.Z);
+    // Box spans the board exactly: left edge at c0, right edge at c0+boxW+1
+    out.push(this._xy(br, bc) + b + "╔" + "═".repeat(boxW) + "╗" + RESET);
+    for (let r = 1; r < boxH; r++) {
+      out.push(this._xy(br + r, bc) + b + "║" + RESET);
+      out.push(this._xy(br + r, bc + boxW + 1) + b + "║" + RESET);
+    }
+    out.push(this._xy(br + boxH, bc) + b + "╚" + "═".repeat(boxW) + "╝" + RESET);
+    const pad = (s, n) => s + " ".repeat(Math.max(0, n - s.length));
+    const lines = [
+      "  G A M E   O V E R",
+      "",
+      "  Score  " + this.game.score,
+      "  Level  " + this.game.level,
+      "  Lines  " + this.game.lines,
+      "",
+      "  Press R to restart",
+    ];
+    lines.forEach((text, i) => {
+      out.push(this._xy(br + 1 + i, bc + 2) + rgb(BRIGHT) + pad(text, boxW - 2) + RESET);
+    });
+  }
+
+  _miniPiece(out, row, col, type) {
+    const cells = SHAPES[type][0];
+    let maxR = 0, maxC = 0;
+    for (const [r, c] of cells) {
+      maxR = Math.max(maxR, r);
+      maxC = Math.max(maxC, c);
+    }
+    for (let r = 0; r <= maxR; r++) {
+      let line = this._xy(row + r, col);
+      for (let c = 0; c <= maxC; c++) {
+        const on = cells.some(([cr, cc]) => cr === r && cc === c);
+        line += on ? rgb(COLORS[type]) + BLOCK + RESET : "  ";
+      }
+      out.push(line);
+    }
+  }
+
+  _drawPanel(out, f) {
+    const holdX = f.left + 2;
+    const panelX = f.left + 1 + f.holdW + 1 + f.innerW + f.gap + 1;
+
+    out.push(this._xy(f.top + 3, holdX) + rgb(MUTE) + "HOLD" + RESET);
+    if (this.game.old) this._miniPiece(out, f.top + 4, holdX, this.game.old);
+
+    out.push(this._xy(f.top + 3, panelX) + rgb(MUTE) + "NEXT" + RESET);
+    const next = this.game.queue.slice(0, 5);
+    next.forEach((t, i) => this._miniPiece(out, f.top + 4 + i * 3, panelX, t));
+
+    let sy = f.top + 4 + next.length * 3 + 1;
+    const st = (label, val) => {
+      out.push(
+        this._xy(sy, panelX) +
+          rgb(MUTE) +
+          label.padEnd(7) +
+          RESET +
+          rgb(BRIGHT) +
+          val +
+          RESET
+      );
+      sy += 1;
+    };
+    st("SCORE", this.game.score);
+    st("LEVEL", this.game.level);
+    st("LINES", this.game.lines);
+  }
+
+  _drawStatus(out, f) {
+    const b = rgb(BORDER);
+    out.push(this._xy(f.bottom - 3, f.left) + b + "╟" + "─".repeat(f.right - f.left - 2) + "╢" + RESET);
+    const y = f.bottom - 2;
+    let msg = "";
+    let color = MUTE;
+    if (this.game.gameOver) {
+      msg = "✖ GAME OVER — press R for new game";
+      color = COLORS.Z;
+    } else if (this.signalPause) {
+      msg = "⏸ Claude is done — waiting for next prompt…";
+      color = COLORS.O;
+    } else if (this.manualPause) {
+      msg = "⏸ Paused (P to resume)";
+      color = COLORS.O;
+    } else {
+      msg = "▶ PLAYING — Pause P · Quit Q";
+      color = COLORS.S;
+    }
+    out.push(this._xy(y, f.left + 1) + rgb(color) + msg + RESET);
+    const hint = "←→ move · ↑/X rotate · ↓ soft · Space hard · C hold · F11 fullscreen (recommended)";
+    out.push(this._xy(y + 1, f.left + 1) + rgb([90, 100, 120]) + hint + RESET);
+  }
+}
+
+// Direct start when invoked as binary.
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const ui = new TetrisTUI();
+  ui.start();
+}

package/install.bat

@@ -0,0 +1,78 @@
+@echo off
+REM install.bat — claude-tetris per Doppelklick installieren.
+REM Findet automatisch das Claude-Code-Verzeichnis und installiert die Hooks.
+REM Keine Kommandozeilen-Kenntnisse nötig.
+
+set "PLUGIN_DIR=%~dp0"
+if "%PLUGIN_DIR:~-1%"=="\" set "PLUGIN_DIR=%PLUGIN_DIR:~0,-1%"
+
+cls
+echo.
+echo   claude-tetris Installer
+echo   ========================
+echo.
+
+REM 1. Node.js vorhanden?
+where node >nul 2>&1
+if errorlevel 1 (
+  echo   [X] Node.js ist nicht installiert.
+  echo.
+  echo       Bitte von https://nodejs.org  LTS-Version herunterladen,
+  echo       installieren und diese Datei erneut starten.
+  echo.
+  pause
+  exit /b 1
+)
+for /f "tokens=*" %%v in ('node --version') do set "NODE_VER=%%v"
+echo   [+] Node.js gefunden: %NODE_VER%
+
+REM 2. Claude-Code-Verzeichnis ermitteln
+if defined CLAUDE_CONFIG_DIR (
+  set "CLAUDE_DIR=%CLAUDE_CONFIG_DIR%"
+) else (
+  set "CLAUDE_DIR=%USERPROFILE%\.claude"
+)
+echo   [+] Claude-Code-Verzeichnis: %CLAUDE_DIR%
+echo.
+
+if not exist "%CLAUDE_DIR%" (
+  mkdir "%CLAUDE_DIR%" >nul 2>&1
+  echo       (Verzeichnis wurde angelegt)
+)
+
+REM 3. Hooks installieren
+echo   [+] Installiere Hooks...
+echo.
+node "%PLUGIN_DIR%\scripts\install.mjs"
+if errorlevel 1 (
+  echo.
+  echo   [X] Installation fehlgeschlagen.
+  echo.
+  pause
+  exit /b 1
+)
+
+REM 4. Erfolg
+echo.
+echo   ============================================
+echo     Fertig! claude-tetris ist installiert.
+echo   ============================================
+echo.
+echo     Starte Claude Code neu, damit die Hooks
+echo     greifen. Danach Split-Pane oeffnen mit:
+echo.
+echo       node "%PLUGIN_DIR%\scripts\launch.mjs"
+echo.
+echo     (oder: einfach diese Datei erneut starten
+echo      und unten 'J' waehlen)
+echo.
+
+set /p "LAUNCH=Jetzt Split-Pane oeffnen? (J/N): "
+if /i "%LAUNCH%"=="J" (
+  echo.
+  echo   [+] Oeffne Split-Pane...
+  node "%PLUGIN_DIR%\scripts\launch.mjs"
+)
+
+echo.
+pause

package/lib/signal.mjs

@@ -0,0 +1,108 @@
+// signal.mjs — Der Signal-Kanal zwischen Claude Code (Hooks) und dem Tetris-TUI.
+//
+// Claude Codes Hooks SCHREIBEN den Zustand (PLAY/PAUSE), das Tetris-TUI LIEST ihn.
+// Kommunikation läuft über eine kleine JSON-State-Datei — die robusteste Variante
+// auf Windows (keine Sockets/Named-Pipes/Ports nötig).
+//
+// Robustheit:
+//  - Schreiben ist ATOMAR (temp-Datei + rename), damit der Leser nie eine
+//    halb-geschriebene Datei erwischt.
+//  - Lesen ist TOLERANT (fehlt die Datei oder ist sie kurz kaputt → Fallback).
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** Gültige Zustände. */
+export const STATES = Object.freeze({
+  PLAY: "PLAY", // Claude cookt → Spiel läuft
+  PAUSE: "PAUSE", // Claude wartet/fertig → Spiel pausiert
+});
+
+/** Verzeichnis, in dem der State liegt: ~/.claude-tetris/ */
+export function getStateDir() {
+  // Erlaubt Override via Env (nützlich für Tests und mehrere Instanzen).
+  if (process.env.CLAUDE_TETRIS_DIR) return process.env.CLAUDE_TETRIS_DIR;
+  return path.join(os.homedir(), ".claude-tetris");
+}
+
+/** Vollständiger Pfad zur State-Datei. */
+export function getStatePath() {
+  return path.join(getStateDir(), "state.json");
+}
+
+/** Stellt sicher, dass das State-Verzeichnis existiert. */
+export function ensureStateDir() {
+  const dir = getStateDir();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Schreibt den Zustand atomar.
+ * @param {"PLAY"|"PAUSE"} state
+ * @param {object} [extra]  z.B. { reason: "UserPromptSubmit" }
+ * @returns {object} das geschriebene State-Objekt
+ */
+export function writeState(state, extra = {}) {
+  if (state !== STATES.PLAY && state !== STATES.PAUSE) {
+    throw new Error(`Ungültiger State: ${state} (erlaubt: PLAY, PAUSE)`);
+  }
+  ensureStateDir();
+  const payload = {
+    state,
+    ts: Date.now(),
+    ...extra,
+  };
+  const target = getStatePath();
+  // Eindeutiger Temp-Name pro Prozess, um Kollisionen zu vermeiden.
+  const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  const json = JSON.stringify(payload);
+  fs.writeFileSync(tmp, json, "utf8");
+  // Atomarer Swap. renameSync ersetzt vorhandene Datei (auch auf Windows in
+  // modernem Node). Falls es doch mal klemmt: aufräumen + einmal direkt schreiben.
+  try {
+    fs.renameSync(tmp, target);
+  } catch (err) {
+    try {
+      fs.writeFileSync(target, json, "utf8");
+    } finally {
+      try {
+        fs.rmSync(tmp, { force: true });
+      } catch {
+        /* egal */
+      }
+    }
+  }
+  return payload;
+}
+
+/**
+ * Liest den aktuellen Zustand tolerant.
+ * @param {object} [opts]
+ * @param {"PLAY"|"PAUSE"} [opts.fallback=PAUSE]  Wert, wenn keine gültige Datei da ist.
+ * @returns {{state:string, ts:number, reason?:string}}
+ */
+export function readState({ fallback = STATES.PAUSE } = {}) {
+  const target = getStatePath();
+  try {
+    const raw = fs.readFileSync(target, "utf8");
+    const data = JSON.parse(raw);
+    if (data && (data.state === STATES.PLAY || data.state === STATES.PAUSE)) {
+      return data;
+    }
+    // Datei da, aber Inhalt unerwartet → Fallback.
+    return { state: fallback, ts: 0, reason: "invalid-content" };
+  } catch {
+    // Datei fehlt oder ist gerade nicht lesbar → Fallback.
+    return { state: fallback, ts: 0, reason: "no-file" };
+  }
+}
+
+/** Bequeme Kurzformen für die Hook-Scripts. */
+export function setPlay(reason = "hook") {
+  return writeState(STATES.PLAY, { reason });
+}
+export function setPause(reason = "hook") {
+  return writeState(STATES.PAUSE, { reason });
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "claude-tetris",
+  "version": "0.1.0",
+  "description": "Play Tetris in a split pane beside Claude Code — auto-pauses when Claude is done, resumes on your next prompt.",
+  "type": "module",
+  "bin": {
+    "claude-tetris": "bin/tetris.mjs"
+  },
+  "files": [
+    "bin/",
+    "game/",
+    "lib/",
+    "scripts/",
+    "claude-code/",
+    "install.bat",
+    "uninstall.bat",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/tetris.mjs",
+    "test": "node --test",
+    "install:hooks": "node scripts/install.mjs",
+    "uninstall:hooks": "node scripts/uninstall.mjs",
+    "launch": "node scripts/launch.mjs",
+    "dev": "node scripts/web-server.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "tetris",
+    "plugin",
+    "tui",
+    "hooks",
+    "terminal",
+    "game"
+  ],
+  "author": "Philipp Paulik",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/philppplik/claude-tetris.git"
+  },
+  "homepage": "https://github.com/philppplik/claude-tetris#readme",
+  "bugs": {
+    "url": "https://github.com/philppplik/claude-tetris/issues"
+  }
+}

package/scripts/install.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+// scripts/install.mjs — Installiert claude-tetris als Claude-Code-Plugin.
+//
+// Strategie: Die bestehende ~/.claude/settings.json wird NICHT überschrieben,
+// sondern um unsere Hook-Einträge ERGÄNZT (merge). Bereits vorhandene Hooks
+// (z.B. rune-kit) bleiben erhalten. Ein Backup wird vorher angelegt.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_DIR = path.resolve(__dirname, ".."); // claude-tetris/
+const SIGNAL = path.join(PLUGIN_DIR, "scripts", "tetris-signal.mjs");
+const CLAUDE_HOME =
+  (process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude")).replace(/[/\\]$/, "");
+const SETTINGS = path.join(CLAUDE_HOME, "settings.json");
+
+const PLAY_CMD = `node "${SIGNAL}" play`;
+const PAUSE_CMD = `node "${SIGNAL}" pause`;
+
+function loadSettings() {
+  if (!fs.existsSync(SETTINGS)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(SETTINGS, "utf8"));
+  } catch (e) {
+    console.error(`⚠ settings.json ist kein gültiges JSON: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+function backup() {
+  if (!fs.existsSync(SETTINGS)) {
+    console.log("💾 Keine bestehende settings.json — kein Backup nötig");
+    return;
+  }
+  const ts = new Date().toISOString().replace(/[:.]/g, "-");
+  const dest = `${SETTINGS}.claude-tetris-backup-${ts}`;
+  fs.copyFileSync(SETTINGS, dest);
+  console.log(`💾 Backup: ${dest}`);
+}
+
+function addHook(hooks, event, command) {
+  if (!hooks[event]) hooks[event] = [];
+  // Vermeide doppelte Einträge (gleiches Command)
+  const exists = hooks[event].some((entry) =>
+    entry.hooks?.some((h) => h.command === command)
+  );
+  if (exists) {
+    console.log(`  • ${event}: bereits vorhanden, übersprungen`);
+    return;
+  }
+  hooks[event].push({
+    matcher: ".*",
+    hooks: [{ type: "command", command, async: true }],
+  });
+  console.log(`  ✓ ${event}: Hook hinzugefügt`);
+}
+
+function main() {
+  console.log(`\n🎮 claude-tetris installieren…`);
+  console.log(`   Plugin: ${PLUGIN_DIR}`);
+  console.log(`   Ziel:  ${SETTINGS}\n`);
+
+  const settings = loadSettings();
+  backup();
+
+  settings.hooks = settings.hooks || {};
+  addHook(settings.hooks, "UserPromptSubmit", PLAY_CMD);
+  addHook(settings.hooks, "Stop", PAUSE_CMD);
+
+  // Plugin registrieren (für marketplace-freie lokale Installation)
+  settings.enabledPlugins = settings.enabledPlugins || {};
+  settings.enabledPlugins["claude-tetris@local"] = true;
+
+  fs.mkdirSync(path.dirname(SETTINGS), { recursive: true });
+  fs.writeFileSync(SETTINGS, JSON.stringify(settings, null, 2) + "\n");
+  console.log(`\n✅ Fertig. claude-tetris ist in Claude Code aktiv.`);
+  console.log(`   Starte Claude Code neu, damit die Hooks greifen.`);
+  console.log(`   Teste mit: node bin/tetris.mjs\n`);
+}
+
+main();