dual-brain 7.1.21 → 7.1.23

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

package/src/outcome.mjs

@@ -0,0 +1,256 @@
+import { mkdirSync, appendFileSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+const STOP_WORDS = new Set([
+  'the', 'a', 'an', 'is', 'are', 'was', 'were', 'to', 'from',
+  'in', 'on', 'for', 'with', 'and', 'or', 'but', 'not', 'this', 'that', 'it',
+]);
+
+function outcomesDir(cwd) {
+  return join(cwd, '.dualbrain', 'outcomes');
+}
+
+function todayFile(cwd) {
+  const date = new Date().toISOString().slice(0, 10);
+  return join(outcomesDir(cwd), `outcomes-${date}.jsonl`);
+}
+
+function ensureDir(cwd) {
+  mkdirSync(outcomesDir(cwd), { recursive: true });
+}
+
+function readOutcomeFile(filePath) {
+  try {
+    return readFileSync(filePath, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .flatMap(line => {
+        try { return [JSON.parse(line)]; } catch { return []; }
+      });
+  } catch {
+    return [];
+  }
+}
+
+function last7DaysFiles(cwd) {
+  const dir = outcomesDir(cwd);
+  const files = [];
+  for (let i = 0; i < 7; i++) {
+    const d = new Date(Date.now() - i * 86_400_000).toISOString().slice(0, 10);
+    const f = join(dir, `outcomes-${d}.jsonl`);
+    if (existsSync(f)) files.push(f);
+  }
+  return files;
+}
+
+export function computeRoutingScore(plan, result, verification) {
+  let score = 3;
+  if (result.success && result.duration < 60_000) score += 1;
+  if (verification.filesVerified && verification.testsPassed === true) score += 1;
+  if (result.error) score -= 1;
+  if (result.duration > 180_000) score -= 1;
+  if ((plan.challengerPolicy === 'none' || !plan.challengerPolicy) && !result.success) score -= 2;
+  return Math.max(1, Math.min(5, score));
+}
+
+export function generateLessons(plan, result, verification) {
+  const lessons = [];
+  const noChallenger = !plan.challengerPolicy || plan.challengerPolicy === 'none';
+
+  if (noChallenger && !result.success) {
+    lessons.push('Task failed without challenger — consider escalating similar tasks');
+  }
+
+  if (
+    plan.reasoningDepth === 'ultra' &&
+    result.duration < 60_000 &&
+    (plan.complexity === 'simple' || plan.complexity === 'low')
+  ) {
+    lessons.push('Ultra reasoning unnecessary — task completed quickly at low complexity');
+  }
+
+  if (!result.success) {
+    const keywords = (plan.prompt || '')
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(w => w.length > 3 && !STOP_WORDS.has(w))
+      .slice(0, 4)
+      .join(' ');
+    if (keywords) {
+      lessons.push(`Prior failure pattern: ${keywords} on ${plan.tier}`);
+    }
+  }
+
+  if (!noChallenger && result.success && verification.filesVerified) {
+    lessons.push(`Challenger caught issues — keep challenger policy for ${plan.risk} risk`);
+  }
+
+  return lessons;
+}
+
+export async function recordOutcome(plan, result, verification, cwd) {
+  try {
+    ensureDir(cwd);
+
+    const routingScore = computeRoutingScore(plan, result, verification);
+    const lessons = generateLessons(plan, result, verification);
+
+    const record = {
+      id: randomUUID(),
+      timestamp: Date.now(),
+      prompt: plan.prompt ?? '',
+      tier: plan.tier ?? '',
+      primaryModel: plan.primaryModel ?? '',
+      reasoningDepth: plan.reasoningDepth ?? '',
+      challengerPolicy: plan.challengerPolicy ?? 'none',
+      risk: plan.risk ?? '',
+      result: {
+        success: result.success ?? false,
+        filesChanged: result.filesChanged ?? [],
+        duration: result.duration ?? 0,
+        error: result.error ?? null,
+      },
+      verification: {
+        filesVerified: verification.filesVerified ?? false,
+        testsRun: verification.testsRun ?? false,
+        testsPassed: verification.testsPassed ?? null,
+      },
+      routingScore,
+      lessons,
+    };
+
+    appendFileSync(todayFile(cwd), JSON.stringify(record) + '\n', 'utf8');
+    return record;
+  } catch {
+    return null;
+  }
+}
+
+function tokenize(text) {
+  return (text || '')
+    .toLowerCase()
+    .split(/\W+/)
+    .filter(w => w.length > 3 && !STOP_WORDS.has(w));
+}
+
+function promptOverlap(a, b) {
+  const wordsA = new Set(tokenize(a));
+  const wordsB = tokenize(b);
+  return wordsB.filter(w => wordsA.has(w)).length;
+}
+
+function fileOverlap(filesA = [], filesB = []) {
+  const setA = new Set(filesA.map(f => f.split('/').pop()));
+  return filesB.map(f => f.split('/').pop()).filter(f => setA.has(f)).length;
+}
+
+export async function getRelevantOutcomes(prompt, files = [], cwd, options = {}) {
+  try {
+    const allFiles = last7DaysFiles(cwd);
+    const outcomes = allFiles.flatMap(readOutcomeFile);
+
+    const scored = outcomes.map(o => {
+      let score = promptOverlap(prompt, o.prompt);
+      score += fileOverlap(files, o.result?.filesChanged ?? []);
+      return { o, score };
+    });
+
+    return scored
+      .filter(({ score }) => score >= 2)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 5)
+      .map(({ o, score }) => ({
+        id: o.id,
+        timestamp: o.timestamp,
+        prompt: o.prompt,
+        success: o.result?.success ?? false,
+        routingScore: o.routingScore,
+        lessons: o.lessons,
+        relevanceScore: score,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+export async function getOutcomeStats(cwd, days = 7) {
+  try {
+    const allFiles = last7DaysFiles(cwd).slice(0, days);
+    const outcomes = allFiles.flatMap(readOutcomeFile);
+
+    if (outcomes.length === 0) {
+      return {
+        totalTasks: 0,
+        successRate: 0,
+        avgRoutingScore: 0,
+        avgDuration: 0,
+        challengerHelpRate: 0,
+        topLessons: [],
+        modelBreakdown: {},
+      };
+    }
+
+    const totalTasks = outcomes.length;
+    const successes = outcomes.filter(o => o.result?.success).length;
+    const successRate = successes / totalTasks;
+
+    const avgRoutingScore =
+      outcomes.reduce((sum, o) => sum + (o.routingScore ?? 3), 0) / totalTasks;
+
+    const avgDuration =
+      outcomes.reduce((sum, o) => sum + (o.result?.duration ?? 0), 0) / totalTasks;
+
+    const challengerUsed = outcomes.filter(
+      o => o.challengerPolicy && o.challengerPolicy !== 'none'
+    );
+    const challengerHelped = challengerUsed.filter(o => o.result?.success);
+    const challengerHelpRate =
+      challengerUsed.length > 0 ? challengerHelped.length / challengerUsed.length : 0;
+
+    const lessonCounts = {};
+    for (const o of outcomes) {
+      for (const lesson of o.lessons ?? []) {
+        lessonCounts[lesson] = (lessonCounts[lesson] ?? 0) + 1;
+      }
+    }
+    const topLessons = Object.entries(lessonCounts)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([lesson]) => lesson);
+
+    const modelBreakdown = {};
+    for (const o of outcomes) {
+      const model = o.primaryModel;
+      if (!model) continue;
+      if (!modelBreakdown[model]) modelBreakdown[model] = { count: 0, successCount: 0 };
+      modelBreakdown[model].count += 1;
+      if (o.result?.success) modelBreakdown[model].successCount += 1;
+    }
+    for (const model of Object.keys(modelBreakdown)) {
+      const { count, successCount } = modelBreakdown[model];
+      modelBreakdown[model].successRate = count > 0 ? successCount / count : 0;
+      delete modelBreakdown[model].successCount;
+    }
+
+    return {
+      totalTasks,
+      successRate,
+      avgRoutingScore,
+      avgDuration,
+      challengerHelpRate,
+      topLessons,
+      modelBreakdown,
+    };
+  } catch {
+    return {
+      totalTasks: 0,
+      successRate: 0,
+      avgRoutingScore: 0,
+      avgDuration: 0,
+      challengerHelpRate: 0,
+      topLessons: [],
+      modelBreakdown: {},
+    };
+  }
+}