dual-brain 0.2.30 → 0.3.0

package/src/calibration.mjs

@@ -1,148 +0,0 @@
-// User calibration module — tracks specificity, corrections, and autonomy signals
-// to adapt dual-brain behavior to any user from vague vibe-coder to precise expert.
-
-const FILE_REF_RE = /(?:src\/|\.mjs|\.tsx?|\.jsx?|\.json|\.ya?ml|\.sh|line\s+\d+|\bL\d+\b)/i;
-const TECH_TERM_RE = /\b(?:regex|middleware|api|endpoint|refactor|migration|schema|auth(?:entication)?|jwt|token|hook|dispatch|pipeline|module|function|class|interface|type|import|export|async|await|promise|callback|handler|router|controller|service|repository|factory|singleton|decorator|mixin|proxy|guard|interceptor|serializer|validator|transformer|adapter|facade|strategy|observer|subscriber|emitter|stream|buffer|cache|queue|worker|thread|mutex|semaphore|socket|websocket|http|grpc|graphql|rest|orm|sql|nosql|index|query|transaction|migration|seed|fixture|mock|stub|spy|assertion|coverage|lint|typecheck|bundle|compile|transpile|minify|tree.shake|dead.code|chunk|lazy.load|ssr|csr|hydrat)\b/i;
-const VAGUE_RE = /\b(?:idk|just|make\s+it|fix\s+it|whatever|vibes?|better|nicer|faster|cleaner|improve|help|do\s+it|yeah|sure|ok|okay|hmm|uh|er|um)\b/i;
-const AUTONOMY_HIGH_RE = /\b(?:just\s+do\s+it|go(?:\s+ahead)?|build\s+it|ship\s+it|run\s+it|execute|do\s+it|proceed|continue|carry\s+on|handle\s+it|take\s+care|make\s+it\s+happen|yolo)\b/i;
-const QUESTION_RE = /\?|^(?:how|what|why|when|where|which|should|can|could|would|is|are|do|does|did|will|won't|don't)\b/i;
-const CORRECTION_RE = /^(?:no[,.]?|not\s|wrong|stop|don't|that'?s?\s+not|i\s+said|i\s+meant)\b|(?:\binstead\b|\brather\b|\bactually\b)/i;
-
-export function analyzeInput(input) {
-  const text = (input || '').trim();
-  const lower = text.toLowerCase();
-  const words = text.split(/\s+/).filter(Boolean);
-  const wordCount = words.length;
-
-  const hasFileRefs = FILE_REF_RE.test(text);
-  const hasTechTerms = TECH_TERM_RE.test(text);
-  const hasExactInstructions = /\b(?:step\s+\d|first[,\s]|then[,\s]|finally[,\s]|specifically|exactly|must|should\s+(?:use|call|return|handle)|(?:use|call|return|throw|emit|dispatch)\s+\w)/i.test(text);
-  const isVague = VAGUE_RE.test(lower) || wordCount <= 3;
-
-  let specificity;
-  if (hasFileRefs || /\bline\s*\d+\b|\bL\d+\b/i.test(text) || (hasTechTerms && hasExactInstructions)) {
-    specificity = 5;
-  } else if (hasTechTerms && wordCount >= 6) {
-    specificity = 4;
-  } else if (!isVague && wordCount >= 8) {
-    specificity = 3;
-  } else if (wordCount >= 4 && !isVague) {
-    specificity = 2;
-  } else {
-    specificity = 1;
-  }
-
-  return {
-    specificity,
-    signals: {
-      hasFileRefs,
-      hasTechTerms,
-      hasExactInstructions,
-      isVague,
-      wordCount
-    }
-  };
-}
-
-export function detectCorrection(input) {
-  return CORRECTION_RE.test((input || '').trim());
-}
-
-function clamp(value, min = 1, max = 5) {
-  return Math.min(max, Math.max(min, value));
-}
-
-function round1(value) {
-  return Math.round(value * 10) / 10;
-}
-
-function detectAutonomySignal(input) {
-  const text = (input || '').trim();
-  if (AUTONOMY_HIGH_RE.test(text)) return 5;
-  if (QUESTION_RE.test(text)) return 2;
-  return null;
-}
-
-export function updateCalibration(calibration, input, correction = false) {
-  const { specificity: newSpec } = analyzeInput(input);
-  const autonomySignal = detectAutonomySignal(input);
-
-  const prev = {
-    specificity: calibration.specificity ?? 3,
-    corrections: calibration.corrections ?? 3,
-    autonomy: calibration.autonomy ?? 3,
-    interactions: calibration.interactions ?? 0
-  };
-
-  const specificity = round1(clamp(prev.specificity * 0.7 + newSpec * 0.3));
-
-  const corrections = round1(clamp(
-    correction ? prev.corrections - 0.3 : prev.corrections + 0.1
-  ));
-
-  let autonomy = prev.autonomy;
-  if (autonomySignal !== null) {
-    autonomy = round1(clamp(prev.autonomy * 0.7 + autonomySignal * 0.3));
-  }
-
-  return {
-    specificity,
-    corrections,
-    autonomy,
-    interactions: prev.interactions + 1,
-    lastUpdated: new Date().toISOString()
-  };
-}
-
-export function getAdaptation(calibration) {
-  const s = calibration.specificity ?? 3;
-  const c = calibration.corrections ?? 3;
-  const a = calibration.autonomy ?? 3;
-
-  const clarifyBeforeActing = s < 2.5 || c > 3;
-  const explainReasoning = a < 3;
-  const suggestNextSteps = a < 4;
-  const askForApproval = c < 2.5;
-  const autoExecute = a > 4 && c > 3.5;
-
-  let responseStyle;
-  const combined = (s + c + a) / 3;
-  if (combined >= 4) {
-    responseStyle = 'terse';
-  } else if (combined >= 2.5) {
-    responseStyle = 'normal';
-  } else {
-    responseStyle = 'detailed';
-  }
-
-  let userLevel;
-  if (s >= 4) {
-    userLevel = 'advanced';
-  } else if (s >= 2.5) {
-    userLevel = 'intermediate';
-  } else {
-    userLevel = 'beginner';
-  }
-
-  return {
-    clarifyBeforeActing,
-    explainReasoning,
-    suggestNextSteps,
-    askForApproval,
-    autoExecute,
-    responseStyle,
-    userLevel
-  };
-}
-
-export function formatCalibration(calibration) {
-  const { userLevel, responseStyle } = getAdaptation(calibration);
-  const s = calibration.specificity ?? 3;
-  const c = calibration.corrections ?? 3;
-  const a = calibration.autonomy ?? 3;
-
-  const autonomyLabel = a >= 4 ? 'high autonomy' : a >= 2.5 ? 'normal autonomy' : 'low autonomy';
-  const trustLabel = c >= 4 ? 'high trust' : c >= 2.5 ? 'good trust' : 'low trust';
-
-  return `User: ${userLevel} · ${autonomyLabel} · ${trustLabel}\n      (specificity: ${s}, corrections: ${c}, autonomy: ${a})`;
-}

