claude-simple 0.2.6 → 0.2.8

package/src/agents/meta-agent.js

@@ -41,7 +41,7 @@ export const AI_DEFAULTS = {
 export const DEFAULT_SYSTEM = `你是 Claude Simple UI 的内置工作助手（Meta Agent）。你能访问本机上的 Claude / Codex / Grok 会话、项目笔记、Git 与文件，并生成「我做了啥」的工作报告。
 
 规则：
-1. 需要会话 id / 项目路径时，先 list_projects 或 search_activity / list_sessions，再深入 get_session_summary。
+1. 需要会话 id / 项目路径时，先 list_projects 或 search_activity / list_sessions，再深入 get_session_brief / get_session_summary。超长会话先读 get_session_brief；只有需要逐事件定位问题时才读 get_session_jsonl。
 2. 回答要具体：引用项目路径、会话标题、时间范围；不确定就再查。
 3. 写日报/周报用 generate_activity_digest 拉快照，再组织成清晰 Markdown（亮点、按项目、未完成、建议）。
 4. 改文件或跑命令前说明意图；危险命令拒绝（rm -rf /、格式化磁盘等）。
@@ -133,6 +133,39 @@ const TOOLS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'get_session_brief',
+      description: '读取会话压缩上下文，适合非常长的 session；包含项目/会话备注、关键用户意图与最近进展',
+      parameters: {
+        type: 'object',
+        required: ['sessionId'],
+        properties: {
+          sessionId: { type: 'string' },
+          agent: { type: 'string' },
+          maxTurns: { type: 'integer', description: '默认 6，返回多少个采样转折点' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'get_session_jsonl',
+      description: '读取 Claude/Codex/Grok 指定会话的原始 JSONL 行，用于逐事件、工具调用或失败原因分析；内容可能敏感，只在当前回答中使用',
+      parameters: {
+        type: 'object',
+        required: ['sessionId'],
+        properties: {
+          sessionId: { type: 'string' },
+          agent: { type: 'string', enum: ['claude', 'codex', 'grok'], description: '建议明确指定来源 agent' },
+          offset: { type: 'integer', description: '从第几行开始，默认 0' },
+          maxLines: { type: 'integer', description: '每次最多 2000 行，默认 500' },
+        },
+      },
+    },
+  },
   {
     type: 'function',
     function: {
@@ -161,6 +194,62 @@ const TOOLS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'list_meta_notes',
+      description: '列出 Meta Notes（Hub 侧持久化工作笔记）',
+      parameters: {
+        type: 'object',
+        properties: {
+          scope: { type: 'string', enum: ['all', 'project', 'session', 'general'], description: '默认 all' },
+          q: { type: 'string', description: '按标题/正文搜索' },
+          cwd: { type: 'string', description: '按项目路径过滤' },
+          sessionId: { type: 'string', description: '按 session 过滤' },
+          agent: { type: 'string', description: 'session 过滤时可指定 agent' },
+          limit: { type: 'integer', description: '默认 30' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'save_meta_note',
+      description: '创建或更新一条 Meta Note，可关联项目或 session',
+      parameters: {
+        type: 'object',
+        required: ['title', 'content'],
+        properties: {
+          id: { type: 'string' },
+          title: { type: 'string' },
+          content: { type: 'string' },
+          cwd: { type: 'string' },
+          sessionId: { type: 'string' },
+          agent: { type: 'string' },
+          pinned: { type: 'boolean' },
+          tags: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'delete_meta_note',
+      description: '删除一条 Meta Note',
+      parameters: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+          id: { type: 'string' },
+        },
+      },
+    },
+  },
   {
     type: 'function',
     function: {
@@ -399,10 +488,12 @@ export function createMetaAgent(deps) {
     listSessions,
     searchActivity,
     loadSessionMessages,
+    loadSessionJsonl,
     groupByProject,
     toClientSession,
     getProjectNotesStore,
     saveProjectNotesStore,
+    getSessionMetaStore,
     normalizeProjectEntry,
     git,
     isGitRepo,
@@ -417,6 +508,8 @@ export function createMetaAgent(deps) {
   const aiDir = process.env.AI_DATA_DIR
     ? expandPath(process.env.AI_DATA_DIR)
     : path.join(rootDir, '.ai');
+  const notesFile = path.join(aiDir, 'meta-notes.json');
+  const sessionBriefsFile = path.join(aiDir, 'session-briefs.json');
   const sessionsDir = path.join(aiDir, 'sessions');
   /** @deprecated global vlm — only for one-time migration */
   const legacyGlobalVlmDir = path.join(aiDir, 'vlm');
@@ -461,6 +554,8 @@ export function createMetaAgent(deps) {
 
   let configCache = null;
   let reportsCache = null;
+  let notesCache = null;
+  let sessionBriefsCache = null;
   /** @type {{ version: number, sessions: Array<{id,title,createdAt,updatedAt,messageCount}> } | null} */
   let sessionsIndexCache = null;
   /** in-memory cache of full sessions (id → session) */
@@ -477,6 +572,42 @@ export function createMetaAgent(deps) {
     await fs.mkdir(sessionsDir, { recursive: true });
   }
 
+  async function loadNotesStore() {
+    if (notesCache) return notesCache;
+    await ensureAiDirs();
+    try {
+      const raw = JSON.parse(await fs.readFile(notesFile, 'utf8'));
+      notesCache = {
+        version: raw.version || 1,
+        notes: Array.isArray(raw.notes) ? raw.notes : [],
+      };
+    } catch {
+      notesCache = { version: 1, notes: [] };
+    }
+    return notesCache;
+  }
+
+  async function saveNotesStore() {
+    if (!notesCache) return;
+    await atomicWriteJson(notesFile, notesCache);
+  }
+
+  async function loadSessionBriefsStore() {
+    if (sessionBriefsCache) return sessionBriefsCache;
+    await ensureAiDirs();
+    try {
+      sessionBriefsCache = JSON.parse(await fs.readFile(sessionBriefsFile, 'utf8'));
+    } catch {
+      sessionBriefsCache = {};
+    }
+    return sessionBriefsCache;
+  }
+
+  async function saveSessionBriefsStore() {
+    if (!sessionBriefsCache) return;
+    await atomicWriteJson(sessionBriefsFile, sessionBriefsCache);
+  }
+
   async function atomicWriteText(filePath, text) {
     await fs.mkdir(path.dirname(filePath), { recursive: true });
     const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
@@ -918,6 +1049,178 @@ export function createMetaAgent(deps) {
     return '';
   }
 
+  function extractRoleText(message) {
+    if (!message) return '';
+    const text = extractTextParts(message.content ?? message.message?.content ?? message.text);
+    return String(text || '').replace(/\s+/g, ' ').trim();
+  }
+
+  function pickSample(items, count) {
+    if (!Array.isArray(items) || !items.length) return [];
+    if (items.length <= count) return items.slice();
+    const out = [];
+    const last = items.length - 1;
+    for (let i = 0; i < count; i += 1) {
+      const idx = Math.round((i * last) / Math.max(1, count - 1));
+      out.push(items[idx]);
+    }
+    return out.filter((item, i, arr) => i === arr.findIndex((x) => x === item));
+  }
+
+  async function listMetaNotes(query = {}) {
+    const store = await loadNotesStore();
+    const scope = query.scope || 'all';
+    const q = String(query.q || '').trim().toLowerCase();
+    const cwd = query.cwd ? expandPath(query.cwd) : '';
+    const sessionId = String(query.sessionId || '').trim();
+    const agent = String(query.agent || '').trim();
+    const limit = Math.min(query.limit || 30, 200);
+    let rows = [...store.notes];
+    if (scope !== 'all') rows = rows.filter((n) => n.scope === scope);
+    if (cwd) rows = rows.filter((n) => n.cwd === cwd);
+    if (sessionId) rows = rows.filter((n) => n.sessionId === sessionId);
+    if (agent) rows = rows.filter((n) => n.agent === agent);
+    if (q) {
+      rows = rows.filter((n) => `${n.title || ''}\n${n.content || ''}\n${(n.tags || []).join(' ')}`.toLowerCase().includes(q));
+    }
+    rows.sort((a, b) => {
+      if (!!b.pinned !== !!a.pinned) return Number(b.pinned) - Number(a.pinned);
+      return (b.updatedAt || 0) - (a.updatedAt || 0);
+    });
+    return rows.slice(0, limit);
+  }
+
+  async function getMetaNote(id) {
+    if (!id) return null;
+    const store = await loadNotesStore();
+    return store.notes.find((n) => n.id === id) || null;
+  }
+
+  async function saveMetaNote(input = {}) {
+    const store = await loadNotesStore();
+    const now = Date.now();
+    const id = input.id ? String(input.id) : crypto.randomUUID();
+    const cwd = input.cwd ? expandPath(input.cwd) : '';
+    const sessionId = String(input.sessionId || '').trim();
+    const agent = String(input.agent || '').trim() || (sessionId ? 'claude' : '');
+    const scope = sessionId ? 'session' : cwd ? 'project' : 'general';
+    const tags = Array.isArray(input.tags)
+      ? [...new Set(input.tags.map((x) => String(x || '').trim()).filter(Boolean))].slice(0, 12)
+      : [];
+    const prev = store.notes.find((n) => n.id === id);
+    const note = {
+      id,
+      scope,
+      title: String(input.title || '').trim().slice(0, 200),
+      content: String(input.content || '').trim(),
+      cwd,
+      sessionId,
+      agent,
+      pinned: Boolean(input.pinned),
+      tags,
+      createdAt: prev?.createdAt || now,
+      updatedAt: now,
+    };
+    if (!note.title) throw new Error('title required');
+    if (!note.content) throw new Error('content required');
+    if (prev) {
+      const idx = store.notes.findIndex((n) => n.id === id);
+      store.notes[idx] = note;
+    } else {
+      store.notes.unshift(note);
+    }
+    await saveNotesStore();
+    return note;
+  }
+
+  async function deleteMetaNote(id) {
+    if (!id) return { ok: false };
+    const store = await loadNotesStore();
+    const next = store.notes.filter((n) => n.id !== id);
+    const changed = next.length !== store.notes.length;
+    store.notes = next;
+    if (changed) await saveNotesStore();
+    return { ok: changed };
+  }
+
+  async function getSessionMetaNote(sessionId, agent) {
+    if (!sessionId || !getSessionMetaStore) return null;
+    const db = await getSessionMetaStore();
+    const key = `${agent || 'claude'}:${sessionId}`;
+    return db?.[key] || null;
+  }
+
+  async function findSessionRecord(sessionId, preferredAgent = null) {
+    const sessions = await listSessions(null, preferredAgent || null);
+    let hit = sessions.find((s) => s.sessionId === sessionId && (!preferredAgent || s.agent === preferredAgent));
+    if (!hit && !preferredAgent) hit = sessions.find((s) => s.sessionId === sessionId);
+    return hit || null;
+  }
+
+  async function buildSessionBrief(args = {}) {
+    const sessionId = args.sessionId || args.id;
+    if (!sessionId) return { error: 'sessionId required' };
+    const maxTurns = Math.min(args.maxTurns || 6, 12);
+    const record = await findSessionRecord(sessionId, args.agent || null);
+    const resolvedAgent = record?.agent || args.agent || null;
+    const updatedAt = record?.updatedAt || 0;
+    const cacheKey = `${resolvedAgent || '*'}:${sessionId}`;
+    const cache = await loadSessionBriefsStore();
+    const cached = cache[cacheKey];
+    if (cached && cached.updatedAt === updatedAt && cached.maxTurns === maxTurns) return cached.brief;
+
+    const bundle = await loadSessionMessages(sessionId, resolvedAgent, sessionOpts());
+    if (!bundle) return { error: 'session not found' };
+    const msgs = Array.isArray(bundle) ? bundle : (bundle.messages || []);
+    const userTurns = [];
+    const assistantTurns = [];
+    for (const m of msgs) {
+      const role = m.role || m.type;
+      if (role !== 'user' && role !== 'assistant') continue;
+      const text = extractRoleText(m);
+      if (!text || text.startsWith('Caveat:') || text.startsWith('<command-')) continue;
+      const row = { role, text: shortTitle(text, role === 'user' ? 260 : 220) };
+      if (role === 'user') userTurns.push(row);
+      else assistantTurns.push(row);
+    }
+    const checkpoints = pickSample(userTurns, maxTurns).map((turn, idx) => ({
+      index: idx + 1,
+      prompt: turn.text,
+    }));
+    const cwd = record?.cwd || null;
+    const projectNotesStore = cwd ? await getProjectNotesStore() : null;
+    const projectNotes = cwd ? normalizeProjectEntry(projectNotesStore?.[cwd] || {}) : { goal: '', notes: '' };
+    const sessionMeta = await getSessionMetaNote(sessionId, resolvedAgent || 'claude');
+    const linkedNotes = await listMetaNotes({ scope: 'session', sessionId, agent: resolvedAgent || undefined, limit: 8 });
+    const brief = {
+      sessionId,
+      agent: Array.isArray(bundle) ? resolvedAgent : (bundle.agent || resolvedAgent),
+      cwd,
+      projectName: record?.projectName || (cwd ? path.basename(cwd) : ''),
+      title: shortTitle(record?.display || record?.title || sessionId, 120),
+      updatedAt,
+      totalMessages: msgs.length,
+      userTurnCount: userTurns.length,
+      assistantTurnCount: assistantTurns.length,
+      firstUserPrompt: userTurns[0]?.text || '',
+      latestUserPrompt: userTurns[userTurns.length - 1]?.text || '',
+      latestAssistantReply: assistantTurns[assistantTurns.length - 1]?.text || '',
+      checkpoints,
+      projectGoal: projectNotes.goal || '',
+      projectNotes: projectNotes.notes ? shortTitle(projectNotes.notes, 300) : '',
+      sessionNote: (sessionMeta?.notes || '').trim(),
+      linkedNotes: linkedNotes.map((n) => ({
+        id: n.id,
+        title: n.title,
+        content: shortTitle(n.content, 240),
+        updatedAt: n.updatedAt,
+      })),
+    };
+    cache[cacheKey] = { updatedAt, maxTurns, brief, cachedAt: Date.now() };
+    await saveSessionBriefsStore();
+    return brief;
+  }
+
   function indexEntryFromSession(s) {
     return {
       id: s.id,
@@ -1441,6 +1744,20 @@ export function createMetaAgent(deps) {
           messages: summary,
         };
       }
+      case 'get_session_brief': {
+        return buildSessionBrief(args);
+      }
+      case 'get_session_jsonl': {
+        const sid = args.sessionId || args.id;
+        if (!sid) return { error: 'sessionId required' };
+        if (!loadSessionJsonl) return { error: 'raw session reader unavailable' };
+        const result = await loadSessionJsonl(sid, args.agent || null, sessionOpts(), {
+          offset: args.offset,
+          maxLines: args.maxLines,
+        });
+        if (!result) return { error: 'session JSONL not found' };
+        return result;
+      }
       case 'get_project_notes': {
         const store = await getProjectNotesStore();
         const cwd = expandPath(args.cwd);
@@ -1457,6 +1774,15 @@ export function createMetaAgent(deps) {
         await saveProjectNotesStore();
         return { ok: true, cwd, ...cur };
       }
+      case 'list_meta_notes': {
+        return listMetaNotes(args);
+      }
+      case 'save_meta_note': {
+        return saveMetaNote(args);
+      }
+      case 'delete_meta_note': {
+        return deleteMetaNote(args.id);
+      }
       case 'git_status': {
         const cwd = expandPath(args.cwd);
         if (!(await isGitRepo(cwd))) return { isGit: false };
@@ -1975,6 +2301,11 @@ export function createMetaAgent(deps) {
         .slice(0, limit);
     },
     buildDigest,
+    listMetaNotes,
+    getMetaNote,
+    saveMetaNote,
+    deleteMetaNote,
+    buildSessionBrief,
     executeTool,
     runLoop,
     resolveApproval,

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 };
 }
-