dual-brain 0.1.2 → 0.1.4

package/bin/dual-brain.mjs

@@ -1113,6 +1113,22 @@ async function mainScreen(rl, ask) {
 
   // ── Header: one line above the box ────────────────────────────────────────
   process.stdout.write(`\n🧠 dual-brain v${version}\n`);
+  {
+    let gitName = '';
+    try {
+      const { execSync } = await import('node:child_process');
+      gitName = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
+    } catch { /* ignore */ }
+    if (gitName) {
+      const hour = new Date().getHours();
+      let greet;
+      if (hour >= 5 && hour <= 11)  greet = 'Good morning';
+      else if (hour >= 12 && hour <= 16) greet = 'Good afternoon';
+      else if (hour >= 17 && hour <= 21) greet = 'Good evening';
+      else                               greet = 'Late night';
+      process.stdout.write(`\x1b[2m${greet}, ${gitName}\x1b[0m\n`);
+    }
+  }
 
   // ── Status section ────────────────────────────────────────────────────────
   const providerLine = buildProviderStatusLine(profile, auth);
@@ -1164,11 +1180,126 @@ async function mainScreen(rl, ask) {
     bot,
   ];
   process.stdout.write(lines.join('\n') + '\n');
-  process.stdout.write(`\x1b[2mBuilt on data-tools by Steve Moraco\x1b[0m\n\n`);
+  process.stdout.write(`\x1b[2mPowered by data-tools · Steve Moraco\x1b[0m\n\n`);
 
   // ── Key handling ──────────────────────────────────────────────────────────
-  const raw = (await ask('')).trim();
-  const choice = raw.toLowerCase();
+  // Use raw keypress mode so we can show a live type-to-start buffer.
+  // Single-key commands (n, s, q, /, 1-9, Enter) only fire when buffer is empty.
+  let taskBuffer = '';
+
+  const readline = await import('node:readline');
+
+  // Render the type-ahead line below the box (overwrites the current cursor line)
+  const renderBuffer = (buf) => {
+    // Move to the prompt line (we're already at it after printing the box + footer)
+    // Use carriage return + clear-to-end-of-line to overwrite
+    if (buf.length === 0) {
+      process.stdout.write('\r\x1b[K');
+    } else {
+      const display = buf.length > W - 4 ? buf.slice(-(W - 4)) : buf;
+      process.stdout.write(`\r\x1b[K> ${display}\x1b[7m \x1b[0m`);
+    }
+  };
+
+  // Enable keypress events on stdin (safe to call multiple times)
+  readline.emitKeypressEvents(process.stdin, rl);
+
+  const raw = await new Promise((resolve) => {
+    // Switch to raw mode if possible (TTY only)
+    const wasRaw = process.stdin.isRaw;
+    const canRaw = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+    if (canRaw) process.stdin.setRawMode(true);
+
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', onKey);
+      if (canRaw) {
+        try { process.stdin.setRawMode(wasRaw || false); } catch {}
+      }
+    };
+
+    const onKey = (str, key) => {
+      if (!key) return;
+
+      const name = key.name || '';
+      const seq  = key.sequence || str || '';
+
+      // Ctrl-C / Ctrl-D → exit
+      if (key.ctrl && (name === 'c' || name === 'd')) {
+        cleanup();
+        process.stdout.write('\n');
+        resolve('q');
+        return;
+      }
+
+      // Enter key
+      if (name === 'return' || name === 'enter' || seq === '\r' || seq === '\n') {
+        cleanup();
+        if (taskBuffer.length > 0) {
+          process.stdout.write('\n');
+          resolve(`__task__:${taskBuffer}`);
+        } else {
+          resolve('');
+        }
+        return;
+      }
+
+      // Escape → clear buffer
+      if (name === 'escape') {
+        taskBuffer = '';
+        renderBuffer('');
+        return;
+      }
+
+      // Backspace / delete
+      if (name === 'backspace' || name === 'delete') {
+        if (taskBuffer.length > 0) {
+          taskBuffer = taskBuffer.slice(0, -1);
+          renderBuffer(taskBuffer);
+        }
+        return;
+      }
+
+      // Ignore non-printable / control keys
+      if (key.ctrl || key.meta || !str || str.length === 0) return;
+      const code = str.codePointAt(0);
+      if (code < 32 || code === 127) return;
+
+      // Single-key commands only fire when buffer is empty
+      if (taskBuffer.length === 0) {
+        const lower = str.toLowerCase();
+        if (lower === 'n' || lower === 's' || lower === 'q' || lower === '/') {
+          cleanup();
+          process.stdout.write('\n');
+          resolve(lower);
+          return;
+        }
+        const digit = parseInt(str, 10);
+        if (!isNaN(digit) && digit >= 1 && digit <= 9) {
+          cleanup();
+          process.stdout.write('\n');
+          resolve(str);
+          return;
+        }
+      }
+
+      // Accumulate into buffer
+      taskBuffer += str;
+      renderBuffer(taskBuffer);
+    };
+
+    process.stdin.on('keypress', onKey);
+  });
+
+  const choice = typeof raw === 'string' ? raw.toLowerCase() : '';
+
+  // Typed task → dispatch as "dual-brain go"
+  if (raw.startsWith('__task__:')) {
+    const prompt = raw.slice('__task__:'.length).trim();
+    if (prompt) {
+      return { next: 'go', prompt };
+    }
+    return { next: 'main' };
+  }
 
   // Enter (empty) → resume most recent session
   if (raw === '' || choice === '\r') {
@@ -2455,13 +2586,40 @@ async function runScreens(startScreen = 'dashboard') {
   let current = startScreen;
   let ctx = {};
   while (current && current !== 'exit') {
+    // Handle type-to-start dispatch from mainScreen
+    if (current === 'go' && ctx.prompt) {
+      const prompt = ctx.prompt;
+      const cwd    = process.cwd();
+      const profile   = loadProfile(cwd);
+      const detection = detectTask({ prompt });
+      const decision  = decideRoute({ profile, detection, cwd });
+      process.stdout.write(`\n  Routing: ${decision.provider}/${decision.model} (${decision.tier})\n`);
+      process.stdout.write(`  Reason: ${decision.explanation}\n\n`);
+      const { spawnSync } = await import('node:child_process');
+      const launchTool = decision.provider === 'openai' ? 'codex' : 'claude';
+      if (launchTool === 'codex') {
+        spawnSync('codex', [prompt], { stdio: 'inherit' });
+      } else {
+        spawnSync('claude', ['-p', prompt], { stdio: 'inherit' });
+      }
+      const freshSessions = importReplitSessions(cwd);
+      if (freshSessions.length > 0) {
+        saveTerminalState(cwd, getTerminalId(), freshSessions[0].id, launchTool);
+      }
+      current = 'main';
+      ctx = {};
+      continue;
+    }
+
     const screen = SCREENS[current];
     if (!screen) break;
     try {
       const result = await screen(rl, ask, ctx);
       current = result?.next || 'exit';
-      // Pass through context (e.g. selected session) to next screen
-      ctx = result?.session ? { session: result.session } : {};
+      // Pass through context (e.g. selected session, typed prompt) to next screen
+      ctx = result?.session ? { session: result.session }
+          : result?.prompt  ? { prompt: result.prompt }
+          : {};
     } catch (e) {
       console.error(`Error: ${e.message}`);
       current = 'main';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

package/src/profile.mjs

@@ -387,8 +387,6 @@ function loadProfile(cwd) {
     if (!profile.providers[provider]) continue;
     const stored = profile.providers[provider].plan;
     if (stored !== detectedPlan) {
-      const providerName = provider === 'claude' ? 'Claude' : 'OpenAI';
-      process.stderr.write(`[dual-brain] ${providerName}: plan updated to ${detectedPlan} (from auth config)\n`);
       profile.providers[provider].plan = detectedPlan;
     }
   }

package/src/session.mjs

@@ -461,23 +461,38 @@ export function importReplitSessions(cwd = process.cwd()) {
   const windowMs = windowHours * 60 * 60 * 1000;
   const cutoff = Date.now() - windowMs;
 
+  // Load existing session index for smartName lookup (best-effort, non-fatal)
+  let sessionIndex = {};
+  try {
+    const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+    if (existsSync(indexPath)) {
+      sessionIndex = JSON.parse(readFileSync(indexPath, 'utf8'));
+    }
+  } catch { /* non-fatal */ }
+
   // Build session list
   for (const [id, sess] of bySession) {
     // Skip sessions outside the recency window (timestamps are in ms)
     if (sess.lastTimestamp < cutoff) continue;
-    // Derive display name
-    let name = sess.firstPrompt;
+
+    // Use smartName from index if available, otherwise fall back to first prompt
+    let name = sessionIndex[id]?.smartName || null;
+
     if (!name) {
-      // Fallback: use first non-login display
-      const firstReal = sess.entries.find(e => e.display && e.display !== 'login');
-      name = firstReal?.display || `Session ${id.slice(0, 8)}`;
+      // Classic fallback: first meaningful prompt
+      name = sess.firstPrompt;
+      if (!name) {
+        const firstReal = sess.entries.find(e => e.display && e.display !== 'login');
+        name = firstReal?.display || `Session ${id.slice(0, 8)}`;
+      }
+      // Truncate long names that came from raw prompts
+      if (name.length > 60) name = name.slice(0, 57) + '...';
     }
-    // Truncate long names
-    if (name.length > 60) name = name.slice(0, 57) + '...';
 
     sessions.push({
       id: sess.sessionId,
       name,
+      smartName: sessionIndex[id]?.smartName || null,
       project: sess.project,
       promptCount: sess.entries.length,
       lastActive: new Date(sess.lastTimestamp).toISOString(),
@@ -741,6 +756,159 @@ export function syncSessionMirror(cwd = process.cwd()) {
   return { copied: totalCopied, grew: totalGrew };
 }
 
+// ─── Smart session naming ─────────────────────────────────────────────────────
+
+/**
+ * File pattern → human label mapping (checked in order, first match wins).
+ * Each entry: { pattern: RegExp, label: string, action?: string }
+ */
+const FILE_PATTERN_RULES = [
+  { pattern: /auth/i,      label: 'Auth',      action: 'Refactor' },
+  { pattern: /test|spec/i, label: 'Tests',     action: 'Fix' },
+  { pattern: /dispatch/i,  label: 'Dispatch',  action: 'Update' },
+  { pattern: /session/i,   label: 'Session',   action: 'Update' },
+  { pattern: /profile/i,   label: 'Profile',   action: 'Update' },
+  { pattern: /detect/i,    label: 'Detection', action: 'Update' },
+  { pattern: /decide/i,    label: 'Routing',   action: 'Update' },
+  { pattern: /budget/i,    label: 'Budget',    action: 'Update' },
+  { pattern: /hook/i,      label: 'Hooks',     action: 'Update' },
+  { pattern: /install/i,   label: 'Install',   action: 'Update' },
+  { pattern: /config/i,    label: 'Config',    action: 'Update' },
+  { pattern: /migrate/i,   label: 'Migration', action: 'Add' },
+];
+
+/**
+ * Topic words that suggest a dominant action verb.
+ */
+const TOPIC_ACTION_MAP = [
+  { words: ['fix', 'bug', 'error', 'crash', 'broken', 'fail'],  action: 'Fix' },
+  { words: ['refactor', 'cleanup', 'clean', 'reorganize'],       action: 'Refactor' },
+  { words: ['add', 'implement', 'create', 'build', 'write'],     action: 'Add' },
+  { words: ['update', 'upgrade', 'bump', 'patch'],               action: 'Update' },
+  { words: ['test', 'spec', 'coverage'],                         action: 'Fix' },
+  { words: ['deploy', 'release', 'publish'],                     action: 'Deploy' },
+  { words: ['audit', 'review', 'check'],                         action: 'Review' },
+];
+
+/**
+ * Convert a string to Title Case.
+ * @param {string} str
+ * @returns {string}
+ */
+function toTitleCase(str) {
+  return str.replace(/\b\w/g, c => c.toUpperCase());
+}
+
+/**
+ * Strip file extensions from a name candidate.
+ * @param {string} name
+ * @returns {string}
+ */
+function stripExtensions(name) {
+  return name.replace(/\.(mjs|js|ts|tsx|jsx|json|md|css|html|py|sh|sql|toml|yaml|yml)\b/gi, '');
+}
+
+/**
+ * Truncate a string to maxLen characters, preserving whole words where possible.
+ * @param {string} str
+ * @param {number} maxLen
+ * @returns {string}
+ */
+function truncate(str, maxLen = 40) {
+  if (str.length <= maxLen) return str;
+  const cut = str.slice(0, maxLen).replace(/\s+\S*$/, '');
+  return cut || str.slice(0, maxLen);
+}
+
+/**
+ * Generate a smart human-readable session name from session index data.
+ *
+ * Priority:
+ *   1. Dominant file pattern (e.g. auth*.mjs → "Refactor Auth Module")
+ *   2. Top topics (e.g. ['auth','token','refresh'] → "Auth Token Refresh")
+ *   3. Fallback: first prompt truncated to 40 chars
+ *
+ * Rules: ≤40 chars, Title Case, no file extensions, action-prefixed when detectable.
+ *
+ * @param {{ topics?: string[], files?: string[], prompts?: { first?: string } }} sessionData
+ * @returns {string}
+ */
+export function generateSmartName(sessionData) {
+  const topics = sessionData.topics || [];
+  const files  = sessionData.files  || [];
+  const firstPrompt = sessionData.prompts?.first || '';
+
+  // ── Step 1: Detect dominant action from topics ─────────────────────────────
+  let detectedAction = null;
+  for (const { words, action } of TOPIC_ACTION_MAP) {
+    if (topics.some(t => words.includes(t))) {
+      detectedAction = action;
+      break;
+    }
+  }
+
+  // ── Step 2: Try file pattern match ─────────────────────────────────────────
+  if (files.length > 0) {
+    // Flatten all filenames for pattern matching
+    const fileNames = files.map(f => f.split('/').pop()).join(' ');
+
+    for (const { pattern, label, action } of FILE_PATTERN_RULES) {
+      if (pattern.test(fileNames)) {
+        const actionWord = detectedAction || action || 'Update';
+        const candidate = `${actionWord} ${label}`;
+        return truncate(toTitleCase(candidate));
+      }
+    }
+
+    // No named pattern — derive a label from the most common directory or base name
+    const basenames = files.map(f => {
+      const base = f.split('/').pop() || f;
+      // Strip extension and convert camelCase/kebab to words
+      return stripExtensions(base)
+        .replace(/[-_]/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .trim();
+    }).filter(Boolean);
+
+    if (basenames.length > 0) {
+      // Use the most common prefix or first significant basename
+      const label = basenames[0];
+      const actionWord = detectedAction || 'Update';
+      const candidate = `${actionWord} ${label}`;
+      return truncate(toTitleCase(stripExtensions(candidate)));
+    }
+  }
+
+  // ── Step 3: Try top topics ─────────────────────────────────────────────────
+  if (topics.length >= 2) {
+    // Take top 3 topics and compose a name
+    const topTopics = topics.slice(0, 3);
+    const actionWord = detectedAction || null;
+
+    let candidate;
+    if (actionWord) {
+      // Use action + remaining topics
+      candidate = [actionWord, ...topTopics.filter(t => t !== actionWord.toLowerCase())].slice(0, 3).join(' ');
+    } else {
+      candidate = topTopics.join(' ');
+    }
+
+    return truncate(toTitleCase(candidate));
+  }
+
+  if (topics.length === 1) {
+    const actionWord = detectedAction || 'Work on';
+    return truncate(toTitleCase(`${actionWord} ${topics[0]}`));
+  }
+
+  // ── Step 4: Fallback — first prompt truncated ──────────────────────────────
+  if (firstPrompt) {
+    return truncate(firstPrompt);
+  }
+
+  return 'Session';
+}
+
 // ─── Session index ────────────────────────────────────────────────────────────
 
 /**
@@ -841,7 +1009,7 @@ export function buildSessionIndex(cwd = process.cwd()) {
           .slice(0, 10)
           .map(([w]) => w);
 
-        index[sessionId] = {
+        const sessionEntry = {
           id: sessionId,
           topics,
           files: [...fileSet].slice(0, 20),
@@ -851,6 +1019,8 @@ export function buildSessionIndex(cwd = process.cwd()) {
           tool: 'claude',
           _fileSize: fileSize,
         };
+        sessionEntry.smartName = generateSmartName(sessionEntry);
+        index[sessionId] = sessionEntry;
       } catch { continue; }
     }
   }
@@ -904,12 +1074,14 @@ export function buildSessionIndex(cwd = process.cwd()) {
           } catch { continue; }
         }
 
-        index[id] = {
+        const codexEntry = {
           id, topics: [], files: [],
           prompts: { first: firstPrompt || '', last: lastPrompt || '' },
           date: lastTimestamp ? new Date(lastTimestamp * 1000).toISOString() : null,
           messageCount, tool: 'codex', _fileSize: fileSize,
         };
+        codexEntry.smartName = generateSmartName(codexEntry);
+        index[id] = codexEntry;
       } catch { continue; }
     }
   }