brain-dev 0.1.0

package/bin/lib/health.cjs

@@ -0,0 +1,356 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { migrateState, atomicWriteSync } = require('./state.cjs');
+
+/**
+ * Expected subdirectories under .brain/
+ */
+const EXPECTED_SUBDIRS = ['hooks', 'debug', 'sessions', 'specs', 'codebase'];
+
+/**
+ * Health check definitions.
+ * Each check has: name, category ('safe'|'report'), check(brainDir), repair(brainDir)|null
+ */
+const CHECKS = [
+  // --- Safe (auto-repairable) checks ---
+  {
+    name: 'brain-subdirs',
+    category: 'safe',
+    check(brainDir) {
+      const missing = EXPECTED_SUBDIRS.filter(
+        s => !fs.existsSync(path.join(brainDir, s))
+      );
+      if (missing.length === 0) {
+        return { status: 'pass', message: 'All subdirectories present' };
+      }
+      return { status: 'fail', message: `Missing subdirs: ${missing.join(', ')}` };
+    },
+    repair(brainDir) {
+      for (const s of EXPECTED_SUBDIRS) {
+        const p = path.join(brainDir, s);
+        if (!fs.existsSync(p)) {
+          fs.mkdirSync(p, { recursive: true });
+        }
+      }
+    }
+  },
+  {
+    name: 'stale-bridge',
+    category: 'safe',
+    check(brainDir) {
+      const bridgePath = path.join(brainDir, '.context-bridge.json');
+      if (!fs.existsSync(bridgePath)) {
+        return { status: 'pass', message: 'No bridge file' };
+      }
+      // Read state to check session staleness
+      const statePath = path.join(brainDir, 'brain.json');
+      try {
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        const lastPaused = state.session && state.session.lastPaused;
+        if (lastPaused) {
+          // Session is paused -- bridge may be stale
+          const pausedAt = new Date(lastPaused).getTime();
+          const now = Date.now();
+          if (now - pausedAt > 24 * 60 * 60 * 1000) {
+            return { status: 'fail', message: 'Bridge file stale (session paused >24h ago)' };
+          }
+        }
+        // Active session with no pause -- bridge is fine
+        if (!lastPaused) {
+          return { status: 'pass', message: 'Bridge file present, session active' };
+        }
+        return { status: 'pass', message: 'Bridge file present, session recent' };
+      } catch {
+        return { status: 'fail', message: 'Bridge file exists but cannot read state' };
+      }
+    },
+    repair(brainDir) {
+      const bridgePath = path.join(brainDir, '.context-bridge.json');
+      if (fs.existsSync(bridgePath)) {
+        fs.unlinkSync(bridgePath);
+      }
+    }
+  },
+  {
+    name: 'brain-json-fields',
+    category: 'safe',
+    check(brainDir) {
+      const statePath = path.join(brainDir, 'brain.json');
+      try {
+        const data = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        const migrated = migrateState(data);
+        // Compare stringified to detect any differences
+        if (JSON.stringify(data) !== JSON.stringify(migrated)) {
+          return { status: 'fail', message: 'brain.json missing fields (needs migration)' };
+        }
+        return { status: 'pass', message: 'brain.json fields up to date' };
+      } catch {
+        return { status: 'fail', message: 'Cannot parse brain.json for field check' };
+      }
+    },
+    repair(brainDir) {
+      const statePath = path.join(brainDir, 'brain.json');
+      try {
+        const data = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        const migrated = migrateState(data);
+        atomicWriteSync(statePath, JSON.stringify(migrated, null, 2));
+      } catch {
+        // Cannot repair if JSON is corrupt -- that's a report-only issue
+      }
+    }
+  },
+  {
+    name: 'orphaned-sessions',
+    category: 'safe',
+    check(brainDir) {
+      const sessDir = path.join(brainDir, 'sessions');
+      if (!fs.existsSync(sessDir)) {
+        return { status: 'pass', message: 'No sessions directory' };
+      }
+      const now = Date.now();
+      const sevenDays = 7 * 24 * 60 * 60 * 1000;
+      const files = fs.readdirSync(sessDir).filter(f => {
+        const fp = path.join(sessDir, f);
+        const stat = fs.statSync(fp);
+        return stat.isFile() && (now - stat.mtimeMs > sevenDays);
+      });
+      if (files.length === 0) {
+        return { status: 'pass', message: 'No orphaned sessions' };
+      }
+      return { status: 'fail', message: `${files.length} session(s) older than 7 days` };
+    },
+    repair(brainDir) {
+      const sessDir = path.join(brainDir, 'sessions');
+      if (!fs.existsSync(sessDir)) return;
+      const archiveDir = path.join(sessDir, 'archive');
+      fs.mkdirSync(archiveDir, { recursive: true });
+      const now = Date.now();
+      const sevenDays = 7 * 24 * 60 * 60 * 1000;
+      for (const f of fs.readdirSync(sessDir)) {
+        const fp = path.join(sessDir, f);
+        const stat = fs.statSync(fp);
+        if (stat.isFile() && (now - stat.mtimeMs > sevenDays)) {
+          fs.renameSync(fp, path.join(archiveDir, f));
+        }
+      }
+    }
+  },
+
+  // --- Report-only checks ---
+  {
+    name: 'brain-json-corrupt',
+    category: 'report',
+    check(brainDir) {
+      const statePath = path.join(brainDir, 'brain.json');
+      if (!fs.existsSync(statePath)) {
+        return { status: 'fail', message: 'brain.json does not exist' };
+      }
+      try {
+        JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        return { status: 'pass', message: 'brain.json is valid JSON' };
+      } catch {
+        return { status: 'fail', message: 'brain.json is corrupt (invalid JSON)' };
+      }
+    },
+    repair: null
+  },
+  {
+    name: 'state-roadmap-mismatch',
+    category: 'report',
+    check(brainDir) {
+      const statePath = path.join(brainDir, 'brain.json');
+      // Find project root (parent of .brain/)
+      const projectRoot = path.dirname(brainDir);
+      const roadmapPath = path.join(projectRoot, '.planning', 'ROADMAP.md');
+
+      try {
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        const currentPhase = state.phase && state.phase.current;
+
+        if (!fs.existsSync(roadmapPath)) {
+          if (currentPhase > 0) {
+            return { status: 'fail', message: 'State has active phase but no ROADMAP.md found' };
+          }
+          return { status: 'pass', message: 'No ROADMAP.md, state at phase 0' };
+        }
+
+        // Simple check: look for phase progress markers in ROADMAP.md
+        return { status: 'pass', message: 'State and roadmap present' };
+      } catch {
+        return { status: 'fail', message: 'Cannot read state for roadmap comparison' };
+      }
+    },
+    repair: null
+  },
+  {
+    name: 'unregistered-hooks',
+    category: 'report',
+    check(brainDir) {
+      const projectRoot = path.dirname(brainDir);
+      const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+      if (!fs.existsSync(settingsPath)) {
+        return { status: 'fail', message: 'No .claude/settings.json found' };
+      }
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        const hooks = settings.hooks || {};
+        const sessionStart = hooks.SessionStart || [];
+        const hasBootstrap = sessionStart.some(h => {
+          const cmd = typeof h === 'string' ? h : (h.command || '');
+          return cmd.includes('bootstrap.sh');
+        });
+        if (hasBootstrap) {
+          return { status: 'pass', message: 'SessionStart hook registered' };
+        }
+        return { status: 'fail', message: 'bootstrap.sh not registered in SessionStart hooks' };
+      } catch {
+        return { status: 'fail', message: 'Cannot parse .claude/settings.json' };
+      }
+    },
+    repair: null
+  },
+  {
+    name: 'missing-templates',
+    category: 'report',
+    check(brainDir) {
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      const required = ['planner.md', 'executor.md', 'verifier.md', 'debugger.md'];
+      const missing = required.filter(t => !fs.existsSync(path.join(templatesDir, t)));
+      if (missing.length === 0) {
+        return { status: 'pass', message: 'All required templates present' };
+      }
+      return { status: 'fail', message: `Missing templates: ${missing.join(', ')}` };
+    },
+    repair: null
+  },
+  {
+    name: 'git-not-initialized',
+    category: 'report',
+    check(brainDir) {
+      const projectRoot = path.dirname(brainDir);
+      if (fs.existsSync(path.join(projectRoot, '.git'))) {
+        return { status: 'pass', message: 'Git repository initialized' };
+      }
+      return { status: 'fail', message: 'No .git/ directory found at project root' };
+    },
+    repair: null
+  }
+];
+
+/**
+ * FIX_MODE_REPAIRS: aggressive repairs for --fix flag.
+ * Maps check name to repair function for report-category checks.
+ */
+const FIX_MODE_REPAIRS = {
+  // Could add hook registration and template copying here in future
+};
+
+/**
+ * Run all health checks.
+ * @param {string} brainDir - Path to .brain/ directory
+ * @returns {Array<{name: string, status: string, category: string, message: string}>}
+ */
+function runChecks(brainDir) {
+  return CHECKS.map(c => {
+    try {
+      const result = c.check(brainDir);
+      return {
+        name: c.name,
+        status: result.status,
+        category: c.category,
+        message: result.message
+      };
+    } catch (err) {
+      return {
+        name: c.name,
+        status: 'fail',
+        category: c.category,
+        message: `Check error: ${err.message}`
+      };
+    }
+  });
+}
+
+/**
+ * Auto-repair safe-category failures.
+ * @param {string} brainDir - Path to .brain/ directory
+ * @param {Array} results - Results from runChecks
+ * @returns {string[]} Names of repaired checks
+ */
+function autoRepair(brainDir, results) {
+  const repaired = [];
+  for (const r of results) {
+    if (r.status === 'fail' && r.category === 'safe') {
+      const check = CHECKS.find(c => c.name === r.name);
+      if (check && check.repair) {
+        try {
+          check.repair(brainDir);
+          repaired.push(r.name);
+          r.status = 'repaired';
+        } catch {
+          // Repair failed, leave as fail
+        }
+      }
+    }
+  }
+  return repaired;
+}
+
+/**
+ * Generate a structured report from check results.
+ * @param {Array} results - Results from runChecks
+ * @returns {{total: number, passed: number, failed: number, checks: Array}}
+ */
+function generateReport(results) {
+  const passed = results.filter(r => r.status === 'pass' || r.status === 'repaired').length;
+  const failed = results.filter(r => r.status === 'fail').length;
+  return {
+    total: results.length,
+    passed,
+    failed,
+    checks: results.map(r => ({
+      name: r.name,
+      status: r.status,
+      category: r.category,
+      message: r.message
+    }))
+  };
+}
+
+/**
+ * Quick health check: runs only safe-category checks, auto-repairs failures.
+ * Designed to complete in under 100ms for bootstrap use.
+ * @param {string} brainDir - Path to .brain/ directory
+ * @returns {boolean} true if all safe checks pass (or are repaired)
+ */
+function quickCheck(brainDir) {
+  const safeChecks = CHECKS.filter(c => c.category === 'safe');
+  const results = safeChecks.map(c => {
+    try {
+      const result = c.check(brainDir);
+      return {
+        name: c.name,
+        status: result.status,
+        category: c.category,
+        message: result.message
+      };
+    } catch (err) {
+      return {
+        name: c.name,
+        status: 'fail',
+        category: c.category,
+        message: `Check error: ${err.message}`
+      };
+    }
+  });
+
+  // Auto-repair any failures
+  autoRepair(brainDir, results);
+
+  // All good if no remaining failures
+  return results.every(r => r.status !== 'fail');
+}
+
+module.exports = { CHECKS, FIX_MODE_REPAIRS, runChecks, autoRepair, generateReport, quickCheck };

