dual-brain 7.1.13 → 7.1.14

package/bin/dual-brain.mjs

@@ -95,6 +95,40 @@ function cleanStaleMarkers(cwd) {
   } catch {}
 }
 
+function buildSparkline(cwd) {
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+  let index = {};
+  try { index = JSON.parse(readFileSync(indexPath, 'utf8')); } catch { return null; }
+
+  const sessions = Object.values(index);
+  if (sessions.length < 2) return null;
+
+  const now = Date.now();
+  const days = 7;
+  const buckets = new Array(days).fill(0);
+
+  for (const sess of sessions) {
+    if (!sess.date) continue;
+    const age = (now - Date.parse(sess.date)) / 86400000;
+    const bucket = Math.floor(age);
+    if (bucket >= 0 && bucket < days) {
+      buckets[days - 1 - bucket]++;
+    }
+  }
+
+  const max = Math.max(...buckets, 1);
+  const blocks = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+  const spark = buckets.map(v => {
+    if (v === 0) return ' ';
+    const idx = Math.min(Math.floor((v / max) * (blocks.length - 1)), blocks.length - 1);
+    return blocks[idx];
+  }).join('');
+
+  const total = buckets.reduce((a, b) => a + b, 0);
+  if (total === 0) return null;
+  return `${spark} ${total} sessions (7d)`;
+}
+
 function daysUntil(isoDate) {
   if (!isoDate) return null;
   const ms = Date.parse(isoDate) - Date.now();
@@ -134,6 +168,7 @@ Commands:
   cool <provider>           Manually clear hot state for a provider
   remember "preference"     Save a project-scoped preference
   forget "preference"       Remove a preference by fuzzy match
+  search "keyword"           Search across all sessions
   shell-hook                Output bash snippet to add dual-brain to your shell
                             Usage: dual-brain shell-hook >> ~/.bashrc
 
@@ -148,6 +183,30 @@ Options:
 `.trim());
 }
 
+// ─── replit-tools detection ───────────────────────────────────────────────────
+
+function detectReplitTools(cwd) {
+  const replitToolsDir = join(cwd, '.replit-tools');
+  const hasDir = existsSync(replitToolsDir);
+  const hasConfig = existsSync(join(replitToolsDir, 'config.json'));
+  const hasScripts = existsSync(join(replitToolsDir, 'scripts', 'setup-claude-code.sh'));
+  const hasArchive = existsSync(join(replitToolsDir, '.session-archive'));
+
+  let version = null;
+  try {
+    version = readFileSync(join(replitToolsDir, '.version'), 'utf8').trim();
+  } catch {}
+
+  return {
+    installed: hasDir,
+    version,
+    hasConfig,
+    hasScripts,
+    hasArchive,
+    dir: replitToolsDir,
+  };
+}
+
 // ─── Subscription status table ────────────────────────────────────────────────
 
 /**
@@ -677,9 +736,26 @@ async function welcomeScreen(rl, ask) {
     detectedLines.push(`  ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} found from data-tools`);
   }
 
+  // --- Detect replit-tools ---
+  const rt = detectReplitTools(cwd);
+  if (rt.installed) {
+    detectedLines.push(`  replit-tools v${rt.version || '?'} detected`);
+    if (rt.hasArchive) {
+      try {
+        const archiveDir = join(rt.dir, '.session-archive', 'claude', 'projects', '-home-runner-workspace');
+        if (existsSync(archiveDir)) {
+          const count = readdirSync(archiveDir).filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-')).length;
+          if (count > 0) detectedLines.push(`  ${count} archived sessions available`);
+        }
+      } catch {}
+    }
+  } else {
+    detectedLines.push(`  replit-tools not found — install with: npx replit-tools`);
+  }
+
   // Show detection results in a box
   const detectedFormatted = detectedLines.map(line => {
-    const ok = !line.includes('not logged');
+    const ok = !line.includes('not logged') && !line.includes('not found');
     return `${ok ? '✅' : '⚠️ '} ${line.trim()}`;
   });
   console.log('');
@@ -699,6 +775,11 @@ async function welcomeScreen(rl, ask) {
   if (existingSessions.length > 0) {
     console.log(`  [i]     Import ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} from data-tools`);
   }
+  if (!rt.installed) {
+    console.log('');
+    console.log('  💡 Tip: Install replit-tools for session persistence:');
+    console.log('     npx replit-tools');
+  }
   console.log('');
 
   const choice = (await ask('  Choice: ')).trim().toLowerCase();
@@ -948,6 +1029,17 @@ async function mainScreen(rl, ask) {
     console.log(`  ${line}`);
   }
 
+  // replit-tools indicator
+  const rtMain = detectReplitTools(cwd);
+  if (rtMain.installed && rtMain.version) {
+    console.log(`  🔗 replit-tools v${rtMain.version}`);
+  }
+
+  const sparkline = buildSparkline(cwd);
+  if (sparkline) {
+    console.log(`  Activity: ${sparkline}`);
+  }
+
   // Silent OAuth token auto-refresh (like data-tools)
   try {
     const { autoRefreshToken } = await import('../src/profile.mjs');
@@ -992,6 +1084,12 @@ async function mainScreen(rl, ask) {
   }
   console.log('');
 
+  // Build session index in background (powers search + smart resume)
+  try {
+    const { buildSessionIndex } = await import('../src/session.mjs');
+    buildSessionIndex(cwd);
+  } catch {}
+
   const recentSessions = enrichSessions(importReplitSessions(cwd), cwd).slice(0, 7);
 
   if (recentSessions.length > 0) {
@@ -1035,6 +1133,7 @@ async function mainScreen(rl, ask) {
     console.log('  [1-9] Resume numbered above');
   }
   console.log('  [r] Resume (full list)');
+  console.log('  [/] Search sessions');
   console.log('  [e] Manage sessions');
   console.log('  [i] Import from replit-tools');
   console.log('  [m] Manage subscriptions');
@@ -1061,6 +1160,17 @@ async function mainScreen(rl, ask) {
       return { next: 'main' };
     }
 
+    // Smart resume preview
+    try {
+      const { getSessionContext } = await import('../src/session.mjs');
+      const ctx = getSessionContext(targetId, cwd);
+      if (ctx) {
+        console.log('');
+        if (ctx.lastPrompt) console.log(`  Last working on: ${ctx.lastPrompt}`);
+        if (ctx.filesTouched.length > 0) console.log(`  Files touched: ${ctx.filesTouched.join(', ')}`);
+      }
+    } catch {}
+
     const { spawnSync } = await import('node:child_process');
     const tool = termState?.tool || 'claude';
     console.log(`\n  Resuming: ${tool} --resume ${targetId}\n`);
@@ -1072,6 +1182,18 @@ async function mainScreen(rl, ask) {
   const numChoice = parseInt(choice, 10);
   if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= recentSessions.length) {
     const sess = recentSessions[numChoice - 1];
+
+    // Smart resume preview
+    try {
+      const { getSessionContext } = await import('../src/session.mjs');
+      const ctx = getSessionContext(sess.id, cwd);
+      if (ctx) {
+        console.log('');
+        if (ctx.lastPrompt) console.log(`  Last working on: ${ctx.lastPrompt}`);
+        if (ctx.filesTouched.length > 0) console.log(`  Files touched: ${ctx.filesTouched.join(', ')}`);
+      }
+    } catch {}
+
     const { spawnSync } = await import('node:child_process');
     console.log(`\n  Launching: claude --resume ${sess.id}\n`);
     spawnSync('claude', ['--resume', sess.id], { stdio: 'inherit' });
@@ -1109,6 +1231,43 @@ async function mainScreen(rl, ask) {
     return { next: 'main' };
   }
 
+  if (choice === '/') {
+    const query = (await ask('  Search: ')).trim();
+    if (!query) return { next: 'main' };
+
+    const { searchSessions, buildSessionIndex } = await import('../src/session.mjs');
+    // Build index if needed (silent)
+    try { buildSessionIndex(cwd); } catch {}
+
+    const results = searchSessions(query, cwd);
+    if (results.length === 0) {
+      console.log(`\n  No sessions matching "${query}"\n`);
+      await ask('  Press Enter to continue...');
+      return { next: 'main' };
+    }
+
+    console.log(`\n  Found ${results.length} session${results.length === 1 ? '' : 's'}:`);
+    results.slice(0, 9).forEach((sess, i) => {
+      const tool = sess.tool === 'codex' ? 'cdx' : 'cld';
+      const date = sess.date ? new Date(sess.date).toLocaleDateString() : '?';
+      const topics = sess.topics.slice(0, 3).join(', ');
+      console.log(`  [${i + 1}] ${tool}  ${date}  ${sess.prompts.first || sess.id.slice(0, 8)}`);
+      if (topics) console.log(`       topics: ${topics}`);
+    });
+    console.log('');
+
+    const pick = (await ask('  Enter number to resume (or Enter to cancel): ')).trim();
+    const num = parseInt(pick, 10);
+    if (!isNaN(num) && num >= 1 && num <= Math.min(results.length, 9)) {
+      const sess = results[num - 1];
+      const { spawnSync } = await import('node:child_process');
+      const tool = sess.tool === 'codex' ? 'codex' : 'claude';
+      console.log(`\n  Launching: ${tool} --resume ${sess.id}\n`);
+      spawnSync(tool, ['--resume', sess.id], { stdio: 'inherit' });
+    }
+    return { next: 'main' };
+  }
+
   if (choice === 'e') { return { next: 'sessions' }; }
 
   if (choice === 'i') {
@@ -2147,6 +2306,37 @@ async function main() {
   if (cmd === 'remember') { cmdRemember(args[1]); return; }
   if (cmd === 'forget')   { cmdForget(args[1]); return; }
 
+  if (cmd === 'search') {
+    const query = args.slice(1).filter(a => !a.startsWith('--')).join(' ');
+    if (!query) {
+      console.log('Usage: dual-brain search "keyword"');
+      process.exit(1);
+    }
+
+    const { searchSessions, buildSessionIndex } = await import('../src/session.mjs');
+    const cwd = process.cwd();
+    try { buildSessionIndex(cwd); } catch {}
+
+    const results = searchSessions(query, cwd);
+    if (results.length === 0) {
+      console.log(`No sessions matching "${query}"`);
+      process.exit(0);
+    }
+
+    console.log(`Found ${results.length} session${results.length === 1 ? '' : 's'}:\n`);
+    results.slice(0, 10).forEach((sess, i) => {
+      const tool = sess.tool === 'codex' ? 'cdx' : 'cld';
+      const date = sess.date ? new Date(sess.date).toLocaleDateString() : '?';
+      console.log(`  ${i + 1}. [${tool}] ${date}  ${sess.prompts.first || sess.id.slice(0, 8)}`);
+      if (sess.topics.length > 0) console.log(`     topics: ${sess.topics.slice(0, 5).join(', ')}`);
+      if (sess.files.length > 0) console.log(`     files: ${sess.files.slice(0, 5).join(', ')}`);
+      console.log(`     id: ${sess.id}`);
+      console.log('');
+    });
+
+    process.exit(0);
+  }
+
   if (cmd === 'shell-hook') {
     // Output a bash snippet users can add to their .bashrc or source directly.
     const hook = `

