dual-brain 7.1.21 → 7.1.23

package/src/receipt.mjs

@@ -0,0 +1,131 @@
+const DIM   = '\x1b[2m';
+const GREEN = '\x1b[32m';
+const YELLOW= '\x1b[33m';
+const RED   = '\x1b[31m';
+const RESET = '\x1b[0m';
+
+const SEP = `${DIM}──────────────────────────────────${RESET}`;
+
+const AUTH_PAT = /\b(auth|credential|secret|token|password|encrypt|permission|oauth|jwt|api.?key)\b/i;
+
+function classifyRisk(plan, result) {
+  if (plan.risk) return plan.risk;
+  const files = result.filesChanged ?? [];
+  if (files.some(f => AUTH_PAT.test(f))) return 'critical';
+  if (plan.tier === 'think') return 'high';
+  if (plan.tier === 'execute') return 'medium';
+  return 'low';
+}
+
+function classifyChallenger(plan, result) {
+  const policy = plan.challengerPolicy;
+  if (!plan.useChallenger && (!policy || policy === 'none')) return 'not used';
+  if (!result.success) return 'blocked';
+  if (result.output && /concern|issue|warn|problem/i.test(String(result.output))) return 'concerns raised';
+  return 'pass';
+}
+
+function nextStep(result, plan, verification) {
+  const files = result.filesChanged ?? [];
+  const changed = files.length > 0;
+  const authFiles = files.some(f => AUTH_PAT.test(f));
+
+  if (!result.success) {
+    const retry = result.error && /test/i.test(String(result.error));
+    return retry ? 'fix failing tests' : 'retry with deeper analysis';
+  }
+
+  if (authFiles) return 'security review recommended';
+
+  if (changed) {
+    if (!verification.testsRun) return 'run tests to verify';
+    if (verification.testsPassed === false) return 'fix failing tests';
+    if (verification.testsPassed === true) return 'commit this patch';
+    return 'review the diff';
+  }
+
+  return 'review the output';
+}
+
+export function buildReceipt(result, plan, verification) {
+  const files = result.filesChanged ?? [];
+  const changed = files.length > 0 ? files.join(', ') : 'no files changed';
+
+  let verified;
+  if (verification.testsPassed === true) verified = 'tests passed';
+  else if (verification.filesVerified) verified = 'files confirmed changed';
+  else verified = 'not verified';
+
+  return {
+    changed,
+    verified,
+    risk: classifyRisk(plan, result),
+    challenger: classifyChallenger(plan, result),
+    next: nextStep(result, plan, verification),
+    success: result.success ?? false,
+  };
+}
+
+function colorRisk(risk) {
+  if (risk === 'low') return `${GREEN}${risk}${RESET}`;
+  if (risk === 'medium') return `${YELLOW}${risk}${RESET}`;
+  return `${RED}${risk}${RESET}`;
+}
+
+function colorChallenger(ch) {
+  if (ch === 'pass') return `${GREEN}${ch}${RESET}`;
+  if (ch === 'concerns raised') return `${YELLOW}${ch}${RESET}`;
+  if (ch === 'blocked') return `${RED}${ch}${RESET}`;
+  return `${DIM}${ch}${RESET}`;
+}
+
+export function formatReceipt(receipt) {
+  return [
+    SEP,
+    `  Changed:    ${receipt.changed}`,
+    `  Verified:   ${receipt.verified}`,
+    `  Risk:       ${colorRisk(receipt.risk)}`,
+    `  Challenger: ${colorChallenger(receipt.challenger)}`,
+    `  Next:       ${receipt.next}`,
+    SEP,
+  ].join('\n');
+}
+
+export function formatFailureReceipt(receipt, failureContext) {
+  const errorLine = failureContext ? `  Error:      ${failureContext}` : null;
+  const lines = [
+    SEP,
+    `  Changed:    ${receipt.changed}`,
+    `  Verified:   ${receipt.verified}`,
+    `  Risk:       ${colorRisk(receipt.risk)}`,
+    `  Challenger: ${colorChallenger(receipt.challenger)}`,
+  ];
+  if (errorLine) lines.push(errorLine);
+  lines.push(`  Next:       ${receipt.next}`, SEP);
+  return lines.join('\n');
+}
+
+export function buildReceiptFromOutcome(outcome = {}) {
+  const result = {
+    success: outcome.success ?? outcome.result?.success ?? false,
+    filesChanged: outcome.filesChanged ?? outcome.result?.filesChanged ?? [],
+    error: outcome.error ?? outcome.result?.error ?? null,
+    duration: outcome.duration ?? outcome.result?.duration ?? 0,
+    output: outcome.output ?? null,
+  };
+  const plan = {
+    primaryModel: outcome.primaryModel ?? '',
+    reasoningDepth: outcome.reasoningDepth ?? '',
+    challengerPolicy: outcome.challengerPolicy ?? 'none',
+    useChallenger: !!(outcome.challengerPolicy && outcome.challengerPolicy !== 'none'),
+    tier: outcome.tier ?? '',
+    workStyle: outcome.workStyle ?? '',
+    risk: outcome.risk ?? '',
+  };
+  const verification = {
+    filesVerified: outcome.verification?.filesVerified ?? false,
+    testsRun: outcome.verification?.testsRun ?? false,
+    testsPassed: outcome.verification?.testsPassed ?? null,
+  };
+  return buildReceipt(result, plan, verification);
+}

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(),
@@ -508,7 +523,7 @@ export function getSessionMeta(cwd = process.cwd()) {
   try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return {}; }
 }
 
