@aiplumber/session-recall 1.8.6 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiplumber/session-recall",
-  "version": "1.8.6",
+  "version": "1.9.0",
   "description": "Pull context from previous Claude Code sessions. Sessions end, context resets - this tool lets you continue where you left off.",
   "bin": {
     "session-recall": "./session-recall"

package/session-recall

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 
-const VERSION = '1.8.6';
+const VERSION = '1.9.0';
 
 const fs = require('fs');
 const path = require('path');
+const readline = require('readline');
 
 // Cross-platform home directory
 const HOME = process.env.HOME || process.env.USERPROFILE;
@@ -49,12 +50,7 @@ function readJsonl(filePath) {
     const stats = fs.statSync(filePath);
     const sizeMB = stats.size / (1024 * 1024);
 
-    if (sizeMB > LARGE_FILE_DANGER_MB && !process.env.SESSION_RECALL_FORCE) {
-      console.error(`[session-recall] ERROR: File is ${sizeMB.toFixed(0)}MB - too large, will crash.`);
-      console.error(`Tip: Use 'session-recall last 1 --compactions' for just current phase`);
-      console.error(`Or: SESSION_RECALL_FORCE=1 NODE_OPTIONS="--max-old-space-size=8192" session-recall ...`);
-      process.exit(1);
-    } else if (sizeMB > LARGE_FILE_WARNING_MB) {
+    if (sizeMB > LARGE_FILE_WARNING_MB) {
       console.error(`[session-recall] WARNING: ${sizeMB.toFixed(0)}MB file - may be slow`);
     }
   } catch (e) {
@@ -71,6 +67,129 @@ function readJsonl(filePath) {
   }).filter(Boolean);
 }
 
+// Streaming JSONL reader - processes line by line, filters noise, returns promise
+async function streamReadJsonl(filePath, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const messages = [];
+    const rl = readline.createInterface({
+      input: fs.createReadStream(filePath, { encoding: 'utf-8' }),
+      crlfDelay: Infinity
+    });
+
+    rl.on('line', (line) => {
+      if (!line.trim()) return;
+      try {
+        const msg = JSON.parse(line);
+
+        // Skip noise types immediately - don't store
+        if (NOISE_TYPES.includes(msg.type)) return;
+
+        // If only scanning for compactions, check and skip non-markers
+        if (opts.compactionsOnly) {
+          if (isCompactionMarker(msg)) {
+            messages.push({
+              timestamp: msg.timestamp,
+              line: messages.length,
+              data: msg.data
+            });
+          }
+          return;
+        }
+
+        // Keep message for discourse extraction
+        messages.push(msg);
+      } catch (e) {
+        // Skip unparseable lines
+      }
+    });
+
+    rl.on('close', () => resolve(messages));
+    rl.on('error', reject);
+  });
+}
+
+// Lightweight scan for compaction markers only
+async function streamScanCompactions(filePath) {
+  return new Promise((resolve, reject) => {
+    const markers = [];
+    let lineNum = 0;
+
+    const rl = readline.createInterface({
+      input: fs.createReadStream(filePath, { encoding: 'utf-8' }),
+      crlfDelay: Infinity
+    });
+
+    rl.on('line', (line) => {
+      lineNum++;
+      // Quick string check before parsing
+      if (!line.includes('SessionStart:compact')) return;
+
+      try {
+        const msg = JSON.parse(line);
+        if (isCompactionMarker(msg)) {
+          markers.push({
+            line: lineNum,
+            timestamp: msg.timestamp,
+            timestampMs: msg.timestamp ? new Date(msg.timestamp).getTime() : 0
+          });
+        }
+      } catch (e) {}
+    });
+
+    rl.on('close', () => {
+      // Deduplicate markers
+      resolve(deduplicateCompactionMarkers(markers));
+    });
+    rl.on('error', reject);
+  });
+}
+
+// Extract deduplication logic from scanCompactionMarkers into reusable function
+function deduplicateCompactionMarkers(rawMarkers) {
+  if (rawMarkers.length === 0) return [];
+
+  // Deduplicate markers into compaction events
+  // Markers are same event if within COMPACTION_DEDUP_WINDOW_MS AND fewer than COMPACTION_DEDUP_MAX_MESSAGES between them
+  const compactions = [];
+  let currentCluster = [rawMarkers[0]];
+
+  for (let i = 1; i < rawMarkers.length; i++) {
+    const prev = currentCluster[currentCluster.length - 1];
+    const curr = rawMarkers[i];
+
+    const timeGapMs = curr.timestampMs - prev.timestampMs;
+
+    // For deduplication without full messages, just use time window
+    // (discourse counting needs full message bodies, which we don't have in lightweight scan)
+    if (timeGapMs <= COMPACTION_DEDUP_WINDOW_MS) {
+      currentCluster.push(curr);
+    } else {
+      // New cluster - finalize previous one
+      compactions.push(finalizeMarkerCluster(currentCluster));
+      currentCluster = [curr];
+    }
+  }
+
+  // Finalize last cluster
+  compactions.push(finalizeMarkerCluster(currentCluster));
+
+  return compactions;
+}
+
+// Convert a cluster of markers into a single compaction event (lightweight version)
+function finalizeMarkerCluster(cluster) {
+  const first = cluster[0];
+  const retries = cluster.length - 1;
+
+  return {
+    timestamp: first.timestamp,
+    timestampMs: first.timestampMs,
+    line: first.line,
+    retries: retries,
+    messagesAfter: 0  // Not computed in lightweight scan
+  };
+}
+
 function isToolResult(msg) {
   if (!msg.message?.content) return false;
   const content = msg.message.content;
@@ -1028,7 +1147,7 @@ function cwdToProjectFolder() {
   return null;
 }
 
-function cmdLast(arg1, arg2, opts) {
+async function cmdLast(arg1, arg2, opts) {
   // Usage: last [N] [folder]
   // arg1 could be: undefined, a number string, or a folder path
   // arg2 could be: undefined, or a folder path (if arg1 was a number)
@@ -1174,7 +1293,14 @@ function cmdLast(arg1, arg2, opts) {
   const candidateCount = Math.min(allSessions.length, n + 5);
   for (let i = 0; i < candidateCount; i++) {
     const s = allSessions[i];
-    s.msgs = readJsonl(s.filePath);
+    // Use streaming for large files, sync for small files
+    const stats = fs.statSync(s.filePath);
+    const sizeMB = stats.size / (1024 * 1024);
+    if (sizeMB > 100) {
+      s.msgs = await streamReadJsonl(s.filePath);
+    } else {
+      s.msgs = readJsonl(s.filePath);
+    }
     const timestamps = s.msgs.filter(m => m.timestamp).map(m => new Date(m.timestamp));
     s.lastTs = timestamps.length > 0 ? new Date(Math.max(...timestamps)) : s.startTs;
   }
@@ -2357,7 +2483,7 @@ function finalizeCluster(cluster, messages) {
 }
 
 // cmdCompactions: List compaction events in a JSONL file
-function cmdCompactions(jsonlPath, opts) {
+async function cmdCompactions(jsonlPath, opts) {
   // Auto-detect if no path provided
   if (!jsonlPath) {
     const dir = cwdToProjectFolder();
@@ -2382,30 +2508,87 @@ function cmdCompactions(jsonlPath, opts) {
     jsonlPath = filesWithStats[0].filePath;
   }
 
-  const messages = readJsonl(jsonlPath);
-  const compactions = scanCompactionMarkers(messages);
+  const compactions = await streamScanCompactions(jsonlPath);
+  // Read full messages only if we found compactions and need phase token estimates
+  let messages = [];
+  if (compactions.length > 0) {
+    const stats = fs.statSync(jsonlPath);
+    const sizeMB = stats.size / (1024 * 1024);
+    if (sizeMB > 100) {
+      messages = await streamReadJsonl(jsonlPath);
+    } else {
+      messages = readJsonl(jsonlPath);
+    }
+  }
 
   if (compactions.length === 0) {
     console.log('No compaction events found.');
     return;
   }
 
+  // Calculate token estimates for messages between two timestamps
+  function estimatePhaseTokensByTime(startTs, endTs) {
+    let tokens = 0;
+    let count = 0;
+    for (const msg of messages) {
+      const msgTs = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
+      if (msgTs >= startTs && msgTs < endTs) {
+        count++;
+        if (msg.message?.content) {
+          const content = msg.message.content;
+          if (typeof content === 'string') {
+            tokens += estimateTokens({ length: content.length });
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block.text) tokens += estimateTokens({ length: block.text.length });
+            }
+          }
+        }
+      }
+    }
+    return { tokens, count };
+  }
+
+  // Get file size
+  let fileSizeMB = 0;
+  try {
+    const stats = fs.statSync(jsonlPath);
+    fileSizeMB = stats.size / (1024 * 1024);
+  } catch (e) {}
+
   console.log(`=== COMPACTION EVENTS (${compactions.length} total) ===`);
-  console.log(`Source: ${path.basename(jsonlPath)}`);
+  console.log(`Source: ${path.basename(jsonlPath)}${fileSizeMB > 0 ? ` (${fileSizeMB.toFixed(0)}MB)` : ''}`);
   console.log(``);
+  console.log(`#    TIME      MSGS    ~TOKENS   PHASE`);
+  console.log(`───────────────────────────────────────`);
 
   for (let i = 0; i < compactions.length; i++) {
     const c = compactions[i];
     const ts = c.timestamp ? new Date(c.timestamp).toISOString().substring(11, 19) : '??:??:??';
-    const retryInfo = c.retries > 0 ? `, +${c.retries} retries` : '';
 
-    console.log(`Compaction #${i + 1} @ ${ts} (line ${c.line}${retryInfo})`);
-    console.log(`  Messages after: ${c.messagesAfter}`);
-    console.log(``);
+    // Calculate phase boundaries using timestamps
+    const startTs = i === 0 ? 0 : compactions[i - 1].timestampMs;
+    const endTs = c.timestampMs;
+    const { tokens: phaseTokens, count: phaseCount } = estimatePhaseTokensByTime(startTs, endTs);
+    const tokensK = (phaseTokens / 1000).toFixed(0) + 'k';
+
+    const num = String(i + 1).padStart(2);
+    const msgs = String(phaseCount).padStart(5);
+    const toks = tokensK.padStart(8);
+
+    console.log(`${num}   ${ts}  ${msgs}  ${toks}   Phase ${i + 1}`);
   }
 
+  // Current phase (after last compaction)
+  const lastCompaction = compactions[compactions.length - 1];
+  const { tokens: currentTokens, count: currentCount } = estimatePhaseTokensByTime(lastCompaction.timestampMs, Date.now());
+  const currentK = (currentTokens / 1000).toFixed(0) + 'k';
+  console.log(`───────────────────────────────────────`);
+  console.log(`     (current)  ${String(currentCount).padStart(5)}  ${currentK.padStart(8)}   After #${compactions.length}`);
+  console.log(``);
+
   // Usage hint
-  console.log(`Use: session-recall last 1 --before-compaction to recall pre-compaction content`);
+  console.log(`Tip: session-recall last 1 --before-compaction N  (load phase N)`);
 }
 
 // ========== TANGENT COMMANDS ==========
@@ -2616,6 +2799,7 @@ function parseArgs(args) {
 
 // ========== MAIN ==========
 
+(async () => {
 const args = process.argv.slice(2);
 const { opts, positional } = parseArgs(args);
 
@@ -2792,7 +2976,7 @@ switch (command) {
     cmdCost(jsonlPath);
     break;
   case 'last':
-    cmdLast(jsonlPath, positional[2], opts);
+    await cmdLast(jsonlPath, positional[2], opts);
     break;
   case 'tools':
     cmdTools(opts);
@@ -2801,7 +2985,7 @@ switch (command) {
     cmdCheckpoints(opts);
     break;
   case 'compactions':
-    cmdCompactions(jsonlPath, opts);
+    await cmdCompactions(jsonlPath, opts);
     break;
   case 'help':
     showHelp();
@@ -2811,3 +2995,4 @@ switch (command) {
     showHelp();
     process.exit(1);
 }
+})();