claude-code-session-manager 0.113.0 → 0.115.0

package/src/main/lib/remoteDrilldown.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+// Pure builders for the phone remote's drill-down lists: projects (open tabs),
+// then one project's Epics in every lifecycle status. readIndex is injected
+// (production passes epicMint's readActiveIndex) so this module stays pure.
+
+const path = require('node:path');
+
+const STATUS_RANK = { active: 0, proposed: 1, completed: 2 };
+
+function readSessions(readIndex, cwd) {
+  try {
+    const sessions = readIndex(cwd)?.sessions;
+    return sessions && typeof sessions === 'object' ? sessions : {};
+  } catch {
+    return {};
+  }
+}
+
+function tabTitle(tab) {
+  return tab.label || path.basename(tab.cwd);
+}
+
+function validTabs(tabs) {
+  return (Array.isArray(tabs) ? tabs : []).filter((t) => t && typeof t.cwd === 'string' && t.cwd);
+}
+
+function toMs(value) {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (typeof value === 'string' && value) {
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? null : ms;
+  }
+  return null;
+}
+
+function epicUpdatedAt(epic) {
+  for (const v of [epic.updatedAt, epic.completedAt, epic.createdAt]) {
+    if (v !== undefined && v !== null && v !== '') return toMs(v);
+  }
+  return null;
+}
+
+function listRemoteProjects(tabs, readIndex) {
+  const seen = new Set();
+  const out = [];
+  for (const tab of validTabs(tabs)) {
+    if (seen.has(tab.cwd)) continue;
+    seen.add(tab.cwd);
+    const counts = { proposed: 0, active: 0, completed: 0 };
+    for (const epic of Object.values(readSessions(readIndex, tab.cwd))) {
+      if (epic && Object.prototype.hasOwnProperty.call(counts, epic.status)) counts[epic.status] += 1;
+    }
+    out.push({ cwd: tab.cwd, title: tabTitle(tab), mainTabId: tab.id ?? tab.sessionId, counts });
+  }
+  return out.sort((a, b) => a.title.localeCompare(b.title));
+}
+
+function listRemoteProjectSessions(tabs, readIndex, cwd, { completedLimit = 20 } = {}) {
+  const tab = validTabs(tabs).find((t) => t.cwd === cwd);
+  if (!tab) return null;
+  const project = { cwd: tab.cwd, title: tabTitle(tab), mainTabId: tab.id ?? tab.sessionId };
+  const rows = [];
+  for (const epic of Object.values(readSessions(readIndex, tab.cwd))) {
+    if (!epic || !Object.prototype.hasOwnProperty.call(STATUS_RANK, epic.status)) continue;
+    const firstLine = typeof epic.goalText === 'string' ? epic.goalText.split('\n')[0].trim().slice(0, 80).trim() : '';
+    rows.push({
+      epicId: epic.id,
+      claudeSessionId: typeof epic.claudeSessionId === 'string' && epic.claudeSessionId ? epic.claudeSessionId : null,
+      title: firstLine || epic.id,
+      status: epic.status,
+      tag: epic.tag,
+      agentType: epic.agentType,
+      spawnCwd: epic.worktree?.dir || epic.cwd || tab.cwd,
+      updatedAt: epicUpdatedAt(epic),
+    });
+  }
+  rows.sort((a, b) => {
+    const r = STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    if (r !== 0) return r;
+    if (a.updatedAt === b.updatedAt) return 0;
+    if (a.updatedAt === null) return 1;
+    if (b.updatedAt === null) return -1;
+    return b.updatedAt - a.updatedAt;
+  });
+  let completed = 0;
+  const sessions = rows.filter((s) => s.status !== 'completed' || ++completed <= completedLimit);
+  return { project, sessions };
+}
+
+module.exports = { listRemoteProjects, listRemoteProjectSessions };

