claude-raid 0.1.1 → 0.1.3

package/bin/cli.js

@@ -3,32 +3,59 @@
 '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: () => {
+    if (process.argv.includes('--dry-run')) {
+      console.log('\n' + banner());
+      console.log(require('../src/init').dryRun(process.cwd()));
+      return;
+    }
+    return require('../src/init').run();
+  },
   update: () => require('../src/update').run(),
+  dismantle: () => require('../src/remove').run(),
+  heal: () => require('../src/doctor').run(),
+  // Aliases (backward compat)
+  init: () => {
+    if (process.argv.includes('--dry-run')) {
+      console.log('\n' + banner());
+      console.log(require('../src/init').dryRun(process.cwd()));
+      return;
+    }
+    return 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.1",
+  "version": "0.1.3",
   "type": "commonjs",
   "description": "Adversarial multi-agent development system for Claude Code",
   "author": "Pedro Picardi",

package/src/descriptions.js

@@ -0,0 +1,57 @@
+'use strict';
+
+// Single source of truth for file descriptions used by dry-run and install output.
+// Keep descriptions under 80 chars — they appear in terminal columns.
+
+const AGENTS = {
+  'wizard.md':  'Dungeon master — opens phases, dispatches team, closes with rulings',
+  'warrior.md': 'Stress-tester — breaks things under load, edge cases, pressure',
+  'archer.md':  'Pattern-seeker — traces ripple effects, naming drift, contract violations',
+  'rogue.md':   'Assumption-destroyer — thinks like a failing system, malicious input',
+};
+
+const HOOKS = {
+  lifecycle: [
+    { name: 'raid-lib.sh',            desc: 'Shared config — reads raid.json, exports session state' },
+    { name: 'raid-session-start.sh',   desc: 'Activates Raid workflow when session begins' },
+    { name: 'raid-session-end.sh',     desc: 'Archives Dungeon, cleans up when session ends' },
+    { name: 'raid-stop.sh',           desc: 'Backs up Dungeon on phase transitions' },
+    { name: 'raid-pre-compact.sh',    desc: 'Backs up Dungeon before message compaction' },
+    { name: 'raid-task-created.sh',   desc: 'Validates task subjects are meaningful' },
+    { name: 'raid-task-completed.sh', desc: 'Blocks task completion without test evidence' },
+    { name: 'raid-teammate-idle.sh',  desc: 'Nudges idle agents to participate' },
+  ],
+  gates: [
+    { name: 'validate-commit.sh',              desc: 'Enforces conventional commits + test gate' },
+    { name: 'validate-write-gate.sh',          desc: 'Blocks implementation before design doc exists' },
+    { name: 'validate-file-naming.sh',         desc: 'Enforces naming convention (kebab-case, etc.)' },
+    { name: 'validate-no-placeholders.sh',     desc: 'Blocks TBD/TODO in specs and plans' },
+    { name: 'validate-dungeon.sh',             desc: 'Requires multi-agent verification on pins' },
+    { name: 'validate-browser-tests-exist.sh', desc: 'Checks Playwright tests exist before commits' },
+    { name: 'validate-browser-cleanup.sh',     desc: 'Verifies browser processes cleaned up properly' },
+  ],
+};
+
+const SKILLS = {
+  'raid-protocol':            'Session lifecycle and team rules',
+  'raid-design':              'Phase 1: adversarial exploration',
+  'raid-implementation-plan': 'Phase 2: task decomposition',
+  'raid-implementation':      'Phase 3: TDD with direct challenge',
+  'raid-review':              'Phase 4: independent review + fighting',
+  'raid-finishing':           'Completeness debate + merge options',
+  'raid-tdd':                 'RED-GREEN-REFACTOR enforcement',
+  'raid-debugging':           'Root-cause investigation',
+  'raid-verification':        'Evidence-before-claims gate',
+  'raid-git-worktrees':       'Isolated workspace creation',
+  'raid-browser':             'Browser startup discovery',
+  'raid-browser-playwright':  'Playwright test authoring',
+  'raid-browser-chrome':      'Live browser inspection',
+};
+
+const CONFIG = {
+  'raid.json':      'Project settings (editable)',
+  'raid-rules.md':  '17 team rules (editable)',
+  'settings.json':  'Hooks merged into existing (backup created)',
+};
+
+module.exports = { AGENTS, HOOKS, SKILLS, CONFIG };

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;
 }