memhouse 0.18.12 → 0.20.1

package/editors/claude.js

@@ -5,7 +5,7 @@ const adapterErrors = require('./adapter-errors');
 
 const HOME = os.homedir();
 
-// Discover all Claude Code config roots — ports memory-house agent-sync's
+// Discover all Claude Code config roots — ports the predecessor tool's
 // discover_roots("claude-code"). Claude sessions don't live only under ~/.claude:
 // every CLAUDE_CONFIG_DIR (e.g. playbook installs under
 // ~/.claude-playbooks/<name>[/playbook]) has its own projects/ dir. A dir qualifies
@@ -430,108 +430,6 @@ function extractAssistantContent(content) {
   return { text: parts.join('\n') || '', toolCalls };
 }
 
-// ============================================================
-// Usage / quota data from Anthropic OAuth API
-// ============================================================
-
-function getClaudeCredentials() {
-  // macOS: Keychain; Linux: secret-tool; Windows: not yet supported
-  // Requires explicit user permission (allowSubscriptionAccess in config)
-  const { isSubscriptionAccessAllowed } = require('./base');
-  if (!isSubscriptionAccessAllowed()) return null;
-  try {
-    const { execSync } = require('child_process');
-    let raw;
-    if (process.platform === 'darwin') {
-      raw = execSync('security find-generic-password -s "Claude Code-credentials" -w', { encoding: 'utf-8', timeout: 5000 }).trim();
-    } else if (process.platform === 'linux') {
-      raw = execSync('secret-tool lookup service "Claude Code-credentials"', { encoding: 'utf-8', timeout: 5000 }).trim();
-    } else {
-      return null;
-    }
-    const creds = JSON.parse(raw);
-    const oauth = creds.claudeAiOauth;
-    if (!oauth || !oauth.accessToken) return null;
-    return oauth;
-  } catch { return null; }
-}
-
-function claudeApiFetch(token) {
-  return new Promise((resolve) => {
-    const https = require('https');
-    const req = https.get('https://api.anthropic.com/api/oauth/usage', {
-      headers: {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-        'User-Agent': 'agentlytics/1.0',
-        'Authorization': `Bearer ${token}`,
-        'anthropic-beta': 'oauth-2025-04-20',
-      },
-      timeout: 10000,
-    }, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        try { resolve(JSON.parse(data)); } catch { resolve(null); }
-      });
-    });
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
-  });
-}
-
-async function getUsage() {
-  const creds = getClaudeCredentials();
-  if (!creds) return null;
-
-  const usage = await claudeApiFetch(creds.accessToken);
-  if (!usage) return null;
-
-  const result = {
-    source: 'claude-code',
-    plan: {
-      name: creds.subscriptionType || null,
-    },
-    usage: {},
-    extraUsage: null,
-  };
-
-  if (usage.five_hour) {
-    result.usage.fiveHour = {
-      utilization: usage.five_hour.utilization,
-      resetsAt: usage.five_hour.resets_at || null,
-    };
-  }
-  if (usage.seven_day) {
-    result.usage.sevenDay = {
-      utilization: usage.seven_day.utilization,
-      resetsAt: usage.seven_day.resets_at || null,
-    };
-  }
-  if (usage.seven_day_sonnet) {
-    result.usage.sevenDaySonnet = {
-      utilization: usage.seven_day_sonnet.utilization,
-      resetsAt: usage.seven_day_sonnet.resets_at || null,
-    };
-  }
-  if (usage.seven_day_opus) {
-    result.usage.sevenDayOpus = {
-      utilization: usage.seven_day_opus.utilization,
-      resetsAt: usage.seven_day_opus.resets_at || null,
-    };
-  }
-  if (usage.extra_usage) {
-    result.extraUsage = {
-      isEnabled: usage.extra_usage.is_enabled || false,
-      monthlyLimit: usage.extra_usage.monthly_limit || null,
-      usedCredits: usage.extra_usage.used_credits || null,
-      utilization: usage.extra_usage.utilization || null,
-    };
-  }
-
-  return result;
-}
-
 const labels = { 'claude-code': 'Claude Code' };
 
 function getArtifacts(folder) {
@@ -554,8 +452,278 @@ function getMCPServers() {
   return results;
 }
 
+// <derive> ====================================================================================
+// Capture (schema v3) — docs/design/source-identity.md draft 5, §2 and §5. Fingerprinted by
+// misc/capture-test.js: change anything in this region and bump CLAUDE_DERIVE_VERSION.
+//
+//   message_id  the record `uuid` (+ `part`, the block index); '@<byte offset>' for records
+//               that have none (summary)
+//   ts          the record `timestamp`; else first-seen, stored once
+//   tokens      on ONE row per message.id: the first row of the response. A response is the
+//               open unit until the next one starts; a later record of it reporting more usage
+//               re-emits that row at a higher rev. Never per record (that doubled the totals).
+//   agent_id    '' for the main conversation, the sub-agent's id for subagents/**/agent-<id>.jsonl
+// Version 2: layout 3.2 (part_id/part_ord, harness_path, full tool output). Version 3: no derive change: comment wording in the shared capture region.
+const CLAUDE_DERIVE_VERSION = 3;
+
+function cRespId(rec) {
+  const m = rec.obj && rec.obj.message;
+  return (m && typeof m.id === 'string' && m.id) ? m.id : `@${rec.pos}`;
+}
+function cUsage(u) {
+  if (!u || typeof u !== 'object') return null;
+  const n = (v) => { const x = Math.trunc(Number(v)); return Number.isFinite(x) && x > 0 ? x : 0; };
+  return {
+    input_tokens: n(u.input_tokens), output_tokens: n(u.output_tokens),
+    cache_read_tokens: n(u.cache_read_input_tokens), cache_write_tokens: n(u.cache_creation_input_tokens),
+    reasoning_tokens: 0,
+  };
+}
+function cUsageTotal(u) { return u ? u.input_tokens + u.output_tokens + u.cache_read_tokens + u.cache_write_tokens : -1; }
+function cBlockText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return content == null ? '' : JSON.stringify(content);
+  return content.map((x) => (x && typeof x.text === 'string') ? x.text : '').filter(Boolean).join('\n');
+}
+// A prompt that is only an envelope (a command, a caveat, a reminder) is not the session's first prompt.
+function cMeaningful(text) {
+  const t = String(text || '')
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+    .replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, '')
+    .replace(/<command-(name|message|args|contents|stdout|stderr)>[\s\S]*?<\/command-\1>/g, '')
+    .replace(/<[^>]+>/g, '').trim();
+  return t.length > 0 && !/^Caveat: The messages below were generated by the user/i.test(t);
+}
+
+const claudeDeriveAdapter = {
+  harness: 'claude-code',
+  deriveVersion: CLAUDE_DERIVE_VERSION,
+  initState() { return { u: { resp: null }, model: '', effort: '', version: '', folder: '', cur: null, closed: [], agentCalls: {} }; },
+  unitStart(rec, u) { return !!rec.obj && rec.obj.type === 'assistant' && cRespId(rec) !== u.resp; },
+  track(rec, u) { if (rec.obj && rec.obj.type === 'assistant') u.resp = cRespId(rec); },
+
+  closeUnit(d) {
+    const cur = d.a.cur;
+    if (!cur) return;
+    claudeDeriveAdapter.usageRowIfNeeded(d, cur);
+    // Kept for a response that resumes after another one (interleaved sidechain records): its
+    // anchor can still be re-emitted with the larger usage. Small and bounded.
+    const keep = { id: cur.id, usage: cur.usage, anchor: cur.anchorRow && cur.anchorRow.text_len <= 4000 ? { ...cur.anchorRow } : null };
+    d.a.closed = [...(d.a.closed || []).filter((x) => x.id !== cur.id), keep].slice(-4);
+    d.a.cur = null;
+  },
+  openUnit(d, rec) {
+    const id = cRespId(rec);
+    const was = (d.a.closed || []).find((x) => x.id === id);
+    d.a.closed = (d.a.closed || []).filter((x) => x.id !== id);
+    d.a.cur = was
+      ? { id, usage: was.usage, anchorRow: was.anchor, first: null, reopened: true }
+      : { id, usage: null, anchorRow: null, first: { pos: rec.pos, uuid: rec.obj.uuid || `@${rec.pos}`, ts: null } };
+  },
+  endReplay(d) { if (d.a.cur) claudeDeriveAdapter.usageRowIfNeeded(d, d.a.cur); },
+
+  // A response that reported usage but produced no row still has its tokens: they go on a
+  // kind = 'usage' row keyed by the response's first record.
+  usageRowIfNeeded(d, cur) {
+    if (cur.anchorRow || !cur.usage || !cur.first || cUsageTotal(cur.usage) <= 0) return;
+    const rec = { pos: cur.first.pos, capturedAt: cur.first.capturedAt };
+    const row = d.turn(rec, {
+      message_id: cur.first.uuid, part: 0, role: 'assistant', kind: 'usage', text: '', ts: cur.first.ts,
+      response_id: cur.id, model: cur.first.model, effort: cur.first.effort, parent_id: cur.first.parent,
+      agent_id: cur.first.agent_id,
+    });
+    const next = d.revise(row, cur.usage, { pos: cur.lastUsagePos || cur.first.pos });
+    cur.anchorRow = next;
+  },
+
+  process(d, rec) {
+    const o = rec.obj;
+    const a = d.a;
+    if (typeof o.version === 'string' && o.version) { a.version = o.version; d.c.meta.version = o.version; }
+    if (typeof o.cwd === 'string' && o.cwd) {
+      a.folder = o.cwd;
+      if (!d.c.meta.folder) d.c.meta.folder = o.cwd;
+    }
+    if (typeof o.gitBranch === 'string' && o.gitBranch) d.c.meta.git_branch = o.gitBranch;
+    const effort = typeof o.effort === 'string' ? o.effort
+      : (o.message && typeof o.message.effort === 'string' ? o.message.effort : null);
+    if (effort !== null) a.effort = effort;
+    const agentId = d.file.agent_id || (o.isSidechain && typeof o.agentId === 'string' ? o.agentId : '');
+    const uuid = typeof o.uuid === 'string' && o.uuid ? o.uuid : `@${rec.pos}`;
+    const parent = typeof o.parentUuid === 'string' ? o.parentUuid : '';
+    const tsMs = parseTsC(o.timestamp);
+
+    // Session names: the user's own title wins over Claude Code's generated one (the latest of each).
+    if (o.type === 'custom-title' && typeof o.customTitle === 'string') { d.c.meta.title = o.customTitle; return; }
+    if (o.type === 'ai-title' && typeof o.aiTitle === 'string') { d.c.meta.ai_title = o.aiTitle; return; }
+    if (o.type === 'agent-name' && typeof o.agentName === 'string') { d.c.meta.agent_name = o.agentName; return; }
+    if (o.type === 'summary') {
+      d.turn(rec, { message_id: `@${rec.pos}`, part: 0, role: 'system', kind: 'summary', text: o.summary || '', ts: d.tsOf(rec, tsMs), agent_id: agentId });
+      return;
+    }
+    if (o.type === 'system') {
+      const inMsg = o.message && typeof o.message.content === 'string';
+      const text = inMsg ? o.message.content : (typeof o.content === 'string' ? o.content : '');
+      if (!text && !o.subtype) return;
+      d.turn(rec, {
+        message_id: uuid, part: 0, role: 'system', kind: inMsg ? 'text' : 'event', text, parent_id: parent,
+        ts: d.tsOf(rec, tsMs), agent_id: agentId, extra: o.subtype ? { subtype: String(o.subtype) } : {},
+      });
+      return;
+    }
+    if (o.type === 'user' && o.message) {
+      const ts = d.tsOf(rec, tsMs);
+      const content = o.message.content;
+      const blocks = typeof content === 'string' ? [{ type: 'text', text: content }] : (Array.isArray(content) ? content : []);
+      blocks.forEach((b, i) => {
+        if (!b || i > 255) return;
+        if (b.type === 'text') {
+          const extra = o.isMeta ? { meta: true } : (o.isCompactSummary ? { compact_summary: true } : {});
+          d.turn(rec, { message_id: uuid, part: i, role: 'user', kind: 'text', text: b.text || '', parent_id: parent, ts, agent_id: agentId, extra });
+          if (!o.isMeta && !o.isCompactSummary && cMeaningful(b.text)) {
+            if (!agentId && !d.c.meta.first_prompt) d.c.meta.first_prompt = String(b.text).slice(0, 2000);
+            if (agentId && !d.c.meta.agent_prompt) d.c.meta.agent_prompt = String(b.text).replace(/\s+/g, ' ').trim().slice(0, 160);
+          }
+          claudeDeriveAdapter.noteNotification(d, b.text);
+        } else if (b.type === 'tool_result') {
+          const text = cBlockText(b.content);
+          d.turn(rec, { message_id: uuid, part: i, role: 'tool', kind: 'tool_result', text, parent_id: parent, ts, agent_id: agentId, extra: { tool_use_id: String(b.tool_use_id || '') } });
+          d.result(rec, b.tool_use_id, { ts, is_error: b.is_error === true, result_len: text.length });
+          const info = a.agentCalls && a.agentCalls[b.tool_use_id];
+          if (info) {
+            const m = /agentId:\s*([0-9a-z][0-9a-z_-]{5,})/i.exec(text);
+            if (m) claudeDeriveAdapter.nameAgent(d, m[1], info);
+          }
+        }
+      });
+      return;
+    }
+    if (o.type === 'assistant' && o.message) {
+      const msg = o.message;
+      const ts = d.tsOf(rec, tsMs);
+      const model = typeof msg.model === 'string' ? msg.model : '';
+      const cur = a.cur || (a.cur = { id: cRespId(rec), usage: null, anchorRow: null, first: { pos: rec.pos, uuid, ts: null } });
+      if (cur.first && cur.first.pos === rec.pos) Object.assign(cur.first, { ts, model, effort: a.effort, parent, agent_id: agentId, capturedAt: rec.capturedAt });
+      const blocks = typeof msg.content === 'string' ? [{ type: 'text', text: msg.content }] : (Array.isArray(msg.content) ? msg.content : []);
+      const base = { message_id: uuid, parent_id: parent, response_id: cur.id, ts, model, effort: a.effort, agent_id: agentId };
+      let first = null;
+      blocks.forEach((b, i) => {
+        if (!b || i > 255) return;
+        let row = null;
+        if (b.type === 'text') row = d.turn(rec, { ...base, part: i, role: 'assistant', kind: 'text', text: b.text || '' });
+        else if (b.type === 'thinking') row = d.turn(rec, { ...base, part: i, role: 'assistant', kind: 'thinking', text: b.thinking || '' });
+        else if (b.type === 'redacted_thinking') row = d.turn(rec, { ...base, part: i, role: 'assistant', kind: 'thinking', text: '' });
+        else if (b.type === 'tool_use' || b.type === 'server_tool_use') {
+          const args = JSON.stringify(b.input === undefined ? {} : b.input);
+          const name = String(b.name || 'unknown');
+          row = d.turn(rec, { ...base, part: i, role: 'assistant', kind: 'tool_call', text: `${name}(${args})` });
+          const callId = b.id || `${uuid}:${i}`;
+          d.call(rec, { call_id: callId, message_id: uuid, ts, tool_name: name, args, model, agent_id: agentId });
+          if ((name === 'Agent' || name === 'Task') && b.input && typeof b.input === 'object') {
+            a.agentCalls = a.agentCalls || {};
+            a.agentCalls[callId] = { description: String(b.input.description || ''), type: String(b.input.subagent_type || '') };
+            const ids = Object.keys(a.agentCalls);
+            if (ids.length > 64) delete a.agentCalls[ids[0]];
+          }
+        } else if (typeof b.type === 'string' && b.type.endsWith('_tool_result')) {
+          row = d.turn(rec, { ...base, part: i, role: 'tool', kind: 'tool_result', text: cBlockText(b.content) });
+        }
+        if (row && !first) first = row;
+      });
+      // Tokens: once per message.id, on its first row; a larger later usage re-emits that row.
+      const usage = cUsage(msg.usage);
+      if (usage && cUsageTotal(usage) > cUsageTotal(cur.usage)) { cur.usage = usage; cur.lastUsagePos = rec.pos; }
+      if (!cur.anchorRow && first) cur.anchorRow = first;
+      if (cur.anchorRow && cur.usage) {
+        const r = cur.anchorRow;
+        const same = r.input_tokens === cur.usage.input_tokens && r.output_tokens === cur.usage.output_tokens
+          && r.cache_read_tokens === cur.usage.cache_read_tokens && r.cache_write_tokens === cur.usage.cache_write_tokens;
+        if (!same) cur.anchorRow = d.revise(r, cur.usage, rec);
+      }
+    }
+  },
+
+  // The parent names its sub-agents: an Agent/Task tool_use carries description and type, and its
+  // result (or a later task notification) carries the agent's id.
+  nameAgent(d, id, info) {
+    const names = d.c.meta.agent_names || (d.c.meta.agent_names = {});
+    if (!names[id]) names[id] = { description: info.description, type: info.type };
+    const ids = Object.keys(names);
+    if (ids.length > 512) delete names[ids[0]];
+  },
+  noteNotification(d, text) {
+    if (typeof text !== 'string' || !text.includes('<task-notification>')) return;
+    for (const block of text.split('<task-notification>').slice(1)) {
+      const t = /<task-id>([0-9a-z][0-9a-z_-]{5,})<\/task-id>/i.exec(block);
+      const u = /<tool-use-id>(toolu_[A-Za-z0-9]+)<\/tool-use-id>/.exec(block);
+      if (t && u && d.a.agentCalls && d.a.agentCalls[u[1]]) claudeDeriveAdapter.nameAgent(d, t[1], d.a.agentCalls[u[1]]);
+    }
+  },
+};
+function parseTsC(v) {
+  if (typeof v === 'number' && Number.isFinite(v)) return v < 1e11 ? v * 1000 : v;
+  return typeof v === 'string' && v ? Date.parse(v) : NaN;
+}
+// </derive> ===================================================================================
+
+// Discovery under one source root: a Claude Code `projects/` directory (MEMHOUSE_SOURCE_ROOTS).
+function captureSessions(root) {
+  const out = [];
+  let projects = [];
+  try { projects = fs.readdirSync(root.dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort(); } catch { return out; }
+  for (const proj of projects) {
+    const pdir = path.join(root.dir, proj);
+    let entries = [];
+    try { entries = fs.readdirSync(pdir, { withFileTypes: true }); } catch { continue; }
+    const ids = new Set();
+    for (const e of entries) {
+      if (e.isFile() && e.name.endsWith('.jsonl')) ids.add(e.name.slice(0, -6));
+      else if (e.isDirectory() && fs.existsSync(path.join(pdir, e.name, 'subagents'))) ids.add(e.name);
+    }
+    for (const id of [...ids].sort()) out.push({ harness: 'claude-code', session_id: id, root: root.name, dir: pdir, project_dir: proj });
+  }
+  return out;
+}
+
+// A session's source files: the main transcript, every sub-agent transcript, and each
+// sub-agent's .meta.json (a side file: archived, never derived; its attribution is read lazily).
+function captureSourceFiles(session) {
+  const files = [];
+  const main = path.join(session.dir, `${session.session_id}.jsonl`);
+  if (fs.existsSync(main)) files.push({ file_key: `${session.session_id}.jsonl`, path: main, agent_id: '', role: 'main' });
+  const sdir = path.join(session.dir, session.session_id);
+  for (const { file, workflow } of subagentFiles(path.join(sdir, 'subagents'))) {
+    const agentId = path.basename(file).replace(/^agent-/, '').replace(/\.jsonl$/, '');
+    const metaPath = file.replace(/\.jsonl$/, '.meta.json');
+    const hasMeta = fs.existsSync(metaPath);
+    files.push({ file_key: path.relative(sdir, file), path: file, agent_id: agentId, role: 'agent', workflow: workflow || '', meta_path: hasMeta ? metaPath : '' });
+    if (hasMeta) files.push({ file_key: path.relative(sdir, metaPath), path: metaPath, agent_id: agentId, role: 'side', workflow: workflow || '', meta_path: metaPath });
+  }
+  return files;
+}
+
+// What a sub-agent is, from its .meta.json: { agentType, description?, … }.
+function captureAttribution(entry) {
+  if (!entry.meta_path) return { agent_type: entry.workflow ? 'workflow-subagent' : '', agent_desc: '' };
+  let meta = {};
+  try { meta = JSON.parse(fs.readFileSync(entry.meta_path, 'utf-8')) || {}; } catch { /* unreadable: no attribution */ }
+  const type = meta.agentType || meta.agent_type || meta.subagent_type || meta.type || (entry.workflow ? 'workflow-subagent' : '');
+  return { agent_type: String(type || ''), agent_desc: String(meta.description || '') };
+}
+
+const capture = {
+  harness: 'claude-code',
+  deriveVersion: CLAUDE_DERIVE_VERSION,
+  sessions: captureSessions,
+  sourceFiles: captureSourceFiles,
+  attribution: captureAttribution,
+  tsless: (o) => !o || typeof o.timestamp !== 'string',   // dated by first sighting (§2.1)
+  derive: (input) => require('./base').capture.runDerive(claudeDeriveAdapter, input),
+  adapter: claudeDeriveAdapter,
+};
+
 // discoverClaudeRoots is exported for the CLI's plugin installer, which needs the same
-// answer to a different question: where this pilot's Claude Code instances live. Two
+// answer to a different question: where this user's Claude Code instances live. Two
 // implementations of "find every CLAUDE_CONFIG_DIR" would drift the first time a playbook
 // layout changes, and this is the copy exercised on every single ship.
-module.exports = { name, labels, getChats, getMessages, getUsage, getArtifacts, getMCPServers, discoverClaudeRoots, subagentNames, subagentFiles };
+module.exports = { name, labels, getChats, getMessages, getArtifacts, getMCPServers, discoverClaudeRoots, subagentNames, subagentFiles, capture };