dual-brain 7.1.21 → 7.1.22

package/src/failure-memory.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * failure-memory.mjs — Track task failures and enable automatic escalation.
+ *
+ * Exports: recordFailure, checkFailureHistory, formatEscalation,
+ *          clearFailures, getFailureStats
+ */
+
+import { readFileSync, appendFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+const STOP_WORDS = new Set(['the','a','an','is','in','on','at','to','for','of','and','or','with','this','that','it','be','was','are','were','has','have','had','do','does','did','not','from','by','as','if','but','we','i','you']);
+const WINDOW_48H = 48 * 60 * 60 * 1000;
+
+const DEPTH_ORDER = ['low', 'medium', 'high', 'ultra'];
+const MODEL_ORDER = ['haiku', 'sonnet', 'opus'];
+
+function failuresPath(cwd) {
+  const dir = join(cwd, '.dualbrain');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, 'failures.jsonl');
+}
+
+function categorizeError(error = '') {
+  const e = error.toLowerCase();
+  if (/test|assert|expect/.test(e))             return 'test-failure';
+  if (/timeout|timed out/.test(e))              return 'timeout';
+  if (/syntax|parse|unexpected token/.test(e))  return 'syntax-error';
+  if (/permission|eacces/.test(e))              return 'permission-error';
+  if (/not found|enoent/.test(e))               return 'not-found';
+  return 'unknown';
+}
+
+function tokenize(text = '') {
+  return text.toLowerCase().split(/\W+/).filter(w => w.length > 2 && !STOP_WORDS.has(w));
+}
+
+function similarity(promptA, promptB, filesA = [], filesB = []) {
+  const wordsA = new Set(tokenize(promptA));
+  const wordsB = new Set(tokenize(promptB));
+  if (!wordsA.size && !wordsB.size) return 0;
+  const shared = [...wordsA].filter(w => wordsB.has(w)).length;
+  const wordScore = shared / Math.max(wordsA.size, wordsB.size);
+  const sharedFiles = filesA.some(f => filesB.includes(f));
+  return sharedFiles ? Math.max(wordScore, 0.5) : wordScore;
+}
+
+function readFailures(cwd) {
+  const path = failuresPath(cwd);
+  if (!existsSync(path)) return [];
+  return readFileSync(path, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map(line => { try { return JSON.parse(line); } catch { return null; } })
+    .filter(Boolean);
+}
+
+function writeAll(cwd, records) {
+  writeFileSync(failuresPath(cwd), records.map(r => JSON.stringify(r)).join('\n') + '\n');
+}
+
+function bumpDepth(depth) {
+  const idx = DEPTH_ORDER.indexOf(depth);
+  return idx === -1 || idx >= DEPTH_ORDER.length - 1 ? 'ultra' : DEPTH_ORDER[idx + 1];
+}
+
+function bumpModel(model = '') {
+  const m = model.toLowerCase();
+  const match = MODEL_ORDER.find(k => m.includes(k)) ?? 'sonnet';
+  const idx = MODEL_ORDER.indexOf(match);
+  return idx >= MODEL_ORDER.length - 1 ? `claude-opus-4-5` : `claude-${MODEL_ORDER[idx + 1]}-4-5`;
+}
+
+// ─── Exports ──────────────────────────────────────────────────────────────────
+
+export async function recordFailure(prompt, plan = {}, error = '', cwd = process.cwd()) {
+  const record = {
+    id: randomUUID(),
+    timestamp: Date.now(),
+    prompt,
+    promptWords: tokenize(prompt),
+    model: plan.model ?? null,
+    reasoningDepth: plan.reasoningDepth ?? null,
+    tier: plan.tier ?? null,
+    error: String(error),
+    errorCategory: categorizeError(error),
+    files: plan.files ?? [],
+    escalatedFrom: plan.escalatedFrom ?? null,
+    resolved: false,
+  };
+  appendFileSync(failuresPath(cwd), JSON.stringify(record) + '\n');
+  return record;
+}
+
+export async function checkFailureHistory(prompt, files = [], cwd = process.cwd()) {
+  const cutoff = Date.now() - WINDOW_48H;
+  const all = readFailures(cwd);
+  const recent = all.filter(r => !r.resolved && r.timestamp >= cutoff);
+  const matches = recent
+    .map(r => ({ r, score: similarity(prompt, r.prompt, files, r.files ?? []) }))
+    .filter(({ score }) => score >= 0.4)
+    .sort((a, b) => b.r.timestamp - a.r.timestamp);
+
+  const count = matches.length;
+  const last = matches[0]?.r ?? null;
+
+  const escalation = { recommended: false, fromModel: null, toModel: null, fromDepth: null, toDepth: null, useChallenger: false, reason: '' };
+
+  if (count >= 1) {
+    escalation.recommended = true;
+    escalation.fromModel = last.model;
+    escalation.fromDepth = last.reasoningDepth;
+
+    if (count === 1) {
+      escalation.toDepth = bumpDepth(last.reasoningDepth ?? 'medium');
+      escalation.toModel = last.model;
+      escalation.useChallenger = false;
+      escalation.reason = `1 prior failure on similar task, bumping depth to ${escalation.toDepth}`;
+    } else if (count === 2) {
+      escalation.toDepth = 'ultra';
+      escalation.toModel = last.model?.includes('opus') ? last.model : bumpModel(last.model);
+      escalation.useChallenger = false;
+      escalation.reason = `2 prior failures on similar task, escalating to Opus + ultrathink`;
+    } else {
+      escalation.toDepth = 'ultra';
+      escalation.toModel = last.model?.includes('opus') ? last.model : bumpModel(last.model);
+      escalation.useChallenger = true;
+      escalation.reason = `${count} prior failures on similar task, forcing dual-brain`;
+    }
+  }
+
+  return { hasPriorFailures: count > 0, failureCount: count, lastFailure: last, escalation };
+}
+
+export function formatEscalation(escalation) {
+  if (!escalation?.recommended) return '';
+  const prev = [escalation.fromModel, escalation.fromDepth].filter(Boolean).join(', ') || 'unknown';
+  const next = [escalation.toModel, escalation.toDepth, escalation.useChallenger ? 'GPT challenger' : null].filter(Boolean).join(' + ');
+  return `⚡ Strategy changed\n  Previous: failed (${prev})\n  Escalated: ${next}\n  Reason: ${escalation.reason}`;
+}
+
+export async function clearFailures(prompt, cwd = process.cwd()) {
+  const all = readFailures(cwd);
+  const promptWords = tokenize(prompt);
+  const fakePrompt = promptWords.join(' ');
+  let changed = false;
+  const updated = all.map(r => {
+    if (!r.resolved && similarity(fakePrompt, r.prompt) >= 0.4) {
+      changed = true;
+      return { ...r, resolved: true };
+    }
+    return r;
+  });
+  if (changed) writeAll(cwd, updated);
+}
+
+export async function getFailureStats(cwd = process.cwd()) {
+  const all = readFailures(cwd);
+  const byCategory = {};
+  let resolved = 0;
+  let escalationSum = 0;
+  let escalationCount = 0;
+
+  for (const r of all) {
+    if (r.resolved) resolved++;
+    byCategory[r.errorCategory] = (byCategory[r.errorCategory] ?? 0) + 1;
+    if (r.escalatedFrom) { escalationSum++; escalationCount++; }
+  }
+
+  return {
+    total: all.length,
+    resolved,
+    unresolved: all.length - resolved,
+    byCategory,
+    avgEscalationsToResolve: escalationCount ? +(escalationSum / escalationCount).toFixed(2) : 0,
+  };
+}

package/src/nextstep.mjs

@@ -0,0 +1,100 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+const AUTH_PAT = /\b(auth|credential|secret|token|password|encrypt|permission|oauth|jwt|api.?key)\b/i;
+const TEST_PAT = /\b(test|spec|\.test\.|\.spec\.)\b/i;
+
+function gitBranch(cwd) {
+  try { return execSync('git rev-parse --abbrev-ref HEAD', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(); }
+  catch { return null; }
+}
+
+function packageVersionChanged(cwd, files) {
+  if (!files.some(f => f.includes('package.json'))) return false;
+  try { return execSync('git diff HEAD~1 HEAD -- package.json', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().includes('"version"'); }
+  catch { return false; }
+}
+
+function changelogExists(cwd) {
+  return ['CHANGELOG.md', 'CHANGELOG', 'changelog.md'].some(f => existsSync(join(cwd, f)));
+}
+
+function step(priority, type, message, command, reason) {
+  return { priority, type, message, command, reason };
+}
+
+function dedup(steps) {
+  const seen = new Set();
+  return steps.filter(s => { if (seen.has(s.type)) return false; seen.add(s.type); return true; });
+}
+
+export async function suggestNextSteps(completedTask = {}, outcome = {}, cwd = process.cwd()) {
+  try {
+    const { prompt = '', files = [], trigger } = completedTask;
+    const { success = false, filesChanged = [], error = '' } = outcome;
+    const steps = [];
+    const branch = gitBranch(cwd);
+    const onMain = !branch || branch === 'main' || branch === 'master';
+    const allFiles = [...files, ...filesChanged];
+    const hasAuth = allFiles.some(f => AUTH_PAT.test(f));
+    const hasTests = allFiles.some(f => TEST_PAT.test(f));
+    const n = filesChanged.length;
+    const fs = (count) => `${count} file${count !== 1 ? 's' : ''}`;
+
+    if (trigger === 'auto-commit') {
+      steps.push(!onMain && branch
+        ? step(4, 'pr', `Open a pull request for branch "${branch}"`, `gh pr create --head ${branch}`, `On feature branch — changes need review before merging`)
+        : step(3, 'deploy', 'Deploy or tag a release', null, 'Committed to main — ready to ship or version'));
+      if (packageVersionChanged(cwd, filesChanged))
+        steps.push(step(4, 'publish', 'Publish the new package version to npm', 'npm publish', 'package.json version changed in this commit'));
+      if (changelogExists(cwd) && !filesChanged.some(f => /changelog/i.test(f)))
+        steps.push(step(2, 'changelog', 'Update CHANGELOG with this change', null, 'CHANGELOG exists but was not updated'));
+
+    } else if (trigger === 'review' || trigger === 'think') {
+      const issues = error || /issue|problem|fail|error|warn/i.test(prompt);
+      steps.push(issues
+        ? step(5, 'fix', 'Fix the issues identified in the review', `dual-brain go "fix issues identified in review"`, 'Review found problems that need resolution')
+        : step(3, 'continue', 'Ship it — the review looks good', null, 'Review completed without critical findings'));
+
+    } else if (!success) {
+      steps.push(step(5, 'fix', 'Retry with higher reasoning depth', `dual-brain go --tier think "${prompt}"`, 'Task failed — escalating tier may resolve it'));
+      if (error && /test/i.test(error))
+        steps.push(step(4, 'test', 'Look at test output for clues', null, 'Error references tests — check output to understand the failure'));
+      steps.push(step(3, 'review', 'Try a different approach — dual-brain think', `node .claude/hooks/dual-brain-think.mjs --question "${prompt}"`, 'GPT perspective may surface a different solution'));
+
+    } else if (success && n > 0) {
+      if (!hasTests)
+        steps.push(step(5, 'test', `Run tests to verify the ${fs(n)} changed`, 'npm test', `${fs(n)} changed without test verification`));
+      if (hasAuth)
+        steps.push(step(5, 'review', 'Run a security review on auth/credential changes', `node .claude/hooks/dual-brain-think.mjs --question "Security review: ${prompt}"`, 'Auth or security-sensitive files were modified'));
+      if (n > 3)
+        steps.push(step(4, 'review', `Review the ${n}-file diff before committing`, 'git diff', `${n} files changed — quick diff review before committing`));
+      if (!onMain && branch)
+        steps.push(step(4, 'pr', `Open a pull request for branch "${branch}"`, `gh pr create --head ${branch}`, `Changes are on feature branch "${branch}" — ready for PR`));
+      if (hasTests)
+        steps.push(step(3, 'commit', 'Commit changes', 'git add -p && git commit', 'Tests passed — safe to commit'));
+      steps.push(step(2, 'continue', 'Check for edge cases in the changed code', null, 'Edge cases are often missed during implementation'));
+      if (changelogExists(cwd) && !filesChanged.some(f => /changelog/i.test(f)))
+        steps.push(step(2, 'changelog', 'Update CHANGELOG with this change', null, 'CHANGELOG exists but was not updated in this batch'));
+    }
+
+    const sorted = dedup(steps.sort((a, b) => b.priority - a.priority));
+    return {
+      steps: sorted,
+      topSuggestion: sorted.length > 0 ? `→ ${sorted[0].message}` : '→ Nothing urgent — task complete',
+    };
+  } catch {
+    return { steps: [], topSuggestion: '→ Task complete' };
+  }
+}
+
+export function formatNextSteps(steps, limit = 3) {
+  if (!steps?.length) return '';
+  return `📋 Next steps\n${steps.slice(0, limit).map((s, i) => `  ${i + 1}. ${s.message}`).join('\n')}`;
+}
+
+export function getTopSuggestion(steps) {
+  if (!steps?.length) return '→ Task complete';
+  return `→ ${steps[0].message}`;
+}

package/src/observer.mjs

@@ -0,0 +1,241 @@
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const SEC_PATTERNS = /auth|login|password|token|secret|credential|session|jwt|oauth|permission|role|middleware/i;
+const SOURCE_EXT = /\.(mjs|js|ts|py)$/;
+
+function exec(cmd, cwd, timeout = 5000) {
+  try {
+    return execSync(cmd, { cwd, encoding: 'utf8', timeout, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function changedFiles(cwd) {
+  const output = exec('git diff --name-only HEAD 2>/dev/null || git diff --name-only', cwd);
+  return output ? output.split('\n').filter(Boolean) : [];
+}
+
+function checkSecurity(files) {
+  const hits = files.filter(f => SEC_PATTERNS.test(f));
+  if (!hits.length) return null;
+  return {
+    type: 'security-review',
+    priority: 'high',
+    message: 'Auth-related files changed — want a security review?',
+    action: 'dual-brain review',
+    files: hits,
+  };
+}
+
+function checkNoTests(files, cwd) {
+  const sources = files.filter(f => SOURCE_EXT.test(f));
+  if (!sources.length) return null;
+
+  const untested = sources.filter(f => {
+    const base = f.replace(SOURCE_EXT, '');
+    const dir = join(cwd, f.split('/').slice(0, -1).join('/'));
+    const name = f.split('/').pop().replace(SOURCE_EXT, '');
+    const candidates = ['test','spec'].flatMap(k =>
+      ['mjs','js','ts'].flatMap(e => [
+        join(cwd, `${base}.${k}.${e}`),
+        join(dir, '__tests__', `${name}.${e}`),
+      ])
+    );
+    return !candidates.some(c => existsSync(c));
+  });
+
+  if (!untested.length) return null;
+  return {
+    type: 'no-tests',
+    priority: 'medium',
+    message: `${untested.length} changed file${untested.length > 1 ? 's' : ''} have no tests`,
+    action: "dual-brain go 'add tests for changed files'",
+    files: untested,
+  };
+}
+
+function checkLargeDiff(cwd) {
+  const stat = exec('git diff --stat', cwd);
+  if (!stat) return null;
+  const match = stat.match(/(\d+) insertion|(\d+) deletion/g);
+  if (!match) return null;
+  const total = match.reduce((sum, m) => sum + parseInt(m), 0);
+  if (total <= 500) return null;
+  return {
+    type: 'large-diff',
+    priority: 'medium',
+    message: `Large uncommitted changes (${total} lines) — consider committing`,
+    action: "dual-brain go 'commit current changes'",
+    files: [],
+  };
+}
+
+function checkStaleBranch(cwd, files) {
+  if (!files.length) return null;
+  const ts = exec('git log -1 --format=%ct', cwd);
+  if (!ts) return null;
+  const age = Date.now() / 1000 - parseInt(ts);
+  if (age < 86400) return null;
+  const hours = Math.round(age / 3600);
+  return {
+    type: 'stale-branch',
+    priority: 'low',
+    message: `Last commit was ${hours}h ago with uncommitted work`,
+    action: "dual-brain go 'commit current changes'",
+    files: [],
+  };
+}
+
+function checkConflicts(cwd) {
+  const conflicted = exec('git diff --name-only --diff-filter=U', cwd);
+  if (!conflicted) return null;
+  const files = conflicted.split('\n').filter(Boolean);
+  if (!files.length) return null;
+  return {
+    type: 'conflict',
+    priority: 'high',
+    message: `${files.length} file${files.length > 1 ? 's' : ''} have merge conflicts`,
+    action: "dual-brain go 'resolve merge conflicts'",
+    files,
+  };
+}
+
+function checkUnfinishedWork(cwd) {
+  const outcomesDir = join(cwd, '.dualbrain', 'outcomes');
+  if (!existsSync(outcomesDir)) return null;
+
+  const cutoff = Date.now() - 86_400_000;
+  let failed = null;
+
+  try {
+    const files = readdirSync(outcomesDir).filter(f => f.endsWith('.jsonl')).sort().reverse();
+    for (const file of files) {
+      const lines = readFileSync(join(outcomesDir, file), 'utf8')
+        .split('\n').filter(Boolean);
+      for (const line of lines.reverse()) {
+        try {
+          const rec = JSON.parse(line);
+          if (rec.timestamp && rec.timestamp < cutoff) break;
+          if (rec.result && rec.result.success === false && rec.prompt) {
+            failed = rec;
+            break;
+          }
+        } catch { /* skip */ }
+      }
+      if (failed) break;
+    }
+  } catch { return null; }
+
+  if (!failed) return null;
+  const prompt = failed.prompt.slice(0, 60);
+  return {
+    type: 'unfinished-work',
+    priority: 'medium',
+    message: `Last session had a failed task: '${prompt}' — resume?`,
+    action: `dual-brain go '${failed.prompt}'`,
+    files: [],
+  };
+}
+
+async function checkFailingTests(cwd) {
+  const pkgPath = join(cwd, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    if (!pkg.scripts?.test) return null;
+  } catch { return null; }
+
+  try {
+    execSync('npm test --silent 2>&1', { cwd, encoding: 'utf8', timeout: 30000, stdio: 'pipe' });
+    return null;
+  } catch {
+    return {
+      type: 'failing-tests',
+      priority: 'high',
+      message: 'Tests are failing — want me to investigate?',
+      action: "dual-brain go 'fix failing tests'",
+      files: [],
+    };
+  }
+}
+
+function buildSummary(files, observations) {
+  const conflicts = observations.filter(o => o.type === 'conflict').length;
+  const hi = observations.filter(o => o.priority === 'high').length;
+  const parts = [];
+  if (files.length) parts.push(`${files.length} file${files.length > 1 ? 's' : ''} changed`);
+  else parts.push('no uncommitted changes');
+  if (conflicts) parts.push(`${conflicts} conflict${conflicts > 1 ? 's' : ''}`);
+  if (hi) parts.push(`${hi} high-priority suggestion${hi > 1 ? 's' : ''}`);
+  return parts.join(', ');
+}
+
+export async function observe(cwd, options = {}) {
+  const observations = [];
+  try {
+    const files = changedFiles(cwd);
+
+    const sec = checkSecurity(files);
+    if (sec) observations.push(sec);
+
+    const conflicts = checkConflicts(cwd);
+    if (conflicts) observations.push(conflicts);
+
+    const noTests = checkNoTests(files, cwd);
+    if (noTests) observations.push(noTests);
+
+    const largeDiff = checkLargeDiff(cwd);
+    if (largeDiff) observations.push(largeDiff);
+
+    const stale = checkStaleBranch(cwd, files);
+    if (stale) observations.push(stale);
+
+    const unfinished = checkUnfinishedWork(cwd);
+    if (unfinished) observations.push(unfinished);
+
+    if (options.runTests) {
+      const failing = await checkFailingTests(cwd);
+      if (failing) observations.push(failing);
+    }
+
+    return { observations, summary: buildSummary(files, observations) };
+  } catch {
+    return { observations: [], summary: 'unable to observe repo state' };
+  }
+}
+
+export function formatObservations(observations) {
+  if (!observations.length) return '💡 Suggestions\n  (none)';
+  const icon = { high: '🔴', medium: '🟡', low: '🟢' };
+  const lines = observations.map(o => `  ${icon[o.priority] || '⚪'} ${o.message}`);
+  return `💡 Suggestions\n${lines.join('\n')}`;
+}
+
+export async function getQuickState(cwd) {
+  try {
+    const files = changedFiles(cwd);
+    const observations = [];
+
+    const sec = checkSecurity(files);
+    if (sec) observations.push(sec);
+
+    const conflicts = checkConflicts(cwd);
+    if (conflicts) observations.push(conflicts);
+
+    const noTests = checkNoTests(files, cwd);
+    if (noTests) observations.push(noTests);
+
+    const largeDiff = checkLargeDiff(cwd);
+    if (largeDiff) observations.push(largeDiff);
+
+    const stale = checkStaleBranch(cwd, files);
+    if (stale) observations.push(stale);
+
+    return { observations, summary: buildSummary(files, observations) };
+  } catch {
+    return { observations: [], summary: 'unable to observe repo state' };
+  }
+}