claude-casualties 1.0.0

package/README.md

@@ -0,0 +1,59 @@
+# ClaudeCasualties
+
+Every time you spawn an AI agent, it does your bidding and dies. ClaudeCasualties shows you the body count.
+
+A persistent on-screen kill counter + GTA-style **WASTED** screen every time an agent finishes. The counter never stops.
+
+## Install
+
+### Electron App (the overlay)
+
+```bash
+npm install -g claude-casualties
+claude-casualties
+```
+
+Runs in your system tray. Shows a persistent kill counter at the top of your screen and plays the WASTED animation + sound every time an agent dies.
+
+### Claude Code Plugin (the tracker)
+
+Add the PostToolUse hook to your `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node /path/to/claude-casualties/plugin/scripts/on-agent-death.js"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Or use the plugin directory:
+
+```bash
+claude --plugin-dir /path/to/claude-casualties/plugin
+```
+
+## How it works
+
+1. Claude Code spawns a subagent
+2. Agent finishes -> PostToolUse hook fires
+3. Hook records the kill to `~/.claude-casualties/events.jsonl`
+4. Electron app detects the new event and plays **WASTED**
+
+## Credits
+
+Inspired by [BadClaude](https://github.com/GitFrog1111/badclaude). They brought the whip, we brought the body bags.
+
+## License
+
+MIT

package/bin/claude-casualties.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const path = require('path');
+const electronPath = require('electron');
+
+const env = { ...process.env };
+delete env.ELECTRON_RUN_AS_NODE;
+
+const child = spawn(electronPath, [path.join(__dirname, '..')], {
+  stdio: 'inherit',
+  env,
+});
+
+child.on('close', (code) => process.exit(code ?? 0));

package/main.js

@@ -0,0 +1,167 @@
+const { app, BrowserWindow, Tray, Menu, nativeImage, ipcMain, screen } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const DATA_DIR = path.join(process.env.HOME, '.claude-casualties');
+const EVENTS_FILE = path.join(DATA_DIR, 'events.jsonl');
+
+let tray = null;
+let overlayWindow = null;
+let eventCount = 0;
+let fileOffset = 0;
+
+const HOOK_SCRIPT = path.join(__dirname, 'plugin', 'scripts', 'on-agent-death.js');
+const CLAUDE_SETTINGS = path.join(process.env.HOME, '.claude', 'settings.json');
+
+function installHook() {
+  try {
+    let settings = {};
+    if (fs.existsSync(CLAUDE_SETTINGS)) {
+      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, 'utf8'));
+    }
+
+    if (!settings.hooks) settings.hooks = {};
+    if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+
+    const hookCommand = `node ${HOOK_SCRIPT}`;
+    const alreadyInstalled = settings.hooks.PostToolUse.some(
+      (entry) => entry.matcher === 'Agent' &&
+        entry.hooks?.some((h) => h.command?.includes('on-agent-death.js'))
+    );
+
+    if (alreadyInstalled) return;
+
+    settings.hooks.PostToolUse.push({
+      matcher: 'Agent',
+      hooks: [{ type: 'command', command: hookCommand }],
+    });
+
+    fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
+  } catch {}
+}
+
+function createOverlayWindow() {
+  const primaryDisplay = screen.getPrimaryDisplay();
+  const { width, height } = primaryDisplay.workAreaSize;
+
+  overlayWindow = new BrowserWindow({
+    width,
+    height,
+    x: 0,
+    y: 0,
+    transparent: true,
+    frame: false,
+    alwaysOnTop: true,
+    skipTaskbar: true,
+    hasShadow: false,
+    resizable: false,
+    focusable: false,
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  });
+
+  overlayWindow.setIgnoreMouseEvents(true, { forward: true });
+  overlayWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+  overlayWindow.loadFile('overlay.html');
+
+  if (process.platform === 'darwin') {
+    overlayWindow.setAlwaysOnTop(true, 'floating', 1);
+  }
+}
+
+function loadExistingCount() {
+  try {
+    if (!fs.existsSync(EVENTS_FILE)) return;
+    const content = fs.readFileSync(EVENTS_FILE, 'utf8');
+    fileOffset = Buffer.byteLength(content);
+    eventCount = content.trim().split('\n').filter(Boolean).length;
+  } catch {}
+}
+
+function watchEvents() {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  if (!fs.existsSync(EVENTS_FILE)) {
+    fs.writeFileSync(EVENTS_FILE, '');
+  }
+
+  fs.watchFile(EVENTS_FILE, { interval: 500 }, () => {
+    try {
+      const stat = fs.statSync(EVENTS_FILE);
+      if (stat.size <= fileOffset) {
+        if (stat.size < fileOffset) {
+          fileOffset = 0;
+          eventCount = 0;
+        }
+        return;
+      }
+
+      const fd = fs.openSync(EVENTS_FILE, 'r');
+      const buf = Buffer.alloc(stat.size - fileOffset);
+      fs.readSync(fd, buf, 0, buf.length, fileOffset);
+      fs.closeSync(fd);
+      fileOffset = stat.size;
+
+      const newLines = buf.toString('utf8').trim().split('\n').filter(Boolean);
+      for (const line of newLines) {
+        eventCount++;
+        let agentName = 'Unknown Agent';
+        try { agentName = JSON.parse(line).agent || agentName; } catch {}
+        overlayWindow?.webContents.send('agent-killed', { count: eventCount, agent: agentName });
+      }
+      updateTray();
+    } catch {}
+  });
+}
+
+function updateTray() {
+  tray?.setToolTip(`ClaudeCasualties — ${eventCount.toLocaleString()} killed`);
+  const menu = Menu.buildFromTemplate([
+    { label: `☠ ${eventCount.toLocaleString()} agents killed`, enabled: false },
+    { type: 'separator' },
+    { label: 'Reset', click: () => {
+      try { fs.unlinkSync(EVENTS_FILE); } catch {}
+      eventCount = 0;
+      fileOffset = 0;
+      overlayWindow?.webContents.send('reset');
+      updateTray();
+    }},
+    { label: 'Quit', click: () => app.quit() },
+  ]);
+  tray?.setContextMenu(menu);
+}
+
+function createTrayIcon() {
+  return nativeImage.createFromBuffer(
+    Buffer.from(`<svg xmlns="http://www.w3.org/2000/svg" width="22" height="22" viewBox="0 0 22 22">
+      <circle cx="11" cy="9" r="7" fill="white"/>
+      <circle cx="8" cy="8" r="2" fill="black"/>
+      <circle cx="14" cy="8" r="2" fill="black"/>
+      <polygon points="11,11 9,14 13,14" fill="black"/>
+      <rect x="8" y="15" width="2" height="3" fill="white"/>
+      <rect x="12" y="15" width="2" height="3" fill="white"/>
+    </svg>`),
+    { width: 22, height: 22 }
+  );
+}
+
+app.whenReady().then(() => {
+  if (process.platform === 'darwin') app.dock.hide();
+
+  installHook();
+  loadExistingCount();
+
+  tray = new Tray(createTrayIcon());
+  updateTray();
+
+  createOverlayWindow();
+  watchEvents();
+
+  overlayWindow.webContents.on('did-finish-load', () => {
+    overlayWindow.webContents.send('init', eventCount);
+  });
+});
+
+app.on('window-all-closed', (e) => e.preventDefault());

package/overlay.html

@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+
+  body {
+    background: transparent;
+    overflow: hidden;
+    user-select: none;
+    -webkit-app-region: no-drag;
+  }
+
+  /* ═══ PERSISTENT COUNTER — TOP CENTER ═══ */
+  #counter {
+    position: fixed;
+    top: 12px;
+    left: 50%;
+    transform: translateX(-50%);
+    z-index: 100;
+    text-align: center;
+  }
+
+  #counter-label {
+    font-family: 'Arial Black', 'Helvetica Neue', sans-serif;
+    font-size: 11px;
+    font-weight: 900;
+    letter-spacing: 4px;
+    text-transform: uppercase;
+    color: rgba(255, 255, 255, 0.7);
+    text-shadow: 0 1px 3px rgba(0,0,0,0.9), 0 0 10px rgba(0,0,0,0.5);
+    margin-bottom: 2px;
+  }
+
+  #counter-number {
+    font-family: 'Arial Black', 'Helvetica Neue', sans-serif;
+    font-size: 32px;
+    font-weight: 900;
+    color: #ff2222;
+    text-shadow: 0 2px 4px rgba(0,0,0,0.9), 0 0 20px rgba(255,0,0,0.3);
+    font-variant-numeric: tabular-nums;
+    letter-spacing: 2px;
+    transition: transform 0.1s ease-out;
+  }
+
+  #counter-number.bump {
+    transform: scale(1.15);
+  }
+
+  /* ═══ WASTED FULLSCREEN OVERLAY ═══ */
+  #wasted-overlay {
+    position: fixed;
+    inset: 0;
+    z-index: 50;
+    pointer-events: none;
+    opacity: 0;
+    background: black;
+  }
+
+  #wasted-overlay.active {
+    animation: wastedBg 4s ease-out forwards;
+  }
+
+  #wasted-center {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    text-align: center;
+  }
+
+  #wasted-text {
+    font-family: 'Impact', 'Arial Black', 'Helvetica Neue', sans-serif;
+    font-size: 90px;
+    font-weight: 900;
+    color: #c20000;
+    letter-spacing: 8px;
+    text-transform: lowercase;
+    text-shadow:
+      0 0 40px rgba(180, 0, 0, 0.5),
+      0 0 80px rgba(120, 0, 0, 0.3);
+    opacity: 0;
+  }
+
+  #agent-name {
+    font-family: 'Arial', 'Helvetica Neue', sans-serif;
+    font-size: 18px;
+    color: rgba(255, 255, 255, 0.8);
+    letter-spacing: 2px;
+    margin-top: 12px;
+    opacity: 0;
+  }
+
+  #wasted-overlay.active #wasted-text {
+    animation: wastedText 4s ease-out forwards;
+  }
+
+  #wasted-overlay.active #agent-name {
+    animation: wastedText 4s ease-out forwards;
+  }
+
+  /* Black bg: fade in fast, hold, fade out */
+  @keyframes wastedBg {
+    0%   { opacity: 0; }
+    10%  { opacity: 0.85; }
+    70%  { opacity: 0.85; }
+    100% { opacity: 0; }
+  }
+
+  /* Text: appears after bg darkens, holds, fades with bg */
+  @keyframes wastedText {
+    0%   { opacity: 0; }
+    15%  { opacity: 0; }
+    25%  { opacity: 1; }
+    70%  { opacity: 1; }
+    100% { opacity: 0; }
+  }
+</style>
+</head>
+<body>
+
+<div id="counter">
+  <div id="counter-label">TOTAL KILLED</div>
+  <div id="counter-number">0</div>
+</div>
+
+<div id="wasted-overlay">
+  <div id="wasted-center">
+    <div id="wasted-text">wasted</div>
+    <div id="agent-name"></div>
+  </div>
+</div>
+
+<audio id="wasted-sound" preload="auto">
+  <source src="sounds/wasted.mp3" type="audio/mpeg">
+</audio>
+
+<script>
+  const counterNumber = document.getElementById('counter-number');
+  const wastedOverlay = document.getElementById('wasted-overlay');
+  const wastedSound = document.getElementById('wasted-sound');
+  const agentNameEl = document.getElementById('agent-name');
+
+  let animating = false;
+  let killQueue = [];
+
+  function updateCount(count) {
+    counterNumber.textContent = count.toLocaleString();
+    counterNumber.classList.add('bump');
+    setTimeout(() => counterNumber.classList.remove('bump'), 100);
+  }
+
+  function processQueue() {
+    if (animating || !killQueue.length) return;
+    animating = true;
+
+    const kill = killQueue.shift();
+    updateCount(kill.count);
+    agentNameEl.textContent = kill.agent;
+
+    wastedOverlay.classList.remove('active');
+    void wastedOverlay.offsetWidth;
+    wastedOverlay.classList.add('active');
+
+    wastedSound.currentTime = 0;
+    wastedSound.play().catch(() => {});
+
+    setTimeout(() => {
+      wastedOverlay.classList.remove('active');
+      animating = false;
+      processQueue();
+    }, 4100);
+  }
+
+  window.casualties.onInit((count) => {
+    counterNumber.textContent = count.toLocaleString();
+  });
+
+  window.casualties.onAgentKilled((data) => {
+    killQueue.push(data);
+    processQueue();
+  });
+
+  window.casualties.onReset(() => {
+    counterNumber.textContent = '0';
+    killQueue = [];
+  });
+</script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "claude-casualties",
+  "version": "1.0.0",
+  "description": "Track and mourn your fallen AI subagents. A death counter for the agents you create and destroy.",
+  "main": "main.js",
+  "bin": {
+    "claude-casualties": "./bin/claude-casualties.js"
+  },
+  "scripts": {
+    "start": "ELECTRON_RUN_AS_NODE= electron .",
+    "dev": "ELECTRON_RUN_AS_NODE= electron ."
+  },
+  "keywords": [
+    "claude",
+    "ai",
+    "agents",
+    "dark-humor",
+    "electron",
+    "death-counter"
+  ],
+  "author": "guts",
+  "license": "MIT",
+  "dependencies": {
+    "electron": "^33.0.0"
+  },
+  "files": [
+    "bin/",
+    "main.js",
+    "preload.js",
+    "overlay.html",
+    "sounds/",
+    "plugin/"
+  ],
+  "os": [
+    "darwin",
+    "win32",
+    "linux"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "claude-casualties",
+  "version": "1.0.0",
+  "description": "Counts your AI agent kills",
+  "author": {
+    "name": "guts",
+    "url": "https://github.com/Atomics-hub"
+  },
+  "repository": "https://github.com/Atomics-hub/claude-casualties",
+  "license": "MIT",
+  "keywords": ["dark-humor", "agents", "death-counter"],
+  "hooks": "./hooks/hooks.json"
+}

package/plugin/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/on-agent-death.js"
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugin/scripts/on-agent-death.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+const DATA_DIR = path.join(process.env.HOME, '.claude-casualties');
+const EVENTS_FILE = path.join(DATA_DIR, 'events.jsonl');
+
+function main() {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(input);
+
+      if (data.tool_name !== 'Agent') return;
+
+      const agentName = data.tool_input?.description
+        || data.tool_input?.subagent_type
+        || data.tool_input?.prompt?.slice(0, 60)
+        || 'Unknown Agent';
+
+      const event = {
+        id: Date.now(),
+        agent: agentName,
+        session: data.session_id || 'unknown',
+        timestamp: new Date().toISOString(),
+        toolUseId: data.tool_use_id || null
+      };
+
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+      fs.appendFileSync(EVENTS_FILE, JSON.stringify(event) + '\n');
+    } catch {
+      // silent fail — never interfere with Claude
+    }
+  });
+}
+
+main();

package/preload.js

@@ -0,0 +1,7 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('casualties', {
+  onInit: (cb) => ipcRenderer.on('init', (_, count) => cb(count)),
+  onAgentKilled: (cb) => ipcRenderer.on('agent-killed', (_, data) => cb(data)),
+  onReset: (cb) => ipcRenderer.on('reset', () => cb()),
+});