feat: optimize parse caching across providers

Author: spMohanty

bin/codeburn

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { homedir } from "node:os";
+
+try {
+  process.cwd();
+} catch (error) {
+  if (
+    error &&
+    typeof error === "object" &&
+    "code" in error &&
+    (error).code === "ENOENT"
+  ) {
+    process.chdir(homedir());
+  } else {
+    throw error;
+  }
+}
+
+await import("../dist/cli.js");

package.json

@@ -5,10 +5,11 @@
   "type": "module",
   "main": "./dist/cli.js",
   "bin": {
-    "codeburn": "dist/cli.js"
+    "codeburn": "bin/codeburn"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "build": "tsup",

src/dashboard.tsx

@@ -4,7 +4,7 @@ import React, { useState, useCallback, useEffect, useRef } from 'react'
 import { render, Box, Text, useInput, useApp, useWindowSize } from 'ink'
 import { CATEGORY_LABELS, type DateRange, type ProjectSummary, type TaskCategory } from './types.js'
 import { formatCost, formatTokens } from './format.js'
-import { parseAllSessions, filterProjectsByName } from './parser.js'
+import { parseAllSessions, filterProjectsByDateRange, filterProjectsByName } from './parser.js'
 import { loadPricing } from './models.js'
 import { getAllProviders } from './providers/index.js'
 import { scanAndDetect, type WasteFinding, type WasteAction, type OptimizeResult } from './optimize.js'
@@ -20,6 +20,15 @@ import { join } from 'path'
 type Period = 'today' | 'week' | '30days' | 'month' | 'all'
 type View = 'dashboard' | 'optimize' | 'compare'
 
+type CachedWindow = {
+  period: Period
+  range: {
+    start: Date
+    end: Date
+  }
+  projects: ProjectSummary[]
+}
+
 const PERIODS: Period[] = ['today', 'week', '30days', 'month', 'all']
 const PERIOD_LABELS: Record<Period, string> = {
   today: 'Today',
@@ -108,6 +117,10 @@ function getDateRange(period: Period): { start: Date; end: Date } {
   }
 }
 
+function rangeCovers(outer: { start: Date; end: Date }, inner: { start: Date; end: Date }): boolean {
+  return outer.start <= inner.start && outer.end >= inner.end
+}
+
 type Layout = { dashWidth: number; wide: boolean; halfWidth: number; barWidth: number }
 
 function getLayout(columns?: number): Layout {
@@ -630,9 +643,156 @@ function InteractiveDashboard({ initialProjects, initialPeriod, initialProvider,
   ).size
   const compareAvailable = modelCount >= 2
   const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const reloadGenerationRef = useRef(0)
+  const cacheByProviderRef = useRef(new Map<string, CachedWindow[]>())
+  const reloadSeqRef = useRef(0)
+  const preloadingRef = useRef(new Map<string, Promise<ProjectSummary[]>>())
   const findingCount = optimizeResult?.findings.length ?? 0
 
+  const providerCacheKey = useCallback((provider: string) => `${provider}:${noCache ? 'nocache' : 'cache'}`, [noCache])
+  const getRangeWidth = useCallback((range: { start: Date; end: Date }) => range.end.getTime() - range.start.getTime(), [])
+  const makeCacheToken = useCallback((provider: string, period: Period) => `${providerCacheKey(provider)}:${period}`, [providerCacheKey])
+
+  const storeCachedWindow = useCallback((provider: string, period: Period, range: { start: Date; end: Date }, projects: ProjectSummary[]) => {
+    if (noCache) return
+    const key = providerCacheKey(provider)
+    const windows = cacheByProviderRef.current.get(key) ?? []
+    const normalizedRange = { start: new Date(range.start), end: new Date(range.end) }
+    const existing = windows.findIndex(
+      existing => existing.period === period && existing.range.start.getTime() === normalizedRange.start.getTime() && existing.range.end.getTime() === normalizedRange.end.getTime(),
+    )
+    if (existing >= 0) windows.splice(existing, 1)
+    windows.push({ period, range: normalizedRange, projects })
+    windows.sort((a, b) => a.range.start.getTime() - b.range.start.getTime())
+    cacheByProviderRef.current.set(key, windows)
+  }, [noCache, providerCacheKey])
+
+  const findCachedWindow = useCallback((provider: string, range: { start: Date; end: Date }) => {
+    const candidates = cacheByProviderRef.current.get(providerCacheKey(provider)) ?? []
+    let best: CachedWindow | undefined
+    for (const candidate of candidates) {
+      if (!rangeCovers(candidate.range, range)) continue
+      if (!best) { best = candidate; continue }
+      if (getRangeWidth(candidate.range) < getRangeWidth(best.range)) {
+        best = candidate
+      } else if (candidate.period !== best.period && getRangeWidth(candidate.range) === getRangeWidth(best.range) && candidate.range.start > best.range.start) {
+        best = candidate
+      }
+    }
+    return best
+  }, [getRangeWidth, providerCacheKey])
+
+  const preloadWindow = useCallback(async (periodToLoad: Period, provider: string) => {
+    if (noCache) return
+    const preloadKey = makeCacheToken(provider, periodToLoad)
+    const range = getDateRange(periodToLoad)
+    const cached = findCachedWindow(provider, range)
+    if (cached) return
+    const inFlight = preloadingRef.current.get(preloadKey)
+    if (inFlight) return
+
+    const promise = (async () => {
+      const projects = await parseAllSessions(range, provider, { noCache, progress: null })
+      if (!noCache) {
+        storeCachedWindow(provider, periodToLoad, range, projects)
+      }
+      return projects
+    })()
+
+    preloadingRef.current.set(preloadKey, promise)
+    try {
+      await promise
+    } finally {
+      preloadingRef.current.delete(preloadKey)
+    }
+  }, [findCachedWindow, makeCacheToken, noCache, storeCachedWindow])
+
+  const reloadData = useCallback(async (p: Period, prov: string, options?: { silent?: boolean }) => {
+    const range = getDateRange(p)
+    const request = ++reloadSeqRef.current
+    const token = makeCacheToken(prov, p)
+    const cachedWindow = findCachedWindow(prov, range)
+    if (!options?.silent) {
+      setOptimizeResult(null)
+    }
+
+    if (cachedWindow) {
+      const projectsFromCache = filterProjectsByName(
+        filterProjectsByDateRange(cachedWindow.projects, range),
+        projectFilter,
+        excludeFilter,
+      )
+      if (!options?.silent && request === reloadSeqRef.current) {
+        setProjects(projectsFromCache)
+      }
+      if (!options?.silent) {
+        const usage = await getPlanUsageOrNull()
+        if (request !== reloadSeqRef.current) return
+        setPlanUsage(usage ?? undefined)
+      }
+      return
+    }
+
+    const inFlight = preloadingRef.current.get(token)
+    if (inFlight) {
+      if (!options?.silent) setLoading(true)
+      try {
+        const projects = await inFlight
+        if (!noCache) {
+          storeCachedWindow(prov, p, range, projects)
+        }
+        if (request !== reloadSeqRef.current) return
+        const filtered = filterProjectsByName(projects, projectFilter, excludeFilter)
+        if (!options?.silent) {
+          setProjects(filtered)
+        }
+      } finally {
+        if (!options?.silent && request === reloadSeqRef.current) setLoading(false)
+      }
+      if (!options?.silent) {
+        const usage = await getPlanUsageOrNull()
+        if (request !== reloadSeqRef.current) return
+        setPlanUsage(usage ?? undefined)
+      }
+      return
+    }
+
+    if (!options?.silent) setLoading(true)
+    try {
+      const projects = await parseAllSessions(range, prov, { noCache, progress: null })
+      if (!noCache) {
+        storeCachedWindow(prov, p, range, projects)
+      }
+      if (request !== reloadSeqRef.current) return
+      const filtered = filterProjectsByName(projects, projectFilter, excludeFilter)
+      if (!options?.silent) {
+        setProjects(filtered)
+      }
+    } finally {
+      if (!options?.silent && request === reloadSeqRef.current) setLoading(false)
+    }
+    if (!options?.silent) {
+      const usage = await getPlanUsageOrNull()
+      if (request !== reloadSeqRef.current) return
+      setPlanUsage(usage ?? undefined)
+    }
+  }, [excludeFilter, findCachedWindow, getPlanUsageOrNull, noCache, projectFilter, storeCachedWindow])
+
+  useEffect(() => {
+    if (noCache) return
+    const initialRange = getDateRange(initialPeriod)
+    const initialKey = providerCacheKey(initialProvider)
+    const existing = cacheByProviderRef.current.get(initialKey) ?? []
+    const alreadyCached = existing.some(entry => rangeCovers(entry.range, initialRange))
+    if (!alreadyCached) {
+      storeCachedWindow(initialProvider, initialPeriod, initialRange, initialProjects)
+    }
+  }, [initialPeriod, initialProvider, initialProjects, noCache, providerCacheKey, storeCachedWindow])
+
+  useEffect(() => {
+    if (noCache || period === '30days') return
+    void preloadWindow('30days', activeProvider)
+  }, [noCache, period, activeProvider, preloadWindow])
+
   useEffect(() => {
     let cancelled = false
     async function detect() {
@@ -673,32 +833,6 @@ function InteractiveDashboard({ initialProjects, initialPeriod, initialProvider,
     return () => { cancelled = true }
   }, [projects, period, optimizeAvailable])
 
-  const reloadData = useCallback(async (p: Period, prov: string) => {
-    const generation = ++reloadGenerationRef.current
-    setLoading(true)
-    setOptimizeResult(null)
-    try {
-      const range = getDateRange(p)
-      const data = filterProjectsByName(
-        await parseAllSessions(range, prov, { noCache: noCache ?? false, progress: null }),
-        projectFilter,
-        excludeFilter,
-      )
-      if (reloadGenerationRef.current !== generation) return
-
-      setProjects(data)
-      const usage = await getPlanUsageOrNull()
-      if (reloadGenerationRef.current !== generation) return
-      setPlanUsage(usage ?? undefined)
-    } catch (error) {
-      console.error(error)
-    } finally {
-      if (reloadGenerationRef.current === generation) {
-        setLoading(false)
-      }
-    }
-  }, [excludeFilter, noCache, projectFilter])
-
   useEffect(() => {
     if (!refreshSeconds || refreshSeconds <= 0) return
     const id = setInterval(() => { reloadData(period, activeProvider) }, refreshSeconds * 1000)

src/discovery-cache.ts

@@ -8,12 +8,21 @@ import type { SessionSource } from './providers/types.js'
 
 const DISCOVERY_CACHE_VERSION = 1
 
+const DISCOVERY_DIRECTORY_MARKER_PREFIX = '__dir__:'
+
+function traceDiscoveryCacheRead(op: string, filePath: string, note?: string): void {
+  if (process.env['CODEBURN_FILE_TRACE'] !== '1') return
+  const suffix = note ? ` ${note}` : ''
+  process.stderr.write(`codeburn-trace discovery ${op} ${filePath}${suffix}\n`)
+}
+
 export type DiscoverySnapshotEntry = {
   path: string
   mtimeMs: number
+  dirSignature?: string
 }
 
-type DiscoveryCacheEntry = {
+export type DiscoveryCacheEntry = {
   version: number
   provider: string
   scope: string
@@ -78,10 +87,46 @@ function snapshotsMatch(left: DiscoverySnapshotEntry[], right: DiscoverySnapshot
   if (left.length !== right.length) return false
   return left.every((entry, index) => {
     const other = right[index]
-    return !!other && entry.path === other.path && entry.mtimeMs === other.mtimeMs
+    return !!other
+      && entry.path === other.path
+      && entry.mtimeMs === other.mtimeMs
+      && entry.dirSignature === other.dirSignature
   })
 }
 
+function makeDirectoryMarker(path: string, dirSignature?: string): DiscoverySnapshotEntry {
+  return {
+    path: `${DISCOVERY_DIRECTORY_MARKER_PREFIX}${path}`,
+    mtimeMs: 0,
+    dirSignature,
+  }
+}
+
+export function isDiscoveryDirectoryMarker(path: string): boolean {
+  return path.startsWith(DISCOVERY_DIRECTORY_MARKER_PREFIX)
+}
+
+export function directoryPathFromMarker(markerPath: string): string | null {
+  return markerPath.startsWith(DISCOVERY_DIRECTORY_MARKER_PREFIX)
+    ? markerPath.slice(DISCOVERY_DIRECTORY_MARKER_PREFIX.length)
+    : null
+}
+
+async function loadDiscoveryCacheEntry(provider: string, scope: string): Promise<DiscoveryCacheEntry | null> {
+  const path = cachePath(provider, scope)
+  if (!existsSync(path)) return null
+  traceDiscoveryCacheRead('entry:read', path, `provider=${provider} scope=${scope}`)
+
+  try {
+    const raw = await readFile(path, 'utf-8')
+    const parsed: unknown = JSON.parse(raw)
+    if (!isDiscoveryCacheEntry(parsed) || parsed.provider !== provider || parsed.scope !== scope) return null
+    return parsed
+  } catch {
+    return null
+  }
+}
+
 async function atomicWriteJson(path: string, value: unknown): Promise<void> {
   await mkdir(dirname(path), { recursive: true })
   const temp = `${path}.${randomBytes(8).toString('hex')}.tmp`
@@ -129,6 +174,13 @@ export async function loadDiscoveryCache(
   }
 }
 
+export async function loadDiscoveryCacheEntryUnchecked(
+  provider: string,
+  scope: string,
+): Promise<DiscoveryCacheEntry | null> {
+  return loadDiscoveryCacheEntry(provider, scope)
+}
+
 export async function saveDiscoveryCache(
   provider: string,
   scope: string,
@@ -144,3 +196,7 @@ export async function saveDiscoveryCache(
     sources,
   } satisfies DiscoveryCacheEntry)
 }
+
+export function discoveryDirectoryMarker(prefixPath: string, dirSignature?: string): DiscoverySnapshotEntry {
+  return makeDirectoryMarker(prefixPath, dirSignature)
+}