claude-simple 0.2.9 → 0.2.11

package/src/agents/sessions.js

@@ -757,8 +757,18 @@ async function loadGrokContext(sessionDir) {
 }
 
 /** Public helper: load usage/context for any agent session. */
-export async function loadSessionUsage(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function loadSessionUsage(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   const a = (agent || 'claude').toLowerCase();
+  if (a === 'cursor') {
+    const sessions = await scanCursorSessions(cursorHome);
+    if (!sessions.some(s => s.sessionId === sessionId)) return null;
+    return { agent: 'cursor', sessionId, context: await loadCursorContext(sessionId, cursorHome) };
+  }
+  if (a === 'gemini') {
+    const sessions = await scanGeminiSessions(geminiHome);
+    if (!sessions.some(s => s.sessionId === sessionId)) return null;
+    return { agent: 'gemini', sessionId, context: await loadGeminiContext(sessionId, geminiHome) };
+  }
   if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     if (!dir) return null;
@@ -890,8 +900,242 @@ export async function loadGrokSessionBundle(sessionDir) {
   return { messages, context };
 }
 
+// ─── Gemini / agy ────────────────────────────────────────────────────────────
+
+function geminiUiSessionsRoot(geminiHome) {
+  return path.join(geminiHome || path.join(os.homedir(), '.gemini'), 'claude-simple-ui', 'sessions');
+}
+
+function geminiJournalPath(sessionId, geminiHome) {
+  return path.join(geminiUiSessionsRoot(geminiHome), `${sessionId}.jsonl`);
+}
+
+// agy keeps the actual native transcript here.  This is plain JSONL (unlike
+// its conversation SQLite database) and is available for conversations made
+// in the Antigravity app as well as print-mode conversations created by us.
+function geminiNativeTranscriptPath(sessionId, geminiHome) {
+  const home = geminiHome || path.join(os.homedir(), '.gemini');
+  return path.join(home, 'antigravity-cli', 'brain', sessionId, '.system_generated', 'logs', 'transcript.jsonl');
+}
+
+function geminiPathFromUri(uri) {
+  if (!uri || typeof uri !== 'string') return null;
+  try { return decodeURIComponent(uri.replace(/^file:\/\//, '')); } catch { return null; }
+}
+
+async function readGeminiJournalMeta(filePath) {
+  let meta = null;
+  let firstUser = null;
+  let turnCount = 0;
+  let totalTokens = 0;
+  try {
+    const stream = fsSync.createReadStream(filePath);
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      let d; try { d = JSON.parse(line); } catch { continue; }
+      if (d.type === 'session_meta') meta = { ...(meta || {}), ...d };
+      if (d.type === 'user' && d.content?.trim()) {
+        turnCount++;
+        if (!firstUser) firstUser = d.content.trim();
+      }
+      if (d.type === 'result' && d.usage) totalTokens += Number(d.usage.total_tokens) || 0;
+    }
+  } catch {}
+  return { meta, firstUser, turnCount, totalTokens };
+}
+
+/** agy keeps public conversation metadata plus a UI-owned readable journal. */
+export async function scanGeminiSessions(geminiHome, filterCwd = null) {
+  const home = geminiHome || path.join(os.homedir(), '.gemini');
+  const records = new Map();
+  const metadataPath = path.join(home, 'antigravity-cli', 'cache', 'conversation_metadata.json');
+  try {
+    const raw = JSON.parse(await fs.readFile(metadataPath, 'utf8'));
+    for (const [sessionId, item] of Object.entries(raw?.conversations || {})) {
+      const summary = item?.summary || {};
+      const cwd = geminiPathFromUri(summary.WorkspaceURIs?.[0]) || null;
+      records.set(sessionId, {
+        sessionId, agent: 'gemini', cwd, configDir: home,
+        display: summary.Title || summary.Preview || sessionId.slice(0, 8),
+        updatedAt: Date.parse(item?.last_modified_time || summary.UpdatedAt || '') || 0,
+        turnCount: Number(summary.NumSteps) || 0,
+        hasMemory: false,
+      });
+    }
+  } catch {}
+  // history.jsonl catches fresh print-mode conversations before metadata cache
+  // catches up, and provides a useful title for older conversations.
+  try {
+    const stream = fsSync.createReadStream(path.join(home, 'antigravity-cli', 'history.jsonl'));
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      let d; try { d = JSON.parse(line); } catch { continue; }
+      const sessionId = d.conversationId;
+      if (!sessionId) continue;
+      const existing = records.get(sessionId) || {
+        sessionId, agent: 'gemini', cwd: d.workspace || null, configDir: home,
+        display: sessionId.slice(0, 8), updatedAt: 0, turnCount: 0, hasMemory: false,
+      };
+      existing.cwd ||= d.workspace || null;
+      existing.display = existing.display === sessionId.slice(0, 8) ? (d.display || existing.display) : existing.display;
+      existing.updatedAt = Math.max(existing.updatedAt || 0, Number(d.timestamp) || 0);
+      if (d.type !== 'slash_command') existing.turnCount = Math.max(existing.turnCount || 0, 1);
+      records.set(sessionId, existing);
+    }
+  } catch {}
+  try {
+    const entries = await fs.readdir(geminiUiSessionsRoot(home), { withFileTypes: true });
+    await Promise.all(entries.filter(e => e.isFile() && e.name.endsWith('.jsonl')).map(async e => {
+      const filePath = path.join(geminiUiSessionsRoot(home), e.name);
+      const sessionId = e.name.slice(0, -6);
+      const [stat, parsed] = await Promise.all([fs.stat(filePath), readGeminiJournalMeta(filePath)]);
+      const existing = records.get(sessionId) || { sessionId, agent: 'gemini', configDir: home, hasMemory: false };
+      existing.cwd = parsed.meta?.cwd || existing.cwd || null;
+      existing.display = parsed.firstUser || existing.display || sessionId.slice(0, 8);
+      existing.updatedAt = Math.max(existing.updatedAt || 0, stat.mtimeMs);
+      existing.turnCount = parsed.turnCount || existing.turnCount || 0;
+      existing.totalTokens = parsed.totalTokens || existing.totalTokens || 0;
+      existing.journalPath = filePath;
+      records.set(sessionId, existing);
+    }));
+  } catch {}
+  return [...records.values()].filter(s => !filterCwd || s.cwd === filterCwd);
+}
+
+export async function parseGeminiMessages(filePath) {
+  const messages = [];
+  let pendingAssistant = null;
+  const flushAssistant = () => {
+    if (pendingAssistant?.content) messages.push(pendingAssistant);
+    pendingAssistant = null;
+  };
+  try {
+    const stream = fsSync.createReadStream(filePath);
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      let d; try { d = JSON.parse(line); } catch { continue; }
+      if (d.type === 'user' && d.content?.trim()) {
+        flushAssistant();
+        messages.push({ role: 'user', type: 'text', content: d.content.trim(), ts: d.ts });
+      } else if (d.type === 'assistant_delta' && d.data) {
+        if (!pendingAssistant) pendingAssistant = { role: 'assistant', type: 'text', content: '', ts: d.ts };
+        pendingAssistant.content += d.data;
+      } else if (d.type === 'tool') {
+        flushAssistant();
+        messages.push({ role: 'tool', type: 'tool_use', name: d.name || 'tool', input: d.input || {}, ts: d.ts });
+      } else if (d.type === 'result' && d.usage) {
+        flushAssistant();
+        messages.push({ type: 'token_usage', usage: d.usage, ts: d.ts });
+      }
+    }
+  } catch {}
+  flushAssistant();
+  return messages;
+}
+
+async function findGeminiJournal(sessionId, geminiHome) {
+  const file = geminiJournalPath(sessionId, geminiHome);
+  try { await fs.access(file); return file; } catch { return null; }
+}
+
+async function findGeminiNativeTranscript(sessionId, geminiHome) {
+  const file = geminiNativeTranscriptPath(sessionId, geminiHome);
+  try { await fs.access(file); return file; } catch { return null; }
+}
+
+function geminiUserText(content) {
+  const text = String(content || '').trim();
+  // Native rows wrap the visible user request in transport metadata.  Keep
+  // the chat transcript readable while retaining a safe fallback for old rows.
+  const request = text.match(/<USER_REQUEST>\s*([\s\S]*?)\s*<\/USER_REQUEST>/i);
+  return (request?.[1] || text).trim();
+}
+
+/** Parse agy's native brain transcript into the common UI history shape. */
+export async function parseGeminiNativeMessages(filePath) {
+  const messages = [];
+  try {
+    const stream = fsSync.createReadStream(filePath);
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      let d; try { d = JSON.parse(line); } catch { continue; }
+      if (d.status && d.status !== 'DONE') continue;
+      const ts = Date.parse(d.created_at || '') || undefined;
+      if (d.source === 'USER_EXPLICIT' && d.type === 'USER_INPUT') {
+        const content = geminiUserText(d.content);
+        if (content) messages.push({ role: 'user', type: 'text', content, ts });
+      } else if (d.source === 'MODEL' && ['GENERIC', 'PLANNER_RESPONSE'].includes(d.type)) {
+        const content = String(d.content || '').trim();
+        if (content) messages.push({ role: 'assistant', type: 'text', content, ts });
+      }
+    }
+  } catch {}
+  return messages;
+}
+
+async function loadGeminiContext(sessionId, geminiHome) {
+  const native = await findGeminiNativeTranscript(sessionId, geminiHome);
+  const file = native || await findGeminiJournal(sessionId, geminiHome);
+  if (!file) return { note: 'This Gemini conversation has no readable transcript on this machine.' };
+  const messages = native ? await parseGeminiNativeMessages(native) : await parseGeminiMessages(file);
+  const usages = messages.filter(m => m.type === 'token_usage').map(m => m.usage || {});
+  const total = { input_tokens: 0, output_tokens: 0, reasoning_tokens: 0, cache_read_input_tokens: 0, total_tokens: 0 };
+  for (const u of usages) for (const key of Object.keys(total)) total[key] += Number(u[key]) || 0;
+  return {
+    turnCount: messages.filter(m => m.role === 'user').length,
+    toolCallCount: messages.filter(m => m.type === 'tool_use').length,
+    lastTurn: usages.at(-1) || null,
+    sessionTotals: total,
+  };
+}
+
 // ─── Unified ──────────────────────────────────────────────────────────────────
 
+// ─── Cursor Agent ────────────────────────────────────────────────────────────
+// Cursor's native transcript format is private. Sessions created through this
+// UI have a durable, UI-owned journal at ~/.cursor/claude-simple-ui/sessions.
+function cursorUiSessionsRoot(cursorHome) {
+  return path.join(cursorHome || path.join(os.homedir(), '.cursor'), 'claude-simple-ui', 'sessions');
+}
+
+function cursorJournalPath(sessionId, cursorHome) {
+  return path.join(cursorUiSessionsRoot(cursorHome), `${sessionId}.jsonl`);
+}
+
+async function findCursorJournal(sessionId, cursorHome) {
+  const file = cursorJournalPath(sessionId, cursorHome);
+  try { await fs.access(file); return file; } catch { return null; }
+}
+
+export async function scanCursorSessions(cursorHome, filterCwd = null) {
+  const home = cursorHome || path.join(os.homedir(), '.cursor');
+  const sessions = [];
+  try {
+    const entries = await fs.readdir(cursorUiSessionsRoot(home), { withFileTypes: true });
+    await Promise.all(entries.filter(e => e.isFile() && e.name.endsWith('.jsonl')).map(async e => {
+      const filePath = path.join(cursorUiSessionsRoot(home), e.name);
+      const [stat, parsed] = await Promise.all([fs.stat(filePath), readGeminiJournalMeta(filePath)]);
+      sessions.push({
+        sessionId: e.name.slice(0, -6), agent: 'cursor', cwd: parsed.meta?.cwd || null,
+        configDir: home, display: parsed.firstUser || e.name.slice(0, 8), updatedAt: stat.mtimeMs,
+        turnCount: parsed.turnCount || 0, totalTokens: parsed.totalTokens || 0,
+        hasMemory: false, journalPath: filePath,
+      });
+    }));
+  } catch {}
+  return sessions.filter(s => !filterCwd || s.cwd === filterCwd);
+}
+
+async function loadCursorContext(sessionId, cursorHome) {
+  const file = await findCursorJournal(sessionId, cursorHome);
+  if (!file) return { note: 'This Cursor conversation predates UI journaling; its native transcript is not exposed by cursor-agent.' };
+  const messages = await parseGeminiMessages(file);
+  const usages = messages.filter(m => m.type === 'token_usage').map(m => m.usage || {});
+  const total = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_write_input_tokens: 0 };
+  for (const u of usages) for (const key of Object.keys(total)) total[key] += Number(u[key]) || 0;
+  return { turnCount: messages.filter(m => m.role === 'user').length, toolCallCount: messages.filter(m => m.type === 'tool_use').length, lastTurn: usages.at(-1) || null, sessionTotals: total };
+}
+
 /** Normalize cwd so /private/tmp and /tmp (etc.) group together on macOS. */
 export function normalizeCwd(cwd) {
   if (!cwd) return null;
@@ -924,15 +1168,18 @@ function publicSession(s) {
     // keep for deep search only when needed — not sent if stripped below
     _filePath: s.filePath || null,
     _sessionDir: s.sessionDir || null,
+    _journalPath: s.journalPath || null,
   };
 }
 
