claude-raid 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,25 @@
 # claude-raid
 
-**Adversarial multi-agent development system for [Claude Code](https://claude.ai/code).**
+```ansi
+[33m  ⚔ ═══════════════════════════════════════════════════════ ⚔[0m
+
+[1;33m      ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗[0m
+[1;33m     ██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝[0m
+[1;33m     ██║     ██║     ███████║██║   ██║██║  ██║█████╗  [0m
+[1;33m     ██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝  [0m
+[1;33m     ╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗[0m
+[1;33m      ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝[0m
+[1;31m              ██████╗  █████╗ ██╗██████╗ [0m
+[1;31m              ██╔══██╗██╔══██╗██║██╔══██╗[0m
+[1;31m              ██████╔╝███████║██║██║  ██║[0m
+[1;31m              ██╔══██╗██╔══██║██║██║  ██║[0m
+[1;31m              ██║  ██║██║  ██║██║██████╔╝[0m
+[1;31m              ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═════╝ [0m
+
+[90m      Adversarial multi-agent warfare for Claude Code[0m
+
+[33m  ⚔ ═══════════════════════════════════════════════════════ ⚔[0m
+```
 
 Four agents -- Wizard, Warrior, Archer, Rogue -- work through a strict 4-phase workflow where every decision, implementation, and review is stress-tested by competing agents who learn from each other's mistakes and push every finding to its edges.
 
@@ -8,19 +27,41 @@ Adapted from [obra/superpowers](https://github.com/obra/superpowers) by Jesse Vi
 
 ---
 
-## Quick Start
+## Summon the Party
+
+```bash
+npx claude-raid summon
+```
+
+The installer auto-detects your realm (project type), copies agents, skills, and hooks into `.claude/`, and walks you through environment setup -- all in one command.
+
+Then start a Raid:
 
 ```bash
-npx claude-raid init
 claude --agent wizard
 ```
 
-That's it. The installer auto-detects your project type, generates configuration, and merges with your existing Claude Code setup. Nothing is overwritten.
+That's it. Describe your task and the Wizard takes over.
+
+### Prerequisites
+
+The setup wizard checks these automatically during `summon`:
+
+| Requirement | Why | Auto-configured? |
+|---|---|---|
+| **Claude Code** v2.1.32+ | Agent teams support | No -- install/update manually |
+| **Node.js** 18+ | Runs the installer | No -- install manually |
+| **teammateMode** in `~/.claude.json` | Display mode for agent sessions | Yes -- wizard prompts you |
+| **tmux** or **iTerm2** | Split-pane mode (optional) | No -- install manually |
+
+`jq` is required for hooks (pre-installed on macOS, `apt install jq` on Linux).
+
+The experimental agent teams flag (`CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS`) is set automatically in your project's `.claude/settings.json` during install.
 
-For split-pane mode (recommended for watching agents interact):
+Diagnose your environment anytime:
 
 ```bash
-claude --agent wizard --teammate-mode tmux
+npx claude-raid heal
 ```
 
 ## How It Works
@@ -40,7 +81,7 @@ Phase 2: PLAN             Agents decompose the design into tasks.
                           Agreed tasks pinned to the Dungeon.
 
 Phase 3: IMPLEMENTATION   One agent implements each task. The others attack
-                          directly — and attack each other's reviews too.
+                          directly -- and attack each other's reviews too.
                           TDD enforced. Every task earns approval.
 
 Phase 4: REVIEW           Independent reviews, then agents fight over findings
@@ -188,7 +229,7 @@ Edit this file to add project-specific rules. Updates via `claude-raid update` w
 
 ## Configuration
 
-`npx claude-raid init` auto-detects your project and generates `.claude/raid.json`:
+`claude-raid summon` auto-detects your realm and generates `.claude/raid.json`:
 
 ```json
 {
@@ -242,15 +283,20 @@ Commands are auto-detected from your project files (e.g., `scripts.test` in `pac
 | `conventions.maxDepth` | `8` | Maximum file nesting depth |
 | `raid.defaultMode` | `full` | Default mode: `full`, `skirmish`, `scout` |
 
-## CLI Commands
+## Commands
 
-```bash
-npx claude-raid init      # Install into current project
-npx claude-raid update    # Update agents, skills, hooks (preserves raid.json)
-npx claude-raid remove    # Uninstall and restore original settings
-```
+| Command | What it does |
+|---|---|
+| `claude-raid summon` | Summon the party into this realm |
+| `claude-raid update` | Reforge the party's arsenal |
+| `claude-raid dismantle` | Dismantle the camp and retreat |
+| `claude-raid heal` | Diagnose wounds and prepare for battle |
 
-### `init`
+> Old names (`init`, `remove`, `doctor`) still work as aliases.
+
+### `summon`
+
+Summons the full Raid party into your project.
 
 - Creates `.claude/` if absent
 - Auto-detects project type and generates `raid.json`
@@ -258,31 +304,45 @@ npx claude-raid remove    # Uninstall and restore original settings
 - Merges settings into existing `settings.json` (with backup)
 - Makes hooks executable
 - Adds session files to `.gitignore`
+- Runs the setup wizard to check and configure prerequisites
 - **Never overwrites** existing files with the same name
 
 ### `update`
 
+Reforges the party's weapons and armor with the latest version.
+
 - Overwrites hooks, skills, and `raid-rules.md` with latest versions
-- **Skips customized agents** (warns you which ones were preserved)
-- Does **not** touch `raid.json` (your project config)
-- Re-runs settings merge to add any new hooks
+- **Skips customized agents** (warns you which warriors were preserved)
+- Does **not** touch `raid.json` (your realm config stays intact)
+- Re-runs settings merge to pick up new hooks
 
-### `remove`
+### `dismantle`
+
+Dismantles the camp and restores your realm to its former state.
 
 - Removes all Raid agents, hooks, skills, and config files
 - Restores `settings.json` from backup (if backup exists)
 - Preserves non-Raid files in `.claude/`
 
+### `heal`
+
+Diagnoses wounds and prepares the party for battle.
+
+- Checks Node.js, Claude Code, teammateMode, and split-pane support
+- Offers to fix missing configuration interactively
+- Shows Quick Start, Controls, and Raid Modes reference
+- Exits with code 1 in CI when required checks fail
+
 ## What Gets Installed
 
 ```
 .claude/
-├── raid.json                        # Project config (auto-generated, editable)
+├── raid.json                        # Realm config (auto-generated, editable)
 ├── raid-rules.md                    # Team rules (editable)
 ├── settings.json                    # Merged with existing (backup at .pre-raid-backup)
 ├── agents/
-│   ├── wizard.md                    # Lead coordinator
-│   ├── warrior.md                   # Aggressive explorer
+│   ├── wizard.md                    # Dungeon master
+│   ├── warrior.md                   # Aggressive stress-tester
 │   ├── archer.md                    # Precision pattern-seeker
 │   └── rogue.md                     # Adversarial assumption-destroyer
 ├── hooks/
@@ -318,12 +378,6 @@ The Raid is a tool in your toolkit, not your project's operating system.
 - **Clean removal** restores your original `settings.json` from backup
 - **Zero npm dependencies** -- pure Node.js stdlib, fast `npx` cold-start
 
-## Requirements
-
-- [Claude Code](https://claude.ai/code) v2.1.32+
-- Node.js 18+ (for installation only -- the installed files are language-agnostic)
-- `jq` (for hooks -- pre-installed on macOS, available via `apt install jq` on Linux)
-
 ## Inherited from Superpowers
 
 The Raid inherits and adapts the [Superpowers](https://github.com/obra/superpowers) behavioral harness:

package/bin/cli.js

@@ -3,32 +3,45 @@
 'use strict';
 
 const command = process.argv[2];
+const { banner, colors, header } = require('../src/ui');
+const versionCheck = require('../src/version-check');
+
+// Start non-blocking version check immediately
+const showUpdateNotice = versionCheck.start();
 
 const COMMANDS = {
-  init: () => require('../src/init').run(),
+  // Primary commands
+  summon: () => require('../src/init').run(),
   update: () => require('../src/update').run(),
+  dismantle: () => require('../src/remove').run(),
+  heal: () => require('../src/doctor').run(),
+  // Aliases (backward compat)
+  init: () => require('../src/init').run(),
   remove: () => require('../src/remove').run(),
   doctor: () => require('../src/doctor').run(),
 };
 
 if (!command || !COMMANDS[command]) {
-  console.log(`
-claude-raid — Adversarial multi-agent development for Claude Code
-
-Usage:
-  claude-raid init     Install The Raid into the current project
-  claude-raid update   Update to the latest version
-  claude-raid remove   Uninstall The Raid
-  claude-raid doctor   Check prerequisites and show quick start guide
-
-Learn more: https://github.com/pedropicardi/claude-raid
-`);
+  console.log('\n' + banner());
+  console.log(header('Commands') + '\n');
+  const cmds = [
+    ['summon',    'Summon the party into this realm'],
+    ['update',    'Reforge the party\'s arsenal'],
+    ['dismantle', 'Dismantle the camp and retreat'],
+    ['heal',      'Diagnose wounds and prepare for battle'],
+  ];
+  for (const [name, desc] of cmds) {
+    console.log('    ' + colors.bold(name.padEnd(12)) + desc);
+  }
+  console.log(header('Begin the Raid') + '\n');
+  console.log('    claude --agent wizard\n');
+  console.log(colors.dim('  github.com/pedropicardi/claude-raid') + '\n');
   process.exit(command ? 1 : 0);
 }
 
-try {
-  COMMANDS[command]();
-} catch (err) {
-  console.error(`\nclaude-raid: ${err.message}\n`);
-  process.exit(1);
-}
+Promise.resolve(COMMANDS[command]())
+  .then(() => showUpdateNotice(colors))
+  .catch((err) => {
+    console.error(`\nclaude-raid: ${err.message}\n`);
+    process.exit(1);
+  });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-raid",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "commonjs",
   "description": "Adversarial multi-agent development system for Claude Code",
   "author": "Pedro Picardi",
@@ -9,10 +9,10 @@
   "bugs": "https://github.com/pedropicardi/claude-raid/issues",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pedropicardi/claude-raid.git"
+    "url": "git+https://github.com/pedropicardi/claude-raid.git"
   },
   "bin": {
-    "claude-raid": "./bin/cli.js"
+    "claude-raid": "bin/cli.js"
   },
   "files": [
     "bin/",

package/src/detect-browser.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Single-file detectors: first matching variant wins
+const SINGLE_FILE_DETECTORS = [
+  {
+    variants: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+    framework: 'next',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 3000,
+  },
+  {
+    variants: ['nuxt.config.ts', 'nuxt.config.js'],
+    framework: 'nuxt',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 3000,
+  },
+  {
+    variants: ['remix.config.js', 'remix.config.ts'],
+    framework: 'remix',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 3000,
+  },
+  {
+    variants: ['svelte.config.js', 'svelte.config.ts'],
+    framework: 'svelte',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 5173,
+  },
+  {
+    variants: ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'],
+    framework: 'vite',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 5173,
+  },
+  {
+    variants: ['angular.json'],
+    framework: 'angular',
+    devCommand: () => 'ng serve',
+    defaultPort: 4200,
+  },
+  {
+    variants: ['astro.config.mjs', 'astro.config.js', 'astro.config.ts'],
+    framework: 'astro',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 4321,
+  },
+  {
+    variants: ['gatsby-config.js', 'gatsby-config.ts'],
+    framework: 'gatsby',
+    devCommand: (run) => `${run} develop`,
+    defaultPort: 8000,
+  },
+  {
+    variants: ['manage.py'],
+    framework: 'django',
+    devCommand: () => 'python manage.py runserver',
+    defaultPort: 8000,
+  },
+  {
+    variants: ['trunk.toml'],
+    framework: 'trunk',
+    devCommand: () => 'trunk serve',
+    defaultPort: 8080,
+  },
+];
+
+// Multi-file detectors: ALL listed files must exist
+const MULTI_FILE_DETECTORS = [
+  {
+    files: ['webpack.config.js', 'index.html'],
+    framework: 'webpack',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 8080,
+  },
+];
+
+// Content-checked detectors: file must exist AND contain a marker string
+const CONTENT_DETECTORS = [
+  {
+    file: 'app.py',
+    markers: ['flask', 'Flask'],
+    framework: 'flask',
+    devCommand: () => 'flask run',
+    defaultPort: 5000,
+  },
+];
+
+// Directory+file detectors: the nested path must exist
+const DIR_FILE_DETECTORS = [
+  {
+    filePath: path.join('app', 'root.tsx'),
+    framework: 'remix',
+    devCommand: (run) => `${run} dev`,
+    defaultPort: 3000,
+  },
+];
+
+function detectBrowser(cwd, runCommand) {
+  // Check single-file detectors (first match wins)
+  for (const detector of SINGLE_FILE_DETECTORS) {
+    for (const variant of detector.variants) {
+      if (fs.existsSync(path.join(cwd, variant))) {
+        return {
+          detected: true,
+          framework: detector.framework,
+          devCommand: detector.devCommand(runCommand),
+          defaultPort: detector.defaultPort,
+        };
+      }
+    }
+  }
+
+  // Check content-based detectors (file must exist and contain marker)
+  for (const detector of CONTENT_DETECTORS) {
+    const filePath = path.join(cwd, detector.file);
+    if (fs.existsSync(filePath)) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        if (detector.markers.some(m => content.includes(m))) {
+          return {
+            detected: true,
+            framework: detector.framework,
+            devCommand: detector.devCommand(runCommand),
+            defaultPort: detector.defaultPort,
+          };
+        }
+      } catch {
+        // Unreadable file, skip
+      }
+    }
+  }
+
+  // Check multi-file detectors (all files must exist)
+  for (const detector of MULTI_FILE_DETECTORS) {
+    const allExist = detector.files.every((f) => fs.existsSync(path.join(cwd, f)));
+    if (allExist) {
+      return {
+        detected: true,
+        framework: detector.framework,
+        devCommand: detector.devCommand(runCommand),
+        defaultPort: detector.defaultPort,
+      };
+    }
+  }
+
+  // Check directory+file detectors
+  for (const detector of DIR_FILE_DETECTORS) {
+    if (fs.existsSync(path.join(cwd, detector.filePath))) {
+      return {
+        detected: true,
+        framework: detector.framework,
+        devCommand: detector.devCommand(runCommand),
+        defaultPort: detector.defaultPort,
+      };
+    }
+  }
+
+  return null;
+}
+
+module.exports = { detectBrowser };

package/src/detect-package-manager.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const JS_LOCKFILES = [
+  {
+    file: 'pnpm-lock.yaml',
+    packageManager: 'pnpm',
+    runCommand: 'pnpm',
+    execCommand: 'pnpm dlx',
+    installCommand: 'pnpm add',
+  },
+  {
+    file: 'yarn.lock',
+    packageManager: 'yarn',
+    runCommand: 'yarn',
+    execCommand: 'yarn dlx',
+    installCommand: 'yarn add',
+  },
+  {
+    file: 'bun.lockb',
+    packageManager: 'bun',
+    runCommand: 'bun',
+    execCommand: 'bunx',
+    installCommand: 'bun add',
+  },
+  {
+    file: 'bun.lock',
+    packageManager: 'bun',
+    runCommand: 'bun',
+    execCommand: 'bunx',
+    installCommand: 'bun add',
+  },
+  {
+    file: 'package-lock.json',
+    packageManager: 'npm',
+    runCommand: 'npm run',
+    execCommand: 'npx',
+    installCommand: 'npm install',
+  },
+];
+
+const PYTHON_LOCKFILES = [
+  {
+    file: 'uv.lock',
+    packageManager: 'uv',
+    runCommand: 'uv run',
+    execCommand: 'uvx',
+    installCommand: 'uv add',
+  },
+  {
+    file: 'poetry.lock',
+    packageManager: 'poetry',
+    runCommand: 'poetry run',
+    execCommand: 'poetry run',
+    installCommand: 'poetry add',
+  },
+];
+
+const JS_FALLBACK = {
+  packageManager: 'npm',
+  runCommand: 'npm run',
+  execCommand: 'npx',
+  installCommand: 'npm install',
+};
+
+const PYTHON_FALLBACK = {
+  packageManager: 'pip',
+  runCommand: 'python -m',
+  execCommand: 'python -m',
+  installCommand: 'pip install',
+};
+
+function detectPackageManager(cwd, language) {
+  if (language === 'javascript') {
+    for (const entry of JS_LOCKFILES) {
+      if (fs.existsSync(path.join(cwd, entry.file))) {
+        return {
+          packageManager: entry.packageManager,
+          runCommand: entry.runCommand,
+          execCommand: entry.execCommand,
+          installCommand: entry.installCommand,
+        };
+      }
+    }
+    return { ...JS_FALLBACK };
+  }
+
+  if (language === 'python') {
+    for (const entry of PYTHON_LOCKFILES) {
+      if (fs.existsSync(path.join(cwd, entry.file))) {
+        return {
+          packageManager: entry.packageManager,
+          runCommand: entry.runCommand,
+          execCommand: entry.execCommand,
+          installCommand: entry.installCommand,
+        };
+      }
+    }
+    return { ...PYTHON_FALLBACK };
+  }
+
+  return null;
+}
+
+module.exports = { detectPackageManager };

package/src/detect-project.js

@@ -2,21 +2,28 @@
 
 const fs = require('fs');
 const path = require('path');
+const { detectPackageManager } = require('./detect-package-manager');
+const { detectBrowser } = require('./detect-browser');
 
 const DETECTORS = [
   {
     file: 'package.json',
     language: 'javascript',
-    detect(cwd) {
+    detect(cwd, pm) {
       const pkgPath = path.join(cwd, 'package.json');
+      const run = pm ? pm.runCommand : 'npm run';
+      // For pnpm/yarn/bun the runCommand is just the pm name (e.g. 'pnpm'),
+      // so 'pnpm test' is correct. For npm the runCommand is 'npm run',
+      // so we special-case 'npm run test' -> 'npm test'.
+      const testCmd = (run === 'npm run') ? 'npm test' : `${run} test`;
       try {
         const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
         const scripts = pkg.scripts || {};
         return {
           language: 'javascript',
-          testCommand: scripts.test ? 'npm test' : '',
-          lintCommand: scripts.lint ? 'npm run lint' : '',
-          buildCommand: scripts.build ? 'npm run build' : '',
+          testCommand: scripts.test ? testCmd : '',
+          lintCommand: scripts.lint ? `${run} lint` : '',
+          buildCommand: scripts.build ? `${run} build` : '',
           name: pkg.name || path.basename(cwd),
         };
       } catch {
@@ -40,10 +47,29 @@ const DETECTORS = [
   {
     file: 'pyproject.toml',
     language: 'python',
-    detect(cwd) {
+    detect(cwd, pm) {
       try {
         const content = fs.readFileSync(path.join(cwd, 'pyproject.toml'), 'utf8');
         const usesPoetry = content.includes('[tool.poetry]');
+        // If a pm is provided (uv or poetry), use its runCommand
+        if (pm && pm.packageManager === 'uv') {
+          return {
+            language: 'python',
+            testCommand: 'uv run pytest',
+            lintCommand: 'uv run ruff check .',
+            buildCommand: 'uv run python -m build',
+            name: path.basename(cwd),
+          };
+        }
+        if (pm && pm.packageManager === 'poetry') {
+          return {
+            language: 'python',
+            testCommand: 'poetry run pytest',
+            lintCommand: 'poetry run ruff check .',
+            buildCommand: 'poetry build',
+            name: path.basename(cwd),
+          };
+        }
         return {
           language: 'python',
           testCommand: usesPoetry ? 'poetry run pytest' : 'pytest',
@@ -89,7 +115,15 @@ function detectProject(cwd) {
 
   for (const detector of DETECTORS) {
     if (fs.existsSync(path.join(cwd, detector.file))) {
-      detected.push(detector.detect(cwd));
+      const pm = detectPackageManager(cwd, detector.language);
+      const entry = detector.detect(cwd, pm);
+      if (pm) {
+        entry.packageManager = pm.packageManager;
+        entry.runCommand = pm.runCommand;
+        entry.execCommand = pm.execCommand;
+        entry.installCommand = pm.installCommand;
+      }
+      detected.push(entry);
     }
   }
 
@@ -100,11 +134,15 @@ function detectProject(cwd) {
       lintCommand: '',
       buildCommand: '',
       name: path.basename(cwd),
+      browser: null,
       detected: [],
     };
   }
 
   const primary = detected[0];
+  // Use the primary entry's runCommand for browser detection, fall back to 'npm run'
+  const primaryRunCommand = primary.runCommand || 'npm run';
+  primary.browser = detectBrowser(cwd, primaryRunCommand);
   primary.detected = detected;
   return primary;
 }