dual-brain 0.2.30 → 0.3.1

package/src/observer.mjs

@@ -1,241 +0,0 @@
-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

@@ -1,400 +0,0 @@
-import { mkdirSync, appendFileSync, writeFileSync, readFileSync, existsSync, readdirSync, unlinkSync } from 'fs';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-import { execSync } from 'child_process';
-
-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;
-}
-
-const INTENT_KEYWORDS = ['implement', 'fix', 'refactor', 'review', 'search', 'test'];
-
-function deriveIntent(prompt, tier) {
-  const lower = (prompt ?? '').toLowerCase();
-  for (const kw of INTENT_KEYWORDS) {
-    if (lower.includes(kw)) return kw;
-  }
-  return tier ?? 'execute';
-}
-
-function pruneOutcomes(cwd) {
-  const dir = join(cwd, '.dualbrain', 'outcomes');
-  try {
-    const files = readdirSync(dir).filter(f => f.startsWith('outcome_')).sort();
-    if (files.length > 500) {
-      const toDelete = files.slice(0, files.length - 400);
-      for (const f of toDelete) {
-        try { unlinkSync(join(dir, f)); } catch {}
-      }
-    }
-  } catch {}
-}
-
-export function recordDispatchOutcome(dispatchInput, result) {
-  try {
-    const cwd = dispatchInput.cwd ?? process.cwd();
-    const decision = dispatchInput.decision ?? {};
-    ensureDir(cwd);
-
-    const id = `out_${Date.now().toString(36)}`;
-    const record = {
-      id,
-      timestamp: new Date().toISOString(),
-      prompt: (dispatchInput.prompt ?? '').slice(0, 200),
-      tier: decision.tier ?? result.tier ?? 'execute',
-      model: decision.model ?? result.model ?? 'unknown',
-      provider: decision.provider ?? result.provider ?? 'unknown',
-      success: result.status === 'success' || result.status === 'completed',
-      status: result.status ?? 'unknown',
-      durationMs: result.durationMs ?? 0,
-      filesChanged: result.filesChanged?.length ?? 0,
-      errors: (result.errors ?? (result.error ? [result.error] : [])).slice(0, 3),
-      lesson: '',
-    };
-
-    const filePath = join(outcomesDir(cwd), `outcome_${id}.json`);
-    writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8');
-
-    // Score the outcome for the routing advisor (non-blocking)
-    try {
-      import('./signal.mjs').then(({ scoreOutcome }) =>
-        import('./routing-advisor.mjs').then(({ recordReward }) => {
-          const scored = scoreOutcome(record);
-          const intent = deriveIntent(record.prompt, record.tier);
-          const cellKey = `${record.tier}:${intent}`;
-          // Normalize full model ID to short name for the advisor cell
-          const modelId = record.model ?? 'sonnet';
-          const shortModel = /haiku/i.test(modelId) ? 'haiku'
-            : /opus/i.test(modelId) ? 'opus'
-            : 'sonnet';
-          recordReward(cellKey, shortModel, scored.reward, cwd);
-        })
-      ).catch(() => { /* non-blocking */ });
-    } catch { /* non-blocking */ }
-
-    pruneOutcomes(cwd);
-    return record;
-  } catch {
-    return null;
-  }
-}
-
-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 checkFileSurvival(cwd) {
-  try {
-    const dir = join(cwd, '.dualbrain', 'outcomes');
-    if (!existsSync(dir)) return [];
-
-    // Collect up to the last 20 individual outcome JSON files
-    let files;
-    try {
-      files = readdirSync(dir)
-        .filter(f => f.startsWith('outcome_') && f.endsWith('.json'))
-        .sort()
-        .slice(-20);
-    } catch {
-      return [];
-    }
-
-    // Get current git-modified files (best-effort)
-    let modifiedFiles = new Set();
-    try {
-      const gitOut = execSync('git diff --name-only', { cwd, stdio: ['ignore', 'pipe', 'pipe'] }).toString();
-      for (const f of gitOut.split('\n').map(l => l.trim()).filter(Boolean)) {
-        modifiedFiles.add(f);
-        modifiedFiles.add(join(cwd, f));
-      }
-    } catch {
-      // git unavailable — proceed without modified-file check
-    }
-
-    const scored = [];
-
-    for (const fname of files) {
-      const fpath = join(dir, fname);
-      let record;
-      try {
-        record = JSON.parse(readFileSync(fpath, 'utf8'));
-      } catch {
-        continue;
-      }
-
-      // Skip if already scored or no filesChanged list
-      if (record.survivalScore !== undefined) continue;
-      const changedFiles = record.result?.filesChanged;
-      if (!Array.isArray(changedFiles) || changedFiles.length === 0) continue;
-
-      let survived = 0;
-      for (const f of changedFiles) {
-        const absPath = f.startsWith('/') ? f : join(cwd, f);
-        const exists = existsSync(absPath);
-        const modified = modifiedFiles.has(f) || modifiedFiles.has(absPath);
-        if (exists && !modified) survived++;
-      }
-
-      const survivalScore = survived / changedFiles.length;
-      record.survivalScore = survivalScore;
-
-      try {
-        writeFileSync(fpath, JSON.stringify(record, null, 2), 'utf8');
-      } catch {
-        // write failed — skip
-        continue;
-      }
-
-      scored.push({ id: record.id, survivalScore });
-    }
-
-    return scored;
-  } 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: {},
-    };
-  }
-}