package/src/main/lib/remoteTranscriptTail.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+// Bounded-tail reader for Claude Code JSONL transcripts: the last N human-readable
+// chat messages (user prompts + assistant text) without reading the whole file.
+// Top-level (no domain fits: epic/ transcripts are path-only; util/ is domain-free).
+// Transcripts reach hundreds of MB, so cost is O(maxBytes), never O(file).
+
+const fsp = require('node:fs/promises');
+
+const DEFAULT_LIMIT = 30;
+const MAX_LIMIT = 100;
+const DEFAULT_MAX_BYTES = 524288;
+const MAX_TEXT_CHARS = 4000;
+
+/** Join the plain-text parts of a message `content` (string or block array). */
+function textOf(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+    .map((b) => b.text)
+    .join('\n');
+}
+
+function truncate(text) {
+  return text.length > MAX_TEXT_CHARS ? text.slice(0, MAX_TEXT_CHARS - 1) + '…' : text;
+}
+
+/** Parse one JSONL line into a chat message, or null when it is not one. */
+function toChatMessage(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!entry || typeof entry !== 'object') return null;
+  if (entry.isMeta || entry.isSidechain) return null;
+  const role = entry.type;
+  if (role !== 'user' && role !== 'assistant') return null;
+  const text = textOf(entry.message?.content).trim();
+  if (!text) return null;
+  return {
+    role,
+    text: truncate(text),
+    ts: typeof entry.timestamp === 'string' ? entry.timestamp : null,
+    uuid: typeof entry.uuid === 'string' ? entry.uuid : null,
+  };
+}
+
+/**
+ * @param {string} filePath
+ * @param {{ limit?: number, maxBytes?: number }} [opts]
+ * @returns {Promise<Array<{ role: 'user'|'assistant', text: string, ts: string|null, uuid: string|null }>>}
+ *   oldest first; [] on any read failure.
+ */
+async function readRecentChatMessages(filePath, { limit = DEFAULT_LIMIT, maxBytes = DEFAULT_MAX_BYTES } = {}) {
+  if (typeof filePath !== 'string' || !filePath) return [];
+  const n = Math.floor(Number(limit));
+  const lim = Number.isFinite(n) ? Math.min(MAX_LIMIT, Math.max(1, n)) : DEFAULT_LIMIT;
+  const cap = Math.max(1, Math.floor(Number(maxBytes)) || DEFAULT_MAX_BYTES);
+  let fd;
+  try {
+    fd = await fsp.open(filePath, 'r');
+    const { size } = await fd.stat();
+    if (size === 0) return [];
+    const start = Math.max(0, size - cap);
+    // From mid-file, read one extra leading byte so the first split part is
+    // always a fragment (empty when start sits on a line boundary) — drop it.
+    const from = start > 0 ? start - 1 : 0;
+    const len = size - from;
+    const buf = Buffer.alloc(len);
+    const { bytesRead } = await fd.read(buf, 0, len, from);
+    const parts = buf.toString('utf8', 0, bytesRead).split('\n');
+    if (start > 0) parts.shift();
+    const out = [];
+    for (const line of parts) {
+      if (!line) continue;
+      const msg = toChatMessage(line);
+      if (msg) out.push(msg);
+    }
+    return out.slice(-lim);
+  } catch {
+    return [];
+  } finally {
+    await fd?.close().catch(() => {});
+  }
+}
+
+module.exports = { readRecentChatMessages };

package/src/main/memoryAggregate.cjs

@@ -33,8 +33,15 @@ const { MEMORY_SLUG_RE } = require('./lib/memorySlug.cjs');
 const HOME = os.homedir();
 const CACHE_WRITER = 'memory-clusters';
 
