@unpolarize/code-sessions 0.1.0

package/dist/cli.js

@@ -0,0 +1,308 @@
+import {
+  GitStore,
+  HELP,
+  cmdBackfill,
+  cmdDoctor,
+  cmdExport,
+  cmdIndex,
+  cmdInit,
+  cmdInstallHooks,
+  cmdQuery,
+  cmdReindex,
+  cmdSearch,
+  cmdStatus,
+  envelopeFile,
+  handleHookInput,
+  insightsFile,
+  listSessionDirs,
+  loadConfig,
+  overridesFromFlags,
+  parseFlags,
+  readStdin,
+  startDaemon
+} from "./chunk-ZJG2DWAK.js";
+
+// src/analytics/command.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// src/analytics/digest.ts
+function renderDigest(report) {
+  const lines = [];
+  lines.push("# Session digest");
+  lines.push("");
+  lines.push(`_Generated ${report.generated_at}_`);
+  lines.push("");
+  lines.push(`- **Sessions:** ${report.sessions}`);
+  lines.push(
+    `- **Tokens:** ${report.totals.input_tokens.toLocaleString()} in / ${report.totals.output_tokens.toLocaleString()} out`
+  );
+  lines.push(`- **Estimated cost:** $${report.totals.cost_usd.toFixed(2)}`);
+  lines.push(`- **Hosts:** ${Object.entries(report.hosts).map(([h, n]) => `${h} (${n})`).join(", ") || "\u2014"}`);
+  lines.push("");
+  if (report.topTopics.length) {
+    lines.push("## Top topics");
+    for (const t of report.topTopics) lines.push(`- ${t.topic} \u2014 ${t.count}`);
+    lines.push("");
+  }
+  if (report.topTags.length) {
+    lines.push("## Top tags");
+    lines.push(report.topTags.map((t) => `\`${t.tag}\` (${t.count})`).join(" \xB7 "));
+    lines.push("");
+  }
+  if (Object.keys(report.signalCounts).length) {
+    lines.push("## Signals");
+    for (const [kind, count] of Object.entries(report.signalCounts).sort((a, b) => b[1] - a[1])) {
+      lines.push(`- ${kind}: ${count}`);
+    }
+    lines.push("");
+  }
+  if (report.similar.length) {
+    lines.push("## Related sessions (shared tags)");
+    for (const s of report.similar) lines.push(`- \`${s.tag}\`: ${s.sessions.length} sessions`);
+    lines.push("");
+  }
+  if (Object.keys(report.byMonth).length) {
+    lines.push("## By month");
+    for (const [month, m] of Object.entries(report.byMonth).sort()) {
+      lines.push(`- ${month}: ${m.sessions} sessions, $${m.cost_usd.toFixed(2)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/analytics/rollup.ts
+import { existsSync, readFileSync } from "fs";
+import {
+  safeParseInsights,
+  safeParseSession
+} from "@unpolarize/code-sessions-schema";
+function loadSession(ref) {
+  const out = { ref };
+  const envPath = envelopeFile(ref.dir);
+  if (existsSync(envPath)) {
+    try {
+      const parsed = safeParseSession(JSON.parse(readFileSync(envPath, "utf8")));
+      if (parsed.success) out.envelope = parsed.data;
+    } catch {
+    }
+  }
+  const insPath = insightsFile(ref.dir);
+  if (existsSync(insPath)) {
+    try {
+      const parsed = safeParseInsights(JSON.parse(readFileSync(insPath, "utf8")));
+      if (parsed.success) out.insights = parsed.data;
+    } catch {
+    }
+  }
+  return out;
+}
+function topN(counts, n) {
+  return [...counts.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count || a.key.localeCompare(b.key)).slice(0, n);
+}
+function computeReport(storeDir, now) {
+  const refs = listSessionDirs(storeDir);
+  const loaded = refs.map(loadSession);
+  const hosts = {};
+  const byMonth = {};
+  const totals = { input_tokens: 0, output_tokens: 0, cost_usd: 0 };
+  const topicCounts = /* @__PURE__ */ new Map();
+  const tagCounts = /* @__PURE__ */ new Map();
+  const tagToSessions = /* @__PURE__ */ new Map();
+  const signalCounts = {};
+  for (const { ref, envelope, insights } of loaded) {
+    hosts[ref.host] = (hosts[ref.host] ?? 0) + 1;
+    const month = byMonth[ref.month] ??= { sessions: 0, cost_usd: 0 };
+    month.sessions++;
+    if (envelope) {
+      totals.input_tokens += envelope.totals.input_tokens;
+      totals.output_tokens += envelope.totals.output_tokens;
+      totals.cost_usd += envelope.totals.cost_usd;
+      month.cost_usd += envelope.totals.cost_usd;
+    }
+    if (insights) {
+      if (insights.topic) topicCounts.set(insights.topic, (topicCounts.get(insights.topic) ?? 0) + 1);
+      for (const tag of insights.tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+        (tagToSessions.get(tag) ?? tagToSessions.set(tag, []).get(tag)).push(ref.sessionId);
+      }
+      for (const sig of insights.signals) {
+        signalCounts[sig.kind] = (signalCounts[sig.kind] ?? 0) + 1;
+      }
+    }
+  }
+  totals.cost_usd = Math.round(totals.cost_usd * 1e6) / 1e6;
+  for (const m of Object.values(byMonth)) m.cost_usd = Math.round(m.cost_usd * 1e6) / 1e6;
+  const similar = [...tagToSessions.entries()].filter(([, s]) => s.length >= 2).map(([tag, sessions]) => ({ tag, sessions: [...new Set(sessions)] })).sort((a, b) => b.sessions.length - a.sessions.length).slice(0, 10);
+  return {
+    generated_at: now,
+    sessions: loaded.length,
+    hosts,
+    totals,
+    byMonth,
+    topTopics: topN(topicCounts, 10).map(({ key, count }) => ({ topic: key, count })),
+    topTags: topN(tagCounts, 15).map(({ key, count }) => ({ tag: key, count })),
+    signalCounts,
+    similar
+  };
+}
+
+// src/analytics/site.ts
+function esc(s) {
+  return s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+}
+function renderSite(report) {
+  const rows = (pairs) => pairs.map(([k, v]) => `<tr><td>${esc(k)}</td><td>${esc(String(v))}</td></tr>`).join("");
+  const topics = report.topTopics.map((t) => `<li>${esc(t.topic)} \u2014 ${t.count}</li>`).join("");
+  const tags = report.topTags.map((t) => `<span class="tag">${esc(t.tag)} (${t.count})</span>`).join(" ");
+  const signals = Object.entries(report.signalCounts).map(([k, v]) => `<li>${esc(k)}: ${v}</li>`).join("");
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>code-sessions \u2014 analytics</title>
+<style>
+  body{font:14px/1.5 system-ui,sans-serif;margin:2rem auto;max-width:720px;color:#111}
+  h1{margin-bottom:.2rem} .muted{color:#666}
+  table{border-collapse:collapse;margin:1rem 0} td{padding:.2rem .8rem;border-bottom:1px solid #eee}
+  .tag{display:inline-block;background:#eef;border-radius:4px;padding:.1rem .4rem;margin:.1rem}
+  ul{margin:.3rem 0}
+</style></head><body>
+<h1>code-sessions</h1>
+<div class="muted">analytics \xB7 generated ${esc(report.generated_at)}</div>
+<table>${rows([
+    ["Sessions", report.sessions],
+    ["Input tokens", report.totals.input_tokens],
+    ["Output tokens", report.totals.output_tokens],
+    ["Estimated cost (USD)", report.totals.cost_usd.toFixed(2)]
+  ])}</table>
+<h2>Top topics</h2><ul>${topics || '<li class="muted">none</li>'}</ul>
+<h2>Top tags</h2><div>${tags || '<span class="muted">none</span>'}</div>
+<h2>Signals</h2><ul>${signals || '<li class="muted">none</li>'}</ul>
+</body></html>
+`;
+}
+
+// src/analytics/command.ts
+async function cmdAnalytics(cfg, opts = {}) {
+  const now = opts.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const report = computeReport(cfg.storeDir, now);
+  const dir = join(cfg.storeDir, "analytics");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "report.json"), `${JSON.stringify(report, null, 2)}
+`);
+  writeFileSync(join(dir, "digest.md"), renderDigest(report));
+  writeFileSync(join(dir, "index.html"), renderSite(report));
+  const git = new GitStore(cfg.storeDir, {
+    ...cfg.git.remote ? { remote: cfg.git.remote } : {},
+    autoPush: cfg.git.autoPush
+  });
+  if (git.isRepo()) git.sync(`analytics rollup (${report.sessions} sessions)`);
+  return {
+    code: 0,
+    output: `Analytics written for ${report.sessions} session(s) \u2192 ${dir}`
+  };
+}
+
+// src/cli.ts
+function emit(res) {
+  if (res.output) process.stdout.write(`${res.output}
+`);
+  process.exit(res.code);
+}
+async function main(argv) {
+  const command = argv[0];
+  const flags = parseFlags(argv.slice(1));
+  const cfg = loadConfig(overridesFromFlags(flags));
+  switch (command) {
+    case "init":
+      emit(cmdInit(cfg));
+      break;
+    case "status":
+      emit(cmdStatus(cfg));
+      break;
+    case "doctor":
+      emit(cmdDoctor(cfg));
+      break;
+    case "install-hooks":
+      emit(
+        cmdInstallHooks(cfg, {
+          ...typeof flags.settings === "string" ? { settingsPath: flags.settings } : {},
+          ...typeof flags.command === "string" ? { command: flags.command } : {}
+        })
+      );
+      break;
+    case "backfill":
+      emit(
+        await cmdBackfill(cfg, {
+          ...typeof flags.projects === "string" ? { projectsDir: flags.projects } : {},
+          ...typeof flags.agent === "string" ? { agent: flags.agent } : {}
+        })
+      );
+      break;
+    case "reindex":
+      emit(await cmdReindex(cfg, typeof flags.since === "string" ? { since: flags.since } : {}));
+      break;
+    case "analytics":
+      emit(await cmdAnalytics(cfg));
+      break;
+    case "export":
+      emit(await cmdExport(cfg, typeof flags.since === "string" ? { since: flags.since } : {}));
+      break;
+    case "index":
+      emit(cmdIndex(cfg));
+      break;
+    case "query":
+      emit(
+        cmdQuery(cfg, {
+          ...typeof flags.limit === "string" ? { limit: Number(flags.limit) } : {},
+          ...typeof flags.agent === "string" ? { agent: flags.agent } : {}
+        })
+      );
+      break;
+    case "search": {
+      const q = argv.slice(1).find((a) => !a.startsWith("--")) ?? "";
+      emit(cmdSearch(cfg, { query: q, ...typeof flags.limit === "string" ? { limit: Number(flags.limit) } : {} }));
+      break;
+    }
+    case "hook": {
+      try {
+        const input = await readStdin();
+        await handleHookInput(cfg.socketPath, input);
+      } catch {
+      }
+      process.exit(0);
+      break;
+    }
+    case "start": {
+      const daemon = await startDaemon(cfg);
+      process.stdout.write(`code-sessions daemon listening on ${cfg.socketPath}
+`);
+      const stop = async () => {
+        await daemon.stop();
+        process.exit(0);
+      };
+      process.on("SIGINT", stop);
+      process.on("SIGTERM", stop);
+      break;
+    }
+    case "help":
+    case "--help":
+    case void 0:
+      process.stdout.write(HELP);
+      process.exit(command ? 0 : 1);
+      break;
+    default:
+      process.stderr.write(`Unknown command: ${command}
+
+${HELP}`);
+      process.exit(1);
+  }
+}
+main(process.argv.slice(2)).catch((err) => {
+  process.stderr.write(`error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+export {
+  main
+};

package/dist/index.js

@@ -0,0 +1,162 @@
+import {
+  CaptureEngine,
+  DEFAULT_HOOK_EVENTS,
+  Daemon,
+  FakeProvider,
+  GitStore,
+  LlmProvider,
+  SessionIndex,
+  StateStore,
+  THRESHOLDS,
+  applyHygiene,
+  buildMetricPayload,
+  buildPrompt,
+  buildTracePayload,
+  claudeRunner,
+  cmdBackfill,
+  cmdDoctor,
+  cmdExport,
+  cmdIndex,
+  cmdInit,
+  cmdInstallHooks,
+  cmdQuery,
+  cmdReindex,
+  cmdSearch,
+  cmdStatus,
+  codexSessionsRoot,
+  computeEnvelope,
+  defaultConfig,
+  deriveSignals,
+  deriveTags,
+  discoverCodexSessions,
+  discoverGrokSessions,
+  envelopeFile,
+  estimateCostUsd,
+  exportSession,
+  exportStore,
+  findTranscript,
+  grokRunner,
+  grokSessionsRoot,
+  guessTopic,
+  handleHookInput,
+  insightsFile,
+  installHooks,
+  isSessionEndEvent,
+  isoNano,
+  labelSession,
+  listClaudeTranscripts,
+  listSessionDirs,
+  loadConfig,
+  makeProvider,
+  mergeHooks,
+  monthOf,
+  ollamaRunner,
+  overridesFromFlags,
+  parseCodexSession,
+  parseFlags,
+  parseGrokSession,
+  parseHookEvent,
+  parseLabelJson,
+  postOtlp,
+  priceFor,
+  rawBlobFile,
+  readEntries,
+  readNewLines,
+  readStdin,
+  readTurns,
+  rebuildEnvelope,
+  reindexStore,
+  resolveConfig,
+  scrubSecrets,
+  sendEvent,
+  sessionDir,
+  sha256,
+  startDaemon,
+  syncIndex,
+  telemetryFile,
+  turnFile,
+  writeBlobFile,
+  writeImportedSession,
+  writeTurnFile
+} from "./chunk-ZJG2DWAK.js";
+export {
+  CaptureEngine,
+  DEFAULT_HOOK_EVENTS,
+  Daemon,
+  FakeProvider,
+  GitStore,
+  LlmProvider,
+  SessionIndex,
+  StateStore,
+  THRESHOLDS,
+  applyHygiene,
+  buildMetricPayload,
+  buildPrompt,
+  buildTracePayload,
+  claudeRunner,
+  cmdBackfill,
+  cmdDoctor,
+  cmdExport,
+  cmdIndex,
+  cmdInit,
+  cmdInstallHooks,
+  cmdQuery,
+  cmdReindex,
+  cmdSearch,
+  cmdStatus,
+  codexSessionsRoot,
+  computeEnvelope,
+  defaultConfig,
+  deriveSignals,
+  deriveTags,
+  discoverCodexSessions,
+  discoverGrokSessions,
+  envelopeFile,
+  estimateCostUsd,
+  exportSession,
+  exportStore,
+  findTranscript,
+  grokRunner,
+  grokSessionsRoot,
+  guessTopic,
+  handleHookInput,
+  insightsFile,
+  installHooks,
+  isSessionEndEvent,
+  isoNano,
+  labelSession,
+  listClaudeTranscripts,
+  listSessionDirs,
+  loadConfig,
+  makeProvider,
+  mergeHooks,
+  monthOf,
+  ollamaRunner,
+  overridesFromFlags,
+  parseCodexSession,
+  parseFlags,
+  parseGrokSession,
+  parseHookEvent,
+  parseLabelJson,
+  postOtlp,
+  priceFor,
+  rawBlobFile,
+  readEntries,
+  readNewLines,
+  readStdin,
+  readTurns,
+  rebuildEnvelope,
+  reindexStore,
+  resolveConfig,
+  scrubSecrets,
+  sendEvent,
+  sessionDir,
+  sha256,
+  startDaemon,
+  syncIndex,
+  telemetryFile,
+  turnFile,
+  writeBlobFile,
+  writeImportedSession,
+  writeTurnFile
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@unpolarize/code-sessions",
+  "version": "0.1.0",
+  "description": "Headless, event-driven cross-agent session capture agent (daemon + CLI)",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "code-sessions": "./bin/code-sessions.mjs"
+  },
+  "main": "./dist/index.js",
+  "files": ["dist", "src", "bin"],
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "git+https://github.com/unpolarize/code-sessions.git", "directory": "packages/agent" },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --clean --out-dir dist"
+  },
+  "dependencies": {
+    "@unpolarize/code-sessions-schema": "^0.1.0",
+    "zod": "^3.23.8"
+  }
+}

package/src/adapters/adapters.test.ts

@@ -0,0 +1,121 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { sessionDir, turnFile, envelopeFile } from '../store/paths';
+import { makeConfig, withTempDir } from '../test/tmp';
+import { discoverCodexSessions, parseCodexSession } from './codex';
+import { discoverGrokSessions, parseGrokSession } from './grok';
+import { writeImportedSession } from './import';
+
+function seedGrok(root: string): void {
+  const dir = join(root, '%2FUsers%2Fx%2Fprojects%2Ffoo', 'gg-uuid-1');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, 'summary.json'),
+    JSON.stringify({
+      created_at: '2026-06-20T08:00:00Z',
+      generated_title: 'Fix foo bug',
+      current_model_id: 'grok-build',
+      info: { cwd: '/Users/x/projects/foo' },
+    }),
+  );
+  writeFileSync(
+    join(dir, 'chat_history.jsonl'),
+    [
+      '{"type":"system","content":"sys"}',
+      '{"type":"user","content":"Fix the bug in foo.ts"}',
+      '{"type":"reasoning","summary":"thinking"}',
+      '{"type":"assistant","content":"I\'ll edit it","model_id":"grok-build","tool_calls":[{"id":"c1","name":"Read","arguments":"{\\"path\\":\\"/Users/x/projects/foo/a.ts\\"}"}]}',
+      '{"type":"tool_result","tool_call_id":"c1","content":"file contents"}',
+    ].join('\n'),
+  );
+}
+
+describe('grok adapter', () => {
+  it('discovers and parses a grok session into canonical turns', () => {
+    withTempDir((root) => {
+      seedGrok(root);
+      const found = discoverGrokSessions(root);
+      expect(found).toHaveLength(1);
+      const imported = parseGrokSession(found[0]!, 'test-host')!;
+      expect(imported.agent).toBe('grok');
+      expect(imported.turns.map((t) => t.role)).toEqual(['user', 'assistant', 'tool']);
+      expect(imported.turns[1]!.tool_calls[0]).toMatchObject({ name: 'Read' });
+      expect(imported.meta.model).toBe('grok-build');
+      expect(imported.meta.title).toBe('Fix foo bug');
+      expect(imported.meta.started_at).toBe('2026-06-20T08:00:00.000Z');
+    });
+  });
+
+  it('skips claude_import grok sessions', () => {
+    withTempDir((root) => {
+      const dir = join(root, '%2Fx', 'ci');
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, 'summary.json'), JSON.stringify({ session_kind: 'claude_import' }));
+      writeFileSync(join(dir, 'chat_history.jsonl'), '{"type":"user","content":"hi"}');
+      expect(parseGrokSession(discoverGrokSessions(root)[0]!, 'h')).toBeNull();
+    });
+  });
+});
+
+function seedCodex(root: string): void {
+  const dir = join(root, '2026', '06', '20');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, 'rollout-2026-06-20T09-00-00-11111111-2222-3333-4444-555555555555.jsonl'),
+    [
+      '{"timestamp":"2026-06-20T09:00:00Z","type":"session_meta","payload":{"id":"11111111-2222-3333-4444-555555555555","timestamp":"2026-06-20T09:00:00Z","model":"gpt-5-codex","cwd":"/Users/x/proj"}}',
+      '{"timestamp":"2026-06-20T09:00:01Z","type":"event_msg","payload":{"type":"task_started","turn_id":"t1"}}',
+      '{"timestamp":"2026-06-20T09:00:02Z","type":"response_item","payload":{"type":"message","role":"developer","content":[{"type":"input_text","text":"<permission scaffolding>"}]}}',
+      '{"timestamp":"2026-06-20T09:00:03Z","type":"event_msg","payload":{"type":"user_message","message":"print 42","images":[]}}',
+      '{"timestamp":"2026-06-20T09:00:04Z","type":"response_item","payload":{"type":"function_call","name":"shell","arguments":"{\\"command\\":\\"echo 42\\"}"}}',
+      '{"timestamp":"2026-06-20T09:00:05Z","type":"event_msg","payload":{"type":"agent_message","message":"42","phase":"final_answer"}}',
+      '{"timestamp":"2026-06-20T09:00:06Z","type":"event_msg","payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":100,"cached_input_tokens":10,"output_tokens":5}}}}',
+      '{"timestamp":"2026-06-20T09:00:07Z","type":"event_msg","payload":{"type":"task_complete","turn_id":"t1"}}',
+    ].join('\n'),
+  );
+}
+
+describe('codex adapter', () => {
+  it('discovers and parses a codex rollout into canonical turns', () => {
+    withTempDir((root) => {
+      seedCodex(root);
+      const found = discoverCodexSessions(root);
+      expect(found).toHaveLength(1);
+      expect(found[0]!.sessionId).toBe('11111111-2222-3333-4444-555555555555');
+      const imported = parseCodexSession(found[0]!, 'test-host')!;
+      expect(imported.agent).toBe('codex');
+      expect(imported.meta.model).toBe('gpt-5-codex');
+      expect(imported.meta.project_path).toBe('/Users/x/proj');
+      expect(imported.turns.map((t) => t.role)).toEqual(['user', 'assistant', 'assistant']);
+      expect(imported.turns[0]!.text).toBe('print 42'); // from event_msg/user_message
+      expect(imported.turns[1]!.tool_calls[0]).toMatchObject({ name: 'shell' });
+      expect(imported.turns[2]!.text).toBe('42'); // from event_msg/agent_message
+      // cumulative token_count attributed to the final assistant turn
+      expect(imported.turns[2]!.usage.input_tokens).toBe(100);
+      expect(imported.turns[2]!.usage.cache_read_tokens).toBe(10);
+    });
+  });
+});
+
+describe('writeImportedSession', () => {
+  it('writes per-turn files + envelope for an imported session', () => {
+    withTempDir((store) => {
+      seedGrokInStore(store);
+    });
+  });
+});
+
+function seedGrokInStore(store: string): void {
+  const grokRoot = join(store, 'grok');
+  seedGrok(grokRoot);
+  const imported = parseGrokSession(discoverGrokSessions(grokRoot)[0]!, 'other-host')!;
+  const cfg = makeConfig(store);
+  const res = writeImportedSession(cfg, imported);
+  const dir = sessionDir(store, 'other-host', '2026-06', 'gg-uuid-1');
+  expect(res.sessionDir).toBe(dir);
+  expect(existsSync(turnFile(dir, 0))).toBe(true);
+  expect(existsSync(envelopeFile(dir))).toBe(true);
+  expect(res.envelope.agent).toBe('grok');
+  expect(res.envelope.native_ref.format).toBe('grok-jsonl');
+}