package/src/checkpoint.mjs

@@ -1,109 +0,0 @@
-// checkpoint.mjs — Checkpoint wrapper for dual-brain execution safety.
-// Wraps Replit's native checkpoint system with a git-based fallback.
-// Exports: hasCheckpoints, createCheckpoint, listCheckpoints, getLastCheckpoint
-
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { execSync } from 'node:child_process';
-
-/**
- * Check if checkpoint capability is available.
- * @returns {boolean}
- */
-export function hasCheckpoints() {
-  try {
-    // Check for Replit checkpoint binary
-    if (existsSync('/usr/local/bin/replit-checkpoint')) return true;
-    execSync('which replit-checkpoint', { stdio: 'pipe', timeout: 2000 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Create a checkpoint before a risky operation.
- * @param {string} label — human-readable label like "before auth refactor"
- * @param {object} [opts]
- * @param {string} [opts.cwd]
- * @returns {{ success: boolean, id: string|null, label: string, timestamp: string }}
- */
-export function createCheckpoint(label, opts = {}) {
-  const cwd = opts.cwd || process.cwd();
-  const timestamp = new Date().toISOString();
-  const id = `cp-${Date.now()}`;
-
-  // Try Replit checkpoint first
-  if (hasCheckpoints()) {
-    try {
-      execSync('replit-checkpoint create', { cwd, stdio: 'pipe', timeout: 10000 });
-      _logCheckpoint({ id, label, timestamp, type: 'replit', status: 'created' }, cwd);
-      return { success: true, id, label, timestamp };
-    } catch {
-      // Fall through to git-based checkpoint
-    }
-  }
-
-  // Fallback: git stash + tag
-  try {
-    // Stash any uncommitted changes
-    const status = execSync('git status --porcelain', { cwd, encoding: 'utf8', timeout: 5000 }).trim();
-    if (status) {
-      execSync(`git stash push -m "dual-brain-checkpoint: ${label}"`, { cwd, stdio: 'pipe', timeout: 10000 });
-      execSync('git stash pop', { cwd, stdio: 'pipe', timeout: 10000 });
-    }
-    // Create a lightweight tag
-    const safeLabel = label.replace(/[^a-zA-Z0-9-_]/g, '-').slice(0, 50);
-    const tagName = `db-checkpoint/${safeLabel}-${Date.now()}`;
-    execSync(`git tag "${tagName}"`, { cwd, stdio: 'pipe', timeout: 5000 });
-    _logCheckpoint({ id, label, timestamp, type: 'git-tag', tag: tagName, status: 'created' }, cwd);
-    return { success: true, id, label, timestamp };
-  } catch {
-    _logCheckpoint({ id, label, timestamp, type: 'failed', status: 'failed' }, cwd);
-    return { success: false, id: null, label, timestamp };
-  }
-}
-
-/**
- * List recent checkpoints (most recent first, up to 20).
- * @param {string} [cwd]
- * @returns {object[]}
- */
-export function listCheckpoints(cwd) {
-  const logPath = join(cwd || process.cwd(), '.dual-brain', 'checkpoints.jsonl');
-  if (!existsSync(logPath)) return [];
-  try {
-    return readFileSync(logPath, 'utf8')
-      .trim()
-      .split('\n')
-      .filter(Boolean)
-      .map(line => JSON.parse(line))
-      .reverse()
-      .slice(0, 20);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Get the most recent checkpoint.
- * @param {string} [cwd]
- * @returns {object|null}
- */
-export function getLastCheckpoint(cwd) {
-  const checkpoints = listCheckpoints(cwd);
-  return checkpoints[0] || null;
-}
-
-// ─── Internal helpers ─────────────────────────────────────────────────────────
-
-function _logCheckpoint(entry, cwd) {
-  const dir = join(cwd || process.cwd(), '.dual-brain');
-  mkdirSync(dir, { recursive: true });
-  const logPath = join(dir, 'checkpoints.jsonl');
-  const line = JSON.stringify(entry) + '\n';
-  try {
-    const existing = existsSync(logPath) ? readFileSync(logPath, 'utf8') : '';
-    writeFileSync(logPath, existing + line);
-  } catch {}
-}

package/src/ci-triage.mjs

@@ -1,191 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * Detect CI system in use.
- * @param {string} [cwd]
- * @returns {{ systems: string[], primary: string|null }}
- */
-export function detectCI(cwd) {
-  const root = cwd || process.cwd();
-  const systems = [];
-
-  if (existsSync(join(root, '.github/workflows'))) systems.push('github-actions');
-  if (existsSync(join(root, '.circleci')))          systems.push('circleci');
-  if (existsSync(join(root, '.gitlab-ci.yml')))     systems.push('gitlab-ci');
-  if (existsSync(join(root, 'Jenkinsfile')))        systems.push('jenkins');
-  if (existsSync(join(root, '.travis.yml')))        systems.push('travis');
-  if (existsSync(join(root, 'vercel.json')) || existsSync(join(root, '.vercel'))) systems.push('vercel');
-  if (existsSync(join(root, 'netlify.toml')))       systems.push('netlify');
-
-  return { systems, primary: systems[0] || null };
-}
-
-/**
- * Get recent CI run status using gh CLI.
- * @param {string} [cwd]
- * @returns {{ available: boolean, runs: object[], hasFailures: boolean, lastRun: object|null }}
- */
-export function getCIStatus(cwd) {
-  try {
-    const json = execSync(
-      'gh run list --limit 5 --json databaseId,name,status,conclusion,headBranch,createdAt',
-      { cwd, encoding: 'utf8', timeout: 10000 }
-    );
-    const runs = JSON.parse(json);
-    return {
-      available: true,
-      runs: runs.map(r => ({
-        id: r.databaseId,
-        name: r.name,
-        status: r.status,
-        conclusion: r.conclusion,
-        branch: r.headBranch,
-        createdAt: r.createdAt,
-      })),
-      hasFailures: runs.some(r => r.conclusion === 'failure'),
-      lastRun: runs[0] || null,
-    };
-  } catch {
-    return { available: false, runs: [], hasFailures: false, lastRun: null };
-  }
-}
-
-/**
- * Get failed CI run logs and classify the failure.
- * @param {string|number} runId
- * @param {string} [cwd]
- * @returns {object}
- */
-export function triageFailure(runId, cwd) {
-  try {
-    const logs = execSync(`gh run view ${runId} --log-failed 2>/dev/null | tail -100`, {
-      cwd, encoding: 'utf8', timeout: 15000,
-    });
-
-    const classification = classifyFailure(logs);
-    const fileHints = extractFileHints(logs, cwd);
-
-    return {
-      success: true,
-      runId,
-      logs: logs.slice(-3000), // last 3000 chars
-      classification,
-      fileHints,
-      suggestedAction: getSuggestedAction(classification),
-    };
-  } catch (err) {
-    return { success: false, runId, error: err.message };
-  }
-}
-
-/**
- * Classify a CI failure from log output.
- * @param {string} logs
- * @returns {{ type: string, confidence: string }}
- */
-function classifyFailure(logs) {
-  const lower = logs.toLowerCase();
-
-  if (lower.includes('syntaxerror') || lower.includes('parse error'))               return { type: 'syntax',          confidence: 'high' };
-  if (lower.includes('typeerror') || lower.includes('type error'))                  return { type: 'type-error',      confidence: 'high' };
-  if (lower.includes('referenceerror'))                                              return { type: 'reference-error', confidence: 'high' };
-  if (lower.includes('test fail') || lower.includes('tests failed') || lower.includes('assertion')) return { type: 'test-failure',    confidence: 'high' };
-  if (lower.includes('enoent') || lower.includes('no such file'))                   return { type: 'missing-file',    confidence: 'high' };
-  if (lower.includes('permission denied') || lower.includes('eacces'))             return { type: 'permissions',     confidence: 'high' };
-  if (lower.includes('timeout') || lower.includes('timed out'))                    return { type: 'timeout',         confidence: 'medium' };
-  if (lower.includes('out of memory') || lower.includes('heap'))                   return { type: 'oom',             confidence: 'medium' };
-  if (lower.includes('npm err') || lower.includes('yarn error') || lower.includes('dependency')) return { type: 'dependency',     confidence: 'medium' };
-  if (lower.includes('lint') || lower.includes('eslint'))                           return { type: 'lint',            confidence: 'high' };
-  if (lower.includes('build fail'))                                                  return { type: 'build',           confidence: 'medium' };
-  if (lower.includes('docker') || lower.includes('container'))                      return { type: 'container',       confidence: 'medium' };
-
-  return { type: 'unknown', confidence: 'low' };
-}
-
-/**
- * Extract local file paths referenced in CI logs.
- * @param {string} logs
- * @param {string} [cwd]
- * @returns {string[]}
- */
-function extractFileHints(logs, cwd) {
-  const files = new Set();
-  const root = cwd || process.cwd();
-
-  const patterns = [
-    /(?:at\s+)?([a-zA-Z0-9_./\\-]+\.[a-zA-Z]+):(\d+)/g,
-    /(?:in\s+)?([a-zA-Z0-9_./\\-]+\.[a-zA-Z]+)\((\d+)\)/g,
-    /Error in ([a-zA-Z0-9_./\\-]+\.[a-zA-Z]+)/g,
-  ];
-
-  for (const pattern of patterns) {
-    for (const match of logs.matchAll(pattern)) {
-      const file = match[1];
-      if (file && !file.includes('node_modules') && existsSync(join(root, file))) {
-        files.add(file);
-      }
-    }
-  }
-
-  return [...files];
-}
-
-/**
- * Get a human-readable suggested action for a failure classification.
- * @param {{ type: string }} classification
- * @returns {string}
- */
-function getSuggestedAction(classification) {
-  const actions = {
-    'syntax':          'Fix syntax error in the identified file',
-    'type-error':      'Check type annotations and function signatures',
-    'reference-error': 'Check for undefined variables or missing imports',
-    'test-failure':    'Run tests locally and fix failing assertions',
-    'missing-file':    'Check if a required file was deleted or not committed',
-    'permissions':     'Check file permissions and access rights',
-    'timeout':         'Investigate slow operations or increase timeout',
-    'oom':             'Check for memory leaks or reduce batch size',
-    'dependency':      'Run npm install and check for version conflicts',
-    'lint':            'Run linter locally and fix violations',
-    'build':           'Check build configuration and dependencies',
-    'container':       'Check Dockerfile and container configuration',
-    'unknown':         'Review full CI logs for error details',
-  };
-  return actions[classification.type] || actions.unknown;
-}
-
-/**
- * Full CI triage: detect CI, fetch status, classify failures, map to files.
- * @param {string} [cwd]
- * @returns {object}
- */
-export function fullTriage(cwd) {
-  const ci = detectCI(cwd);
-  if (!ci.primary) return { available: false, reason: 'no-ci-detected' };
-
-  const status = getCIStatus(cwd);
-  if (!status.available) return { available: false, reason: 'gh-cli-unavailable' };
-  if (!status.hasFailures) return { available: true, healthy: true, message: 'All CI runs passing' };
-
-  const failedRuns = status.runs.filter(r => r.conclusion === 'failure');
-  const triages = failedRuns.slice(0, 3).map(r => triageFailure(r.id, cwd));
-
-  return {
-    available: true,
-    healthy: false,
-    failedRuns: failedRuns.length,
-    triages,
-    topIssue: triages[0]?.classification || null,
-  };
-}
-
-// ─── CLI (direct invocation) ──────────────────────────────────────────────────
-
-const isMain = process.argv[1]?.endsWith('ci-triage.mjs');
-if (isMain) {
-  const cwd = process.argv[2] || process.cwd();
-  const result = fullTriage(cwd);
-  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
-}