@unpolarize/code-sessions 0.1.0

package/src/telemetry/otlp.ts

@@ -0,0 +1,215 @@
+import { createHash } from 'node:crypto';
+import type { SessionEnvelope, Turn } from '@unpolarize/code-sessions-schema';
+
+/**
+ * Minimal OTLP/HTTP JSON exporter — emits standard OpenTelemetry traces +
+ * metrics for captured sessions to any OTLP collector, with no SDK dependency.
+ * One trace per session (root span + a child span per turn) + token/cost metrics.
+ */
+
+type AnyValue =
+  | { stringValue: string }
+  | { intValue: number }
+  | { doubleValue: number }
+  | { boolValue: boolean };
+
+interface KeyValue {
+  key: string;
+  value: AnyValue;
+}
+
+function attr(key: string, value: string | number | boolean): KeyValue {
+  if (typeof value === 'boolean') return { key, value: { boolValue: value } };
+  if (typeof value === 'string') return { key, value: { stringValue: value } };
+  return Number.isInteger(value)
+    ? { key, value: { intValue: value } }
+    : { key, value: { doubleValue: value } };
+}
+
+function hexId(input: string, bytes: number): string {
+  return createHash('sha256').update(input).digest('hex').slice(0, bytes * 2);
+}
+
+/** ISO-8601 → unix nanoseconds as a string (avoids float precision loss). */
+export function isoNano(ts: string | undefined): string {
+  if (!ts) return '0';
+  const ms = Date.parse(ts);
+  return Number.isNaN(ms) ? '0' : `${ms}000000`;
+}
+
+const SCOPE = { name: 'code-sessions', version: '0.1.0' };
+
+function resource(serviceName: string, host: string): { attributes: KeyValue[] } {
+  return {
+    attributes: [
+      attr('service.name', serviceName),
+      attr('host.name', host),
+      attr('telemetry.sdk.name', 'code-sessions'),
+      attr('telemetry.sdk.language', 'nodejs'),
+    ],
+  };
+}
+
+function sumUsage(turns: Turn[]) {
+  const u = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  for (const t of turns) {
+    u.input += t.usage.input_tokens;
+    u.output += t.usage.output_tokens;
+    u.cacheRead += t.usage.cache_read_tokens;
+    u.cacheWrite += t.usage.cache_write_tokens;
+    u.cost += t.telemetry?.cost_usd ?? 0;
+  }
+  return u;
+}
+
+export function buildTracePayload(
+  session: SessionEnvelope,
+  turns: Turn[],
+  serviceName: string,
+): unknown {
+  const traceId = hexId(session.session_id, 16);
+  const rootId = hexId(`${session.session_id}:root`, 8);
+  const totals = sumUsage(turns);
+
+  const rootSpan = {
+    traceId,
+    spanId: rootId,
+    name: `session ${session.title ?? session.session_id}`,
+    kind: 1,
+    startTimeUnixNano: isoNano(session.started_at),
+    endTimeUnixNano: isoNano(session.ended_at ?? session.started_at),
+    attributes: [
+      attr('session.id', session.session_id),
+      attr('gen_ai.system', session.agent),
+      ...(session.model ? [attr('gen_ai.request.model', session.model)] : []),
+      attr('session.turn_count', session.turn_count),
+      attr('gen_ai.usage.input_tokens', totals.input),
+      attr('gen_ai.usage.output_tokens', totals.output),
+      attr('code_sessions.cost_usd', Math.round(totals.cost * 1e6) / 1e6),
+      ...(session.project_path ? [attr('project.path', session.project_path)] : []),
+    ],
+    status: {},
+  };
+
+  const turnSpans = turns.map((t) => ({
+    traceId,
+    spanId: hexId(`${session.session_id}:${t.turn_index}`, 8),
+    parentSpanId: rootId,
+    name: `turn ${t.turn_index} ${t.role}`,
+    kind: 1,
+    startTimeUnixNano: isoNano(t.ts),
+    endTimeUnixNano: isoNano(t.ts),
+    attributes: [
+      attr('turn.index', t.turn_index),
+      attr('gen_ai.role', t.role),
+      attr('gen_ai.usage.input_tokens', t.usage.input_tokens),
+      attr('gen_ai.usage.output_tokens', t.usage.output_tokens),
+      attr('code_sessions.tool_count', t.tool_calls.length),
+      attr('code_sessions.cost_usd', t.telemetry?.cost_usd ?? 0),
+    ],
+    status: {},
+  }));
+
+  return {
+    resourceSpans: [
+      {
+        resource: resource(serviceName, session.host),
+        scopeSpans: [{ scope: SCOPE, spans: [rootSpan, ...turnSpans] }],
+      },
+    ],
+  };
+}
+
+export function buildMetricPayload(
+  session: SessionEnvelope,
+  turns: Turn[],
+  serviceName: string,
+): unknown {
+  const totals = sumUsage(turns);
+  const time = isoNano(session.ended_at ?? session.started_at);
+  const base = [attr('session.id', session.session_id), attr('gen_ai.system', session.agent)];
+
+  const tokenPoint = (type: string, value: number) => ({
+    asInt: value,
+    timeUnixNano: time,
+    attributes: [...base, attr('gen_ai.token.type', type)],
+  });
+
+  return {
+    resourceMetrics: [
+      {
+        resource: resource(serviceName, session.host),
+        scopeMetrics: [
+          {
+            scope: SCOPE,
+            metrics: [
+              {
+                name: 'code_sessions.tokens',
+                unit: '{token}',
+                sum: {
+                  aggregationTemporality: 2,
+                  isMonotonic: true,
+                  dataPoints: [
+                    tokenPoint('input', totals.input),
+                    tokenPoint('output', totals.output),
+                    tokenPoint('cache_read', totals.cacheRead),
+                    tokenPoint('cache_write', totals.cacheWrite),
+                  ],
+                },
+              },
+              {
+                name: 'code_sessions.cost_usd',
+                unit: 'USD',
+                gauge: {
+                  dataPoints: [
+                    { asDouble: Math.round(totals.cost * 1e6) / 1e6, timeUnixNano: time, attributes: base },
+                  ],
+                },
+              },
+              {
+                name: 'code_sessions.turns',
+                unit: '{turn}',
+                sum: {
+                  aggregationTemporality: 2,
+                  isMonotonic: true,
+                  dataPoints: [{ asInt: turns.length, timeUnixNano: time, attributes: base }],
+                },
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+export interface PostResult {
+  ok: boolean;
+  status?: number;
+  error?: string;
+}
+
+/** POST an OTLP/HTTP JSON payload; resilient — never throws, returns a result. */
+export async function postOtlp(
+  endpoint: string,
+  signalPath: '/v1/traces' | '/v1/metrics',
+  payload: unknown,
+  timeoutMs: number,
+): Promise<PostResult> {
+  const url = `${endpoint.replace(/\/$/, '')}${signalPath}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+    });
+    return { ok: res.ok, status: res.status };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/test/e2e.test.ts

@@ -0,0 +1,112 @@
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { startDaemon } from '../commands';
+import { sendEvent } from '../ipc';
+import { envelopeFile, insightsFile, sessionDir, turnFile } from '../store/paths';
+import { makeConfig, withTempDirAsync } from './tmp';
+
+const BIN = fileURLToPath(new URL('../../bin/code-sessions.mjs', import.meta.url));
+
+const USER =
+  '{"type":"user","sessionId":"e2e","cwd":"/p","timestamp":"2026-06-20T08:00:00Z","message":{"role":"user","content":"Fix the bug in foo.ts"}}';
+const ASSISTANT =
+  '{"type":"assistant","timestamp":"2026-06-20T08:00:05Z","message":{"role":"assistant","model":"claude-opus-4-8","content":[{"type":"text","text":"ok"},{"type":"tool_use","id":"t","name":"Edit","input":{}}],"usage":{"input_tokens":1000,"output_tokens":20}}}';
+const DONE =
+  '{"type":"assistant","timestamp":"2026-06-20T08:01:00Z","message":{"role":"assistant","model":"claude-opus-4-8","content":[{"type":"text","text":"done"}],"usage":{"input_tokens":50,"output_tokens":5}}}';
+
+function gitLogCount(repo: string): number {
+  const r = spawnSync('git', ['-C', repo, 'log', '--oneline'], { encoding: 'utf8' });
+  return r.status === 0 ? r.stdout.trim().split('\n').filter(Boolean).length : 0;
+}
+
+describe('e2e: live capture pipeline (socket + insights on Stop)', () => {
+  it('captures turns, derives insights, and commits — across hook events', async () => {
+    await withTempDirAsync(async (root) => {
+      const store = join(root, 'store');
+      const src = join(root, 'src');
+      mkdirSync(src, { recursive: true });
+      const transcript = join(src, 'e2e.jsonl');
+      writeFileSync(transcript, `${USER}\n${ASSISTANT}\n`);
+
+      const cfg = makeConfig(store, {
+        socketPath: join(root, 'd.sock'),
+        insights: { provider: 'fake', mode: 'on-stop' },
+      });
+      const daemon = await startDaemon(cfg);
+      try {
+        const a1 = await sendEvent(cfg.socketPath, {
+          event: 'PostToolUse',
+          session_id: 'e2e',
+          transcript_path: transcript,
+        });
+        expect(a1.ok).toBe(true);
+        expect(a1.newTurns).toBe(2);
+
+        appendFileSync(transcript, `${DONE}\n`);
+        const a2 = await sendEvent(cfg.socketPath, {
+          event: 'Stop',
+          session_id: 'e2e',
+          transcript_path: transcript,
+        });
+        expect(a2.ok).toBe(true);
+        expect(a2.newTurns).toBe(1);
+        expect(a2.flushed).toBe(true);
+      } finally {
+        await daemon.stop();
+      }
+
+      const dir = sessionDir(store, cfg.host, '2026-06', 'e2e');
+      expect(existsSync(turnFile(dir, 0))).toBe(true);
+      expect(existsSync(turnFile(dir, 2))).toBe(true);
+
+      const env = JSON.parse(readFileSync(envelopeFile(dir), 'utf8'));
+      expect(env.turn_count).toBe(3);
+      expect(env.model).toBe('claude-opus-4-8');
+
+      const insights = JSON.parse(readFileSync(insightsFile(dir), 'utf8'));
+      expect(insights.provider).toBe('fake');
+      expect(insights.topic).toContain('Fix the bug');
+      expect(insights.tags).toContain('Edit');
+
+      expect(gitLogCount(store)).toBeGreaterThanOrEqual(1);
+    });
+  });
+});
+
+describe('e2e: CLI binary (backfill -> reindex -> analytics -> status)', () => {
+  it('runs the real bin against a fixture projects dir', async () => {
+    await withTempDirAsync(async (root) => {
+      const store = join(root, 'store');
+      const projects = join(root, 'projects', 'enc');
+      mkdirSync(projects, { recursive: true });
+      writeFileSync(join(projects, 'cli-1.jsonl'), `${USER}\n${ASSISTANT}\n${DONE}\n`);
+
+      const run = (...args: string[]) =>
+        spawnSync(process.execPath, [BIN, ...args, '--store', store, '--host', 'cli-host'], {
+          encoding: 'utf8',
+        });
+
+      const backfill = run('backfill', '--projects', join(root, 'projects'));
+      expect(backfill.status).toBe(0);
+      expect(backfill.stdout).toMatch(/Backfilled 1 session/);
+
+      const reindex = run('reindex', '--provider', 'fake');
+      expect(reindex.status).toBe(0);
+      expect(reindex.stdout).toMatch(/Reindexed 1 session/);
+
+      const analytics = run('analytics');
+      expect(analytics.status).toBe(0);
+
+      const status = run('status');
+      expect(status.status).toBe(0);
+      expect(status.stdout).toMatch(/stored:\s+1 session/);
+
+      const dir = sessionDir(store, 'cli-host', '2026-06', 'cli-1');
+      expect(existsSync(insightsFile(dir))).toBe(true);
+      expect(existsSync(join(store, 'analytics', 'report.json'))).toBe(true);
+    });
+  }, 30000);
+});

package/src/test/tmp.ts

@@ -0,0 +1,36 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { defaultConfig, resolveConfig, type CodeSessionsConfig, type DeepPartial } from '../config';
+
+/** Create a throwaway temp dir, run fn, always clean up. */
+export function withTempDir<T>(fn: (dir: string) => T): T {
+  const dir = mkdtempSync(join(tmpdir(), 'cs-test-'));
+  try {
+    return fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/** Async variant: awaits fn before cleaning up the temp dir. */
+export async function withTempDirAsync<T>(fn: (dir: string) => Promise<T>): Promise<T> {
+  const dir = mkdtempSync(join(tmpdir(), 'cs-test-'));
+  try {
+    return await fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+export function makeConfig(
+  storeDir: string,
+  override: DeepPartial<CodeSessionsConfig> = {},
+): CodeSessionsConfig {
+  // telemetry off by default in tests so we never hit a real collector / time out
+  const base = resolveConfig(defaultConfig('/home/test', 'test-host'), {
+    storeDir,
+    telemetry: { enabled: false },
+  });
+  return resolveConfig(base, override);
+}