claude-session-viewer 0.3.5 → 0.3.7

package/dist/server/utils/sessionWindows.js

@@ -0,0 +1,159 @@
+import { SESSION_WINDOW_DURATION_MS, EXPIRING_SOON_THRESHOLD_MINUTES, PLAN_LIMITS } from '../claude/config.js';
+import { extractTokenUsage } from './tokenStats.js';
+/**
+ * Calculate 5-hour session windows from messages
+ * Claude Code uses a 5-hour rolling window starting from the first message
+ */
+export function calculateSessionWindows(sessionsData, planConfig) {
+    const windows = [];
+    const windowMap = new Map();
+    // Collect all messages with timestamps
+    const allMessages = [];
+    for (const session of sessionsData) {
+        for (const message of session.messages) {
+            if (message.timestamp) {
+                allMessages.push({ message, sessionId: session.sessionId });
+            }
+        }
+    }
+    // Sort messages by timestamp
+    allMessages.sort((a, b) => new Date(a.message.timestamp).getTime() - new Date(b.message.timestamp).getTime());
+    if (allMessages.length === 0) {
+        return [];
+    }
+    // Group messages into 5-hour windows
+    for (const { message, sessionId } of allMessages) {
+        const messageTime = new Date(message.timestamp);
+        let assignedToWindow = false;
+        // Check existing windows to see if this message fits
+        for (const [windowId, windowData] of windowMap.entries()) {
+            const windowEnd = new Date(windowData.startTime.getTime() + SESSION_WINDOW_DURATION_MS);
+            if (messageTime >= windowData.startTime && messageTime < windowEnd) {
+                windowData.messages.push(message);
+                windowData.sessionIds.add(sessionId);
+                assignedToWindow = true;
+                break;
+            }
+        }
+        // Create new window if message doesn't fit in existing windows
+        if (!assignedToWindow) {
+            const windowId = `window-${messageTime.getTime()}`;
+            windowMap.set(windowId, {
+                messages: [message],
+                sessionIds: new Set([sessionId]),
+                startTime: messageTime
+            });
+        }
+    }
+    // Convert window map to SessionWindow objects
+    const now = new Date();
+    for (const [windowId, windowData] of windowMap.entries()) {
+        const startTime = windowData.startTime;
+        const endTime = new Date(startTime.getTime() + SESSION_WINDOW_DURATION_MS);
+        // Calculate token usage
+        let totalTokens = 0;
+        for (const message of windowData.messages) {
+            const tokenData = extractTokenUsage(message);
+            if (tokenData) {
+                totalTokens += tokenData.usage.totalTokens;
+            }
+        }
+        // Get first and last message times
+        const messageTimes = windowData.messages.map(m => new Date(m.timestamp).getTime());
+        const firstMessageTime = new Date(Math.min(...messageTimes));
+        const lastMessageTime = new Date(Math.max(...messageTimes));
+        // Calculate status
+        const remainingMs = endTime.getTime() - now.getTime();
+        const remainingMinutes = Math.floor(remainingMs / (1000 * 60));
+        const isCurrentWindow = now >= startTime && now < endTime;
+        let status = 'expired';
+        if (isCurrentWindow) {
+            if (remainingMinutes <= EXPIRING_SOON_THRESHOLD_MINUTES) {
+                status = 'expiring_soon';
+            }
+            else {
+                status = 'active';
+            }
+        }
+        const tokenLimit = planConfig.limits.tokensPerSession;
+        const percentage = (totalTokens / tokenLimit) * 100;
+        windows.push({
+            id: windowId,
+            startTime: startTime.toISOString(),
+            endTime: endTime.toISOString(),
+            firstMessageTime: firstMessageTime.toISOString(),
+            lastMessageTime: lastMessageTime.toISOString(),
+            tokenUsage: {
+                used: totalTokens,
+                limit: tokenLimit,
+                percentage: Math.min(percentage, 100)
+            },
+            messageCount: windowData.messages.length,
+            status,
+            sessionIds: Array.from(windowData.sessionIds),
+            remainingMinutes: isCurrentWindow ? Math.max(remainingMinutes, 0) : undefined,
+            isCurrentWindow
+        });
+    }
+    // Sort windows by start time (most recent first)
+    windows.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    return windows;
+}
+/**
+ * Get the currently active session window
+ */
+export function getActiveWindow(windows) {
+    return windows.find(w => w.isCurrentWindow) || null;
+}
+/**
+ * Detect user's plan based on historical usage (P90 method)
+ * Analyzes the 90th percentile of token usage across sessions
+ */
+export function detectUserPlan(windows) {
+    if (windows.length === 0) {
+        return {
+            name: 'Custom',
+            limits: PLAN_LIMITS.Custom,
+            autoDetected: false
+        };
+    }
+    // Get token usage from all windows
+    const tokenUsages = windows.map(w => w.tokenUsage.used).sort((a, b) => a - b);
+    // Calculate P90 (90th percentile)
+    const p90Index = Math.floor(tokenUsages.length * 0.9);
+    const p90Value = tokenUsages[p90Index] || 0;
+    // Match to known plans with tolerance
+    const tolerance = 0.15; // 15% tolerance
+    for (const [planName, limits] of Object.entries(PLAN_LIMITS)) {
+        const planLimit = limits.tokensPerSession;
+        const lowerBound = planLimit * (1 - tolerance);
+        const upperBound = planLimit * (1 + tolerance);
+        if (p90Value >= lowerBound && p90Value <= upperBound) {
+            const confidence = 100 - Math.abs((p90Value - planLimit) / planLimit) * 100;
+            return {
+                name: planName,
+                limits,
+                autoDetected: true,
+                confidence: Math.round(confidence)
+            };
+        }
+    }
+    // If no match, use Custom plan with P90 as limit
+    return {
+        name: 'Custom',
+        limits: {
+            tokensPerSession: Math.round(p90Value * 1.1), // Add 10% buffer
+            messagesPerSession: undefined
+        },
+        autoDetected: true,
+        confidence: 50
+    };
+}
+/**
+ * Load plan configuration from settings or auto-detect
+ */
+export function loadPlanConfig(windows) {
+    // TODO: Load from user settings/config file if exists
+    // For now, use auto-detection
+    return detectUserPlan(windows);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-session-viewer",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "type": "module",
   "bin": {
     "claude-session-viewer": "./bin/cli.js"
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "dev": "node bin/dev.js",
-    "dev:server": "tsx watch src/server/index.ts",
+    "dev:server": "tsx watch --clear-screen=false src/server/index.ts",
     "dev:client": "vite",
     "build:server": "tsc -p tsconfig.server.json",
     "build:client": "vite build --outDir dist/client",