@tokentop/ttop 0.2.2 → 0.4.0

package/src/tui/contexts/RealTimeActivityContext.tsx

@@ -1,10 +1,18 @@
-import { createContext, useContext, useState, useEffect, useRef, useCallback, type ReactNode } from 'react';
-import { pluginRegistry } from '@/plugins/registry.ts';
-import type { ActivityUpdate } from '@/plugins/types/agent.ts';
-import { createPluginContext } from '@/plugins/plugin-context-factory.ts';
-import { usePlugins } from './PluginContext.tsx';
-import { useLogs } from './LogContext.tsx';
-import { useDemoMode } from './DemoModeContext.tsx';
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+} from "react";
+import { createPluginContext } from "@/plugins/plugin-context-factory.ts";
+import { pluginRegistry } from "@/plugins/registry.ts";
+import type { ActivityUpdate } from "@/plugins/types/agent.ts";
+import { useDemoMode } from "./DemoModeContext.tsx";
+import { useLogs } from "./LogContext.tsx";
+import { usePlugins } from "./PluginContext.tsx";
 
 type ActivityListener = (delta: number, timestamp: number) => void;
 
@@ -16,14 +24,22 @@ interface RealTimeActivityContextValue {
 
 const RealTimeActivityContext = createContext<RealTimeActivityContextValue | null>(null);
 
+const LAST_SEEN_MAX_AGE_MS = 5 * 60_000;
+const LAST_SEEN_MAX_ENTRIES = 10_000;
+
+interface LastSeenEntry {
+  tokens: number;
+  updatedAt: number;
+}
+
 export function RealTimeActivityProvider({ children }: { children: ReactNode }) {
   const [lastActivityAt, setLastActivityAt] = useState<number | null>(null);
   const [isWatching, setIsWatching] = useState(false);
   const { isInitialized: pluginsInitialized } = usePlugins();
   const { debug, info } = useLogs();
   const { demoMode } = useDemoMode();
-  
-  const lastSeenRef = useRef<Map<string, number>>(new Map());
+
+  const lastSeenRef = useRef<Map<string, LastSeenEntry>>(new Map());
   const listenersRef = useRef<Set<ActivityListener>>(new Set());
   const cleanupRef = useRef<(() => void) | null>(null);
 
@@ -34,35 +50,39 @@ export function RealTimeActivityProvider({ children }: { children: ReactNode })
     };
   }, []);
 