-function saveSessionMeta(meta, cwd = process.cwd()) {
+export function saveSessionMeta(meta, cwd = process.cwd()) {
   ensureDir(cwd);
   const p   = sessionMetaPath(cwd);
   const tmp = p + '.tmp.' + process.pid;
@@ -516,6 +531,76 @@ function saveSessionMeta(meta, cwd = process.cwd()) {
   renameSync(tmp, p);
 }
 
+// ─── Archive support ──────────────────────────────────────────────────────────
+
+const ARCHIVE_FILE = '.dualbrain/archive/sessions.json';
+
+function archivePath(cwd) {
+  return join(cwd ?? process.cwd(), ARCHIVE_FILE);
+}
+
+/**
+ * Archive a session — moves it from active sessions.json to archive/sessions.json.
+ * The session data stays in the index (searchable), just flagged as archived.
+ * Non-destructive and reversible.
+ *
+ * @param {string} sessionId
+ * @param {string} [cwd]
+ */
+export function archiveSession(sessionId, cwd = process.cwd()) {
+  // Load active sessions meta
+  const meta = getSessionMeta(cwd);
+  const existing = meta[sessionId] ?? {};
+
+  // Load or init archive
+  const ap = archivePath(cwd);
+  mkdirSync(dirname(ap), { recursive: true });
+  let archive = [];
+  try {
+    if (existsSync(ap)) archive = JSON.parse(readFileSync(ap, 'utf8'));
+  } catch { archive = []; }
+
+  // Avoid duplicates
+  if (!archive.some(s => s.id === sessionId)) {
+    archive.push({
+      ...existing,
+      id: sessionId,
+      archived: true,
+      archivedAt: new Date().toISOString(),
+    });
+    const tmp = ap + '.tmp.' + process.pid;
+    writeFileSync(tmp, JSON.stringify(archive, null, 2) + '\n');
+    renameSync(tmp, ap);
+  }
+
+  // Remove from active sessions.json
+  delete meta[sessionId];
+  saveSessionMeta(meta, cwd);
+
+  // Mark archived in the session index (best-effort)
+  try {
+    const indexPath = join(cwd ?? process.cwd(), '.dualbrain', 'session-index.json');
+    if (existsSync(indexPath)) {
+      const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+      if (index[sessionId]) {
+        index[sessionId].archived = true;
+        writeFileSync(indexPath, JSON.stringify(index, null, 2) + '\n');
+      }
+    }
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Return all archived sessions.
+ * @param {string} [cwd]
+ * @returns {Array<object>}
+ */
+export function getArchivedSessions(cwd = process.cwd()) {
+  const ap = archivePath(cwd);
+  if (!existsSync(ap)) return [];
+  try { return JSON.parse(readFileSync(ap, 'utf8')); } catch { return []; }
+}
+
 export function renameSession(sessionId, name, cwd = process.cwd()) {
   const meta = getSessionMeta(cwd);
   meta[sessionId] = { ...meta[sessionId], name, createdAt: meta[sessionId]?.createdAt ?? new Date().toISOString() };
@@ -741,6 +826,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 +1079,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 +1089,8 @@ export function buildSessionIndex(cwd = process.cwd()) {
           tool: 'claude',
           _fileSize: fileSize,
         };
+        sessionEntry.smartName = generateSmartName(sessionEntry);
+        index[sessionId] = sessionEntry;
       } catch { continue; }
     }
   }
@@ -904,12 +1144,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; }
     }
   }
