mirror of
https://github.com/AgentSeal/codeburn.git
synced 2026-08-11 01:25:03 +00:00
713 lines
31 KiB
TypeScript
713 lines
31 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
|
|
import { mkdir, readFile, rename, rm, writeFile } from 'fs/promises'
|
|
import { existsSync } from 'fs'
|
|
import { tmpdir } from 'os'
|
|
import { join } from 'path'
|
|
|
|
import type { ProjectSummary } from '../src/types.js'
|
|
import { buildPeriodDataFromDays } from '../src/day-aggregator.js'
|
|
|
|
import {
|
|
DAILY_CACHE_VERSION,
|
|
type DailyCache,
|
|
type DailyEntry,
|
|
type ProviderDaySlice,
|
|
currentTzKey,
|
|
dailyCachePath,
|
|
ensureCacheHydrated,
|
|
loadDailyCache,
|
|
mergeDayEntries,
|
|
saveDailyCache,
|
|
} from '../src/daily-cache.js'
|
|
|
|
const TMP_CACHE_ROOT = join(tmpdir(), `codeburn-carry-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`)
|
|
|
|
beforeEach(async () => {
|
|
process.env['CODEBURN_CACHE_DIR'] = TMP_CACHE_ROOT
|
|
await mkdir(TMP_CACHE_ROOT, { recursive: true })
|
|
})
|
|
|
|
afterEach(async () => {
|
|
if (existsSync(TMP_CACHE_ROOT)) {
|
|
await rm(TMP_CACHE_ROOT, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
function slice(cost: number, calls: number, extra: Partial<ProviderDaySlice> = {}): ProviderDaySlice {
|
|
return { cost, calls, savingsUSD: 0, ...extra }
|
|
}
|
|
|
|
function day(date: string, providers: Record<string, ProviderDaySlice>, overrides: Partial<DailyEntry> = {}): DailyEntry {
|
|
const cost = Object.values(providers).reduce((s, p) => s + p.cost, 0)
|
|
const calls = Object.values(providers).reduce((s, p) => s + p.calls, 0)
|
|
return {
|
|
date,
|
|
cost,
|
|
savingsUSD: 0,
|
|
calls,
|
|
sessions: 0,
|
|
inputTokens: 0,
|
|
outputTokens: 0,
|
|
cacheReadTokens: 0,
|
|
cacheWriteTokens: 0,
|
|
editTurns: 0,
|
|
oneShotTurns: 0,
|
|
models: {},
|
|
categories: {},
|
|
providers,
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
function daysAgoStr(n: number): string {
|
|
const d = new Date(Date.now() - n * 24 * 60 * 60 * 1000)
|
|
return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
|
|
}
|
|
|
|
const noSessions = async (): Promise<ProjectSummary[]> => []
|
|
|
|
describe('mergeDayEntries', () => {
|
|
it('keeps primary-only and secondary-only days; secondary days get the carried mark', () => {
|
|
const merged = mergeDayEntries(
|
|
[day('2026-06-01', { claude: slice(10, 2) })],
|
|
[day('2026-05-01', { claude: slice(5, 1) })],
|
|
true,
|
|
)
|
|
expect(merged.map(d => d.date)).toEqual(['2026-05-01', '2026-06-01'])
|
|
expect(merged[0]!.carried).toBe(true)
|
|
expect(merged[1]!.carried).toBeUndefined()
|
|
})
|
|
|
|
it('primary wins per provider on shared dates — no overwrite, no double count', () => {
|
|
const merged = mergeDayEntries(
|
|
[day('2026-06-01', { claude: slice(50, 5) })],
|
|
[day('2026-06-01', { claude: slice(100, 10) })],
|
|
true,
|
|
)
|
|
expect(merged).toHaveLength(1)
|
|
expect(merged[0]!.cost).toBe(50)
|
|
expect(merged[0]!.providers['claude']!.cost).toBe(50)
|
|
expect(merged[0]!.carried).toBeUndefined()
|
|
})
|
|
|
|
it('fills provider slices missing from primary on shared dates and sums day totals', () => {
|
|
// The real 2026-04-26 case: rebuild found only codex, the old cache still
|
|
// had the claude slice — the merged day must hold both.
|
|
const merged = mergeDayEntries(
|
|
[day('2026-04-26', { codex: slice(3.28, 4) })],
|
|
[day('2026-04-26', { codex: slice(3.28, 4), claude: slice(54.08, 120) })],
|
|
true,
|
|
)
|
|
expect(merged).toHaveLength(1)
|
|
expect(merged[0]!.providers['codex']!.cost).toBe(3.28)
|
|
expect(merged[0]!.providers['claude']!.cost).toBe(54.08)
|
|
expect(merged[0]!.cost).toBeCloseTo(57.36, 5)
|
|
expect(merged[0]!.calls).toBe(124)
|
|
expect(merged[0]!.carried).toBe(true)
|
|
})
|
|
|
|
it('a rich slice carries its tokens, models, categories, and projects into the day', () => {
|
|
const rich = slice(20, 3, {
|
|
sessions: 2,
|
|
inputTokens: 1000,
|
|
outputTokens: 500,
|
|
cacheReadTokens: 200,
|
|
cacheWriteTokens: 100,
|
|
editTurns: 2,
|
|
oneShotTurns: 1,
|
|
models: { 'opus-4-8': { calls: 3, cost: 20, savingsUSD: 0, inputTokens: 1000, outputTokens: 500, cacheReadTokens: 200, cacheWriteTokens: 100 } },
|
|
categories: { coding: { turns: 3, cost: 20, savingsUSD: 0, editTurns: 2, oneShotTurns: 1 } },
|
|
projects: { eywa: { cost: 15, calls: 2, savingsUSD: 0, sessions: 1 }, codeburn: { cost: 5, calls: 1, savingsUSD: 0, sessions: 1 } },
|
|
})
|
|
const merged = mergeDayEntries(
|
|
[day('2026-06-01', { codex: slice(1, 1, { projects: { codeburn: { cost: 1, calls: 1, savingsUSD: 0, sessions: 1 } } }) }, { projects: { codeburn: { cost: 1, calls: 1, savingsUSD: 0, sessions: 1 } } })],
|
|
[day('2026-06-01', { claude: rich })],
|
|
true,
|
|
)
|
|
const m = merged[0]!
|
|
expect(m.cost).toBe(21)
|
|
expect(m.sessions).toBe(2)
|
|
expect(m.inputTokens).toBe(1000)
|
|
expect(m.outputTokens).toBe(500)
|
|
expect(m.editTurns).toBe(2)
|
|
expect(m.oneShotTurns).toBe(1)
|
|
expect(m.models['opus-4-8']!.cost).toBe(20)
|
|
expect(m.categories['coding']!.turns).toBe(3)
|
|
// Projects from the carried claude slice fold into the day's project map,
|
|
// summing with the fresh codex contribution on the shared project.
|
|
expect(m.projects!['eywa']).toEqual({ cost: 15, calls: 2, savingsUSD: 0, sessions: 1 })
|
|
expect(m.projects!['codeburn']).toEqual({ cost: 6, calls: 2, savingsUSD: 0, sessions: 2 })
|
|
})
|
|
|
|
it('a skinny pre-v14 slice still restores exact cost/calls/savings', () => {
|
|
const merged = mergeDayEntries(
|
|
[day('2026-06-01', { codex: slice(1, 1) })],
|
|
[day('2026-06-01', { claude: { calls: 7, cost: 13.42, savingsUSD: 2 } })],
|
|
true,
|
|
)
|
|
expect(merged[0]!.cost).toBeCloseTo(14.42, 5)
|
|
expect(merged[0]!.calls).toBe(8)
|
|
expect(merged[0]!.savingsUSD).toBe(2)
|
|
})
|
|
|
|
it('an empty-providers secondary day cannot contribute to an existing date', () => {
|
|
const merged = mergeDayEntries(
|
|
[day('2026-06-01', { claude: slice(10, 2) })],
|
|
[day('2026-06-01', {}, { cost: 999, calls: 999 })],
|
|
true,
|
|
)
|
|
expect(merged[0]!.cost).toBe(10)
|
|
expect(merged[0]!.carried).toBeUndefined()
|
|
})
|
|
|
|
it('never slice-fills an OPAQUE day (totals but empty providers) — no double count', () => {
|
|
// Adversarial-review finding: an adopted pre-v5 day has day totals that
|
|
// already CONTAIN every provider's share, but no slices to dedupe against.
|
|
// Filling a codex slice into it would double-count codex.
|
|
const opaque = day('2026-07-15', {}, { cost: 10, calls: 5 })
|
|
const merged = mergeDayEntries([opaque], [day('2026-07-15', { codex: slice(3, 1) })], false)
|
|
expect(merged).toHaveLength(1)
|
|
expect(merged[0]!.cost).toBe(10)
|
|
expect(merged[0]!.calls).toBe(5)
|
|
expect(merged[0]!.providers).toEqual({})
|
|
})
|
|
|
|
it('a zero-data placeholder slice does not block a carried slice', () => {
|
|
// Adversarial-review finding: a session that starts on day X with all its
|
|
// turns landing on X+1 leaves a {sessions: 1, calls: 0, cost: 0} slice on
|
|
// X. That placeholder must not suppress the baseline's real X data.
|
|
const placeholder = day('2026-07-10', { claude: slice(0, 0, { sessions: 1 }) }, { sessions: 1 })
|
|
const baseline = day('2026-07-10', { claude: slice(8, 2, { sessions: 1 }) }, { sessions: 1 })
|
|
const merged = mergeDayEntries([placeholder], [baseline], true)
|
|
expect(merged[0]!.providers['claude']).toMatchObject({ cost: 8, calls: 2 })
|
|
// The same real session may be counted on both sides — deduplicated by max.
|
|
expect(merged[0]!.providers['claude']!.sessions).toBe(1)
|
|
expect(merged[0]!.sessions).toBe(1)
|
|
expect(merged[0]!.cost).toBe(8)
|
|
expect(merged[0]!.carried).toBe(true)
|
|
})
|
|
|
|
it('does not double-count a project session across a placeholder merge', () => {
|
|
// v15-review finding: the placeholder's project sessions were already
|
|
// counted into the fresh day; folding the carried slice must only add the
|
|
// excess, and day/provider/project session totals must reconcile.
|
|
const placeholder = day('2026-06-01', {
|
|
claude: slice(0, 0, { sessions: 1, projects: { P: { cost: 0, calls: 0, savingsUSD: 0, sessions: 1 } } }),
|
|
}, { sessions: 1, projects: { P: { cost: 0, calls: 0, savingsUSD: 0, sessions: 1 } } })
|
|
const carried = day('2026-06-01', {
|
|
claude: slice(0, 0, { sessions: 1, projects: { P: { cost: 0, calls: 0, savingsUSD: 0, sessions: 1 } } }),
|
|
}, { sessions: 1, projects: { P: { cost: 0, calls: 0, savingsUSD: 0, sessions: 1 } } })
|
|
const merged = mergeDayEntries([placeholder], [carried], true)
|
|
expect(merged[0]!.sessions).toBe(1)
|
|
expect(merged[0]!.projects!['P']!.sessions).toBe(1)
|
|
expect(merged[0]!.providers['claude']!.sessions).toBe(1)
|
|
})
|
|
|
|
it('survives junk project data from foreign caches without crashing or corrupting', () => {
|
|
const junkSlice = slice(5, 2, {
|
|
projects: { good: { cost: 5, calls: 2, savingsUSD: 0, sessions: 1 }, bad: null, worse: [1, 2], strings: { cost: 'x', calls: 2 } } as never,
|
|
})
|
|
const merged = mergeDayEntries([day('2026-06-01', { codex: slice(1, 1) })], [day('2026-06-01', { claude: junkSlice })], true)
|
|
expect(merged[0]!.projects!['good']).toEqual({ cost: 5, calls: 2, savingsUSD: 0, sessions: 1 })
|
|
expect(merged[0]!.projects!['bad']).toBeUndefined()
|
|
expect(merged[0]!.projects!['worse']).toBeUndefined()
|
|
expect(merged[0]!.projects!['strings']).toEqual({ cost: 0, calls: 2, savingsUSD: 0, sessions: 0 })
|
|
})
|
|
|
|
it('a project named __proto__ becomes an own key, never prototype pollution', () => {
|
|
const evil = slice(3, 1, { projects: { ['__proto__']: { cost: 3, calls: 1, savingsUSD: 0, sessions: 1 } } })
|
|
const merged = mergeDayEntries([day('2026-06-01', { codex: slice(1, 1) })], [day('2026-06-01', { claude: evil })], true)
|
|
expect(Object.hasOwn(merged[0]!.projects!, '__proto__')).toBe(true)
|
|
expect(merged[0]!.projects!['__proto__' as string]).toMatchObject({ cost: 3 })
|
|
expect(({} as Record<string, unknown>)['cost']).toBeUndefined()
|
|
})
|
|
|
|
it('a hostile __proto__ provider/model/category key becomes an own key on merge', () => {
|
|
const hostile = day('2026-06-01', Object.defineProperty({}, '__proto__', {
|
|
value: slice(4, 2, {
|
|
models: { ['__proto__']: { calls: 2, cost: 4, savingsUSD: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 } } as never,
|
|
categories: { ['__proto__']: { turns: 1, cost: 4, savingsUSD: 0, editTurns: 0, oneShotTurns: 0 } } as never,
|
|
}),
|
|
enumerable: true, writable: true, configurable: true,
|
|
}) as Record<string, ProviderDaySlice>)
|
|
const merged = mergeDayEntries([day('2026-06-01', { codex: slice(1, 1) })], [hostile], true)
|
|
expect(Object.hasOwn(merged[0]!.providers, '__proto__')).toBe(true)
|
|
expect(Object.hasOwn(merged[0]!.models, '__proto__')).toBe(true)
|
|
expect(Object.hasOwn(merged[0]!.categories, '__proto__')).toBe(true)
|
|
expect(merged[0]!.cost).toBe(5)
|
|
expect(({} as Record<string, unknown>)['cost']).toBeUndefined()
|
|
expect(({} as Record<string, unknown>)['calls']).toBeUndefined()
|
|
})
|
|
|
|
it('does not mutate its inputs', () => {
|
|
const primary = [day('2026-06-01', { codex: slice(1, 1) })]
|
|
const secondary = [day('2026-06-01', { claude: slice(5, 2) })]
|
|
mergeDayEntries(primary, secondary, true)
|
|
expect(primary[0]!.cost).toBe(1)
|
|
expect(Object.keys(primary[0]!.providers)).toEqual(['codex'])
|
|
expect(secondary[0]!.carried).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('never-lose invariant: invalidations with vanished sources', () => {
|
|
const seededDay = () => day(daysAgoStr(30), { claude: slice(230.06, 400), codex: slice(79.29, 60) })
|
|
|
|
async function seed(overrides: Partial<DailyCache> = {}): Promise<DailyEntry> {
|
|
const d = seededDay()
|
|
const cache: DailyCache = {
|
|
version: DAILY_CACHE_VERSION,
|
|
savingsConfigHash: 'cfg-A',
|
|
tzKey: currentTzKey(),
|
|
lastComputedDate: daysAgoStr(1),
|
|
days: [d],
|
|
complete: true,
|
|
...overrides,
|
|
}
|
|
await saveDailyCache(cache)
|
|
return d
|
|
}
|
|
|
|
it('savings-hash change with an empty re-parse keeps the day (carried)', async () => {
|
|
const d = await seed()
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-B')
|
|
expect(out.days).toHaveLength(1)
|
|
expect(out.days[0]).toMatchObject({ date: d.date, cost: d.cost, calls: d.calls, carried: true })
|
|
expect(out.days[0]!.providers['claude']!.cost).toBe(230.06)
|
|
expect(out.days[0]!.providers['codex']!.cost).toBe(79.29)
|
|
})
|
|
|
|
it('timezone change with an empty re-parse keeps the day (carried)', async () => {
|
|
const d = await seed({ tzKey: 'Test/OtherZone' })
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-A')
|
|
expect(out.days[0]).toMatchObject({ date: d.date, cost: d.cost, carried: true })
|
|
expect(out.tzKey).toBe(currentTzKey())
|
|
})
|
|
|
|
it('incomplete-cache retry with an empty re-parse keeps the day', async () => {
|
|
const d = await seed({ complete: false })
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-A')
|
|
expect(out.days[0]).toMatchObject({ date: d.date, cost: d.cost, carried: true })
|
|
expect(out.complete).toBe(true)
|
|
})
|
|
|
|
it('a version bump (current file absent, old-version file remains) keeps the day', async () => {
|
|
const d = await seed()
|
|
// Simulate the upgrade: the new binary's filename does not exist yet; the
|
|
// previous version's file (older internal schema version) is still in the
|
|
// cache dir under its old name.
|
|
const oldContent = JSON.parse(await readFile(dailyCachePath(), 'utf-8'))
|
|
oldContent.version = DAILY_CACHE_VERSION - 1
|
|
await writeFile(join(TMP_CACHE_ROOT, `daily-cache.v${DAILY_CACHE_VERSION - 1}.json`), JSON.stringify(oldContent), 'utf-8')
|
|
await rm(dailyCachePath())
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-A')
|
|
expect(out.days).toHaveLength(1)
|
|
expect(out.days[0]).toMatchObject({ date: d.date, cost: d.cost, calls: d.calls, carried: true })
|
|
})
|
|
|
|
it('a same-version file found under an old name is trusted as-is (no spurious rebuild)', async () => {
|
|
const d = await seed()
|
|
await rename(dailyCachePath(), join(TMP_CACHE_ROOT, 'daily-cache.json'))
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-A')
|
|
expect(out.days).toHaveLength(1)
|
|
expect(out.days[0]).toMatchObject({ date: d.date, cost: d.cost, calls: d.calls })
|
|
expect(out.days[0]!.carried).toBeUndefined()
|
|
expect(out.complete).toBe(true)
|
|
})
|
|
|
|
it('survives a whole gauntlet: version bump, then hash change, then tz change', async () => {
|
|
const d = await seed()
|
|
await rename(dailyCachePath(), join(TMP_CACHE_ROOT, 'daily-cache.v9.json.bak'))
|
|
await ensureCacheHydrated(noSessions, () => [], 'cfg-B')
|
|
await ensureCacheHydrated(noSessions, () => [], 'cfg-C')
|
|
const tampered = await loadDailyCache()
|
|
await saveDailyCache({ ...tampered, tzKey: 'Test/OtherZone' })
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-C')
|
|
expect(out.days).toHaveLength(1)
|
|
expect(out.days[0]).toMatchObject({ date: d.date, cost: d.cost, calls: d.calls })
|
|
expect(out.days[0]!.providers['claude']!.cost).toBe(230.06)
|
|
})
|
|
|
|
it('corrections still land: a re-derivable day takes the fresh (lower) value, not the old one', async () => {
|
|
const target = daysAgoStr(30)
|
|
await seed()
|
|
// The kiro-style correction: the fresh parse re-derives this day at a much
|
|
// lower, correct cost. Fresh must WIN for the provider it re-derived.
|
|
const corrected = [day(target, { claude: slice(14.0, 400) })]
|
|
const out = await ensureCacheHydrated(noSessions, () => corrected, 'cfg-B')
|
|
expect(out.days).toHaveLength(1)
|
|
expect(out.days[0]!.providers['claude']!.cost).toBe(14.0)
|
|
// codex was NOT re-derived (its files are gone) → carried forward.
|
|
expect(out.days[0]!.providers['codex']!.cost).toBe(79.29)
|
|
expect(out.days[0]!.cost).toBeCloseTo(14.0 + 79.29, 5)
|
|
expect(out.days[0]!.carried).toBe(true)
|
|
})
|
|
|
|
it('a PARTIAL session parse cannot overwrite finalized days with undercounts', async () => {
|
|
const target = daysAgoStr(30)
|
|
await seed({ complete: false })
|
|
// Interrupted hydration: the parse only saw half the claude turns.
|
|
const partial = [day(target, { claude: slice(100.0, 150) })]
|
|
const out = await ensureCacheHydrated(noSessions, () => partial, 'cfg-A', () => false)
|
|
// Baseline wins per (date, provider); the undercount is discarded.
|
|
expect(out.days[0]!.providers['claude']!.cost).toBe(230.06)
|
|
expect(out.days[0]!.providers['codex']!.cost).toBe(79.29)
|
|
// Still not finalized — the next complete parse gets to correct for real.
|
|
expect(out.complete).toBe(false)
|
|
})
|
|
|
|
it('a partial parse still fills days the baseline lacks entirely', async () => {
|
|
await seed({ complete: false })
|
|
const newDate = daysAgoStr(10)
|
|
const partial = [day(newDate, { grok: slice(6.29, 9) })]
|
|
const out = await ensureCacheHydrated(noSessions, () => partial, 'cfg-A', () => false)
|
|
expect(out.days.map(d => d.date)).toEqual([daysAgoStr(30), newDate])
|
|
expect(out.days[1]!.providers['grok']!.cost).toBe(6.29)
|
|
})
|
|
|
|
it('a partial parse cannot double into an opaque adopted day', async () => {
|
|
// The full adversarial-review repro: a pre-v5 cache day with totals but no
|
|
// provider slices is adopted, then a PARTIAL parse produces a codex slice
|
|
// for the same date. The opaque day must stand untouched at $10/5.
|
|
const target = daysAgoStr(5)
|
|
const ancient = { version: 2, days: [{ date: target, cost: 10, calls: 5 }] }
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), JSON.stringify(ancient), 'utf-8')
|
|
const partial = [day(target, { codex: slice(3, 1) })]
|
|
const out = await ensureCacheHydrated(noSessions, () => partial, '', () => false)
|
|
const merged = out.days.find(d => d.date === target)!
|
|
expect(merged.cost).toBe(10)
|
|
expect(merged.calls).toBe(5)
|
|
expect(merged.providers).toEqual({})
|
|
expect(out.complete).toBe(false)
|
|
})
|
|
|
|
it('carried days cannot resurrect a today/future entry', async () => {
|
|
const today = daysAgoStr(0)
|
|
await seed({ days: [seededDay(), day(today, { claude: slice(99, 9) })], complete: false })
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-A')
|
|
expect(out.days.map(d => d.date)).toEqual([daysAgoStr(30)])
|
|
})
|
|
|
|
it('retention still prunes ancient carried days after a rebuild', async () => {
|
|
await seed({ days: [seededDay(), day('2010-01-01', { claude: slice(1, 1) })], complete: false })
|
|
const out = await ensureCacheHydrated(noSessions, () => [], 'cfg-A')
|
|
expect(out.days.map(d => d.date)).toEqual([daysAgoStr(30)])
|
|
})
|
|
})
|
|
|
|
describe('adoption union across older cache files', () => {
|
|
it('reconstructs the fullest history from every older daily-cache file, .bak included', async () => {
|
|
// The real machine scenario, miniaturized: a v13 file whose rebuild lost
|
|
// the old claude slices, a v9 .bak that still has them, and a legacy v10
|
|
// written by an installed app. Higher version wins per (date, provider);
|
|
// lower versions only extend.
|
|
const v13 = {
|
|
version: 13,
|
|
savingsConfigHash: '',
|
|
lastComputedDate: '2026-07-17',
|
|
complete: true,
|
|
days: [
|
|
day('2026-04-26', { codex: slice(3.28, 4) }),
|
|
day('2026-06-13', { claude: slice(230.06, 400), codex: slice(79.29, 60) }),
|
|
],
|
|
}
|
|
const v9bak = {
|
|
version: 9,
|
|
lastComputedDate: '2026-07-02',
|
|
days: [
|
|
day('2026-04-26', { codex: slice(3.9, 5), claude: slice(54.08, 120) }),
|
|
day('2026-05-03', { claude: slice(9.27, 15) }),
|
|
],
|
|
}
|
|
const legacyV10 = {
|
|
version: 10,
|
|
lastComputedDate: '2026-07-19',
|
|
days: [
|
|
day('2026-05-20', { cursor: slice(0.01, 1) }),
|
|
],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json'), JSON.stringify(v13), 'utf-8')
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json.v9.bak'), JSON.stringify(v9bak), 'utf-8')
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), JSON.stringify(legacyV10), 'utf-8')
|
|
|
|
const cache = await loadDailyCache()
|
|
expect(cache.version).toBe(DAILY_CACHE_VERSION)
|
|
expect(cache.days.map(d => d.date)).toEqual(['2026-04-26', '2026-05-03', '2026-05-20', '2026-06-13'])
|
|
const apr26 = cache.days[0]!
|
|
// codex from v13 (higher version wins), claude rescued from the v9 .bak.
|
|
expect(apr26.providers['codex']!.cost).toBe(3.28)
|
|
expect(apr26.providers['claude']!.cost).toBe(54.08)
|
|
expect(apr26.cost).toBeCloseTo(57.36, 5)
|
|
expect(apr26.carried).toBe(true)
|
|
expect(cache.days[1]!.providers['claude']!.cost).toBe(9.27)
|
|
expect(cache.days[2]!.providers['cursor']!.cost).toBe(0.01)
|
|
// Adopted history is pending re-derivation.
|
|
expect(cache.complete).not.toBe(true)
|
|
// The v14 file is persisted so adoption is one-time.
|
|
expect(existsSync(dailyCachePath())).toBe(true)
|
|
// None of the source files were touched.
|
|
expect(JSON.parse(await readFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json'), 'utf-8'))).toEqual(JSON.parse(JSON.stringify(v13)))
|
|
expect(JSON.parse(await readFile(join(TMP_CACHE_ROOT, 'daily-cache.json.v9.bak'), 'utf-8'))).toEqual(JSON.parse(JSON.stringify(v9bak)))
|
|
})
|
|
|
|
it('skips malformed candidates without failing the adoption', async () => {
|
|
const good = {
|
|
version: 12,
|
|
lastComputedDate: '2026-07-01',
|
|
days: [day('2026-06-01', { claude: slice(10, 2) })],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v12.json'), JSON.stringify(good), 'utf-8')
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json'), 'not json at all {{', 'utf-8')
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v14.json.deadbeef.tmp'), 'truncated{', 'utf-8')
|
|
const cache = await loadDailyCache()
|
|
expect(cache.days).toHaveLength(1)
|
|
expect(cache.days[0]).toMatchObject({ date: '2026-06-01', cost: 10, carried: true })
|
|
})
|
|
|
|
it('rescues a fully-written .tmp left by a crash before rename', async () => {
|
|
// Adversarial-review finding: the atomic write completes (content synced)
|
|
// but the process dies before rename. The .tmp is then the ONLY copy of
|
|
// the newest state; a parseable one must be adopted.
|
|
const onlyCopy = {
|
|
version: 13,
|
|
days: [day(daysAgoStr(15), { claude: slice(88, 11) })],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json.a1b2c3d4.tmp'), JSON.stringify(onlyCopy), 'utf-8')
|
|
const cache = await loadDailyCache()
|
|
expect(cache.days).toHaveLength(1)
|
|
expect(cache.days[0]).toMatchObject({ date: daysAgoStr(15), cost: 88, carried: true })
|
|
})
|
|
|
|
it('adoption purges today/future entries and applies retention before persisting', async () => {
|
|
// Adversarial-review finding: loadDailyCache has standalone readers, so a
|
|
// frozen today entry or a 2023 day must not survive adoption itself.
|
|
const old = {
|
|
version: 13,
|
|
days: [
|
|
day('2010-01-01', { claude: slice(1, 1) }),
|
|
day(daysAgoStr(15), { claude: slice(5, 2) }),
|
|
day(daysAgoStr(0), { claude: slice(99, 9) }),
|
|
],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json'), JSON.stringify(old), 'utf-8')
|
|
const cache = await loadDailyCache()
|
|
expect(cache.days.map(d => d.date)).toEqual([daysAgoStr(15)])
|
|
})
|
|
|
|
it('drops malformed day entries but keeps the valid ones', async () => {
|
|
const mixed = {
|
|
version: 11,
|
|
days: [
|
|
day('2026-06-01', { claude: slice(10, 2) }),
|
|
{ date: 'garbage', cost: 5 },
|
|
{ cost: 7 },
|
|
{ date: '2026-06-02', cost: 'NaN-ish' },
|
|
],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v11.json'), JSON.stringify(mixed), 'utf-8')
|
|
const cache = await loadDailyCache()
|
|
expect(cache.days.map(d => d.date)).toEqual(['2026-06-01', '2026-06-02'])
|
|
expect(cache.days[0]!.cost).toBe(10)
|
|
expect(cache.days[1]!.cost).toBe(0)
|
|
})
|
|
|
|
it('sanitizes junk inside provider slices at migration, not just at fold time', async () => {
|
|
// v15-closure finding: slice-level junk survived structuredClone into the
|
|
// next cache generation. Migration must scrub it.
|
|
const dirty = {
|
|
version: 13,
|
|
days: [{
|
|
date: daysAgoStr(20), cost: 5, calls: 2,
|
|
providers: {
|
|
claude: { calls: 2, cost: '5', savingsUSD: null, projects: { good: { cost: 5, calls: 2 }, bad: [1] } },
|
|
junk: [1, 2],
|
|
},
|
|
}],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json'), JSON.stringify(dirty), 'utf-8')
|
|
const cache = await loadDailyCache()
|
|
const claude = cache.days[0]!.providers['claude']!
|
|
expect(claude).toMatchObject({ calls: 2, cost: 0, savingsUSD: 0 })
|
|
expect(claude.projects).toEqual({ good: { cost: 5, calls: 2, savingsUSD: 0, sessions: 0 } })
|
|
expect(cache.days[0]!.providers['junk']).toBeUndefined()
|
|
})
|
|
|
|
it('rescues older files even when the current versioned file is corrupt', async () => {
|
|
const old = {
|
|
version: 13,
|
|
days: [day('2026-06-01', { claude: slice(42, 7) })],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json'), JSON.stringify(old), 'utf-8')
|
|
await writeFile(dailyCachePath(), 'corrupted{{{', 'utf-8')
|
|
const cache = await loadDailyCache()
|
|
expect(cache.days).toHaveLength(1)
|
|
expect(cache.days[0]).toMatchObject({ date: '2026-06-01', cost: 42, carried: true })
|
|
})
|
|
|
|
it('adopted carried days then survive a hydration whose parse finds nothing', async () => {
|
|
const old = {
|
|
version: 13,
|
|
days: [day(daysAgoStr(40), { claude: slice(409.62, 900) })],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.v13.json'), JSON.stringify(old), 'utf-8')
|
|
const out = await ensureCacheHydrated(noSessions, () => [], '')
|
|
expect(out.days).toHaveLength(1)
|
|
expect(out.days[0]).toMatchObject({ date: daysAgoStr(40), cost: 409.62, carried: true })
|
|
expect(out.complete).toBe(true)
|
|
|
|
// And KEEP surviving on subsequent normal hydrations.
|
|
const again = await ensureCacheHydrated(noSessions, () => [], '')
|
|
expect(again.days).toHaveLength(1)
|
|
expect(again.days[0]!.cost).toBe(409.62)
|
|
})
|
|
|
|
it('clamps a stale lastComputedDate when adoption purges a frozen today entry', async () => {
|
|
// Verification-pass finding: a trusted same-version candidate carrying
|
|
// lastComputedDate = today (clock skew) would make hydration skip the gap
|
|
// parse forever after the today entry is purged.
|
|
const today = daysAgoStr(0)
|
|
const trusted = {
|
|
version: DAILY_CACHE_VERSION,
|
|
savingsConfigHash: '',
|
|
tzKey: currentTzKey(),
|
|
lastComputedDate: today,
|
|
complete: true,
|
|
days: [day(daysAgoStr(3), { claude: slice(5, 2) }), day(today, { claude: slice(9, 1) })],
|
|
}
|
|
await writeFile(join(TMP_CACHE_ROOT, 'daily-cache.json'), JSON.stringify(trusted), 'utf-8')
|
|
const cache = await loadDailyCache()
|
|
expect(cache.days.map(d => d.date)).toEqual([daysAgoStr(3)])
|
|
expect(cache.lastComputedDate).toBe(daysAgoStr(3))
|
|
// Hydration can now fill the gap up to yesterday instead of skipping it.
|
|
let parsed = 0
|
|
await ensureCacheHydrated(async () => { parsed += 1; return [] }, () => [], '')
|
|
expect(parsed).toBe(1)
|
|
})
|
|
|
|
it('preserves a carried sessions-only slice (its calls landed on the next day)', () => {
|
|
const fresh = day('2026-07-10', { codex: slice(3, 1) })
|
|
const baseline = day('2026-07-10', { claude: slice(0, 0, { sessions: 1 }) }, { sessions: 1 })
|
|
const merged = mergeDayEntries([fresh], [baseline], true)
|
|
expect(merged[0]!.providers['claude']!.sessions).toBe(1)
|
|
expect(merged[0]!.sessions).toBe(1)
|
|
expect(merged[0]!.cost).toBe(3)
|
|
expect(merged[0]!.carried).toBe(true)
|
|
})
|
|
|
|
it('round-trips carried marks and rich slices through save/load', async () => {
|
|
const rich = day(daysAgoStr(20), {
|
|
claude: slice(20, 3, {
|
|
sessions: 2,
|
|
inputTokens: 1000,
|
|
models: { 'opus-4-8': { calls: 3, cost: 20, savingsUSD: 0, inputTokens: 1000, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 } },
|
|
categories: { coding: { turns: 3, cost: 20, savingsUSD: 0, editTurns: 1, oneShotTurns: 1 } },
|
|
}),
|
|
}, { carried: true })
|
|
const cache: DailyCache = {
|
|
version: DAILY_CACHE_VERSION,
|
|
savingsConfigHash: '',
|
|
tzKey: currentTzKey(),
|
|
lastComputedDate: daysAgoStr(1),
|
|
days: [rich],
|
|
complete: true,
|
|
}
|
|
await saveDailyCache(cache)
|
|
const loaded = await loadDailyCache()
|
|
expect(loaded).toEqual(cache)
|
|
})
|
|
|
|
it('sanitizes malformed day-level model and category maps during load', async () => {
|
|
const target = daysAgoStr(20)
|
|
const dirty = {
|
|
version: DAILY_CACHE_VERSION,
|
|
savingsConfigHash: '',
|
|
tzKey: currentTzKey(),
|
|
lastComputedDate: daysAgoStr(1),
|
|
complete: true,
|
|
days: [{
|
|
...day(target, { claude: slice(5, 2) }),
|
|
models: 'bad',
|
|
categories: 9,
|
|
}],
|
|
}
|
|
await writeFile(dailyCachePath(), JSON.stringify(dirty), 'utf-8')
|
|
|
|
const loaded = await loadDailyCache()
|
|
|
|
expect(loaded.days[0]!.models).toEqual({})
|
|
expect(loaded.days[0]!.categories).toEqual({})
|
|
})
|
|
|
|
it('drops inherited provider and model keys before period aggregation', async () => {
|
|
const target = daysAgoStr(20)
|
|
const modelStats = {
|
|
calls: 1,
|
|
cost: 2,
|
|
savingsUSD: 0,
|
|
inputTokens: 3,
|
|
outputTokens: 4,
|
|
cacheReadTokens: 5,
|
|
cacheWriteTokens: 6,
|
|
}
|
|
const dirty = {
|
|
version: DAILY_CACHE_VERSION,
|
|
savingsConfigHash: '',
|
|
tzKey: currentTzKey(),
|
|
lastComputedDate: daysAgoStr(1),
|
|
complete: true,
|
|
days: [{
|
|
...day(target, {
|
|
toString: slice(2, 1),
|
|
safeProvider: slice(3, 1),
|
|
}),
|
|
models: {
|
|
constructor: modelStats,
|
|
safeModel: modelStats,
|
|
},
|
|
}],
|
|
}
|
|
await writeFile(dailyCachePath(), JSON.stringify(dirty), 'utf-8')
|
|
|
|
const loaded = await loadDailyCache()
|
|
const loadedDay = loaded.days[0]!
|
|
let period: ReturnType<typeof buildPeriodDataFromDays>
|
|
try {
|
|
period = buildPeriodDataFromDays(loaded.days, 'loaded')
|
|
} finally {
|
|
const objectConstructor = Object as typeof Object & Record<string, unknown>
|
|
delete objectConstructor.calls
|
|
delete objectConstructor.cost
|
|
delete objectConstructor.savingsUSD
|
|
}
|
|
|
|
expect(Object.hasOwn(loadedDay.providers, 'toString')).toBe(false)
|
|
expect(Object.hasOwn(loadedDay.models, 'constructor')).toBe(false)
|
|
const assertFiniteNumbers = (value: unknown): void => {
|
|
if (typeof value === 'number') {
|
|
expect(Number.isFinite(value)).toBe(true)
|
|
} else if (value && typeof value === 'object') {
|
|
for (const child of Object.values(value)) assertFiniteNumbers(child)
|
|
}
|
|
}
|
|
assertFiniteNumbers(period)
|
|
})
|
|
|
|
it('sanitizes a non-string lastComputedDate before hydration parses it', async () => {
|
|
const dirty = {
|
|
version: DAILY_CACHE_VERSION,
|
|
savingsConfigHash: '',
|
|
tzKey: currentTzKey(),
|
|
lastComputedDate: 42,
|
|
complete: true,
|
|
days: [],
|
|
}
|
|
await writeFile(dailyCachePath(), JSON.stringify(dirty), 'utf-8')
|
|
|
|
const loaded = await loadDailyCache()
|
|
expect(loaded.days).toEqual([])
|
|
|
|
const hydrated = await ensureCacheHydrated(noSessions, () => [], '')
|
|
|
|
expect(loaded.lastComputedDate).toBeNull()
|
|
expect(hydrated.complete).toBe(true)
|
|
})
|
|
})
|