dual-brain 0.1.23 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.1.23",
+  "version": "0.2.0",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -19,7 +19,10 @@
     "./session": "./src/session.mjs",
     "./decompose": "./src/decompose.mjs",
     "./brief": "./src/brief.mjs",
-    "./redact": "./src/redact.mjs"
+    "./redact": "./src/redact.mjs",
+    "./calibration": "./src/calibration.mjs",
+    "./models": "./src/models.mjs",
+    "./prompt-intel": "./src/prompt-intel.mjs"
   },
   "keywords": [
     "claude-code",
@@ -40,6 +43,7 @@
   "scripts": {
     "test": "node .claude/hooks/test-orchestrator.mjs",
     "test:core": "node --test src/test.mjs",
+    "prepublishOnly": "node .claude/hooks/repo-doctor.mjs",
     "postinstall": "echo 'dual-brain installed. Run: dual-brain install (in your project) to set up hooks.'",
     "postpublish": "node scripts/verify-publish.mjs"
   },
@@ -58,6 +62,8 @@
     "src/decompose.mjs",
     "src/brief.mjs",
     "src/redact.mjs",
+    "src/calibration.mjs",
+    "src/models.mjs",
     "src/pipeline.mjs",
     "src/context.mjs",
     "src/outcome.mjs",
@@ -67,9 +73,17 @@
     "src/receipt.mjs",
     "src/failure-memory.mjs",
     "src/index.mjs",
+    "src/ledger.mjs",
+    "src/intelligence.mjs",
+    "src/awareness.mjs",
     "src/tui.mjs",
+    "src/living-docs.mjs",
+    "src/cost-tracker.mjs",
+    "src/think-engine.mjs",
     "src/install-hooks.mjs",
     "src/update-check.mjs",
+    "src/prompt-intel.mjs",
+    "src/fx.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",

package/src/awareness.mjs

@@ -0,0 +1,343 @@
+/**
+ * awareness.mjs — Environment awareness layer for dual-brain.
+ * Scans runtime environment once on startup and caches results with TTL.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+let _cache = null;
+let _cacheTime = 0;
+
+function safeExec(cmd, timeoutMs = 2000) {
+  try {
+    return execSync(cmd, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: timeoutMs,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function extractVersion(output) {
+  if (!output) return null;
+  const m = output.match(/(\d+\.\d+[\.\d]*)/);
+  return m ? m[1] : null;
+}
+
+function probeToolAvailability(name) {
+  const path = safeExec(`which ${name}`);
+  if (!path) return { available: false, version: null };
+  if (name === 'rg' || name === 'replit' || name === 'gh') {
+    return { available: true };
+  }
+  const versionOutput = safeExec(`${name} --version`);
+  return { available: true, version: extractVersion(versionOutput) };
+}
+
+function detectContainerType() {
+  const env = process.env;
+  if (env.REPL_ID || env.REPL_SLUG) return 'replit';
+  if (env.CODESPACES) return 'codespace';
+  if (env.CI || env.GITHUB_ACTIONS || env.GITLAB_CI || env.JENKINS_URL) return 'ci';
+  return 'local';
+}
+
+function scanSecrets() {
+  const keys = [
+    'OPENAI_API_KEY',
+    'ANTHROPIC_API_KEY',
+    'NPM_TOKEN',
+    'DATABASE_URL',
+    'GITHUB_TOKEN',
+    'REPLIT_DB_URL',
+  ];
+  const result = {};
+  for (const key of keys) {
+    result[key] = Boolean(process.env[key]);
+  }
+  return result;
+}
+
+function scanReplitTools() {
+  const home = homedir();
+  const candidates = [
+    join(home, '.replit-tools'),
+    join('/home/runner/workspace', '.replit-tools'),
+    join(process.cwd(), '.replit-tools'),
+  ];
+
+  let toolsDir = null;
+  for (const c of candidates) {
+    if (existsSync(c)) {
+      toolsDir = c;
+      break;
+    }
+  }
+
+  if (!toolsDir) {
+    return { installed: false, version: null, sessionArchivePath: null, capabilities: [] };
+  }
+
+  let version = null;
+  const versionFile = join(toolsDir, '.version');
+  if (existsSync(versionFile)) {
+    try { version = readFileSync(versionFile, 'utf8').trim() || null; } catch { /* skip */ }
+  }
+
+  const persistentBase = join(toolsDir, '.claude-persistent');
+  const projectDir = join(persistentBase, 'projects');
+  let sessionArchivePath = null;
+  if (existsSync(projectDir)) {
+    sessionArchivePath = projectDir;
+  } else if (existsSync(persistentBase)) {
+    sessionArchivePath = persistentBase;
+  }
+
+  const capabilities = [];
+  if (existsSync(join(toolsDir, '.claude-persistent'))) capabilities.push('sessions');
+  const hasSearch = existsSync(join(toolsDir, 'search')) || existsSync(join(toolsDir, 'search.mjs'));
+  if (hasSearch) capabilities.push('search');
+  const hasContext = existsSync(join(toolsDir, 'context')) || existsSync(join(toolsDir, 'context.mjs'));
+  if (hasContext) capabilities.push('context');
+  const hasMcp = existsSync(join(toolsDir, 'mcp-server')) || existsSync(join(toolsDir, 'mcp'));
+  if (hasMcp) capabilities.push('mcp');
+
+  return { installed: true, version, sessionArchivePath, capabilities };
+}
+
+function scanReplit(cwd) {
+  const env = process.env;
+  const isReplit = Boolean(env.REPL_ID || env.REPL_SLUG);
+
+  let hasDeployments = false;
+  const replitConfigPath = join(cwd, '.replit');
+  if (existsSync(replitConfigPath)) {
+    try {
+      const content = readFileSync(replitConfigPath, 'utf8');
+      hasDeployments = content.includes('[deployment]');
+    } catch { /* skip */ }
+  }
+
+  return {
+    isReplit,
+    replId: env.REPL_ID || null,
+    replSlug: env.REPL_SLUG || null,
+    hasDatabase: Boolean(env.DATABASE_URL),
+    hasKV: Boolean(env.REPLIT_DB_URL),
+    hasObjectStorage: Boolean(env.REPLIT_BUCKET_URL || env.OBJECT_STORAGE_URL),
+    hasAuth: existsSync(join(cwd, '.replit-auth')) || Boolean(env.REPLIT_AUTH),
+    hasDeployments,
+  };
+}
+
+function scanClaudeCode(cwd) {
+  const claudeDir = join(cwd, '.claude');
+  const homeClaudeDir = join(homedir(), '.claude');
+  const isInsideClaude = Boolean(
+    process.env.CLAUDE_CODE || process.env.CLAUDE_AGENT || process.env.ANTHROPIC_CLAUDE_CODE
+  );
+
+  let hooksDir = null;
+  const localHooks = join(claudeDir, 'hooks');
+  const rootHooks = join(cwd, 'hooks');
+  if (existsSync(localHooks)) {
+    hooksDir = localHooks;
+  } else if (existsSync(rootHooks)) {
+    hooksDir = rootHooks;
+  }
+
+  let mcpConfigured = false;
+  const mcpPaths = [
+    join(claudeDir, 'mcp.json'),
+    join(claudeDir, 'mcp_servers.json'),
+    join(homeClaudeDir, 'mcp.json'),
+  ];
+  for (const p of mcpPaths) {
+    if (existsSync(p)) { mcpConfigured = true; break; }
+  }
+
+  let settingsPath = null;
+  const settingsCandidates = [
+    join(claudeDir, 'settings.json'),
+    join(homeClaudeDir, 'settings.json'),
+  ];
+  for (const p of settingsCandidates) {
+    if (existsSync(p)) { settingsPath = p; break; }
+  }
+
+  return { isInsideClaude, hooksDir, mcpConfigured, settingsPath };
+}
+
+function scanDualBrain(cwd) {
+  let version = '0.0.0';
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+    version = pkg.version ?? '0.0.0';
+  } catch { /* skip */ }
+
+  const livingDocsDir = join(cwd, '.dual-brain');
+  const livingDocsInit = existsSync(livingDocsDir);
+
+  let sessionCount = 0;
+  const sessionDir = join(cwd, '.dualbrain', 'sessions');
+  if (existsSync(sessionDir)) {
+    try {
+      sessionCount = readdirSync(sessionDir).filter(f => f.endsWith('.jsonl')).length;
+    } catch { /* skip */ }
+  }
+
+  const hasLedger = existsSync(join(cwd, '.dualbrain', 'ledger.jsonl'));
+  const hasFailureMemory = existsSync(join(cwd, '.dualbrain', 'failures.jsonl'));
+
+  return { version, livingDocsInit, sessionCount, hasLedger, hasFailureMemory };
+}
+
+export function scanEnvironment(cwd, options = {}) {
+  const ttl = options.ttl ?? 300000;
+  if (_cache && Date.now() - _cacheTime < ttl && !options.force) return _cache;
+
+  const resolvedCwd = resolve(cwd || process.cwd());
+
+  const container = {
+    type: detectContainerType(),
+    hostname: process.env.HOSTNAME || process.env.REPL_ID || 'unknown',
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+  };
+
+  const toolNames = ['git', 'node', 'npm', 'codex', 'claude'];
+  const flagOnlyTools = ['rg', 'replit', 'gh'];
+  const tools = {};
+
+  for (const name of toolNames) {
+    tools[name] = probeToolAvailability(name);
+  }
+  for (const name of flagOnlyTools) {
+    const path = safeExec(`which ${name}`);
+    tools[name] = { available: Boolean(path) };
+  }
+
+  const secrets = scanSecrets();
+  const replitTools = scanReplitTools();
+  const replit = scanReplit(resolvedCwd);
+  const claudeCode = scanClaudeCode(resolvedCwd);
+  const dualBrain = scanDualBrain(resolvedCwd);
+
+  const report = {
+    scannedAt: Date.now(),
+    ttl,
+    container,
+    tools,
+    secrets,
+    replitTools,
+    replit,
+    claudeCode,
+    dualBrain,
+  };
+
+  _cache = report;
+  _cacheTime = Date.now();
+  return report;
+}
+
+export function formatEnvironment(report) {
+  const { container, tools, secrets, replitTools, replit, dualBrain } = report;
+
+  const nodeShort = container.nodeVersion.replace(/^v/, '').split('.')[0];
+  const containerLabel = container.type === 'replit'
+    ? 'Replit'
+    : container.type.charAt(0).toUpperCase() + container.type.slice(1);
+
+  const lines = [];
+
+  lines.push(`Environment: ${containerLabel} (node ${nodeShort}.x)`);
+
+  const toolEntries = [];
+  for (const [name, info] of Object.entries(tools)) {
+    if (info.available) toolEntries.push(`${name} ✓`);
+  }
+  if (toolEntries.length) lines.push(`Tools: ${toolEntries.join('  ')}`);
+
+  const secretMap = {
+    OPENAI_API_KEY: 'OpenAI',
+    ANTHROPIC_API_KEY: 'Anthropic',
+    NPM_TOKEN: 'npm',
+    GITHUB_TOKEN: 'GitHub',
+    DATABASE_URL: 'PostgreSQL',
+    REPLIT_DB_URL: 'KV',
+  };
+  const secretEntries = [];
+  for (const [key, label] of Object.entries(secretMap)) {
+    if (secrets[key]) secretEntries.push(`${label} ✓`);
+  }
+  if (secretEntries.length) lines.push(`Secrets: ${secretEntries.join('  ')}`);
+
+  const platformParts = [];
+  if (replit.hasDatabase) platformParts.push('PostgreSQL ✓');
+  if (replit.hasKV) platformParts.push('KV ✓');
+  if (replit.hasObjectStorage) platformParts.push('ObjectStorage ✓');
+  if (replit.hasAuth) platformParts.push('Auth ✓');
+  if (replit.hasDeployments) platformParts.push('Deployments ✓');
+  if (platformParts.length) lines.push(`Platform: ${platformParts.join('  ')}`);
+
+  if (replitTools.installed) {
+    const ver = replitTools.version ? `v${replitTools.version}` : 'installed';
+    const caps = replitTools.capabilities.join(', ');
+    lines.push(`replit-tools: ${ver}${caps ? ` (${caps})` : ''}`);
+  }
+
+  const dbFlag = dualBrain.hasLedger ? ', ledger ✓' : '';
+  const docsFlag = dualBrain.livingDocsInit ? 'living docs ✓' : 'living docs ✗';
+  lines.push(`dual-brain: v${dualBrain.version} (${docsFlag}${dbFlag})`);
+
+  return lines.join('\n');
+}
+
+export function getCapabilitySummary(report) {
+  const caps = [];
+
+  if (report.container.type !== 'unknown') {
+    caps.push(`${report.container.type}-container`);
+  }
+
+  if (report.replit.hasDatabase) caps.push('postgresql');
+  if (report.replit.hasKV) caps.push('replit-kv');
+  if (report.replit.hasObjectStorage) caps.push('object-storage');
+  if (report.replit.hasAuth) caps.push('replit-auth');
+  if (report.replit.hasDeployments) caps.push('replit-deployments');
+
+  if (report.tools.codex?.available) caps.push('codex-cli');
+  if (report.tools.claude?.available) caps.push('claude-cli');
+  if (report.tools.git?.available) caps.push('git');
+  if (report.tools.gh?.available) caps.push('github-cli');
+  if (report.tools.rg?.available) caps.push('ripgrep');
+
+  if (report.secrets.OPENAI_API_KEY) caps.push('openai-key');
+  if (report.secrets.ANTHROPIC_API_KEY) caps.push('anthropic-key');
+
+  if (report.replitTools.installed) {
+    for (const c of report.replitTools.capabilities) {
+      caps.push(`replit-tools-${c}`);
+    }
+  }
+
+  if (report.claudeCode.mcpConfigured) caps.push('mcp-configured');
+  if (report.claudeCode.hooksDir) caps.push('claude-hooks');
+
+  if (report.dualBrain.hasLedger) caps.push('dual-brain-ledger');
+  if (report.dualBrain.hasFailureMemory) caps.push('dual-brain-failure-memory');
+  if (report.dualBrain.livingDocsInit) caps.push('dual-brain-living-docs');
+
+  return caps;
+}
+
+export function invalidateCache() {
+  _cache = null;
+  _cacheTime = 0;
+}

package/src/calibration.mjs

@@ -0,0 +1,148 @@
+// 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})`;
+}