modelmeter-collect 0.6.0 → 0.8.0

package/lib.mjs

@@ -42,6 +42,25 @@ export function findLastTokenCount(obj) {
   return last
 }
 
+// Depth-first find of the first string `cwd` in a parsed line (Claude carries it at
+// top level, Codex nests it under payload). Used only to derive a repo identity; the
+// collector hashes it and never sends the raw path.
+export function findCwd(obj) {
+  const stack = [obj]
+  let guard = 0
+  while (stack.length && guard < 5000) {
+    guard++
+    const d = stack.pop()
+    if (Array.isArray(d)) {
+      for (const v of d) stack.push(v)
+    } else if (d && typeof d === 'object') {
+      if (typeof d.cwd === 'string' && d.cwd) return d.cwd
+      for (const v of Object.values(d)) stack.push(v)
+    }
+  }
+  return ''
+}
+
 // Detail endpoint from the ingest URL, tolerating a trailing slash, or an override.
 export function deriveHourlyUrl(ingestUrl, override) {
   if (override) return override
@@ -294,6 +313,9 @@ export function claudeSessionSummary(text) {
   let cacheCreate = 0
   let output = 0
   let requests = 0
+  let firstTs = ''
+  let lastTs = ''
+  let cwd = ''
   const contextSeq = []
   const tools = {}
   for (const line of String(text).split('\n')) {
@@ -304,9 +326,14 @@ export function claudeSessionSummary(text) {
     } catch {
       continue
     }
+    if (!cwd) cwd = findCwd(o)
     const ev = claudeEventFromLine(o)
     if (!ev) continue
     model = ev.model || model
+    if (ev.occurredAt) {
+      if (!firstTs || ev.occurredAt < firstTs) firstTs = ev.occurredAt
+      if (ev.occurredAt > lastTs) lastTs = ev.occurredAt
+    }
     uncached += ev.uncachedInputTokens
     cacheRead += ev.cacheReadInputTokens
     cacheCreate += ev.cacheCreationInputTokens
@@ -329,7 +356,7 @@ export function claudeSessionSummary(text) {
     }
   }
   if (requests === 0) return null
-  return { provider: 'anthropic', model, uncached, cacheRead, cacheCreate, output, requests, contextSeq, tools }
+  return { provider: 'anthropic', model, uncached, cacheRead, cacheCreate, output, requests, firstTs, lastTs, cwd, contextSeq, tools }
 }
 
 // Summarize one Codex session from its final cumulative token_count. Codex totals are
@@ -338,6 +365,9 @@ export function codexSessionSummary(text) {
   let model = 'gpt-5'
   let totals = null
   let requests = 0
+  let firstTs = ''
+  let lastTs = ''
+  let cwd = ''
   const tools = {}
   for (const line of String(text).split('\n')) {
     if (!line.trim()) continue
@@ -347,10 +377,15 @@ export function codexSessionSummary(text) {
     } catch {
       continue
     }
+    if (!cwd) cwd = findCwd(o)
     const p = o.payload || o
     const ptype = p.type || o.type
     if (typeof o.model === 'string') model = o.model
     else if (typeof p.model === 'string') model = p.model
+    if (typeof o.timestamp === 'string') {
+      if (!firstTs || o.timestamp < firstTs) firstTs = o.timestamp
+      if (o.timestamp > lastTs) lastTs = o.timestamp
+    }
     const tc = findLastTokenCount(o)
     if (tc) {
       totals = tc
@@ -375,11 +410,42 @@ export function codexSessionSummary(text) {
     cacheCreate: 0,
     output,
     requests: Math.max(1, requests),
+    firstTs,
+    lastTs,
+    cwd,
     contextSeq: [],
     tools,
   }
 }
 
+// Shape a session summary into the row the collector sends to ingest-hourly. Derives
+// the bloat metrics from the context sequence and the bucket date from the timestamps.
+// Returns null if there is no date to bucket on. The hash is supplied by the caller
+// (the collector hashes the session-file basename, never the path).
+export function sessionSendRow(summary, sessionHash) {
+  if (!summary || !sessionHash) return null
+  const bucketDate = (summary.lastTs || summary.firstTs || '').slice(0, 10)
+  if (!bucketDate) return null
+  const bloat = sessionBloat(summary.contextSeq)
+  return {
+    sessionHash,
+    provider: summary.provider,
+    model: summary.model,
+    bucketDate,
+    firstTs: summary.firstTs || '',
+    lastTs: summary.lastTs || '',
+    requests: summary.requests,
+    uncached: summary.uncached,
+    cacheRead: summary.cacheRead,
+    cacheCreation: summary.cacheCreate,
+    output: summary.output,
+    maxInputTurn: bloat ? bloat.max : 0,
+    first5Avg: bloat ? bloat.first5 : 0,
+    last5Avg: bloat ? bloat.last5 : 0,
+    toolCounts: summary.tools,
+  }
+}
+
 // First-5 vs last-5 average turn size + max, for context-bloat detection.
 export function sessionBloat(seq) {
   if (!Array.isArray(seq) || seq.length < 10) return null

package/package.json

@@ -1,19 +1,15 @@
 {
   "name": "modelmeter-collect",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Report LLM token usage from local Claude Code / Codex logs to ModelMeter. Token counts only, never prompts or keys.",
   "type": "module",
   "bin": {
     "modelmeter-collect": "cli.mjs"
   },
-  "scripts": {
-    "test": "node --test lib.test.mjs"
-  },
   "files": [
     "cli.mjs",
     "collect.mjs",
     "lib.mjs",
-    "lib.test.mjs",
     "README.md"
   ],
   "engines": {

package/lib.test.mjs

@@ -1,173 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  aggregateDaily,
-  aggregateHourly,
-  aggregateTools,
-  claudeEventFromLine,
-  codexDelta,
-  deriveHourlyUrl,
-  findLastTokenCount,
-  formatDoctorReport,
-  mergeDetailBatches,
-  pruneClaudeState,
-} from './lib.mjs'
-
-test('codexDelta leaves post-token-count tool calls for the next batch', () => {
-  const toolCalls = [
-    { ts: '2026-06-18T12:01:00.000Z', group: 'exec_command' },
-    { ts: '2026-06-18T12:03:00.000Z', group: 'apply_patch' },
-  ]
-  const first = codexDelta(
-    {
-      totals: { input_tokens: 100, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0 },
-      totalsTs: '2026-06-18T12:02:00.000Z',
-      maxTs: '2026-06-18T12:03:00.000Z',
-      model: 'gpt-5',
-      fileDate: '2026-06-18',
-      toolCalls,
-    },
-    null,
-  )
-  assert.deepEqual(
-    first.toolDeltas.map((d) => d.tool),
-    ['exec_command'],
-  )
-  assert.equal(first.state.lastToolTs, '2026-06-18T12:02:00.000Z')
-
-  const second = codexDelta(
-    {
-      totals: { input_tokens: 200, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0 },
-      totalsTs: '2026-06-18T12:04:00.000Z',
-      maxTs: '2026-06-18T12:04:00.000Z',
-      model: 'gpt-5',
-      fileDate: '2026-06-18',
-      toolCalls,
-    },
-    first.state,
-  )
-  assert.deepEqual(
-    second.toolDeltas.map((d) => d.tool),
-    ['apply_patch'],
-  )
-})
-
-test('pruneClaudeState keeps newest timestamped ids and normalizes legacy entries', () => {
-  const pruned = pruneClaudeState(
-    {
-      old: { ts: '2026-06-18T10:00:00.000Z' },
-      legacy: 1,
-      newest: { ts: '2026-06-18T12:00:00.000Z' },
-      middle: { ts: '2026-06-18T11:00:00.000Z' },
-    },
-    2,
-  )
-  assert.deepEqual(Object.keys(pruned), ['middle', 'newest'])
-  assert.deepEqual(pruned.middle, { ts: '2026-06-18T11:00:00.000Z' })
-})
-
-test('deriveHourlyUrl fails closed for nonstandard ingest URLs unless overridden', () => {
-  assert.equal(
-    deriveHourlyUrl('https://x.test/functions/v1/ingest/'),
-    'https://x.test/functions/v1/ingest-hourly',
-  )
-  assert.equal(deriveHourlyUrl('https://x.test/custom'), null)
-  assert.equal(deriveHourlyUrl('https://x.test/custom', 'https://x.test/detail'), 'https://x.test/detail')
-})
-
-test('mergeDetailBatches deduplicates additive rows by bucket', () => {
-  const merged = mergeDetailBatches(
-    {
-      hours: [
-        {
-          provider: 'openai',
-          model: 'gpt-5',
-          bucketHour: '2026-06-18T12:00:00.000Z',
-          uncachedInputTokens: 1,
-          cacheReadInputTokens: 2,
-          cacheCreationInputTokens: 3,
-          outputTokens: 4,
-          numRequests: 1,
-        },
-      ],
-      tools: [{ tool: 'exec_command', bucketDate: '2026-06-18', calls: 1, tokens: 10 }],
-    },
-    {
-      hours: [
-        {
-          provider: 'openai',
-          model: 'gpt-5',
-          bucketHour: '2026-06-18T12:00:00.000Z',
-          uncachedInputTokens: 5,
-          cacheReadInputTokens: 0,
-          cacheCreationInputTokens: 0,
-          outputTokens: 6,
-          numRequests: 1,
-        },
-      ],
-      tools: [{ tool: 'exec_command', bucketDate: '2026-06-18', calls: 2, tokens: 20 }],
-    },
-  )
-  assert.equal(merged.hours.length, 1)
-  assert.equal(merged.hours[0].uncachedInputTokens, 6)
-  assert.equal(merged.hours[0].outputTokens, 10)
-  assert.equal(merged.hours[0].numRequests, 2)
-  assert.deepEqual(merged.tools, [{ tool: 'exec_command', bucketDate: '2026-06-18', calls: 3, tokens: 30 }])
-})
-
-test('claude parsing and aggregations exclude prompt text', () => {
-  const event = claudeEventFromLine({
-    uuid: 'c1',
-    timestamp: '2026-06-18T12:34:56.000Z',
-    message: {
-      role: 'assistant',
-      model: 'claude-sonnet',
-      usage: {
-        input_tokens: 100,
-        cache_read_input_tokens: 20,
-        cache_creation_input_tokens: 5,
-        output_tokens: 30,
-      },
-      content: [
-        { type: 'text', text: 'response text must not be copied' },
-        { type: 'tool_use', name: 'mcp__supabase__query' },
-        { type: 'tool_use', name: 'exec_command' },
-      ],
-    },
-  })
-  assert.equal(event.id, 'c1')
-  assert.equal(event.provider, 'anthropic')
-  assert.deepEqual(event.tools, ['mcp__supabase__query', 'exec_command'])
-  assert.equal(JSON.stringify(event).includes('response text'), false)
-
-  assert.equal(aggregateDaily([event], '2026-06-18')[0].uncachedInputTokens, 100)
-  assert.equal(aggregateHourly([event], new Date('2026-06-18T13:00:00.000Z').getTime()).length, 1)
-  assert.deepEqual(
-    aggregateTools([event], [], '2026-06-18').map((d) => d.tool).sort(),
-    ['exec_command', 'mcp:supabase'],
-  )
-})
-
-test('findLastTokenCount and doctor report cover nested Codex usage and privacy copy', () => {
-  const totals = findLastTokenCount({
-    payload: [
-      { type: 'token_count', info: { total_token_usage: { input_tokens: 1 } } },
-      { nested: { type: 'token_count', info: { total_token_usage: { input_tokens: 2 } } } },
-    ],
-  })
-  assert.deepEqual(totals, { input_tokens: 2 })
-
-  const report = formatDoctorReport({
-    configPath: '/tmp/config.json',
-    configFound: true,
-    token: 'mm_live_abcdefghijklmnop',
-    ingestUrl: 'https://x.test/functions/v1/ingest',
-    lookbackDays: 14,
-    nowMs: 1000,
-    claude: { dir: '/tmp/claude', found: false },
-    codex: { dir: '/tmp/codex', found: true, recentCount: 1, lastWriteMs: 1000 },
-  })
-  assert.match(report, /mm_live_abcd\.\.\./)
-  assert.match(report, /never sent: prompts/)
-})