package/package.json

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

package/src/index.mjs

@@ -13,7 +13,7 @@ export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrai
 export { loadPlaybook, listPlaybooks, executePlaybook, createRunArtifact } from './playbook.mjs';
 export { getHealth, markHot, markDegraded, markHealthy, checkCooldown, getProviderScore, recordDispatch, getSessionStats, resetHealth, remainingCooldownMinutes } from './health.mjs';
 export { detectRepo, loadRepoCache, getTestCommand, getLintCommand } from './repo.mjs';
-export { loadSession, saveSession, updateSession, clearSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, getSessionMeta, autoLabel, enrichSessions, ensurePersistence, syncSessionMirror } from './session.mjs';
+export { loadSession, saveSession, updateSession, clearSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, getSessionMeta, autoLabel, enrichSessions, ensurePersistence, syncSessionMirror, buildSessionIndex, searchSessions, getSessionContext } from './session.mjs';
 export { decompose, isSimpleTask, taskGraphToWaves } from './decompose.mjs';
 export { generateBrief, compressPriorResults, listRoles } from './brief.mjs';
 export { redact, redactFiles, isSecretFile } from './redact.mjs';

package/src/session.mjs

@@ -740,6 +740,287 @@ export function syncSessionMirror(cwd = process.cwd()) {
   return { copied: totalCopied, grew: totalGrew };
 }
 
