json-mode-cost-meter (squashed)

Author: frenchie4111

src/main/cost-tracker.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// Controlled fs mock: readFileSync returns a JSONL transcript fixture
+// which we override per-test. existsSync is unused by parseTranscript
+// (it just lets readFileSync throw), so leaving the real one in place
+// is fine.
+const readFileSyncMock = vi.fn((..._args: unknown[]) => '')
+
+vi.mock('fs', async () => {
+  const actual = await vi.importActual<typeof import('fs')>('fs')
+  return {
+    ...actual,
+    readFileSync: (...args: unknown[]) => readFileSyncMock(...args)
+  }
+})
+
+vi.mock('electron', () => ({
+  app: { getPath: () => '/tmp', setPath: () => {}, isPackaged: false }
+}))
+
+import { Store } from './store'
+import { CostTracker } from './cost-tracker'
+
+describe('CostTracker — JSON-mode wiring', () => {
+  beforeEach(() => {
+    readFileSyncMock.mockReset()
+    readFileSyncMock.mockReturnValue('')
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('reparses + dispatches costs/usageUpdated when a json-claude turn completes', () => {
+    const store = new Store()
+    const tracker = new CostTracker(store)
+    tracker.start()
+
+    const sessionId = 'sess-cost-1'
+
+    // Start with an empty transcript so the sessionStarted reparse is
+    // a no-op (gated by the empty-byModel check). This isolates the
+    // assertion to the busyChanged path.
+    readFileSyncMock.mockReturnValue('')
+    store.dispatch({
+      type: 'jsonClaude/sessionStarted',
+      payload: { sessionId, worktreePath: '/tmp/wt' }
+    })
+    expect(store.getSnapshot().state.costs.byTerminal[sessionId]).toBeUndefined()
+
+    // claude has now finished a turn and flushed its session jsonl.
+    // The parser only needs type=assistant, message.model,
+    // message.usage, message.content.
+    const transcript =
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          model: 'claude-sonnet-4-5',
+          usage: { input_tokens: 100, output_tokens: 50 },
+          content: [{ type: 'text', text: 'hi there' }]
+        }
+      }) + '\n'
+    readFileSyncMock.mockReturnValue(transcript)
+
+    // The result-event boundary in JsonClaudeManager dispatches
+    // busyChanged false. CostTracker subscribes to that.
+    store.dispatch({
+      type: 'jsonClaude/busyChanged',
+      payload: { sessionId, busy: false }
+    })
+
+    tracker.stop()
+
+    const usage = store.getSnapshot().state.costs.byTerminal[sessionId]
+    expect(usage).toBeDefined()
+    expect(usage.byModel['claude-sonnet-4-5']?.input).toBe(100)
+    expect(usage.byModel['claude-sonnet-4-5']?.output).toBe(50)
+    expect(usage.sessionId).toBe(sessionId)
+  })
+
+  it('skips the dispatch when the transcript has no parseable assistant turn', () => {
+    // Resume-from-disk before claude has flushed: parseTranscript
+    // returns empty data. Dispatching it would wipe whatever the slice
+    // already had hydrated, so we gate on byModel having entries.
+    readFileSyncMock.mockReturnValue('')
+
+    const store = new Store()
+    const tracker = new CostTracker(store)
+    tracker.start()
+
+    const sessionId = 'sess-cost-2'
+    store.dispatch({
+      type: 'jsonClaude/sessionStarted',
+      payload: { sessionId, worktreePath: '/tmp/wt' }
+    })
+    // sessionStarted itself triggers a reparse on resume; that
+    // empty-transcript run must not have dispatched usageUpdated.
+
+    tracker.stop()
+
+    expect(store.getSnapshot().state.costs.byTerminal[sessionId]).toBeUndefined()
+  })
+})

src/main/cost-tracker.ts

@@ -10,6 +10,14 @@
 // assistant turn), so the simpler full-reparse beats incremental
 // tailing + state juggling.
 //
+// JSON-mode tabs don't fire Claude's Stop hook (we scrub the
+// HARNESS_TERMINAL_ID env var so user-scope hooks stay inert under
+// `claude -p`). Instead, we subscribe to the store and trigger the same
+// reparse on `jsonClaude/busyChanged` transitions to false (the boundary
+// JsonClaudeManager dispatches when claude emits a `result` event), and
+// on `jsonClaude/sessionStarted` so reopened tabs rehydrate from the
+// on-disk JSONL even if the costs slice doesn't persist their entry.
+//
 // Per-block token counts aren't in the Anthropic usage field, so we
 // estimate the $ split by char-length proportion within each turn:
 // the turn's known output-rate cost is divided across this message's
