agent-tracer 0.2.0

package/lib/db.js

@@ -0,0 +1,173 @@
+'use strict';
+/**
+ * SQLite database setup, schema, migrations, and persist helpers.
+ * Call createDb(dbPath) once at startup; pass the returned object to createStore().
+ */
+
+const fs       = require('fs');
+const path     = require('path');
+const Database = require('better-sqlite3');
+
+function createDb(dbPath) {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+
+  // ── Migrations (safe to re-run on every boot) ──────────────────────────────
+  try { db.exec(`ALTER TABLE sessions ADD COLUMN cwd TEXT`);             } catch {}
+  try { db.exec(`ALTER TABLE sessions ADD COLUMN permission_mode TEXT`); } catch {}
+  try { db.exec(`ALTER TABLE sessions ADD COLUMN entrypoint TEXT`);      } catch {}
+  try { db.exec(`ALTER TABLE sessions ADD COLUMN version TEXT`);         } catch {}
+  try { db.exec(`ALTER TABLE sessions ADD COLUMN git_branch TEXT`);      } catch {}
+  try { db.exec(`ALTER TABLE sessions ADD COLUMN package_json TEXT`);    } catch {}
+
+  // ── Schema ────────────────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id              TEXT PRIMARY KEY,
+      parent_id       TEXT,
+      label           TEXT NOT NULL,
+      status          TEXT NOT NULL DEFAULT 'running',
+      started_at      INTEGER NOT NULL,
+      ended_at        INTEGER,
+      cost_usd        REAL NOT NULL DEFAULT 0,
+      tokens_in       INTEGER NOT NULL DEFAULT 0,
+      tokens_out      INTEGER NOT NULL DEFAULT 0,
+      cache_read      INTEGER NOT NULL DEFAULT 0,
+      last_text       TEXT NOT NULL DEFAULT '',
+      cwd             TEXT,
+      permission_mode TEXT,
+      entrypoint      TEXT,
+      version         TEXT,
+      git_branch      TEXT,
+      package_json    TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS tool_calls (
+      id          TEXT PRIMARY KEY,
+      session_id  TEXT NOT NULL REFERENCES sessions(id),
+      name        TEXT NOT NULL,
+      summary     TEXT NOT NULL DEFAULT '',
+      input_json  TEXT,
+      done        INTEGER NOT NULL DEFAULT 0,
+      started_at  INTEGER NOT NULL,
+      duration_ms INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS compactions (
+      id             TEXT PRIMARY KEY,
+      session_id     TEXT NOT NULL REFERENCES sessions(id),
+      timestamp      INTEGER NOT NULL,
+      tokens_before  INTEGER,
+      tokens_after   INTEGER,
+      summary        TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_parent    ON sessions(parent_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started   ON sessions(started_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id);
+  `);
+
+  // ── Prepared statements ───────────────────────────────────────────────────
+  const stmts = {
+    upsertSession: db.prepare(`
+      INSERT INTO sessions(id, parent_id, label, status, started_at, ended_at, cost_usd,
+        tokens_in, tokens_out, cache_read, last_text, cwd, permission_mode, entrypoint,
+        version, git_branch, package_json)
+      VALUES(@id, @parent_id, @label, @status, @started_at, @ended_at, @cost_usd,
+        @tokens_in, @tokens_out, @cache_read, @last_text, @cwd, @permission_mode, @entrypoint,
+        @version, @git_branch, @package_json)
+      ON CONFLICT(id) DO UPDATE SET
+        label=excluded.label, status=excluded.status, ended_at=excluded.ended_at,
+        cost_usd=excluded.cost_usd, tokens_in=excluded.tokens_in, tokens_out=excluded.tokens_out,
+        cache_read=excluded.cache_read, last_text=excluded.last_text, cwd=excluded.cwd,
+        permission_mode=excluded.permission_mode, entrypoint=excluded.entrypoint,
+        version=excluded.version, git_branch=excluded.git_branch,
+        package_json=COALESCE(excluded.package_json, package_json)
+    `),
+
+    upsertTool: db.prepare(`
+      INSERT INTO tool_calls(id, session_id, name, summary, input_json, done, started_at, duration_ms)
+      VALUES(@id, @session_id, @name, @summary, @input_json, @done, @started_at, @duration_ms)
+      ON CONFLICT(id) DO UPDATE SET
+        done=excluded.done, duration_ms=excluded.duration_ms, summary=excluded.summary
+    `),
+
+    upsertCompaction: db.prepare(`
+      INSERT INTO compactions(id, session_id, timestamp, tokens_before, tokens_after, summary)
+      VALUES(@id, @session_id, @timestamp, @tokens_before, @tokens_after, @summary)
+      ON CONFLICT(id) DO UPDATE SET
+        tokens_after=excluded.tokens_after, summary=excluded.summary
+    `),
+
+    listRootSessions: db.prepare(`
+      SELECT id, label, status, started_at, ended_at, cost_usd,
+             tokens_in, tokens_out, cache_read, cwd, permission_mode
+      FROM sessions WHERE parent_id IS NULL
+      ORDER BY started_at DESC LIMIT 100
+    `),
+
+    getSession: db.prepare(`
+      SELECT id, parent_id, label, status, started_at, ended_at, cost_usd,
+             tokens_in, tokens_out, cache_read, last_text, cwd, permission_mode,
+             entrypoint, version, git_branch, package_json
+      FROM sessions WHERE id = ?
+    `),
+
+    getToolCalls:  db.prepare(`SELECT * FROM tool_calls  WHERE session_id = ? ORDER BY started_at`),
+    getCompactions: db.prepare(`SELECT * FROM compactions WHERE session_id = ? ORDER BY timestamp`),
+    getChildren:    db.prepare(`SELECT id FROM sessions   WHERE parent_id  = ? ORDER BY started_at`),
+  };
+
+  // ── Persist helpers ───────────────────────────────────────────────────────
+
+  function persistSession(node) {
+    if (node.isSidechain) return; // virtual nodes — never persisted
+    stmts.upsertSession.run({
+      id:              node.sessionId,
+      parent_id:       node.parentSessionId || null,
+      label:           node.label,
+      status:          node.status,
+      started_at:      node.startedAt,
+      ended_at:        node.endedAt || null,
+      cost_usd:        node.costUsd,
+      tokens_in:       node.tokens.input,
+      tokens_out:      node.tokens.output,
+      cache_read:      node.tokens.cacheRead,
+      last_text:       node.lastText       || '',
+      cwd:             node.cwd            || null,
+      permission_mode: node.permissionMode || null,
+      entrypoint:      node.entrypoint     || null,
+      version:         node.version        || null,
+      git_branch:      node.gitBranch      || null,
+      package_json:    node.packageJson ? JSON.stringify(node.packageJson) : null,
+    });
+  }
+
+  function persistTool(tc) {
+    stmts.upsertTool.run({
+      id:          tc.id,
+      session_id:  tc.sessionId,
+      name:        tc.name,
+      summary:     tc.summary,
+      input_json:  tc.input ? JSON.stringify(tc.input) : null,
+      done:        tc.done ? 1 : 0,
+      started_at:  tc.startedAt,
+      duration_ms: tc.durationMs || null,
+    });
+  }
+
+  function persistCompaction(c, sessionId) {
+    stmts.upsertCompaction.run({
+      id:            c.id,
+      session_id:    sessionId,
+      timestamp:     c.timestamp,
+      tokens_before: c.tokensBefore || null,
+      tokens_after:  c.tokensAfter  || null,
+      summary:       c.summary || null,
+    });
+  }
+
+  return { db, stmts, persistSession, persistTool, persistCompaction };
+}
+
+module.exports = { createDb };

package/lib/parser.js

@@ -0,0 +1,279 @@
+'use strict';
+/**
+ * Pure parsing helpers — no side effects, fully testable, no DB dependency.
+ * Used by agent-trace-daemon.js and the test suite.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+const UUID_RE      = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+// ── Security helpers ──────────────────────────────────────────────────────────
+
+function isValidSessionId(id) {
+  return typeof id === 'string' && UUID_RE.test(id);
+}
+
+/** Returns a canonicalised project directory for a cwd, or null if unsafe. */
+function safeCwdToProjectDir(cwd) {
+  if (!cwd || typeof cwd !== 'string') return null;
+  if (cwd.includes('..')) return null;
+  if (!path.isAbsolute(cwd)) return null;
+  try {
+    const parts = cwd.replace(/\\/g, '/').split('/').filter(Boolean);
+    const encoded = parts.map(p => encodeURIComponent(p).replace(/%2F/g, '-')).join('-');
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', `-${encoded}`);
+    return projectDir;
+  } catch { return null; }
+}
+
+/** Returns true if the given file path is safe to access (within allowed dirs). */
+function safeFilePath(p) {
+  if (!p || typeof p !== 'string') return false;
+  try {
+    const resolved = path.resolve(p);
+    const home = os.homedir();
+    return resolved.startsWith(path.join(home, '.claude')) ||
+           resolved.startsWith(path.join(home, 'Library', 'Application Support', 'Claude'));
+  } catch { return false; }
+}
+
+// ── Tool input summarizer ─────────────────────────────────────────────────────
+
+function summarize(name, input) {
+  if (!input) return '';
+  try {
+    switch (name) {
+      case 'Read': case 'Write': case 'Edit': return input.file_path || '';
+      case 'Glob':      return input.pattern || '';
+      case 'Grep':      return `"${(input.pattern||'').slice(0, 60)}"`;
+      case 'Bash':      return (input.command||'').slice(0, 80);
+      case 'Agent': case 'Task': return input.description || input.prompt || '';
+      case 'WebSearch': return `"${(input.query||'').slice(0, 60)}"`;
+      case 'WebFetch':  return input.url || '';
+      default:          return JSON.stringify(input).slice(0, 80);
+    }
+  } catch { return ''; }
+}
+
+// ── Transcript file discovery ─────────────────────────────────────────────────
+
+function findTranscript(sessionId, cwd) {
+  if (!isValidSessionId(sessionId)) return null;
+  if (cwd) {
+    const projectDir = safeCwdToProjectDir(cwd);
+    if (projectDir) {
+      const p = path.join(projectDir, `${sessionId}.jsonl`);
+      if (safeFilePath(p) && fs.existsSync(p)) return p;
+    }
+  }
+  try {
+    for (const proj of fs.readdirSync(PROJECTS_DIR)) {
+      const p = path.join(PROJECTS_DIR, proj, `${sessionId}.jsonl`);
+      if (safeFilePath(p) && fs.existsSync(p)) return p;
+    }
+  } catch {}
+  return null;
+}
+
+// ── Pricing table ─────────────────────────────────────────────────────────────
+
+const PRICING = {
+  // Claude 4.x Sonnet
+  'claude-sonnet-4-6':         { input: 3.0,  output: 15.0, cacheRead: 0.30, cacheWrite: 3.75 },
+  'claude-sonnet-4-5':         { input: 3.0,  output: 15.0, cacheRead: 0.30, cacheWrite: 3.75 },
+  'claude-sonnet-4-20250514':  { input: 3.0,  output: 15.0, cacheRead: 0.30, cacheWrite: 3.75 },
+  // Claude 4.x Opus
+  'claude-opus-4-6':           { input: 5.0,  output: 25.0, cacheRead: 0.50, cacheWrite: 6.25 },
+  'claude-opus-4-5':           { input: 5.0,  output: 25.0, cacheRead: 0.50, cacheWrite: 6.25 },
+  'claude-opus-4-1':           { input: 15.0, output: 75.0, cacheRead: 1.50, cacheWrite: 18.75 },
+  'claude-opus-4-20250514':    { input: 15.0, output: 75.0, cacheRead: 1.50, cacheWrite: 18.75 },
+  'claude-opus-3':             { input: 15.0, output: 75.0, cacheRead: 1.50, cacheWrite: 18.75 },
+  // Haiku
+  'claude-haiku-4-5':          { input: 1.0,  output: 5.0,  cacheRead: 0.10, cacheWrite: 1.25 },
+  'claude-haiku-4-5-20251001': { input: 1.0,  output: 5.0,  cacheRead: 0.10, cacheWrite: 1.25 },
+  'claude-haiku-3-5':          { input: 0.80, output: 4.0,  cacheRead: 0.08, cacheWrite: 1.0  },
+  'claude-haiku-3':            { input: 0.25, output: 1.25, cacheRead: 0.03, cacheWrite: 0.30 },
+};
+const DEFAULT_PRICE = { input: 3.0, output: 15.0, cacheRead: 0.30, cacheWrite: 3.75 };
+
+// ── Transcript parsers ────────────────────────────────────────────────────────
+
+/** Extract session metadata from first 100 lines of transcript. */
+function parseTranscriptMeta(filePath) {
+  const meta = { permissionMode: null, entrypoint: null, version: null, gitBranch: null, model: null, label: null };
+  try {
+    const lines = fs.readFileSync(filePath, 'utf8').split('\n').slice(0, 100);
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === 'permission-mode' && obj.permissionMode) meta.permissionMode = obj.permissionMode;
+        if (obj.permissionMode && obj.subtype === 'init') meta.permissionMode = obj.permissionMode;
+        if (obj.entrypoint) meta.entrypoint = obj.entrypoint;
+        if (obj.version)    meta.version    = obj.version;
+        if (obj.gitBranch)  meta.gitBranch  = obj.gitBranch;
+        if (obj.message?.model) meta.model  = obj.message.model;
+        if (!meta.label && obj.type === 'user' && obj.message?.content) {
+          const c = obj.message.content;
+          const text = typeof c === 'string' ? c
+            : (Array.isArray(c) ? c.filter(b => b.type === 'text').map(b => b.text).join('') : '');
+          if (text && !text.startsWith('<') && !text.startsWith('/') && text.length > 5) {
+            meta.label = text.replace(/\s+/g, ' ').trim().slice(0, 60);
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  return meta;
+}
+
+/**
+ * Parse compact_boundary events from a transcript.
+ * The summary is taken from the user message whose parentUuid matches the boundary uuid.
+ */
+function parseTranscriptCompactions(filePath) {
+  const results = [];
+  try {
+    const lines = fs.readFileSync(filePath, 'utf8').split('\n');
+    const compactMap = new Map();
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === 'system' && obj.subtype === 'compact_boundary') {
+          const meta = obj.compactMetadata || {};
+          const sid  = obj.sessionId || '';
+          const entry = {
+            id:           `compact-${sid}-${obj.uuid || Date.now()}`,
+            uuid:         obj.uuid,
+            timestamp:    obj.timestamp ? new Date(obj.timestamp).getTime() : Date.now(),
+            summary:      '',
+            tokensBefore: meta.preTokens || null,
+            tokensAfter:  meta.postTokens || null,
+          };
+          compactMap.set(obj.uuid, entry);
+          results.push(entry);
+        }
+        if (obj.type === 'user' && obj.parentUuid && compactMap.has(obj.parentUuid)) {
+          const entry = compactMap.get(obj.parentUuid);
+          const content = obj.message?.content;
+          if (typeof content === 'string' && content.length > 10) {
+            entry.summary = content;
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block.type === 'text' && block.text?.length > 10) { entry.summary = block.text; break; }
+            }
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  return results;
+}
+
+/** Sum token usage from a single transcript file. Returns { inputTokens, outputTokens, cacheReadTokens, costUsd }. */
+function parseTranscriptStats(filePath) {
+  let inputTokens = 0, outputTokens = 0, cacheReadTokens = 0, cacheWriteTokens = 0;
+  let model = null;
+  try {
+    const lines = fs.readFileSync(filePath, 'utf8').split('\n');
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        const msg = obj.message;
+        if (!msg) continue;
+        if (msg.model && !model) model = msg.model;
+        const u = msg.usage;
+        if (!u) continue;
+        inputTokens      += u.input_tokens                                    || 0;
+        outputTokens     += u.output_tokens                                   || 0;
+        cacheReadTokens  += u.cache_read_input_tokens                         || 0;
+        cacheWriteTokens += (u.cache_creation?.ephemeral_5m_input_tokens     || 0)
+                          + (u.cache_creation?.ephemeral_1h_input_tokens     || 0)
+                          + (u.cache_creation_input_tokens                   || 0);
+      } catch {}
+    }
+  } catch {}
+  const price = (model && PRICING[model]) ? PRICING[model] : DEFAULT_PRICE;
+  const costUsd = (inputTokens      * price.input      / 1e6)
+                + (outputTokens     * price.output     / 1e6)
+                + (cacheReadTokens  * price.cacheRead  / 1e6)
+                + (cacheWriteTokens * price.cacheWrite / 1e6);
+  return { inputTokens, outputTokens, cacheReadTokens, costUsd: Math.round(costUsd * 1e6) / 1e6 };
+}
+
+/** Find child session UUIDs referenced in Agent/Task tool results inside a transcript. */
+function findChildSessionIds(filePath, rootSessionId) {
+  const childIds = new Set();
+  const projectDir = path.dirname(filePath);
+  const agentToolUseIds = new Set();
+  try {
+    const lines = fs.readFileSync(filePath, 'utf8').split('\n');
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        for (const block of (obj.message?.content || [])) {
+          if (block.type === 'tool_use' && (block.name === 'Agent' || block.name === 'Task')) {
+            agentToolUseIds.add(block.id);
+          }
+          if (block.type === 'tool_result' && agentToolUseIds.has(block.tool_use_id)) {
+            const text = typeof block.content === 'string'
+              ? block.content : JSON.stringify(block.content || '');
+            const uuids = text.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/g) || [];
+            for (const uuid of uuids) {
+              if (uuid === rootSessionId) continue;
+              if (fs.existsSync(path.join(projectDir, `${uuid}.jsonl`))) childIds.add(uuid);
+            }
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  return [...childIds];
+}
+
+/**
+ * Recursively sum token stats for a session and all subagents referenced from its transcript.
+ * Root nodes get the full tree total — use root-only aggregation in the UI to avoid double-counting.
+ */
+function parseFullSessionStats(filePath, rootSessionId, visited = new Set(), depth = 0) {
+  if (visited.has(filePath) || depth > 50) return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, costUsd: 0 };
+  visited.add(filePath);
+
+  const stats = parseTranscriptStats(filePath);
+  const childIds = findChildSessionIds(filePath, rootSessionId);
+
+  for (const childId of childIds) {
+    const childPath = path.join(path.dirname(filePath), `${childId}.jsonl`);
+    const childStats = parseFullSessionStats(childPath, childId, visited, depth + 1);
+    stats.inputTokens     += childStats.inputTokens;
+    stats.outputTokens    += childStats.outputTokens;
+    stats.cacheReadTokens += childStats.cacheReadTokens;
+    stats.costUsd         += childStats.costUsd;
+  }
+  stats.costUsd = Math.round(stats.costUsd * 1e6) / 1e6;
+  return stats;
+}
+
+module.exports = {
+  PROJECTS_DIR,
+  isValidSessionId,
+  safeCwdToProjectDir,
+  safeFilePath,
+  summarize,
+  findTranscript,
+  PRICING,
+  DEFAULT_PRICE,
+  parseTranscriptMeta,
+  parseTranscriptCompactions,
+  parseTranscriptStats,
+  findChildSessionIds,
+  parseFullSessionStats,
+};