-  const handleActivityUpdate = useCallback((update: ActivityUpdate) => {
-    const key = `${update.sessionId}:${update.messageId}`;
-    const prevTokens = lastSeenRef.current.get(key) ?? 0;
-    const newTokens = update.tokens.input + update.tokens.output + (update.tokens.reasoning ?? 0);
-    const delta = Math.max(0, newTokens - prevTokens);
-    
-    if (delta > 0) {
-      lastSeenRef.current.set(key, newTokens);
-      setLastActivityAt(update.timestamp);
-      debug(`Real-time activity: +${delta} tokens`, { sessionId: update.sessionId }, 'realtime');
-      
-      for (const listener of listenersRef.current) {
-        listener(delta, update.timestamp);
+  const handleActivityUpdate = useCallback(
+    (update: ActivityUpdate) => {
+      const key = `${update.sessionId}:${update.messageId}`;
+      const prev = lastSeenRef.current.get(key);
+      const prevTokens = prev?.tokens ?? 0;
+      const newTokens = update.tokens.input + update.tokens.output + (update.tokens.reasoning ?? 0);
+      const delta = Math.max(0, newTokens - prevTokens);
+
+      if (delta > 0) {
+        lastSeenRef.current.set(key, { tokens: newTokens, updatedAt: Date.now() });
+        setLastActivityAt(update.timestamp);
+        debug(`Real-time activity: +${delta} tokens`, { sessionId: update.sessionId }, "realtime");
+
+        for (const listener of listenersRef.current) {
+          listener(delta, update.timestamp);
+        }
       }
-    }
-  }, [debug]);
+    },
+    [debug],
+  );
 
   useEffect(() => {
     if (demoMode || !pluginsInitialized) return;
 
-    const agentPlugins = pluginRegistry.getAll('agent');
+    const agentPlugins = pluginRegistry.getAll("agent");
     const cleanups: (() => void)[] = [];
 
     for (const plugin of agentPlugins) {
       if (plugin.capabilities.realTimeTracking && plugin.startActivityWatch) {
         const ctx = createPluginContext(plugin.id, plugin.permissions);
-        info(`Starting real-time activity watch for ${plugin.id}`, undefined, 'realtime');
+        info(`Starting real-time activity watch for ${plugin.id}`, undefined, "realtime");
         plugin.startActivityWatch(ctx, handleActivityUpdate);
-        
+
         if (plugin.stopActivityWatch) {
           const stopFn = plugin.stopActivityWatch.bind(plugin, ctx);
           cleanups.push(stopFn);
@@ -73,7 +93,9 @@ export function RealTimeActivityProvider({ children }: { children: ReactNode })
     if (cleanups.length > 0) {
       setIsWatching(true);
       cleanupRef.current = () => {
-        cleanups.forEach(fn => fn());
+        cleanups.forEach((fn) => {
+          fn();
+        });
         setIsWatching(false);
       };
     }
@@ -88,14 +110,28 @@ export function RealTimeActivityProvider({ children }: { children: ReactNode })
 
   useEffect(() => {
     const interval = setInterval(() => {
+      const map = lastSeenRef.current;
       const now = Date.now();
-      if (lastActivityAt && now - lastActivityAt > 60000) {
-        lastSeenRef.current.clear();
+
+      for (const [key, entry] of map) {
+        if (now - entry.updatedAt > LAST_SEEN_MAX_AGE_MS) {
+          map.delete(key);
+        }
       }
-    }, 30000);
+
+      if (map.size > LAST_SEEN_MAX_ENTRIES) {
+        const excess = map.size - LAST_SEEN_MAX_ENTRIES;
+        const keys = map.keys();
+        for (let i = 0; i < excess; i++) {
+          const next = keys.next();
+          if (next.done) break;
+          map.delete(next.value);
+        }
+      }
+    }, 30_000);
 
     return () => clearInterval(interval);
-  }, [lastActivityAt]);
+  }, []);
 
   const value: RealTimeActivityContextValue = {
     lastActivityAt,
@@ -104,16 +140,14 @@ export function RealTimeActivityProvider({ children }: { children: ReactNode })
   };
 
   return (
-    <RealTimeActivityContext.Provider value={value}>
-      {children}
-    </RealTimeActivityContext.Provider>
+    <RealTimeActivityContext.Provider value={value}>{children}</RealTimeActivityContext.Provider>
   );
 }
 
 export function useRealTimeActivity(): RealTimeActivityContextValue {
   const context = useContext(RealTimeActivityContext);
   if (!context) {
-    throw new Error('useRealTimeActivity must be used within RealTimeActivityProvider');
+    throw new Error("useRealTimeActivity must be used within RealTimeActivityProvider");
   }
   return context;
 }

package/src/tui/contexts/StorageContext.tsx

@@ -1,34 +1,32 @@
-import { createContext, useContext, useEffect, useRef, useState, useCallback, useMemo, type ReactNode } from 'react';
-import { initDatabase, closeDatabase, isDatabaseInitialized, getAppRunId } from '@/storage/db.ts';
-import { insertProviderSnapshotBatch } from '@/storage/repos/providerSnapshots.ts';
-import { insertUsageEventBatch } from '@/storage/repos/usageEvents.ts';
-import { upsertAgentSession, insertAgentSessionSnapshot, getLatestStreamTotalsForAllSessions } from '@/storage/repos/agentSessions.ts';
-import type {
-  ProviderSnapshotInsert,
-  UsageEventInsert,
-  AgentSessionUpsert,
-  AgentSessionSnapshotInsert,
-  AgentSessionStreamSnapshotRow,
-  StreamTotals,
-} from '@/storage/types.ts';
-import { computeStreamDelta } from '@/storage/types.ts';
-import { useDemoMode } from './DemoModeContext.tsx';
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import { closeDatabase, getAppRunId, initDatabase, isDatabaseInitialized } from "@/storage/db.ts";
+import { seedPreviousTotals } from "@/storage/persistence-service.ts";
+import { insertProviderSnapshotBatch } from "@/storage/repos/providerSnapshots.ts";
+import { insertUsageEventBatch } from "@/storage/repos/usageEvents.ts";
+import { incrementalVacuum, pruneOldData } from "@/storage/retention.ts";
+import type { ProviderSnapshotInsert, UsageEventInsert } from "@/storage/types.ts";
+import { useDemoMode } from "./DemoModeContext.tsx";
 
 interface StorageContextValue {
   isReady: boolean;
   appRunId: number | null;
   recordProviderSnapshots: (snapshots: ProviderSnapshotInsert[]) => void;
   recordUsageEvents: (events: UsageEventInsert[]) => void;
-  recordAgentSession: (
-    session: AgentSessionUpsert,
-    snapshot: Omit<AgentSessionSnapshotInsert, 'agentSessionId'>,
-    streams: Omit<AgentSessionStreamSnapshotRow, 'agentSessionSnapshotId'>[]
-  ) => number | null;
 }
 
 const StorageContext = createContext<StorageContextValue | null>(null);
 
-const SNAPSHOT_INTERVAL_MS = 60_000;
+const PROVIDER_SNAPSHOT_INTERVAL_MS = 300_000;
+const PRUNE_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
 
 interface StorageProviderProps {
   children: ReactNode;
@@ -38,8 +36,6 @@ export function StorageProvider({ children }: StorageProviderProps) {
   const [isReady, setIsReady] = useState(false);
   const [appRunId, setAppRunId] = useState<number | null>(null);
   const lastProviderSnapshotRef = useRef<Map<string, number>>(new Map());
-  const lastSessionSnapshotRef = useRef<Map<string, number>>(new Map());
-  const previousTotalsRef = useRef<Map<string, StreamTotals>>(new Map());
   const { demoMode, simulator } = useDemoMode();
 
   useEffect(() => {
@@ -55,28 +51,29 @@ export function StorageProvider({ children }: StorageProviderProps) {
     async function init() {
       try {
         await initDatabase();
-        if (mounted) {
-          try {
-            const latestTotals = getLatestStreamTotalsForAllSessions();
-            for (const row of latestTotals) {
-              const streamKey = `${row.agentId}:${row.sessionId}:${row.provider}:${row.model}`;
-              previousTotalsRef.current.set(streamKey, {
-                inputTokens: row.inputTokens,
-                outputTokens: row.outputTokens,
-                cacheReadTokens: row.cacheReadTokens,
-                cacheWriteTokens: row.cacheWriteTokens,
-                costUsd: row.costUsd,
-                requestCount: row.requestCount,
-              });
-            }
-          } catch (err) {
-            console.error('Failed to seed previous totals from DB:', err);
+
+        // Prune expired snapshots before seeding — keeps startup fast
+        try {
+          const pruneResult = pruneOldData();
+          if (pruneResult.agentSessionSnapshots > 0 || pruneResult.providerSnapshots > 0) {
+            console.log(
+              `[retention] Pruned ${pruneResult.agentSessionSnapshots} session snapshots, ` +
+                `${pruneResult.providerSnapshots} provider snapshots in ${pruneResult.durationMs}ms`,
+            );
+            incrementalVacuum();
           }
+        } catch (err) {
+          console.error("Failed to prune old data:", err);
+        }
+
+        if (mounted) {
+          // Seed the persistence service with previous stream totals from DB
+          seedPreviousTotals();
           setIsReady(true);
           setAppRunId(getAppRunId());
         }
       } catch (err) {
-        console.error('Failed to initialize database:', err);
+        console.error("Failed to initialize database:", err);
       }
     }
 
@@ -90,109 +87,42 @@ export function StorageProvider({ children }: StorageProviderProps) {
     };
   }, [demoMode]);
 
-  const recordProviderSnapshots = useCallback((snapshots: ProviderSnapshotInsert[]) => {
-    if (!isReady || demoMode || snapshots.length === 0) return;
-
-    const now = Date.now();
-    const filtered = snapshots.filter(s => {
-      const lastTs = lastProviderSnapshotRef.current.get(s.provider) ?? 0;
-      return now - lastTs >= SNAPSHOT_INTERVAL_MS;
-    });
-
-    if (filtered.length === 0) return;
-
-    try {
-      insertProviderSnapshotBatch(filtered);
-      for (const s of filtered) {
-        lastProviderSnapshotRef.current.set(s.provider, now);
-      }
-    } catch (err) {
-      console.error('Failed to record provider snapshots:', err);
-    }
-  }, [isReady, demoMode]);
-
-  const recordUsageEvents = useCallback((events: UsageEventInsert[]) => {
-    if (!isReady || demoMode || events.length === 0) return;
-
-    try {
-      insertUsageEventBatch(events);
-    } catch (err) {
-      console.error('Failed to record usage events:', err);
-    }
-  }, [isReady, demoMode]);
-
-  const recordAgentSession = useCallback((
-    session: AgentSessionUpsert,
-    snapshot: Omit<AgentSessionSnapshotInsert, 'agentSessionId'>,
-    streams: Omit<AgentSessionStreamSnapshotRow, 'agentSessionSnapshotId'>[]
-  ): number | null => {
-    if (!isReady || demoMode) return null;
+  const recordProviderSnapshots = useCallback(
+    (snapshots: ProviderSnapshotInsert[]) => {
+      if (!isReady || demoMode || snapshots.length === 0) return;
 
-    const sessionKey = `${session.agentId}:${session.sessionId}`;
-    const now = Date.now();
-    const lastTs = lastSessionSnapshotRef.current.get(sessionKey) ?? 0;
+      const now = Date.now();
+      const filtered = snapshots.filter((s) => {
+        const lastTs = lastProviderSnapshotRef.current.get(s.provider) ?? 0;
+        return now - lastTs >= PROVIDER_SNAPSHOT_INTERVAL_MS;
+      });
 
-    if (now - lastTs < SNAPSHOT_INTERVAL_MS) {
-      return null;
-    }
+      if (filtered.length === 0) return;
 
-    try {
-      const agentSessionId = upsertAgentSession(session);
-
-      const snapshotId = insertAgentSessionSnapshot(
-        { ...snapshot, agentSessionId },
-        streams
-      );
-
-      lastSessionSnapshotRef.current.set(sessionKey, now);
-
-      const usageEvents: UsageEventInsert[] = [];
-      for (const stream of streams) {
-        const streamKey = `${sessionKey}:${stream.provider}:${stream.model}`;
-        const current: StreamTotals = {
-          inputTokens: stream.inputTokens,
-          outputTokens: stream.outputTokens,
-          cacheReadTokens: stream.cacheReadTokens,
-          cacheWriteTokens: stream.cacheWriteTokens,
-          costUsd: stream.costUsd,
-          requestCount: stream.requestCount,
-        };
-
-        const previous = previousTotalsRef.current.get(streamKey);
-        const delta = computeStreamDelta(current, previous);
-
-        if (delta) {
-          usageEvents.push({
-            timestamp: now,
-            source: 'agent',
-            provider: stream.provider,
-            model: stream.model,
-            agentId: session.agentId,
-            sessionId: session.sessionId,
-            projectPath: session.projectPath ?? null,
-            inputTokens: delta.inputTokens,
-            outputTokens: delta.outputTokens,
-            cacheReadTokens: delta.cacheReadTokens,
-            cacheWriteTokens: delta.cacheWriteTokens,
-            costUsd: delta.costUsd,
-            requestCount: delta.requestCount,
-            pricingSource: stream.pricingSource ?? null,
-          });
+      try {
+        insertProviderSnapshotBatch(filtered);
+        for (const s of filtered) {
+          lastProviderSnapshotRef.current.set(s.provider, now);
         }
-
-        previousTotalsRef.current.set(streamKey, current);
+      } catch (err) {
+        console.error("Failed to record provider snapshots:", err);
       }
+    },
+    [isReady, demoMode],
+  );
 
-      if (usageEvents.length > 0) {
-        insertUsageEventBatch(usageEvents);
-      }
+  const recordUsageEvents = useCallback(
+    (events: UsageEventInsert[]) => {
+      if (!isReady || demoMode || events.length === 0) return;
 
-      return snapshotId;
-    } catch (err) {
-      console.error('Failed to record agent session:', err);
-      return null;
-    }
-  }, [isReady, demoMode]);
+      try {
+        insertUsageEventBatch(events);
+      } catch (err) {
+        console.error("Failed to record usage events:", err);
+      }
+    },
+    [isReady, demoMode],
+  );
 
   useEffect(() => {
     if (!demoMode || !isReady || !simulator) return;
@@ -204,25 +134,41 @@ export function StorageProvider({ children }: StorageProviderProps) {
     return () => clearInterval(interval);
   }, [demoMode, isReady, simulator]);
 
-  const value: StorageContextValue = useMemo(() => ({
-    isReady,
-    appRunId,
-    recordProviderSnapshots,
-    recordUsageEvents,
-    recordAgentSession,
-  }), [isReady, appRunId, recordProviderSnapshots, recordUsageEvents, recordAgentSession]);
-
-  return (
-    <StorageContext.Provider value={value}>
-      {children}
-    </StorageContext.Provider>
+  // Periodic data retention pruning (every hour)
+  useEffect(() => {
+    if (demoMode || !isReady) return;
+
+    const intervalId = setInterval(() => {
+      try {
+        const result = pruneOldData();
+        if (result.agentSessionSnapshots > 0 || result.providerSnapshots > 0) {
+          incrementalVacuum();
+        }
+      } catch {
+        // Silently ignore periodic prune failures
+      }
+    }, PRUNE_INTERVAL_MS);
+
+    return () => clearInterval(intervalId);
+  }, [demoMode, isReady]);
+
+  const value: StorageContextValue = useMemo(
+    () => ({
+      isReady,
+      appRunId,
+      recordProviderSnapshots,
+      recordUsageEvents,
+    }),
+    [isReady, appRunId, recordProviderSnapshots, recordUsageEvents],
   );
+
+  return <StorageContext.Provider value={value}>{children}</StorageContext.Provider>;
 }
 
 export function useStorage(): StorageContextValue {
   const context = useContext(StorageContext);
   if (!context) {
-    throw new Error('useStorage must be used within StorageProvider');
+    throw new Error("useStorage must be used within StorageProvider");
   }
   return context;
 }

package/src/tui/contexts/ThemeContext.tsx

@@ -1,6 +1,12 @@
-import { createContext, useContext, useState, type ReactNode } from 'react';
-import type { ThemePlugin, ThemeColors, ThemeComponents, ColorScheme, ColorSchemePreference } from '@/plugins/types/theme.ts';
-import { tokyoNightTheme } from '@/plugins/themes/tokyo-night.ts';
+import { createContext, type ReactNode, useContext, useState } from "react";
+import { tokyoNightTheme } from "@/plugins/themes/tokyo-night.ts";
+import type {
+  ColorScheme,
+  ColorSchemePreference,
+  ThemeColors,
+  ThemeComponents,
+  ThemePlugin,
+} from "@/plugins/types/theme.ts";
 
 interface ThemeContextValue {
   theme: ThemePlugin;
@@ -42,17 +48,13 @@ export function ThemeProvider({ initialTheme, children }: ThemeProviderProps) {
     setPreviewTheme,
   };
 
-  return (
-    <ThemeContext.Provider value={value}>
-      {children}
-    </ThemeContext.Provider>
-  );
+  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
 }
 
 export function useTheme(): ThemeContextValue {
   const context = useContext(ThemeContext);
   if (!context) {
-    throw new Error('useTheme must be used within ThemeProvider');
+    throw new Error("useTheme must be used within ThemeProvider");
   }
   return context;
 }
@@ -70,16 +72,19 @@ export function resolveTheme(
   if (themes.length === 0) return tokyoNightTheme;
 
   const targetScheme: ColorScheme | null =
-    schemePref === 'auto' ? detectedMode :
-    schemePref === 'light' ? 'light' :
-    schemePref === 'dark' ? 'dark' :
-    null;
+    schemePref === "auto"
+      ? detectedMode
+      : schemePref === "light"
+        ? "light"
+        : schemePref === "dark"
+          ? "dark"
+          : null;
 
-  const stored = themes.find(t => t.id === themeId);
+  const stored = themes.find((t) => t.id === themeId);
 
   if (!stored) {
     if (targetScheme) {
-      return themes.find(t => t.colorScheme === targetScheme) ?? themes[0]!;
+      return themes.find((t) => t.colorScheme === targetScheme) ?? themes[0]!;
     }
     return themes[0]!;
   }
@@ -89,7 +94,7 @@ export function resolveTheme(
   }
 
   const familySibling = themes.find(
-    t => t.family === stored.family && t.colorScheme === targetScheme && t.id !== stored.id,
+    (t) => t.family === stored.family && t.colorScheme === targetScheme && t.id !== stored.id,
   );
   return familySibling ?? stored;
 }