@@ -965,6 +1207,112 @@ export function searchSessions(query, cwd = process.cwd()) {
   return results.sort((a, b) => b._score - a._score);
 }
 
+/**
+ * Find sessions related to a new task prompt and file list.
+ * Uses the session index (topics + files) — does not parse full JSONL files.
+ *
+ * Scoring:
+ *   +3 for each file in common between the new task and a past session
+ *   +2 for each topic keyword in common
+ *   +1 for matching intent words (fix, refactor, test, etc.)
+ *
+ * Returns top 3 matches with score > 3, sorted by score desc.
+ * Excludes sessions from the last hour (likely the current session).
+ *
+ * @param {string}   prompt  New task prompt
+ * @param {string[]} files   File paths from the new task
+ * @param {string}   [cwd]
+ * @returns {Array<{
+ *   sessionId: string, smartName: string, score: number,
+ *   matchedFiles: string[], matchedTopics: string[],
+ *   date: string|null, messageCount: number
+ * }>}
+ */
+export function findRelatedSessions(prompt, files = [], cwd = process.cwd()) {
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+  let index = {};
+  try { index = JSON.parse(readFileSync(indexPath, 'utf8')); } catch { return []; }
+
+  if (Object.keys(index).length === 0) return [];
+
+  // Intent words for +1 scoring
+  const INTENT_WORDS = ['fix', 'refactor', 'test', 'add', 'update', 'review', 'debug', 'build', 'remove', 'migrate', 'deploy', 'implement', 'create'];
+
+  // Normalize the new task's prompt into words
+  const promptLower = (prompt || '').toLowerCase();
+  const promptWords = new Set(promptLower.split(/\W+/).filter(w => w.length > 3));
+
+  // Normalize the new task's file paths for comparison
+  const normalizeFile = (f) => (f || '').split('/').pop().toLowerCase().replace(/\.[^.]+$/, '');
+  const newFileNames = new Set((files || []).map(normalizeFile).filter(Boolean));
+
+  // One-hour cutoff for excluding likely-current session
+  const oneHourAgo = Date.now() - 60 * 60 * 1000;
+
+  const results = [];
+
+  for (const session of Object.values(index)) {
+    // Skip archived sessions
+    if (session.archived) continue;
+
+    // Skip sessions from the last hour
+    const sessionTs = session.date ? Date.parse(session.date) : 0;
+    if (sessionTs > oneHourAgo) continue;
+
+    let score = 0;
+    const matchedFiles = [];
+    const matchedTopics = [];
+
+    // +3 for each file in common
+    for (const sessionFile of (session.files || [])) {
+      const sessionFileName = normalizeFile(sessionFile);
+      if (sessionFileName && newFileNames.has(sessionFileName)) {
+        score += 3;
+        matchedFiles.push(sessionFile);
+      }
+    }
+
+    // +2 for each topic keyword in common with prompt words
+    for (const topic of (session.topics || [])) {
+      if (topic && promptWords.has(topic)) {
+        score += 2;
+        matchedTopics.push(topic);
+      }
+    }
+
+    // +1 for matching intent words found in both prompt and session topics/prompts
+    const sessionText = [
+      ...(session.topics || []),
+      session.prompts?.first || '',
+      session.prompts?.last  || '',
+    ].join(' ').toLowerCase();
+
+    for (const word of INTENT_WORDS) {
+      if (promptLower.includes(word) && sessionText.includes(word)) {
+        score += 1;
+        break; // only +1 total for intent words
+      }
+    }
+
+    if (score > 3) {
+      results.push({
+        sessionId:     session.id,
+        smartName:     session.smartName || session.prompts?.first?.slice(0, 40) || session.id.slice(0, 8),
+        score,
+        matchedFiles,
+        matchedTopics,
+        date:          session.date,
+        messageCount:  session.messageCount || 0,
+      });
+    }
+  }
+
+  // Return top 3 sorted by score descending
+  return results
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 3);
+}
+
 /**
  * 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