claude-simple 0.2.6 → 0.2.7

package/src/agents/sessions.js

@@ -1187,40 +1187,121 @@ export async function loadSessionMemory(sessionId, agent, { claudeConfigDirs, co
   if (agent === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     if (!dir) return null;
-    // Grok may store memory differently; best-effort empty
-    return { index: null, files: [] };
+    return listMemoryFiles(path.join(dir, 'memory'), 'grok');
   }
   if (agent === 'codex') {
-    return { index: null, files: [] };
+    // Codex memory is account-level rather than nested beneath each rollout.
+    const home = codexHome || path.join(os.homedir(), '.codex');
+    return listMemoryFiles(path.join(home, 'memories'), 'codex', { codexRoot: true });
   }
   const file = await findClaudeSessionFile(sessionId, claudeConfigDirs);
   if (!file) return null;
-  return readProjectMemory(path.dirname(file));
+  const primaryRoot = path.dirname(file);
+  const primary = await listMemoryFiles(primaryRoot, 'claude', { claudeProject: true, rootKind: 'agent-project' });
+  // Some Claude setups keep durable memory in the actual project (cwd/memory)
+  // instead of beside the agent transcript. Expose it when the transcript's
+  // own project directory has no memory files.
+  if (primary.files.length) return primary;
+  const meta = await readClaudeSessionMeta(file);
+  if (!meta.cwd || !path.isAbsolute(meta.cwd)) return primary;
+  return listMemoryFiles(meta.cwd, 'claude', { claudeProject: true, rootKind: 'workspace' });
 }
 
-export async function readProjectMemory(projectDir) {
-  const memoryDir = path.join(projectDir, 'memory');
-  let index = null;
-  try { index = await fs.readFile(path.join(projectDir, 'MEMORY.md'), 'utf8'); }
-  catch {}
-
+async function listMemoryFiles(root, agent, opts = {}) {
   const files = [];
-  let entries = [];
-  try { entries = await fs.readdir(memoryDir, { withFileTypes: true }); }
-  catch {}
-  await Promise.all(
-    entries
-      .filter(e => e.isFile() && e.name.endsWith('.md'))
-      .map(async e => {
-        try {
-          const content = await fs.readFile(path.join(memoryDir, e.name), 'utf8');
-          const stat = await fs.stat(path.join(memoryDir, e.name));
-          files.push({ name: e.name, content, updatedAt: stat.mtimeMs });
-        } catch {}
-      })
-  );
+  const add = async (absolute, id, scope) => {
+    try {
+      const stat = await fs.stat(absolute);
+      if (stat.isFile()) files.push({ id, name: id, agent, scope, updatedAt: stat.mtimeMs, size: stat.size });
+    } catch {}
+  };
+  if (opts.claudeProject) {
+    await add(path.join(root, 'MEMORY.md'), 'MEMORY.md', 'project');
+    let entries = [];
+    try { entries = await fs.readdir(path.join(root, 'memory'), { withFileTypes: true }); } catch {}
+    await Promise.all(entries.filter(e => e.isFile() && e.name.endsWith('.md'))
+      .map(e => add(path.join(root, 'memory', e.name), `memory/${e.name}`, 'project')));
+  } else if (opts.codexRoot) {
+    // Durable Codex memory entry points; rollout summaries and skill packages
+    // remain out of this concise tab.
+    await Promise.all([
+      add(path.join(root, 'MEMORY.md'), 'MEMORY.md', 'account'),
+      add(path.join(root, 'memory_summary.md'), 'memory_summary.md', 'account'),
+    ]);
+    let entries = [];
+    const notes = path.join(root, 'extensions', 'ad_hoc', 'notes');
+    try { entries = await fs.readdir(notes, { withFileTypes: true }); } catch {}
+    await Promise.all(entries.filter(e => e.isFile() && e.name.endsWith('.md'))
+      .map(e => add(path.join(notes, e.name), `extensions/ad_hoc/notes/${e.name}`, 'account')));
+  } else {
+    let entries = [];
+    try { entries = await fs.readdir(root, { withFileTypes: true }); } catch {}
+    await Promise.all(entries.filter(e => e.isFile() && e.name.endsWith('.md'))
+      .map(e => add(path.join(root, e.name), e.name, 'session')));
+  }
   files.sort((a, b) => a.name.localeCompare(b.name));
-  return { index, files };
+  return { agent, files };
+}
+
+/** Read one previously-listed memory file. File ids are relative and validated. */
+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 === 'codex') root = path.join(opts.codexHome || path.join(os.homedir(), '.codex'), 'memories');
+  else if (agent === 'grok') {
+    const dir = await findGrokSessionDir(sessionId, opts.grokHome);
+    if (!dir) return null;
+    root = path.join(dir, 'memory');
+  } else {
+    const file = await findClaudeSessionFile(sessionId, opts.claudeConfigDirs);
+    if (!file) return null;
+    root = path.dirname(file);
+    // Match the same workspace fallback used by loadSessionMemory.
+    const primary = await listMemoryFiles(root, 'claude', { claudeProject: true, rootKind: 'agent-project' });
+    if (!primary.files.length) {
+      const meta = await readClaudeSessionMeta(file);
+      if (meta.cwd && path.isAbsolute(meta.cwd)) root = meta.cwd;
+    }
+  }
+  const listed = await loadSessionMemory(sessionId, agent, opts);
+  const meta = listed?.files?.find(f => f.id === id);
+  if (!meta) return null;
+  try { return { ...meta, content: await fs.readFile(path.resolve(root, id), 'utf8') }; }
+  catch { return null; }
+}
+
+/** 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 } = {}) {
+  if (!agent) {
+    for (const candidate of ['claude', 'codex', 'grok']) {
+      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome }, { offset, maxLines });
+      if (found) return found;
+    }
+    return null;
+  }
+  const a = (agent || 'claude').toLowerCase();
+  let file;
+  if (a === 'codex') file = await findCodexSessionFile(sessionId, codexHome);
+  else if (a === 'grok') {
+    const dir = await findGrokSessionDir(sessionId, grokHome);
+    file = dir ? path.join(dir, 'chat_history.jsonl') : null;
+  } else file = await findClaudeSessionFile(sessionId, claudeConfigDirs);
+  if (!file) return null;
+  const start = Math.max(0, Number(offset) || 0);
+  const limit = Math.min(Math.max(1, Number(maxLines) || 500), 2000);
+  const lines = [];
+  let n = 0;
+  let hasMore = false;
+  const stream = fsSync.createReadStream(file, { encoding: 'utf8' });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (n++ < start) continue;
+    if (lines.length >= limit) { hasMore = true; rl.close(); stream.destroy(); break; }
+    lines.push(line);
+  }
+  const stat = await fs.stat(file).catch(() => null);
+  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 }) {
@@ -1505,4 +1586,3 @@ export async function convertSession(sourceSessionId, sourceAgent, targetAgent,
 
   return { targetSessionId };
 }
-

package/src/app.js

@@ -18,6 +18,8 @@ import {
   scanAllSessions,
   loadSessionMessages,
   loadSessionMemory,
+  readSessionMemoryFile,
+  loadSessionJsonl,
   loadSessionUsage,
   searchActivity,
   groupByProject,
@@ -1008,19 +1010,37 @@ export function createApp() {
         codexHome: CODEX_HOME,
         grokHome: GROK_HOME,
       };
-      const order = [...new Set([preferred, ...ENABLED_AGENTS, 'claude', 'codex', 'grok'].filter(Boolean))];
+      // A selected session already knows its agent. Do not fall back to another
+      // agent's account-level memory (especially Codex) when that session has none.
+      const order = preferred
+        ? [preferred]
+        : [...new Set([...ENABLED_AGENTS, 'claude', 'codex', 'grok'])];
       let memory = null;
       for (const a of order) {
         memory = await loadSessionMemory(sessionId, a, opts);
         if (memory) break;
       }
-      // Memory is Claude-centric; return empty instead of 404 so the tab doesn't hard-fail
-      res.json(memory || { index: null, files: [] });
+      res.json(memory || { agent: preferred || null, files: [] });
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
   });
 
+  app.get('/api/sessions/:sessionId/memory/file', authMiddleware, async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      const agent = typeof req.query.agent === 'string' ? req.query.agent : 'claude';
+      const file = typeof req.query.file === 'string' ? req.query.file : '';
+      if (!/^[0-9a-f-]{36}$/i.test(sessionId)) return res.status(400).json({ error: 'Invalid session id' });
+      const row = await readSessionMemoryFile(sessionId, agent, file, {
+        claudeConfigDirs: CLAUDE_CONFIG_DIRS, codexHome: CODEX_HOME, grokHome: GROK_HOME,
+      });
+      if (!row) return res.status(404).json({ error: 'Memory file not found' });
+      res.setHeader('Cache-Control', 'private, max-age=30');
+      res.json(row);
+    } catch (e) { res.status(500).json({ error: e.message }); }
+  });
+
   app.get('/api/projects/:id/git/log', authMiddleware, async (req, res) => {
     try {
       const projectPath = resolveProjectRoot(req);
@@ -1044,10 +1064,12 @@ export function createApp() {
     listSessions,
     searchActivity,
     loadSessionMessages,
+    loadSessionJsonl,
     groupByProject,
     toClientSession,
     getProjectNotesStore: loadProjectNotes,
     saveProjectNotesStore: saveProjectNotes,
+    getSessionMetaStore: loadSessionMeta,
     normalizeProjectEntry,
     git,
     isGitRepo,
@@ -1122,6 +1144,50 @@ export function createApp() {
     }
   });
 
+  app.get('/api/ai/notes', authMiddleware, async (req, res) => {
+    try {
+      const limit = Math.min(parseInt(req.query.limit || '30', 10) || 30, 200);
+      const scope = typeof req.query.scope === 'string' ? req.query.scope : 'all';
+      const q = typeof req.query.q === 'string' ? req.query.q : '';
+      const cwd = typeof req.query.cwd === 'string' ? req.query.cwd : '';
+      const sessionId = typeof req.query.sessionId === 'string' ? req.query.sessionId : '';
+      const agent = typeof req.query.agent === 'string' ? req.query.agent : '';
+      res.json({
+        notes: await meta.listMetaNotes({ limit, scope, q, cwd, sessionId, agent }),
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.get('/api/ai/notes/:id', authMiddleware, async (req, res) => {
+    try {
+      const note = await meta.getMetaNote(req.params.id);
+      if (!note) return res.status(404).json({ error: 'not found' });
+      res.json(note);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post('/api/ai/notes', authMiddleware, async (req, res) => {
+    try {
+      const note = await meta.saveMetaNote(req.body || {});
+      res.json(note);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.delete('/api/ai/notes/:id', authMiddleware, async (req, res) => {
+    try {
+      const result = await meta.deleteMetaNote(req.params.id);
+      res.json(result);
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   // SSE: generate work report
   app.post('/api/ai/report', authMiddleware, async (req, res) => {
     res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
@@ -1392,24 +1458,35 @@ export function createApp() {
         if (cmd.sessionId) options.sessionId = cmd.sessionId;
         if (cmd.cwd) options.cwd = cmd.cwd;
         if (options.sessionId) client.sessionId = options.sessionId;
-        const agentSend = createAgentSend(outbox, agent);
+        // A socket may subscribe to another session while this agent is still
+        // streaming. Keep this run's delivery target in its own closure rather
+        // than consulting mutable client.sessionId in the shared socket outbox.
+        let runSessionId = options.sessionId || client.sessionId || null;
+        const runOutbox = createOutbox((data) => {
+          broadcastChat(runSessionId, data, ws);
+        }, {
+          maxWait: 48,
+          maxDeltaChars: 720,
+          maxBatchItems: 10,
+          maxBatchBytes: 10_000,
+        });
+        const agentSend = createAgentSend(runOutbox, agent);
         const runSend = (data) => {
+          if (data?.sessionId) runSessionId = data.sessionId;
           if (data?.type === 'result' || data?.type === 'complete' || data?.type === 'error') {
-            markSessionIdle(data.sessionId || client.sessionId, options.sessionId);
-            outbox.flush();
+            markSessionIdle(data.sessionId || runSessionId, options.sessionId);
+            runOutbox.flush();
           }
-          if (data?.sessionId) client.sessionId = data.sessionId;
-          if (data?.type === 'session-created' && data.sessionId) client.sessionId = data.sessionId;
           // permission_request bypasses map filter double-pass carefully
           if (data?.type === 'permission_request' || data?.type === 'permission_resolved') {
-            outbox.send(data);
-            outbox.flush();
+            runOutbox.send(data);
+            runOutbox.flush();
             return;
           }
           agentSend(data);
         };
         await dispatchAgent(agent, cmd.command || '', options, runSend);
-        outbox.flush();
+        runOutbox.flush();
         return;
       }