@threadcrumbs/common 0.0.0-stage → 0.1.0

package/telemetry/claude-code.mjs

@@ -0,0 +1,370 @@
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { claudeDesktopStores, desktopRecordReader, projectOf } from '../lib/claude-desktop.mjs'
+import { awaitedPeers, readLiveSessions, transcriptDetail, transcriptReader, turnEnding } from '../lib/claude-transcript.mjs'
+import { exists, listDirs, listFiles, num } from '../lib/fsutil.mjs'
+import { DETAIL_LIMITS, RECENT_MS, number, planSummary, text, titleFromPrompt } from '../lib/telemetry-fields.mjs'
+
+export { nextPlan } from '../lib/telemetry-fields.mjs'
+
+const STALE_TURN_MS = 2 * 60 * 1000
+const ACTIVE_WINDOW_MS = 30 * 60 * 1000
+const SUBAGENT_WINDOW_MS = 10 * 60 * 1000
+const OLDER_KEPT = 3
+const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export function claudeCode({
+  home = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'),
+  desktop = claudeDesktopStores(),
+  now = Date.now,
+  isAlive,
+} = {}) {
+  const projectsDir = path.join(home, 'projects')
+  const liveDir = path.join(home, 'sessions')
+  const catalogDir = path.join(home, 'cache', 'model-catalog')
+  const transcripts = transcriptReader({ detail: true })
+  const subagentFiles = transcriptReader()
+  const subagentDetails = transcriptReader({ detail: true })
+  const desktopRecords = desktopRecordReader()
+  const olderReaders = new Map()
+  const metas = new Map()
+  let subagentsSweptAt = 0
+  let known = new Map()
+  let listed = new Map()
+  let catalog = { stamp: '', limits: new Map() }
+
+  async function contextLimits() {
+    const files = []
+    for (const file of await listFiles(catalogDir, (n) => n.endsWith('.json'))) {
+      const stat = await fsp.stat(file).catch(() => null)
+      if (stat) files.push({ file, mtime: stat.mtimeMs })
+    }
+    files.sort((a, b) => a.mtime - b.mtime)
+    const stamp = files.map((f) => `${f.file}@${f.mtime}`).join('|')
+    if (stamp === catalog.stamp) return catalog.limits
+    const limits = new Map()
+    for (const { file } of files) {
+      try {
+        const models = JSON.parse(await fsp.readFile(file, 'utf8'))?.catalog?.config?.models
+        for (const m of Array.isArray(models) ? models : []) {
+          const limit = number(m?.runtime?.max_input_tokens)
+          if (m?.id && limit) limits.set(m.id, limit)
+        }
+      } catch {}
+    }
+    catalog = { stamp, limits }
+    return limits
+  }
+
+  async function findTranscripts(live) {
+    const cutoff = now() - RECENT_MS
+    const byId = new Map()
+    for (const projectDir of await listDirs(projectsDir)) {
+      for (const file of await listFiles(projectDir, (n) => n.endsWith('.jsonl'))) {
+        const id = path.basename(file, '.jsonl')
+        const stat = await fsp.stat(file).catch(() => null)
+        if (!stat || (stat.mtimeMs < cutoff && !live.has(id))) continue
+        const existing = byId.get(id)
+        if (existing && existing.stat.mtimeMs >= stat.mtimeMs) continue
+        byId.set(id, { id, file, stat })
+      }
+    }
+    return [...byId.values()]
+  }
+
+  const subagentDir = (file, sessionId) => path.join(path.dirname(file), sessionId, 'subagents')
+
+  async function subagentTotals(file, sessionId) {
+    const cutoff = now() - SUBAGENT_WINDOW_MS
+    const totals = { running: 0, spend: 0, unpriced: false, added: 0, removed: 0 }
+    for (const sub of await listFiles(subagentDir(file, sessionId), (n) => n.endsWith('.jsonl'))) {
+      const stat = await fsp.stat(sub).catch(() => null)
+      if (!stat) continue
+      const state = await subagentFiles.read(sub, stat, { sidechain: true }).catch(() => null)
+      if (!state) continue
+      totals.spend += state.spend
+      totals.unpriced ||= state.unpriced
+      totals.added += state.lines.added
+      totals.removed += state.lines.removed
+      if (stat.mtimeMs >= cutoff && !turnEnding(state).handedBack) totals.running++
+    }
+    return totals
+  }
+
+  function sweepSubagents() {
+    if (now() - subagentsSweptAt < SUBAGENT_WINDOW_MS) return
+    subagentsSweptAt = now()
+    subagentFiles.sweep()
+    subagentDetails.sweep()
+    metas.clear()
+  }
+
+  async function readMeta(file) {
+    const stat = await fsp.stat(file).catch(() => null)
+    if (!stat) return null
+    const cached = metas.get(file)
+    if (cached?.mtime === stat.mtimeMs) return cached.meta
+    let meta = null
+    try {
+      meta = JSON.parse(await fsp.readFile(file, 'utf8'))
+    } catch {}
+    metas.set(file, { mtime: stat.mtimeMs, meta })
+    return meta
+  }
+
+  async function subagentList(file, sessionId) {
+    const found = []
+    for (const sub of await listFiles(subagentDir(file, sessionId), (n) => n.endsWith('.jsonl'))) {
+      const stat = await fsp.stat(sub).catch(() => null)
+      if (stat) found.push({ sub, stat })
+    }
+    found.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
+    const list = []
+    for (const { sub, stat } of found.slice(0, DETAIL_LIMITS.subagents)) {
+      const state = await subagentFiles.read(sub, stat, { sidechain: true }).catch(() => null)
+      if (!state) continue
+      const meta = await readMeta(sub.replace(/\.jsonl$/, '.meta.json'))
+      const ending = turnEnding(state)
+      const lastActivityAt = Math.max(state.lastAt, Math.floor(stat.mtimeMs))
+      const open = !ending.handedBack && meta?.finished !== true
+      const status = ending.failed ? 'error' : !open ? 'done' : now() - lastActivityAt < SUBAGENT_WINDOW_MS ? 'working' : 'idle'
+      list.push({
+        id: path.basename(sub, '.jsonl').replace(/^agent-/, ''),
+        name: text(meta?.description) || titleFromPrompt(state.firstPrompt) || 'Subagent',
+        type: text(meta?.agentType),
+        status,
+        model: state.model,
+        tokens: { ...state.tokens },
+        tool: status === 'working' ? currentTool(state.open) : null,
+        startedAt: state.startedAt,
+        lastActivityAt,
+      })
+    }
+    return list.sort((a, b) => a.startedAt - b.startedAt)
+  }
+
+  async function scanSessions() {
+    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
+    const found = []
+    const files = new Map()
+    const states = new Map()
+    for (const { id, file, stat } of await findTranscripts(live)) {
+      let state
+      try {
+        state = await transcripts.read(file, stat)
+      } catch {
+        continue
+      }
+      files.set(id, file)
+      states.set(id, state)
+      found.push({ id, file, stat, state })
+    }
+    const handedBackAt = (sessionId) => states.get(sessionId)?.handedBackAt || 0
+    const sessions = []
+    for (const { id, file, stat, state } of found) {
+      if (marks.get(id)?.archived) continue
+      const running = live.get(id)
+      if (!running && now() - (state.lastAt || stat.mtimeMs) > RECENT_MS) continue
+      const totals = await subagentTotals(file, id)
+      const awaiting = running ? awaitedPeers(state, live, handedBackAt) : []
+      sessions.push(toSession({ id, state, stat, running, subagents: running ? totals.running : 0, awaiting, totals, limits, mark: marks.get(id), now: now() }))
+    }
+    known = files
+    listed = new Map(sessions.map((s) => [s.id, s]))
+    transcripts.sweep()
+    sweepSubagents()
+    return sessions
+  }
+
+  async function subagentDetail(file, id, agentId) {
+    if (!/^[\w-]{1,100}$/.test(agentId)) return null
+    const sub = path.join(subagentDir(file, id), `agent-${agentId}.jsonl`)
+    const stat = await fsp.stat(sub).catch(() => null)
+    if (!stat) return null
+    const state = await subagentDetails.read(sub, stat, { sidechain: true })
+    return {
+      id: `claude-code:${id}`,
+      sessionId: id,
+      agentId,
+      source: sub,
+      ...transcriptDetail(state),
+      subagents: null,
+    }
+  }
+
+  async function locate(id) {
+    if (known.has(id)) return known.get(id)
+    if (!SESSION_ID.test(id)) return null
+    let newest = null
+    for (const projectDir of await listDirs(projectsDir)) {
+      const file = path.join(projectDir, `${id}.jsonl`)
+      const stat = await fsp.stat(file).catch(() => null)
+      if (stat && (!newest || stat.mtimeMs > newest.mtime)) newest = { file, mtime: stat.mtimeMs }
+    }
+    return newest?.file || null
+  }
+
+  function olderReader(file) {
+    const reader = olderReaders.get(file) || transcriptReader({ detail: true })
+    olderReaders.delete(file)
+    olderReaders.set(file, reader)
+    while (olderReaders.size > OLDER_KEPT) olderReaders.delete(olderReaders.keys().next().value)
+    return reader
+  }
+
+  async function readSession(sessionKey, { subagent = null } = {}) {
+    const id = String(sessionKey).replace(/^claude-code:/, '')
+    const file = await locate(id)
+    const stat = file ? await fsp.stat(file).catch(() => null) : null
+    if (!stat) return null
+    const state = await (known.get(id) === file ? transcripts : olderReader(file)).read(file, stat)
+    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
+    if (marks.get(id)?.archived) return null
+    const running = live.get(id)
+    const totals = await subagentTotals(file, id)
+    const awaiting = running ? awaitedPeers(state, live) : []
+    const session =
+      listed.get(`claude-code:${id}`) ||
+      toSession({ id, state, stat, running, subagents: running ? totals.running : 0, awaiting, totals, limits, mark: marks.get(id), now: now() })
+    if (subagent != null) return { session, detail: await subagentDetail(file, id, String(subagent)) }
+    return {
+      session,
+      detail: { id: `claude-code:${id}`, sessionId: id, source: file, ...transcriptDetail(state), subagents: await subagentList(file, id) },
+    }
+  }
+
+  async function sessionDetail(sessionKey, { subagent = null } = {}) {
+    const id = String(sessionKey).replace(/^claude-code:/, '')
+    const file = known.get(id)
+    const stat = file ? await fsp.stat(file).catch(() => null) : null
+    if (!stat) return null
+    if (subagent != null) return subagentDetail(file, id, String(subagent))
+    const state = await transcripts.read(file, stat)
+    return {
+      id: `claude-code:${id}`,
+      sessionId: id,
+      source: file,
+      ...transcriptDetail(state),
+      subagents: await subagentList(file, id),
+    }
+  }
+
+  return {
+    id: 'claude-code',
+    name: 'Claude Code',
+    detect: () => exists(projectsDir),
+    watchRoots: () => [projectsDir, liveDir, ...desktop],
+    scanSessions,
+    sessionDetail,
+    readSession,
+  }
+}
+
+
+function contextLimit(limits, model) {
+  if (!model) return 0
+  const bare = model.replace(/\[.*\]$/, '')
+  if (limits.has(bare)) return limits.get(bare)
+  for (const [id, limit] of limits) {
+    if (bare.startsWith(id) || id.startsWith(bare)) return limit
+  }
+  return 0
+}
+
+function desktopMarks({ records, deleted }) {
+  const marks = new Map()
+  for (const r of records) {
+    if (typeof r.cliSessionId !== 'string' || !r.cliSessionId) continue
+    const next = {
+      archived: r.isArchived === true || r.isArchived === 'True',
+      originCwd: typeof r.originCwd === 'string' ? r.originCwd : '',
+      cwd: typeof r.cwd === 'string' ? r.cwd : '',
+      focusedAt: num(r.lastFocusedAt),
+      activeAt: num(r.lastActivityAt) || num(r.lastFocusedAt) || num(r.createdAt),
+      outcome: r.turnOutcome || '',
+      failed: Boolean(r.error) || r.turnOutcome === 'failed',
+    }
+    const seen = marks.get(r.cliSessionId)
+    marks.set(
+      r.cliSessionId,
+      seen
+        ? {
+            archived: seen.archived && next.archived,
+            originCwd: seen.originCwd || next.originCwd,
+            cwd: seen.cwd || next.cwd,
+            focusedAt: Math.max(seen.focusedAt, next.focusedAt),
+            activeAt: Math.max(seen.activeAt, next.activeAt),
+            outcome: seen.outcome || next.outcome,
+            failed: seen.failed || next.failed,
+          }
+        : next
+    )
+  }
+  for (const id of deleted) if (!marks.has(id)) marks.set(id, { archived: true, outcome: '', failed: false })
+  return marks
+}
+
+function statusOf({ running, state, subagents, awaiting, lastAt, mark, unread, now }) {
+  const midTurn = Boolean(state.ending && !state.ending.handedBack)
+  const { failed, onAgents: onlyAgents } = turnEnding(state)
+  const blocked = mark?.outcome === 'blocked'
+  const failedTurn = failed || Boolean(mark?.failed)
+  if (running) {
+    if (running.status === 'waiting') return 'asking'
+    const busy = running.status ? running.status === 'busy' : midTurn
+    if (busy) return onlyAgents ? 'delegating' : 'working'
+    if (subagents || awaiting.length) return 'delegating'
+    if (blocked) return 'asking'
+    if (failedTurn) return 'error'
+    return unread || now - lastAt < ACTIVE_WINDOW_MS ? 'done' : 'idle'
+  }
+  if (midTurn && now - lastAt < STALE_TURN_MS) return onlyAgents ? 'delegating' : 'working'
+  if (blocked) return 'asking'
+  if (failedTurn) return 'error'
+  return unread ? 'done' : 'idle'
+}
+
+function currentTool(open) {
+  let latest = null
+  for (const call of open.values()) {
+    if (!latest || call.startedAt >= latest.startedAt) latest = call
+  }
+  return latest ? { name: latest.name, startedAt: latest.startedAt } : null
+}
+
+function toSession({ id, state, stat, running, subagents, awaiting, totals, limits, mark, now }) {
+  const lastActivityAt = state.lastAt || Math.floor(stat.mtimeMs)
+  const unread = Boolean(mark) && (state.handedBackAt || mark.activeAt) > mark.focusedAt
+  const status = statusOf({ running, state, subagents, awaiting, lastAt: lastActivityAt, mark, unread, now })
+  const { projectPath, project, worktree } = projectOf(mark?.cwd || state.firstCwd || state.cwd, mark?.originCwd)
+  const limit = contextLimit(limits, state.model)
+  const promptTitle = state.firstPrompt ? titleFromPrompt(state.firstPrompt) : ''
+  return {
+    id: `claude-code:${id}`,
+    harness: 'claude-code',
+    title: state.customTitle || state.aiTitle || running?.name || state.summary || promptTitle || 'Untitled session',
+    project,
+    projectPath,
+    worktree,
+    cwd: state.cwd,
+    gitBranch: state.gitBranch,
+    model: state.model,
+    effort: state.effort,
+    status,
+    live: Boolean(running),
+    startedAt: state.startedAt,
+    lastActivityAt,
+    tool: status === 'working' || status === 'delegating' ? currentTool(state.open) : null,
+    tokens: { ...state.tokens },
+    context: state.context ? { used: state.context, limit } : null,
+    costUsd: state.unpriced || totals.unpriced ? (state.cost ? state.cost.usd : null) : state.spend + totals.spend,
+    lines: { added: state.lines.added + totals.added, removed: state.lines.removed + totals.removed },
+    plan: planSummary(state.plan),
+    subagents,
+    awaiting: awaiting.map((p) => ({ id: `claude-code:${p.sessionId}`, title: p.name })),
+    prompts: state.prompts,
+  }
+}
+
+export default claudeCode()