package/bin/lib/init.cjs

@@ -0,0 +1,310 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseArgs } = require('node:util');
+const { prefix, error } = require('./core.cjs');
+const { createDefaultState, writeState, atomicWriteSync } = require('./state.cjs');
+const { detectPlatform } = require('./platform.cjs');
+const { isGitRepo, gitInit, gitCommit } = require('./git.cjs');
+
+/**
+ * Resolve a path relative to the package root (two levels up from __dirname).
+ * @param {...string} segments - Path segments relative to package root
+ * @returns {string}
+ */
+function packagePath(...segments) {
+  return path.join(__dirname, '..', '..', ...segments);
+}
+
+/**
+ * Print ASCII art banner for init command.
+ */
+function showBanner() {
+  console.log('');
+  console.log('  ╔══════════════════════════════════════════╗');
+  console.log('  ║                                          ║');
+  console.log('  ║   ██████  ██████   █████  ██ ██   ██     ║');
+  console.log('  ║   ██   ██ ██   ██ ██   ██ ██ ███  ██     ║');
+  console.log('  ║   ██████  ██████  ███████ ██ ██ █ ██     ║');
+  console.log('  ║   ██   ██ ██   ██ ██   ██ ██ ██  ███     ║');
+  console.log('  ║   ██████  ██   ██ ██   ██ ██ ██   ██     ║');
+  console.log('  ║                                          ║');
+  console.log('  ║   AI workflow orchestrator               ║');
+  console.log('  ║                                          ║');
+  console.log('  ║                        ── halilcosdu ──  ║');
+  console.log('  ║                                          ║');
+  console.log('  ╚══════════════════════════════════════════╝');
+  console.log('');
+}
+
+/**
+ * Merge brain SessionStart hook into .claude/settings.json.
+ * Preserves existing settings and hooks.
+ * @param {string} cwd - Working directory
+ */
+function registerClaudeHooks(cwd) {
+  const claudeDir = path.join(cwd, '.claude');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  // Read existing or start fresh
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch {
+      settings = {};
+    }
+  }
+
+  // Ensure hooks object exists
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  // Helper: create Claude Code hook entry in new format {matcher, hooks: [{type, command}]}
+  function makeHookEntry(command) {
+    return { matcher: '', hooks: [{ type: 'command', command }] };
+  }
+
+  // Helper: check if a hook command is already registered (handles both old and new format)
+  function isHookRegistered(hookArray, searchStr) {
+    if (!Array.isArray(hookArray)) return false;
+    return hookArray.some(entry => {
+      if (entry.command && entry.command.includes(searchStr)) return true;
+      if (entry.hooks) return entry.hooks.some(h => h.command && h.command.includes(searchStr));
+      return false;
+    });
+  }
+
+  // SessionStart hook
+  if (!Array.isArray(settings.hooks.SessionStart)) {
+    settings.hooks.SessionStart = [];
+  }
+  if (!isHookRegistered(settings.hooks.SessionStart, 'bootstrap.sh')) {
+    settings.hooks.SessionStart.push(
+      makeHookEntry('bash "$CLAUDE_PROJECT_DIR/.brain/hooks/bootstrap.sh"')
+    );
+  }
+
+  // StatusLine configuration (top-level, NOT under hooks)
+  if (!settings.statusLine) {
+    settings.statusLine = {
+      type: 'command',
+      command: 'bash "$CLAUDE_PROJECT_DIR/.brain/hooks/statusline.sh"'
+    };
+  }
+
+  // PostToolUse hook for context alerts
+  if (!Array.isArray(settings.hooks.PostToolUse)) {
+    settings.hooks.PostToolUse = [];
+  }
+  if (!isHookRegistered(settings.hooks.PostToolUse, 'post-tool-use.sh')) {
+    settings.hooks.PostToolUse.push(
+      makeHookEntry('bash "$CLAUDE_PROJECT_DIR/.brain/hooks/post-tool-use.sh"')
+    );
+  }
+
+  // Write settings
+  fs.mkdirSync(claudeDir, { recursive: true });
+  atomicWriteSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+/**
+ * Clean up legacy skill directories from previous brain versions.
+ * Skills have been replaced by agent definitions + command markdown (GSD-style).
+ * @param {string} cwd - Working directory
+ */
+function cleanupLegacySkills(cwd) {
+  // Only remove brain-created skill directories, NOT the entire .claude/skills/
+  const brainSkillNames = ['brain', 'tdd', 'debug', 'verify-complete', 'defense-in-depth', 'review-request', 'review-receive', 'brainstorm'];
+
+  const claudeSkillsDir = path.join(cwd, '.claude', 'skills');
+  if (fs.existsSync(claudeSkillsDir)) {
+    for (const name of brainSkillNames) {
+      const skillDir = path.join(claudeSkillsDir, name);
+      if (fs.existsSync(skillDir)) {
+        try { fs.rmSync(skillDir, { recursive: true, force: true }); } catch { /* ignore */ }
+      }
+    }
+  }
+
+  // .brain/skills/ is entirely brain-owned, safe to remove completely
+  const brainSkillsDir = path.join(cwd, '.brain', 'skills');
+  if (fs.existsSync(brainSkillsDir)) {
+    try { fs.rmSync(brainSkillsDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Register brain agent definitions in .claude/agents/.
+ * Copies brain-* agent .md files so Claude Code uses brain-specific agents
+ * instead of falling back to globally installed alternatives (e.g. GSD).
+ * @param {string} cwd - Working directory
+ */
+function registerAgents(cwd) {
+  const src = packagePath('agents');
+  if (!fs.existsSync(src)) {
+    return;
+  }
+  const dest = path.join(cwd, '.claude', 'agents');
+  fs.mkdirSync(dest, { recursive: true });
+  for (const file of fs.readdirSync(src)) {
+    if (file.startsWith('brain-') && file.endsWith('.md')) {
+      fs.copyFileSync(path.join(src, file), path.join(dest, file));
+    }
+  }
+}
+
+/**
+ * Register command files from commands/brain/ into .claude/commands/brain/.
+ * @param {string} cwd - Working directory
+ */
+function registerCommands(cwd) {
+  const src = packagePath('commands', 'brain');
+  if (!fs.existsSync(src)) {
+    return;
+  }
+  const dest = path.join(cwd, '.claude', 'commands', 'brain');
+  try {
+    fs.mkdirSync(dest, { recursive: true });
+    fs.cpSync(src, dest, { recursive: true });
+  } catch { /* skip on permission/copy failure */ }
+}
+
+/**
+ * Run the init command.
+ * @param {string[]} args - CLI arguments after 'init'
+ */
+async function run(args = []) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      force: { type: 'boolean', default: false }
+    },
+    strict: false
+  });
+
+  const cwd = process.cwd();
+  const brainDir = path.join(cwd, '.brain');
+
+  // Pre-flight: check existing .brain/
+  if (fs.existsSync(brainDir)) {
+    if (!values.force) {
+      error("'.brain/' already exists. Use --force to wipe and recreate.");
+      process.exit(1);
+      return;
+    }
+    // --force: remove existing
+    fs.rmSync(brainDir, { recursive: true, force: true });
+  }
+
+  // Show banner
+  showBanner();
+
+  // Detect platform
+  const platform = detectPlatform({ cwd });
+  const isClaudeCode = platform === 'claude-code';
+
+  // Create .brain/ skeleton
+  fs.mkdirSync(path.join(brainDir, 'hooks'), { recursive: true });
+  fs.mkdirSync(path.join(brainDir, 'debug'), { recursive: true });
+  fs.mkdirSync(path.join(brainDir, 'specs'), { recursive: true });
+
+  // Create default state and write brain.json + STATE.md
+  const state = createDefaultState(platform);
+
+  // Merge global defaults from ~/.brain/defaults.json if it exists
+  try {
+    const { mergeWithDefaults, deepMerge } = require('./config.cjs');
+    const os = require('node:os');
+    const globalDefaultsPath = path.join(os.homedir(), '.brain', 'defaults.json');
+    if (fs.existsSync(globalDefaultsPath)) {
+      const globalDefaults = JSON.parse(fs.readFileSync(globalDefaultsPath, 'utf8'));
+      // Apply global defaults onto state (state fields override globals)
+      const merged = deepMerge(state, globalDefaults);
+      Object.assign(state, merged);
+    }
+  } catch {
+    // Global defaults merge failed -- continue with default state
+  }
+
+  writeState(brainDir, state);
+
+  // Copy bootstrap.sh hook
+  const hookSrc = packagePath('hooks', 'bootstrap.sh');
+  const hookDest = path.join(brainDir, 'hooks', 'bootstrap.sh');
+  fs.copyFileSync(hookSrc, hookDest);
+  fs.chmodSync(hookDest, 0o755);
+
+  // Copy monitoring hooks
+  const statuslineSrc = packagePath('hooks', 'statusline.sh');
+  const postToolSrc = packagePath('hooks', 'post-tool-use.sh');
+  if (fs.existsSync(statuslineSrc)) {
+    fs.copyFileSync(statuslineSrc, path.join(brainDir, 'hooks', 'statusline.sh'));
+    fs.chmodSync(path.join(brainDir, 'hooks', 'statusline.sh'), 0o755);
+  }
+  if (fs.existsSync(postToolSrc)) {
+    fs.copyFileSync(postToolSrc, path.join(brainDir, 'hooks', 'post-tool-use.sh'));
+    fs.chmodSync(path.join(brainDir, 'hooks', 'post-tool-use.sh'), 0o755);
+  }
+
+  // Write .gitignore
+  const gitignoreContent = [
+    '*.tmp',
+    '*.lock',
+    'storm/fragments/',
+    'storm/events.jsonl',
+    ''
+  ].join('\n');
+  fs.writeFileSync(path.join(brainDir, '.gitignore'), gitignoreContent, 'utf8');
+
+  // Output lines
+  console.log(prefix('Created .brain/ directory'));
+  console.log(prefix(`Platform: ${platform}${!isClaudeCode ? ' (stub -- full support coming in v2)' : ''}`));
+
+  // Platform-specific registrations
+  if (isClaudeCode) {
+    registerClaudeHooks(cwd);
+    console.log(prefix('Registered SessionStart hook'));
+
+    cleanupLegacySkills(cwd);
+
+    registerCommands(cwd);
+    console.log(prefix('Registered brain commands'));
+
+    registerAgents(cwd);
+    console.log(prefix('Registered brain agents'));
+  } else {
+    console.log(prefix('Note: brain currently supports Claude Code only. Other platform adapters are planned for v2.'));
+  }
+
+  // Git integration
+  const filesToCommit = [
+    '.brain/brain.json',
+    '.brain/STATE.md',
+    '.brain/hooks/bootstrap.sh',
+    '.brain/.gitignore'
+  ];
+
+  if (isClaudeCode) {
+    filesToCommit.push('.claude/settings.json');
+    filesToCommit.push('.claude/commands/brain/');
+    filesToCommit.push('.claude/agents/');
+  }
+
+  if (!isGitRepo(cwd)) {
+    gitInit(cwd);
+    console.log(prefix('Initialized git repository'));
+  }
+
+  const committed = gitCommit('chore: initialize brain', filesToCommit, cwd);
+  if (committed) {
+    console.log(prefix('Committed: chore: initialize brain'));
+  }
+
+  console.log(prefix(''));
+  console.log(prefix('Next: /brain:new-project to start planning'));
+}
+
+module.exports = { run };