@@ -21,7 +29,10 @@
 // outputs keep costing money as long as they sit in the context.
 
 import { readFileSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
 import type { Store } from './store'
+import type { StateEvent } from '../shared/state'
 import { onStopEvent, type StopEvent } from './hooks'
 import {
   emptyTally,
@@ -49,17 +60,23 @@ interface ParseResult {
 }
 
 export class CostTracker {
-  private unsubscribe: (() => void) | null = null
+  private unsubscribeHook: (() => void) | null = null
+  private unsubscribeStore: (() => void) | null = null
 
   constructor(private store: Store) {}
 
   start(): void {
-    this.unsubscribe = onStopEvent((ev) => this.handleStop(ev))
+    this.unsubscribeHook = onStopEvent((ev) => this.handleStop(ev))
+    this.unsubscribeStore = this.store.subscribe((event) =>
+      this.handleStoreEvent(event)
+    )
   }
 
   stop(): void {
-    this.unsubscribe?.()
-    this.unsubscribe = null
+    this.unsubscribeHook?.()
+    this.unsubscribeHook = null
+    this.unsubscribeStore?.()
+    this.unsubscribeStore = null
   }
 
   private handleStop(ev: StopEvent): void {
@@ -84,6 +101,65 @@ export class CostTracker {
       )
     }
   }
+
+  private handleStoreEvent(event: StateEvent): void {
+    if (
+      event.type === 'jsonClaude/busyChanged' &&
+      event.payload.busy === false
+    ) {
+      this.recordJsonModeTurnComplete(event.payload.sessionId)
+      return
+    }
+    if (event.type === 'jsonClaude/sessionStarted') {
+      this.recordJsonModeTurnComplete(event.payload.sessionId)
+    }
+  }
+
+  /** Reparse the JSON-mode session's on-disk JSONL and dispatch fresh
+   *  cost totals. Skips the dispatch when parsing yields no model data
+   *  so an early reparse (resume from disk before claude has flushed)
+   *  doesn't wipe an existing hydrated entry. The next reparse picks
+   *  things up. */
+  private recordJsonModeTurnComplete(sessionId: string): void {
+    const session =
+      this.store.getSnapshot().state.jsonClaude.sessions[sessionId]
+    if (!session) return
+    const transcriptPath = jsonClaudeTranscriptPath(
+      session.worktreePath,
+      sessionId
+    )
+    try {
+      const parsed = parseTranscript(transcriptPath)
+      if (Object.keys(parsed.byModel).length === 0) return
+      const usage: SessionUsage = {
+        sessionId,
+        transcriptPath,
+        byModel: parsed.byModel,
+        breakdown: parsed.breakdown,
+        currentModel: parsed.currentModel,
+        updatedAt: Date.now()
+      }
+      this.store.dispatch({
+        type: 'costs/usageUpdated',
+        payload: { terminalId: sessionId, usage }
+      })
+    } catch (err) {
+      log(
+        'cost-tracker',
+        `failed to ingest json-claude ${transcriptPath}: ${err instanceof Error ? err.message : err}`
+      )
+    }
+  }
+}
+
+function jsonClaudeTranscriptPath(worktreePath: string, sessionId: string): string {
+  return join(
+    homedir(),
+    '.claude',
+    'projects',
+    worktreePath.replace(/[^a-zA-Z0-9]/g, '-'),
+    `${sessionId}.jsonl`
+  )
 }
 
 function parseTranscript(path: string): ParseResult {

src/renderer/components/CostPanel.tsx

@@ -101,7 +101,9 @@ export function CostPanel({ worktreePath }: CostPanelProps): JSX.Element | null
       if (tree) {
         for (const leaf of getLeaves(tree)) {
           for (const tab of leaf.tabs) {
-            if (tab.type === 'agent') terminalIds.add(tab.id)
+            if (tab.type === 'agent' || tab.type === 'json-claude') {
+              terminalIds.add(tab.id)
+            }
           }
         }
       }