+// ─── Session index ────────────────────────────────────────────────────────────
+
+/**
+ * Build/update `.dualbrain/session-index.json` from Claude and Codex JSONL session files.
+ * Extracts topics, file references, prompt snippets, and metadata per session.
+ *
+ * @param {string} [cwd]
+ * @returns {object} index — keyed by session UUID
+ */
+export function buildSessionIndex(cwd = process.cwd()) {
+  const home = process.env.HOME || '/root';
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+
+  // Load existing index
+  let index = {};
+  try {
+    if (existsSync(indexPath)) {
+      index = JSON.parse(readFileSync(indexPath, 'utf8'));
+    }
+  } catch {}
+
+  // Find all session JSONLs
+  const sources = [
+    join(home, '.claude', 'projects', '-home-runner-workspace'),
+    join(cwd, '.replit-tools', '.session-archive', 'claude', 'projects', '-home-runner-workspace'),
+  ];
+
+  const STOP_WORDS = new Set(['the','and','this','that','with','from','have','been','will','would','could','should','just','also','into','about','some','what','when','where','which','their','there','then','than','them','these','those','other','more','only','very','each','most','like','make','want','need','does','dont','didnt','cant','wont','your','they','were','are','for','not','but','was','you','all','can','had','her','one','our','out','use','its','let','get','has','him','his','how','did','got','may','new','now','old','see','way','who','any','few','said']);
+
+  for (const dir of sources) {
+    if (!existsSync(dir)) continue;
+    let files;
+    try { files = readdirSync(dir); } catch { continue; }
+
+    for (const f of files) {
+      if (!f.endsWith('.jsonl') || f.startsWith('agent-')) continue;
+      const sessionId = f.replace('.jsonl', '');
+
+      // Skip if already indexed and file hasn't grown
+      const filePath = join(dir, f);
+      let fileSize = 0;
+      try { fileSize = statSync(filePath).size; } catch { continue; }
+      if (index[sessionId] && index[sessionId]._fileSize >= fileSize) continue;
+
+      // Parse session
+      try {
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+
+        const wordCounts = {};
+        const fileSet = new Set();
+        let firstPrompt = null;
+        let lastPrompt = null;
+        let lastTimestamp = 0;
+        let messageCount = 0;
+
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+
+            // Track timestamps
+            if (entry.timestamp) {
+              const ts = typeof entry.timestamp === 'number' ? entry.timestamp : Date.parse(entry.timestamp) / 1000;
+              if (ts > lastTimestamp) lastTimestamp = ts;
+            }
+
+            // Extract user messages
+            let text = null;
+            if (entry.type === 'user' && entry.message?.content) {
+              text = typeof entry.message.content === 'string'
+                ? entry.message.content
+                : entry.message.content?.[0]?.text;
+            }
+            if (entry.display) text = text || entry.display;
+
+            if (!text) continue;
+            messageCount++;
+
+            if (!firstPrompt) firstPrompt = text.slice(0, 80);
+            lastPrompt = text.slice(0, 80);
+
+            // Extract file paths
+            const filePaths = text.match(/[\w./~-]+\.(?:mjs|js|ts|tsx|jsx|json|md|css|html|py|sh|sql|toml|yaml|yml)\b/g);
+            if (filePaths) filePaths.forEach(p => fileSet.add(p));
+
+            // Count words for topics
+            const words = text.toLowerCase().split(/\W+/).filter(w => w.length > 3 && !STOP_WORDS.has(w));
+            for (const w of words) {
+              wordCounts[w] = (wordCounts[w] || 0) + 1;
+            }
+          } catch { continue; }
+        }
+
+        // Top 10 topics by frequency
+        const topics = Object.entries(wordCounts)
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 10)
+          .map(([w]) => w);
+
+        index[sessionId] = {
+          id: sessionId,
+          topics,
+          files: [...fileSet].slice(0, 20),
+          prompts: { first: firstPrompt || '', last: lastPrompt || '' },
+          date: lastTimestamp ? new Date(lastTimestamp * 1000).toISOString() : null,
+          messageCount,
+          tool: 'claude',
+          _fileSize: fileSize,
+        };
+      } catch { continue; }
+    }
+  }
+
+  // Also index codex sessions (same pattern)
+  const codexDir = join(home, '.codex', 'sessions');
+  if (existsSync(codexDir)) {
+    const walk = (dir) => {
+      let results = [];
+      try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          const full = join(dir, entry.name);
+          if (entry.isDirectory()) results = results.concat(walk(full));
+          else if (entry.isFile() && entry.name.endsWith('.jsonl')) results.push(full);
+        }
+      } catch {}
+      return results;
+    };
+
+    for (const filePath of walk(codexDir)) {
+      try {
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+        if (!lines.length) continue;
+        const meta = JSON.parse(lines[0]);
+        if (meta.type !== 'session_meta' || !meta.payload) continue;
+        const id = meta.payload.id;
+        if (!id || index[id]) continue;
+
+        let fileSize = 0;
+        try { fileSize = statSync(filePath).size; } catch { continue; }
+
+        let firstPrompt = null, lastPrompt = null, messageCount = 0;
+        let lastTimestamp = Date.parse(meta.payload.timestamp || meta.timestamp) / 1000 || 0;
+
+        for (const ln of lines) {
+          try {
+            const j = JSON.parse(ln);
+            if (j.timestamp) {
+              const ts = Date.parse(j.timestamp) / 1000;
+              if (ts > lastTimestamp) lastTimestamp = ts;
+            }
+            if (j.type === 'event_msg' && j.payload?.type === 'user_message') {
+              const text = (j.payload.message || '').trim();
+              if (text) {
+                messageCount++;
+                if (!firstPrompt) firstPrompt = text.slice(0, 80);
+                lastPrompt = text.slice(0, 80);
+              }
+            }
+          } catch { continue; }
+        }
+
+        index[id] = {
+          id, topics: [], files: [],
+          prompts: { first: firstPrompt || '', last: lastPrompt || '' },
+          date: lastTimestamp ? new Date(lastTimestamp * 1000).toISOString() : null,
+          messageCount, tool: 'codex', _fileSize: fileSize,
+        };
+      } catch { continue; }
+    }
+  }
+
+  // Save index
+  try {
+    mkdirSync(join(cwd, '.dualbrain'), { recursive: true });
+    writeFileSync(indexPath, JSON.stringify(index, null, 2));
+  } catch {}
+
+  return index;
+}
+
+/**
+ * Search the session index by keyword. Returns matching sessions sorted by relevance.
+ *
+ * @param {string} query
+ * @param {string} [cwd]
+ * @returns {Array<object>} sessions with `_score` field, sorted descending
+ */
+export function searchSessions(query, cwd = process.cwd()) {
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+  let index = {};
+  try { index = JSON.parse(readFileSync(indexPath, 'utf8')); } catch {}
+
+  if (Object.keys(index).length === 0) {
+    index = buildSessionIndex(cwd);
+  }
+
+  const terms = query.toLowerCase().split(/\W+/).filter(Boolean);
+  const results = [];
+
+  for (const session of Object.values(index)) {
+    let score = 0;
+    const searchText = [
+      ...session.topics,
+      ...session.files,
+      session.prompts.first,
+      session.prompts.last,
+    ].join(' ').toLowerCase();
+
+    for (const term of terms) {
+      if (searchText.includes(term)) score++;
+      if (session.topics.includes(term)) score += 2;
+      if (session.files.some(f => f.includes(term))) score += 2;
+    }
+
+    if (score > 0) {
+      results.push({ ...session, _score: score });
+    }
+  }
+
+  return results.sort((a, b) => b._score - a._score);
+}
+
+/**
+ * Get detailed context for a session (for smart resume preview).
+ * Reads the last 20 lines of the session JSONL to surface the most recent prompt
+ * and files touched.
+ *
+ * @param {string} sessionId
+ * @param {string} [cwd]
+ * @returns {{ lastPrompt: string|null, filesTouched: string[], totalLines: number }|null}
+ */
+export function getSessionContext(sessionId, cwd = process.cwd()) {
+  const home = process.env.HOME || '/root';
+  const paths = [
+    join(home, '.claude', 'projects', '-home-runner-workspace', sessionId + '.jsonl'),
+    join(cwd, '.replit-tools', '.session-archive', 'claude', 'projects', '-home-runner-workspace', sessionId + '.jsonl'),
+  ];
+
+  let filePath = null;
+  for (const p of paths) {
+    if (existsSync(p)) { filePath = p; break; }
+  }
+  if (!filePath) return null;
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const lines = content.split('\n').filter(Boolean);
+
+    // Read last 20 lines for recent context
+    const recentLines = lines.slice(-20);
+    let lastUserPrompt = null;
+    const filesSet = new Set();
+
+    for (const line of recentLines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'user' && entry.message?.content) {
+          const text = typeof entry.message.content === 'string'
+            ? entry.message.content
+            : entry.message.content?.[0]?.text;
+          if (text) lastUserPrompt = text.slice(0, 120);
+        }
+        if (entry.display) lastUserPrompt = entry.display.slice(0, 120);
+
+        // Look for file edits in tool use
+        if (entry.type === 'tool_use' || entry.type === 'tool_result') {
+          const fp = entry.tool_input?.file_path || entry.tool_input?.path;
+          if (fp) filesSet.add(fp.split('/').pop());
+        }
+      } catch { continue; }
+    }
+
+    return {
+      lastPrompt: lastUserPrompt,
+      filesTouched: [...filesSet].slice(0, 5),
+      totalLines: lines.length,
+    };
+  } catch { return null; }
+}
+
 // ─── CLI (direct invocation) ──────────────────────────────────────────────────
 
 const isMain = process.argv[1]?.endsWith('session.mjs');