clideck 1.27.0 → 1.29.0

package/transcript.js

@@ -1,34 +1,48 @@
 const { appendFile, writeFileSync, mkdirSync, existsSync, readdirSync, readFileSync, unlinkSync } = require('fs');
 const { join, basename } = require('path');
 const { DATA_DIR } = require('./paths');
+const builder = require('./transcript-builder');
+const parser = require('./transcript-parser');
 
 const DIR = join(DATA_DIR, 'transcripts');
 const ANSI_RE = /\x1b[\[\]()#;?]*[0-9;]*[a-zA-Z@`~]|\x1b\].*?(?:\x07|\x1b\\)|\x1b.|\r|\x07/g;
 const MAX_CACHE = 50 * 1024;
+const LEGACY_SUFFIXES = ['-parsed.jsonl', '.screen'];
 
 const inputBuf = {};
 const outputBuf = {};
 const cache = {};
 const prefixes = {};
+const entriesById = {};
 const userTexts = {}; // sessionId → [text, ...] — user prompts for parser matching
+const finalizePreset = {};
+const lastAgentText = {};
 let broadcast = null;
 let notifyPlugin = null;
 
+function tlog(id, msg) {
+  // console.log(`[transcript:${id.slice(0,8)}] ${msg}`);
+}
+
+function clog(id, msg) {
+  if (finalizePreset[id] !== 'claude-code') return;
+  // console.log(`[claude:transcript:${id.slice(0,8)}] ${msg}`);
+}
+
 function init(bc, validIds, pluginNotify) {
   broadcast = bc;
   notifyPlugin = pluginNotify || null;
   if (!existsSync(DIR)) mkdirSync(DIR, { recursive: true });
-  // Clean up orphaned .screen files (no matching .jsonl or session)
-  for (const file of readdirSync(DIR).filter(f => f.endsWith('.screen'))) {
-    const id = basename(file, '.screen');
-    if (!existsSync(fpath(id)) && (!validIds || !validIds.has(id))) { try { unlinkSync(join(DIR, file)); } catch {} }
+  for (const file of readdirSync(DIR).filter(f => LEGACY_SUFFIXES.some(s => f.endsWith(s)))) {
+    try { unlinkSync(join(DIR, file)); } catch {}
   }
   for (const file of readdirSync(DIR).filter(f => f.endsWith('.jsonl'))) {
     const id = basename(file, '.jsonl');
     if (validIds && !validIds.has(id)) { try { unlinkSync(join(DIR, file)); } catch {} continue; }
     try {
-      const lines = readFileSync(join(DIR, file), 'utf8').trim().split('\n');
-      cache[id] = lines.map(l => { try { return JSON.parse(l).text; } catch { return ''; } }).join('\n');
+      const lines = readFileSync(join(DIR, file), 'utf8').trim().split('\n').filter(Boolean);
+      entriesById[id] = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+      cache[id] = entriesById[id].map(e => e.text).join('\n');
       if (cache[id].length > MAX_CACHE) cache[id] = cache[id].slice(-MAX_CACHE);
     } catch {}
   }
@@ -36,13 +50,36 @@ function init(bc, validIds, pluginNotify) {
 
 function fpath(id) { return join(DIR, `${id}.jsonl`); }
 function setPrefix(id, prefix) { prefixes[id] = prefix; }
+function setFinalizeOnIdle(id, presetId) {
+  if (!presetId) { delete finalizePreset[id]; return; }
+  finalizePreset[id] = presetId;
+  entriesById[id] = builder.compactEntries(entriesById[id], presetId);
+}
+
+function rewrite(id) {
+  const entries = entriesById[id] || [];
+  writeFileSync(fpath(id), entries.map(e => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : ''));
+  cache[id] = entries.map(e => e.text).join('\n');
+  if (cache[id].length > MAX_CACHE) cache[id] = cache[id].slice(-MAX_CACHE);
+  tlog(id, `rewrite entries=${entries.length} last=${entries.length ? entries[entries.length - 1].role : 'none'}`);
+  clog(id, `rewrite entries=${entries.length} last=${entries.length ? entries[entries.length - 1].role : 'none'}`);
+}
 
 function store(id, role, text) {
   const prefix = prefixes[id] || '';
-  appendFile(fpath(id), JSON.stringify({ ts: Date.now(), role, text, ...(prefix && { prefix }) }) + '\n', () => {});
-  if (!cache[id]) cache[id] = '';
-  cache[id] += '\n' + text;
-  if (cache[id].length > MAX_CACHE) cache[id] = cache[id].slice(-MAX_CACHE);
+  if (finalizePreset[id]) {
+    if (!entriesById[id]) entriesById[id] = [];
+    const entry = { ts: Date.now(), role, text, ...(prefix && { prefix }) };
+    tlog(id, `store role=${role} finalize=${finalizePreset[id]} raw=${JSON.stringify(String(text).slice(0, 160))}`);
+    builder.addEntry(entriesById[id], entry, finalizePreset[id]);
+    rewrite(id);
+  } else {
+    tlog(id, `store role=${role} append raw=${JSON.stringify(String(text).slice(0, 160))}`);
+    appendFile(fpath(id), JSON.stringify({ ts: Date.now(), role, text, ...(prefix && { prefix }) }) + '\n', () => {});
+    if (!cache[id]) cache[id] = '';
+    cache[id] += '\n' + text;
+    if (cache[id].length > MAX_CACHE) cache[id] = cache[id].slice(-MAX_CACHE);
+  }
   if (broadcast) broadcast({ type: 'transcript.append', id, role, text });
   if (notifyPlugin) notifyPlugin(id, role, text);
 }
@@ -72,7 +109,12 @@ function trackInput(id, data) {
     }
     if (ch === '\r' || ch === '\n') {
       const line = buf.text.trim();
-      if (line) { store(id, 'user', line); if (!userTexts[id]) userTexts[id] = []; userTexts[id].push(line); }
+      if (line) {
+        delete lastAgentText[id];
+        store(id, 'user', line);
+        if (!userTexts[id]) userTexts[id] = [];
+        userTexts[id].push(line);
+      }
       buf.text = '';
     } else if (ch === '\x7f' || ch === '\x08') {
       const chars = Array.from(buf.text);
@@ -84,8 +126,20 @@ function trackInput(id, data) {
   }
 }
 
+function recordInjectedInput(id, text) {
+  delete lastAgentText[id];
+  for (const raw of String(text).split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    store(id, 'user', line);
+    if (!userTexts[id]) userTexts[id] = [];
+    userTexts[id].push(line);
+  }
+}
+
 // Server-side fallback: captures raw PTY output (noisy but always available)
 function trackOutput(id, data) {
+  if (finalizePreset[id]) return;
   if (!outputBuf[id]) outputBuf[id] = { text: '', timer: null };
   const buf = outputBuf[id];
   buf.text += data;
@@ -102,180 +156,46 @@ function flush(id) {
   if (lines.length) store(id, 'agent', lines.join('\n'));
 }
 
-// Browser-side clean snapshot: overwrites a per-session file with the full
-// xterm buffer as rendered by the browser. No diffing, no JSONL — just the
-// clean screen content. Mobile reads this for "last agent message".
-function storeBuffer(id, lines) {
-  const isChrome = t => !t
-    || /^[─━═\u2500-\u257f]+$/.test(t)                    // box-drawing horizontal lines
-    || /^[▀▄█▌▐░▒▓╭╮╰╯│╔╗╚╝║]+$/.test(t)                 // block elements, box corners, vertical bars
-    || (/[█▀▄▌▐░▒▓]/.test(t) && /^[█▀▄▌▐░▒▓\s]+$/.test(t)) // ASCII art (blocks + whitespace, e.g. logos)
-    || /^[❯>$%#]\s*$/.test(t)                              // bare prompt markers
-    || /^(esc to interrupt|\? for shortcuts)$/i.test(t);   // Claude Code chrome
-  const filtered = lines.filter(l => !isChrome(l.trim()));
-  while (filtered.length && !filtered[filtered.length - 1].trim()) filtered.pop();
-  const screenPath = join(DIR, `${id}.screen`);
-  if (filtered.length) writeFileSync(screenPath, filtered.join('\n'));
-  else try { unlinkSync(screenPath); } catch {}
-}
-
-// Read the clean screen snapshot for a session (if available).
-function getScreen(id) {
-  const file = join(DIR, `${id}.screen`);
-  if (!existsSync(file)) return null;
-  try { return readFileSync(file, 'utf8'); } catch { return null; }
+function parseTurnsFromLines(id, agent, lines, opts) {
+  const turns = parser.parseTurns(agent, lines, getUsers(id));
+  if (!opts?.raw && turns?.length && turns[turns.length - 1].role === 'user') turns.pop();
+  tlog(id, `parse agent=${agent} lines=${lines?.length || 0} turns=${turns?.map(t => t.role).join(',') || 'none'}`);
+  return turns?.length >= 2 ? turns : null;
 }
 
-// Per-agent screen parsers. Each returns [{role, text}] from .screen content.
-const agentParsers = {
-  'claude-code': (lines, id) => {
-    const known = userTexts[id]?.length ? new Set(userTexts[id]) : null;
-    const turns = [];
-    let current = null;
-    for (const line of lines) {
-      const agent = line.match(/^(?:[│ ]\s*)?[⏺•●]\s(.*)$/);
-      if (agent) {
-        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-        current = { role: 'agent', text: agent[1] };
-        continue;
-      }
-      const userM = line.match(/^(?:[│ ]\s*)?[❯›]\s(.*)$/);
-      if (userM && (known ? known.has(userM[1].trim()) : true)) {
-        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-        current = { role: 'user', text: userM[1] };
-        continue;
-      }
-      if (!current) continue;
-      let cont = line;
-      if (cont.startsWith('│ ')) cont = cont.slice(2);
-      else if (cont.startsWith('  ')) cont = cont.slice(2);
-      current.text += '\n' + cont;
-    }
-    if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-    return turns.length >= 2 ? turns : null;
-  },
-  'codex': (lines, id) => {
-    const known = userTexts[id]?.length ? new Set(userTexts[id]) : null;
-    const turns = [];
-    let current = null;
-    for (const line of lines) {
-      const agent = line.match(/^(?:│\s*)?•\s(.*)$/);
-      if (agent) {
-        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-        current = { role: 'agent', text: agent[1] };
-        continue;
-      }
-      const userM = line.match(/^(?:│\s*)?›\s(.*)$/);
-      if (userM && (known ? known.has(userM[1].trim()) : true)) {
-        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-        current = { role: 'user', text: userM[1] };
-        continue;
-      }
-      if (!current) continue;
-      let cont = line;
-      if (cont.startsWith('│ ')) cont = cont.slice(2);
-      else if (cont.startsWith('  ')) cont = cont.slice(2);
-      current.text += '\n' + cont;
-    }
-    if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-    return turns.length >= 2 ? turns : null;
-  },
-  'gemini-cli': (lines, id) => {
-    const known = userTexts[id]?.length ? new Set(userTexts[id]) : null;
-    const geminiChrome = t => {
-      const s = t.trim();
-      return /^shift\+tab to accept/i.test(s)
-        || /^(Type your message|@path\/to\/)/i.test(s)
-        || /^(\/\w+ |no sandbox|\/model )/i.test(s)
-        || /^[~\/\\].*\(main[*]?\)\s*$/i.test(s)
-        || /^(Logged in with|Plan:|Tips for getting started)/i.test(s)
-        || /^\d+\.\s+(Ask questions|Be specific|Create GEMINI)/i.test(s)
-        || /^ℹ\s/.test(s);
-    };
-    const turns = [];
-    let current = null;
-    for (const line of lines) {
-      if (geminiChrome(line)) continue;
-      const isAgent = line.startsWith('✦ ');
-      const userM = line.startsWith(' > ') ? line.slice(3) : null;
-      const isUser = userM && (known ? known.has(userM.trim()) : true);
-      if (isUser || isAgent) {
-        if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-        current = { role: isUser ? 'user' : 'agent', text: isUser ? userM : line.slice(2) };
-        continue;
-      }
-      if (!current) continue;
-      current.text += '\n' + line;
-    }
-    if (current) { current.text = current.text.replace(/\n+$/, ''); turns.push(current); }
-    return turns.length >= 2 ? turns : null;
-  },
-};
-
-// Fallback anchor parser for agents without a dedicated parser.
-// Uses JSONL user inputs to find prompt lines in the screen.
-function anchorParse(id, lines) {
-  const file = fpath(id);
-  if (!existsSync(file)) return null;
-  const users = [];
-  try {
-    for (const l of readFileSync(file, 'utf8').trim().split('\n')) {
-      try { const e = JSON.parse(l); if (e.role === 'user') users.push(e.text); } catch {}
-    }
-  } catch { return null; }
-  if (!users.length) return null;
-
-  const isPrompt = (line, text) => { const t = line.trim(); return t.endsWith(text) && t.length - text.length <= 6; };
-
-  const lastUser = users[users.length - 1];
-  let lastIdx = -1;
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (isPrompt(lines[i], lastUser)) { lastIdx = i; break; }
-  }
-  if (lastIdx < 0) return null;
-
-  const anchors = [{ idx: lastIdx, text: lastUser }];
-  for (let u = users.length - 2; u >= 0 && anchors.length < 3; u--) {
-    for (let i = anchors[anchors.length - 1].idx - 1; i >= 0; i--) {
-      if (isPrompt(lines[i], users[u])) { anchors.push({ idx: i, text: users[u] }); break; }
-    }
-  }
-  anchors.reverse();
-
-  const turns = [];
-  for (let p = 0; p < anchors.length; p++) {
-    turns.push({ role: 'user', text: anchors[p].text });
-    const start = anchors[p].idx + 1;
-    const end = p + 1 < anchors.length ? anchors[p + 1].idx : lines.length;
-    const agentLines = lines.slice(start, end).filter(l => l.trim());
-    if (agentLines.length) turns.push({ role: 'agent', text: agentLines.join('\n') });
-  }
-  if (turns.length < 2 || turns[turns.length - 1].role !== 'agent') return null;
-  return turns;
+function captureAgentTurn(id, agent, lines) {
+  if (!finalizePreset[id]) return;
+  const turns = parseTurnsFromLines(id, agent, lines);
+  // Finalized capture should not depend on the viewport still containing the
+  // matching user prompt line; if the full turn structure is gone, fall back to
+  // the last visible agent block alone.
+  const last = turns?.length ? turns[turns.length - 1] : parser.parseLastAgentOnly(agent, lines);
+  if (last) tlog(id, `capture lastRole=${last.role} raw=${JSON.stringify(String(last.text).slice(0, 200))}`);
+  if (last) clog(id, `capture lastRole=${last.role} raw=${JSON.stringify(String(last.text).slice(0, 200))}`);
+  const text = last?.role === 'agent' ? builder.cleanAgentText(finalizePreset[id], last.text) : '';
+  tlog(id, `capture cleaned=${JSON.stringify(String(text).slice(0, 200))}`);
+  if (!text) { tlog(id, 'capture skip empty-clean'); clog(id, 'capture skip empty-clean'); return; }
+  if (text === lastAgentText[id]) { tlog(id, 'capture skip duplicate-clean'); clog(id, 'capture skip duplicate-clean'); return; }
+  lastAgentText[id] = text;
+  store(id, 'agent', text);
 }
 
-// For consecutive agent turns, keep only the last one (strips tool output, keeps conversational response).
-function collapseAgentTurns(turns) {
-  if (!turns?.length) return turns;
-  const result = [];
-  for (let i = 0; i < turns.length; i++) {
-    if (turns[i].role === 'agent' && i + 1 < turns.length && turns[i + 1].role === 'agent') continue;
-    result.push(turns[i]);
-  }
-  return result;
+function captureFinalAgentText(id, presetId, text) {
+  if (!finalizePreset[id]) return;
+  const clean = builder.cleanAgentText(presetId || finalizePreset[id], text);
+  tlog(id, `captureFinal raw=${JSON.stringify(String(text).slice(0, 200))}`);
+  tlog(id, `captureFinal cleaned=${JSON.stringify(String(clean).slice(0, 200))}`);
+  clog(id, `captureFinal raw=${JSON.stringify(String(text).slice(0, 200))}`);
+  clog(id, `captureFinal cleaned=${JSON.stringify(String(clean).slice(0, 200))}`);
+  if (!clean) { tlog(id, 'captureFinal skip empty-clean'); clog(id, 'captureFinal skip empty-clean'); return; }
+  if (clean === lastAgentText[id]) { tlog(id, 'captureFinal skip duplicate-clean'); clog(id, 'captureFinal skip duplicate-clean'); return; }
+  lastAgentText[id] = clean;
+  store(id, 'agent', clean);
 }
 
-// Parse .screen into structured turns — use agent-specific parser if available, else anchor fallback.
-// opts.raw: if true, preserve trailing user turn (needed by autopilot for freshness checks).
-function getScreenTurns(id, agent, opts) {
-  const screen = getScreen(id);
-  if (!screen) return null;
-  const lines = screen.split('\n');
-  const parser = agentParsers[agent];
-  const turns = collapseAgentTurns(parser ? parser(lines, id) : anchorParse(id, lines));
-  // Drop trailing user turn — it's the empty prompt or unanswered input
-  if (!opts?.raw && turns?.length && turns[turns.length - 1].role === 'user') turns.pop();
-  return turns?.length >= 2 ? turns : null;
+function getUsers(id) {
+  if (userTexts[id]?.length) return userTexts[id];
+  return (entriesById[id] || []).filter(e => e.role === 'user').map(e => e.text);
 }
 
 function getLastTurns(id, n) {
@@ -301,6 +221,18 @@ function getLastTurns(id, n) {
 
 function getCache() { return { ...cache }; }
 
+function getReplayText(id, presetId) {
+  const entries = builder.compactEntries(entriesById[id], presetId);
+  if (!entries?.length) return '';
+  const marks = {
+    'claude-code': { user: '❯', agent: '⏺' },
+    codex: { user: '›', agent: '•' },
+    'gemini-cli': { user: '>', agent: '✦' },
+    opencode: { user: '›', agent: '•' },
+  }[presetId] || { user: '›', agent: '•' };
+  return entries.map(e => `${e.role === 'user' ? marks.user : marks.agent} ${e.text}`).join('\n\n');
+}
+
 function clear(id) {
   flush(id);
   delete inputBuf[id];
@@ -309,9 +241,11 @@ function clear(id) {
     delete outputBuf[id];
   }
   delete cache[id];
+  delete entriesById[id];
   delete prefixes[id];
   delete userTexts[id];
-  try { unlinkSync(join(DIR, `${id}.screen`)); } catch {}
+  delete lastAgentText[id];
+  delete finalizePreset[id];
 }
 
 // Detect interactive menus from raw screen lines. Returns [{value, label, selected}] or null.
@@ -340,4 +274,4 @@ function detectMenu(lines, presetId) {
   return choices.length ? choices : null;
 }
 
-module.exports = { init, trackInput, trackOutput, storeBuffer, getScreen, getScreenTurns, getLastTurns, getCache, clear, setPrefix, detectMenu };
+module.exports = { init, trackInput, recordInjectedInput, trackOutput, captureAgentTurn, captureFinalAgentText, parseTurnsFromLines, getLastTurns, getCache, getReplayText, clear, setPrefix, setFinalizeOnIdle, detectMenu };