-export async function scanAllSessions({ claudeConfigDirs, codexHome, grokHome, filterCwd, agents }) {
-  const want = new Set(agents || ['claude', 'codex', 'grok']);
+export async function scanAllSessions({ claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome, filterCwd, agents }) {
+  const want = new Set(agents || ['claude', 'codex', 'grok', 'gemini', 'cursor']);
   const tasks = [];
   if (want.has('claude')) tasks.push(scanClaudeSessions(claudeConfigDirs, filterCwd));
   if (want.has('codex'))  tasks.push(scanCodexSessions(codexHome, filterCwd));
   if (want.has('grok'))   tasks.push(scanGrokSessions(grokHome, filterCwd));
+  if (want.has('gemini')) tasks.push(scanGeminiSessions(geminiHome, filterCwd));
+  if (want.has('cursor')) tasks.push(scanCursorSessions(cursorHome, filterCwd));
 
   const results = await Promise.all(tasks);
   const seen = new Set();
@@ -949,7 +1196,7 @@ export async function scanAllSessions({ claudeConfigDirs, codexHome, grokHome, f
 
 /** Strip internal-only fields before sending to clients. */
 export function toClientSession(s) {
-  const { _filePath, _sessionDir, ...rest } = s;
+  const { _filePath, _sessionDir, _journalPath, ...rest } = s;
   return rest;
 }
 
@@ -1060,6 +1307,14 @@ async function peekSessionText(s, query) {
         },
       });
     }
+    if (s.agent === 'gemini') {
+      const file = s._journalPath || await findGeminiJournal(s.sessionId, s.configDir);
+      if (!file) return null;
+      return await scanFileForQuery(file, query, {
+        maxLines: 160,
+        extract: d => (d.type === 'user' ? d.content : d.type === 'assistant_delta' ? d.data : null),
+      });
+    }
     // claude
     const file = await findClaudeSessionFile(s.sessionId, null);
     // findClaudeSessionFile needs config dirs — skip if we don't have path
@@ -1165,8 +1420,26 @@ export function groupByProject(sessions) {
  * Load session history. Returns { messages, context } or null.
  * `context` carries window / token usage when the agent exposes it (Grok signals.json).
  */
-export async function loadSessionMessages(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function loadSessionMessages(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   const a = agent || 'claude';
+  if (a === 'cursor') {
+    const file = await findCursorJournal(sessionId, cursorHome);
+    if (!file) return null;
+    return { messages: await parseGeminiMessages(file), context: await loadCursorContext(sessionId, cursorHome), agent: 'cursor' };
+  }
+  if (a === 'gemini') {
+    const native = await findGeminiNativeTranscript(sessionId, geminiHome);
+    const file = native || await findGeminiJournal(sessionId, geminiHome);
+    if (!file) {
+      const native = (await scanGeminiSessions(geminiHome)).some(s => s.sessionId === sessionId);
+      if (!native) return null;
+      return { messages: [], context: await loadGeminiContext(sessionId, geminiHome), agent: 'gemini' };
+    }
+    return {
+      messages: native ? await parseGeminiNativeMessages(native) : await parseGeminiMessages(file),
+      context: await loadGeminiContext(sessionId, geminiHome), agent: 'gemini',
+    };
+  }
   if (a === 'codex') {
     const file = await findCodexSessionFile(sessionId, codexHome);
     if (!file) return null;
@@ -1183,7 +1456,8 @@ export async function loadSessionMessages(sessionId, agent, { claudeConfigDirs,
   return { messages: await parseClaudeMessages(file), context: null, agent: 'claude' };
 }
 
-export async function loadSessionMemory(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function loadSessionMemory(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
+  if (agent === 'gemini' || agent === 'cursor') return { agent, files: [] };
   if (agent === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     if (!dir) return null;
@@ -1248,6 +1522,7 @@ export async function readSessionMemoryFile(sessionId, agent, fileId, opts) {
   const id = String(fileId || '').replaceAll('\\', '/');
   if (!id || id.startsWith('/') || id.split('/').some(p => p === '..' || !p)) return null;
   let root;
+  if (agent === 'gemini' || agent === 'cursor') return null;
   if (agent === 'codex') root = path.join(opts.codexHome || path.join(os.homedir(), '.codex'), 'memories');
   else if (agent === 'grok') {
     const dir = await findGrokSessionDir(sessionId, opts.grokHome);
@@ -1272,10 +1547,10 @@ export async function readSessionMemoryFile(sessionId, agent, fileId, opts) {
 }
 
 /** Return bounded raw JSONL for a particular agent session, for Meta Agent analysis. */
-export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }, { offset = 0, maxLines = 500 } = {}) {
+export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset = 0, maxLines = 500 } = {}) {
   if (!agent) {
-    for (const candidate of ['claude', 'codex', 'grok']) {
-      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome }, { offset, maxLines });
+    for (const candidate of ['claude', 'codex', 'grok', 'gemini', 'cursor']) {
+      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset, maxLines });
       if (found) return found;
     }
     return null;
@@ -1283,6 +1558,8 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
   const a = (agent || 'claude').toLowerCase();
   let file;
   if (a === 'codex') file = await findCodexSessionFile(sessionId, codexHome);
+  else if (a === 'cursor') file = await findCursorJournal(sessionId, cursorHome);
+  else if (a === 'gemini') file = await findGeminiJournal(sessionId, geminiHome);
   else if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     file = dir ? path.join(dir, 'chat_history.jsonl') : null;
@@ -1304,11 +1581,20 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
   return { agent: a, fileName: path.basename(file), offset: start, lines, nextOffset: start + lines.length, truncated: hasMore, size: stat?.size || 0 };
 }
 
-export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   const a = (agent || 'claude').toLowerCase();
   let cwd = null;
   let display = null;
-  if (a === 'grok') {
+  if (a === 'cursor') {
+    const found = (await scanCursorSessions(cursorHome)).find(s => s.sessionId === sessionId);
+    cwd = found?.cwd || null;
+    display = found?.display || null;
+  } else if (a === 'gemini') {
+    const sessions = await scanGeminiSessions(geminiHome);
+    const found = sessions.find(s => s.sessionId === sessionId);
+    cwd = found?.cwd || null;
+    display = found?.display || null;
+  } else if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     if (dir) {
       try {
@@ -1339,13 +1625,13 @@ export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codex
   return { cwd, display };
 }
 
-export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   // 1. Get meta and messages from source session
-  const meta = await getSessionMeta(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome });
+  const meta = await getSessionMeta(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
   const cwd = meta.cwd || null;
   const display = meta.display || 'Converted Session';
   
-  const bundle = await loadSessionMessages(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome });
+  const bundle = await loadSessionMessages(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
   const messages = bundle.messages || [];
 
   // 2. Generate target session ID
@@ -1353,6 +1639,9 @@ export async function convertSession(sourceSessionId, sourceAgent, targetAgent,
 
   // 3. Serialize messages to the target agent
   const ta = targetAgent.toLowerCase();
+  if (ta === 'gemini' || ta === 'cursor') {
+    throw new Error(`${ta === 'cursor' ? 'Cursor' : 'Gemini'} sessions use native conversation storage and cannot be cloned safely. Start a new session instead.`);
+  }
   
   if (ta === 'claude') {
     const configDir = claudeConfigDirs?.[0] || path.join(os.homedir(), '.claude');