-function memoryDir(workspace) {
-  return path.join(HOME, '.claude', 'projects', workspace, 'memory');
+// Resolved through memoryTool.cjs so cwd-addressed callers read Claude Code's
+// native dir (git root + autoMemoryDirectory); no cwd -> legacy workspace dir.
+async function memoryDir(workspace, cwd) {
+  const { resolveDir } = require('./memoryTool.cjs');
+  try {
+    return (await resolveDir({ workspace, cwd })).dir;
+  } catch {
+    return path.join(HOME, '.claude', 'projects', workspace, 'memory');
+  }
 }
 
 function clustersCachePath(cwd) {
@@ -94,15 +101,15 @@ function parseFrontmatter(text) {
   return { type, description, body: m[2] };
 }
 
-async function listMemoryFiles(workspace) {
-  const dir = memoryDir(workspace);
+async function listMemoryFiles(workspace, cwd) {
+  const dir = await memoryDir(workspace, cwd);
   const r = await config.listDir(dir, { filesOnly: true });
   if (!r.ok) return [];
   return r.entries.filter((e) => MEMORY_SLUG_RE.test(e.name)).map((e) => e.name).sort();
 }
 
-async function readMemories(workspace, names) {
-  const dir = memoryDir(workspace);
+async function readMemories(workspace, names, cwd) {
+  const dir = await memoryDir(workspace, cwd);
   const out = [];
   for (const name of names) {
     const abs = path.join(dir, name);
@@ -178,8 +185,8 @@ async function aggregate({ workspace, refresh, cwd }) {
     return { workspace: ws, generatedAt: null, clusters: [], orphans: [], cached: false };
   }
 
-  const names = await listMemoryFiles(ws);
-  const memories = await readMemories(ws, names);
+  const names = await listMemoryFiles(ws, cwd);
+  const memories = await readMemories(ws, names, cwd);
   const slugs = memories.map((m) => m.slug);
 
   let clusters = [];

package/src/main/memoryTool.cjs

@@ -32,6 +32,14 @@ const config = require('./config.cjs');
 
 const { MEMORY_SLUG_RE: SLUG_RE } = require('./lib/memorySlug.cjs');
 const { scoreMemories } = require('./lib/memoryStale.cjs');
+const { addIndexLine, removeIndexLines, indexHealth } = require('./lib/memoryIndex.cjs');
+const {
+  resolveWorkspaceMemoryDir,
+  autoMemoryEnabled,
+  resolveAgentMemoryDir,
+  listMemoryAgents,
+  gitRepoRoot,
+} = require('./lib/memoryDirResolve.cjs');
 
 const MAX_FILE_BYTES = 1024 * 1024; // 1 MiB
 const MAX_ENTRIES = 1000;
@@ -52,13 +60,59 @@ function workspaceDir(workspace) {
   return path.join(memoryRoot(), workspace, 'memory');
 }
 
+/** Read + parse a settings file; missing/malformed -> null. */
+async function readSettings(abs) {
+  try {
+    const r = await config.readText(abs);
+    if (!r.exists) return null;
+    const parsed = JSON.parse(r.text);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The one place a memory directory is chosen.
+ *   agent -> native subagent memory dir (root = git root of cwd, or cwd)
+ *   cwd   -> Claude Code's native workspace dir (git root + autoMemoryDirectory)
+ *   else  -> legacy ~/.claude/projects/<workspace>/memory
+ * Returns { dir, autoMemoryEnabled }. Throws on an invalid cwd/agent; every path
+ * the callers derive from `dir` still goes through config.validatePath/validateWrite.
+ */
+async function resolveDir({ workspace, cwd, agent } = {}) {
+  const home = os.homedir();
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  if (typeof cwd !== 'string' || !cwd) {
+    if (agent) throw new Error('agent memory requires a cwd');
+    return { dir: workspaceDir(ws), autoMemoryEnabled: true };
+  }
+  const realCwd = config.validatePath(cwd);
+  const root = gitRepoRoot(realCwd, require('node:child_process').execFileSync) || realCwd;
+  const realRoot = config.validatePath(root);
+  // Project-scoped native dirs live under <root>/.claude; validateWrite only
+  // permits that subtree for registered roots.
+  config.addAllowedRoot(realRoot);
+  const settings = {
+    user: await readSettings(path.join(home, '.claude', 'settings.json')),
+    project: await readSettings(path.join(realRoot, '.claude', 'settings.json')),
+    local: await readSettings(path.join(realRoot, '.claude', 'settings.local.json')),
+  };
+  const enabled = autoMemoryEnabled(settings);
+  if (agent) {
+    return { dir: resolveAgentMemoryDir({ home, root: realRoot, name: agent.name, scope: agent.scope }), autoMemoryEnabled: enabled };
+  }
+  const r = resolveWorkspaceMemoryDir({ home, cwd: realCwd, settings, repoRoot: realRoot });
+  return { dir: r.dir, autoMemoryEnabled: enabled };
+}
+
 /**
  * Reject NUL chars, '..' segments, absolute paths, or anything that would
  * resolve outside the workspace dir. Returns the resolved absolute path.
  * The downstream config.cjs helpers add a second layer of validation, but
  * this lets us return a clean error message before we get there.
  */
-function resolveEntryPath(workspace, name) {
+function resolveEntryPath(dir, name) {
   if (typeof name !== 'string' || !name) {
     throw new Error('invalid entry name');
   }
@@ -66,7 +120,6 @@ function resolveEntryPath(workspace, name) {
   if (!SLUG_RE.test(name)) {
     throw new Error(`invalid slug (must match ${SLUG_RE.source}): ${name}`);
   }
-  const dir = workspaceDir(workspace);
   const full = path.resolve(dir, name);
   // path.resolve normalizes; verify the result is still under dir to guard
   // against bizarre name inputs.
@@ -84,12 +137,15 @@ function validWorkspaceName(name) {
   return typeof name === 'string' && /^[a-zA-Z0-9-_]{1,256}$/.test(name);
 }
 
-async function list({ workspace }) {
+async function list({ workspace, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const dir = workspaceDir(ws);
+  let resolved;
+  try { resolved = await resolveDir({ workspace: ws, cwd, agent }); }
+  catch (e) { return { entries: [], workspace: ws, dir: null, autoMemoryEnabled: true, error: e.message }; }
+  const { dir } = resolved;
   const r = await config.listDir(dir, { filesOnly: true });
   if (!r.ok) {
-    return { entries: [], workspace: ws, error: r.error };
+    return { entries: [], workspace: ws, dir, autoMemoryEnabled: resolved.autoMemoryEnabled, error: r.error };
   }
   const entries = r.entries
     .filter((e) => e.name.endsWith('.md'))
@@ -100,12 +156,14 @@ async function list({ workspace }) {
       bytes: e.size,
     }))
     .sort((a, b) => a.name.localeCompare(b.name));
-  return { entries, workspace: ws, error: null };
+  return { entries, workspace: ws, dir, autoMemoryEnabled: resolved.autoMemoryEnabled, error: null };
 }
 
-async function read({ workspace, name }) {
+async function read({ workspace, name, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  try { abs = resolveEntryPath((await resolveDir({ workspace: ws, cwd, agent })).dir, name); }
+  catch (e) { return { content: '', exists: false, mtimeMs: 0, bytes: 0, error: e.message }; }
   const r = await config.readText(abs);
   if (!r.exists) {
     return { content: '', exists: false, mtimeMs: 0, bytes: 0, error: r.error };
@@ -119,7 +177,7 @@ async function read({ workspace, name }) {
   };
 }
 
-async function write({ workspace, name, content }) {
+async function write({ workspace, name, content, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
   if (typeof content !== 'string') {
     return { ok: false, error: 'content must be a string' };
@@ -128,7 +186,9 @@ async function write({ workspace, name, content }) {
   if (bytes > MAX_FILE_BYTES) {
     return { ok: false, error: `file exceeds 1 MiB cap (${bytes} bytes)` };
   }
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  try { abs = resolveEntryPath((await resolveDir({ workspace: ws, cwd, agent })).dir, name); }
+  catch (e) { return { ok: false, error: e.message }; }
   // Enforce per-workspace entry cap on creates (writes to existing files are
   // always allowed regardless of count). Cheap fs.stat check rather than a
   // full directory enumeration where possible.
@@ -136,7 +196,7 @@ async function write({ workspace, name, content }) {
   try { await fsp.access(abs, fs.constants.F_OK); }
   catch { exists = false; }
   if (!exists) {
-    const l = await list({ workspace: ws });
+    const l = await list({ workspace: ws, cwd, agent });
     if (l.entries.length >= MAX_ENTRIES) {
       return { ok: false, error: `workspace at ${MAX_ENTRIES}-entry cap` };
     }
@@ -149,9 +209,22 @@ async function write({ workspace, name, content }) {
   }
 }
 
-async function deleteEntry({ workspace, name }) {
+const INDEX_NAME = 'MEMORY.md';
+
+/** Read <dir>/MEMORY.md; missing/unreadable -> null. */
+async function readIndexText(dir) {
+  const r = await config.readText(path.join(dir, INDEX_NAME));
+  return r.exists ? r.text : null;
+}
+
+async function deleteEntry({ workspace, name, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  let dir;
+  try {
+    dir = (await resolveDir({ workspace: ws, cwd, agent })).dir;
+    abs = resolveEntryPath(dir, name);
+  } catch (e) { return { ok: false, error: e.message }; }
   // Route through config.cjs::validatePath (home-boundary pin, symlink-safe)
   // plus validateWrite (write-prefix pin) — same contract every other
   // mutating call in the codebase follows. Complexity: O(1) per call.
@@ -164,16 +237,30 @@ async function deleteEntry({ workspace, name }) {
   }
   try {
     await fsp.unlink(real);
-    return { ok: true, error: null };
   } catch (e) {
-    if (e.code === 'ENOENT') return { ok: true, error: null };
-    return { ok: false, error: e.message };
+    if (e.code !== 'ENOENT') return { ok: false, error: e.message };
+  }
+  if (name === INDEX_NAME) return { ok: true, error: null };
+  try {
+    const text = await readIndexText(dir);
+    if (text !== null) {
+      const next = removeIndexLines(text, name);
+      if (next !== text) await config.writeTextAtomic(path.join(dir, INDEX_NAME), next);
+    }
+  } catch (e) {
+    return { ok: true, error: null, indexError: e.message };
   }
+  return { ok: true, error: null };
 }
 
-async function create({ workspace, name, description }) {
+async function create({ workspace, name, description, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const abs = resolveEntryPath(ws, name);
+  let abs;
+  let dir;
+  try {
+    dir = (await resolveDir({ workspace: ws, cwd, agent })).dir;
+    abs = resolveEntryPath(dir, name);
+  } catch (e) { return { ok: false, error: e.message }; }
   // Refuse to overwrite — create is strictly "new file".
   try {
     await fsp.access(abs, fs.constants.F_OK);
@@ -190,7 +277,16 @@ async function create({ workspace, name, description }) {
     desc || `# ${stem}`,
     '',
   ].join('\n');
-  return await write({ workspace: ws, name, content: fm });
+  const w = await write({ workspace: ws, name, content: fm, cwd, agent });
+  if (!w.ok || name === INDEX_NAME) return w;
+  try {
+    const text = (await readIndexText(dir)) || '';
+    const next = addIndexLine(text, { file: name, title: stem, hook: desc.replace(/\n/g, ' ') });
+    if (next !== text) await config.writeTextAtomic(path.join(dir, INDEX_NAME), next);
+  } catch (e) {
+    return { ...w, indexError: e.message };
+  }
+  return w;
 }
 
 /**
@@ -200,9 +296,11 @@ async function create({ workspace, name, description }) {
  * the dead-ref existence check. Absent/invalid cwd disables dead-ref
  * detection entirely rather than mass-flagging memories.
  */
-async function stale({ workspace, cwd }) {
+async function stale({ workspace, cwd, agent }) {
   const ws = validWorkspaceName(workspace) ? workspace : 'default';
-  const dir = workspaceDir(ws);
+  let dir;
+  try { dir = (await resolveDir({ workspace: ws, cwd, agent })).dir; }
+  catch (e) { return { entries: [], workspace: ws, error: e.message }; }
   const r = await config.listDir(dir, { filesOnly: true });
   if (!r.ok) {
     return { entries: [], workspace: ws, error: r.error };
@@ -236,7 +334,30 @@ async function stale({ workspace, cwd }) {
     entries.push({ name, mtimeMs: r2.mtimeMs, body: r2.text });
   }
 
-  return { entries: scoreMemories({ entries, now: Date.now(), existsPath }), workspace: ws, error: null };
+  const index = indexHealth({ indexText: await readIndexText(dir), files: r.entries.map((e) => e.name).filter((n) => n.endsWith('.md')) });
+  return { entries: scoreMemories({ entries, now: Date.now(), existsPath }), workspace: ws, error: null, index };
+}
+
+/** Agents (user + project) with their `memory:` frontmatter scope. */
+async function agents({ cwd } = {}) {
+  const home = os.homedir();
+  let root = null;
+  if (typeof cwd === 'string' && cwd) {
+    try {
+      const realCwd = config.validatePath(cwd);
+      root = config.validatePath(gitRepoRoot(realCwd, require('node:child_process').execFileSync) || realCwd);
+    } catch {
+      root = null;
+    }
+  }
+  return {
+    agents: listMemoryAgents({
+      home,
+      root,
+      readDir: (d) => fs.readdirSync(d),
+      readText: (f) => fs.readFileSync(f, 'utf8'),
+    }),
+  };
 }
 
 function registerMemoryHandlers() {
@@ -247,6 +368,7 @@ function registerMemoryHandlers() {
   ipcMain.handle('memory:delete', v(s.memoryDelete, deleteEntry));
   ipcMain.handle('memory:create', v(s.memoryCreate, create));
   ipcMain.handle('memory:stale', v(s.memoryStale, stale));
+  ipcMain.handle('memory:agents', v(s.memoryAgents, agents));
 }
 
 module.exports = {
@@ -255,5 +377,12 @@ module.exports = {
   // exported for tests
   memoryRoot,
   workspaceDir,
+  resolveDir,
+  list,
+  read,
+  write,
+  create,
+  deleteEntry,
+  agents,
   stale,
 };