Add persistent AI cache for TLDRs and chat with 7-day expiry (#25)

* Add persistent caching for TLDR summaries and chat history

- Store TLDR summaries in ~/.cache/hn-cli/tldr-cache.json with 7-day expiry
- Store chat sessions in ~/.cache/hn-cli/chat-cache.json with 7-day expiry
- Both caches survive app restarts and system reboots
- Expired entries are automatically cleaned up on load
- Users can regenerate TLDRs by pressing 't' again

* Add tests for persistent cache and improve testability

- Add setPersistentCachePaths() for test path injection
- Add comprehensive tests for TLDR and chat cache functions
- Improve merge behavior comment explaining precedence logic
- Export AI_CACHE_TTL_MS constant for test verification

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: brianlovin

src/app.ts

@@ -95,6 +95,10 @@ import {
   cacheToSessions,
   viewModesToCache,
   cacheToViewModes,
+  loadTLDRCache,
+  saveTLDRCache,
+  loadChatCache,
+  saveChatCache,
   type AppCache,
   type CachedChatSession,
   type StoryViewMode,
@@ -206,6 +210,10 @@ export class HackerNewsApp {
       savedAt: Date.now(),
     };
     saveCache(cache);
+
+    // Also save persistent caches (TLDR and chat history with 7-day expiry)
+    saveTLDRCache(this.tldrCache);
+    saveChatCache(this.savedChatSessions as Map<number, CachedChatSession>);
   }
 
   async initialize(options: InitializeOptions = {}) {
@@ -215,25 +223,40 @@ export class HackerNewsApp {
     this.setupLayout();
     this.setupKeyboardHandlers();
 
-    // If a specific story is requested, skip cache and load fresh
+    // Load persistent caches (TLDR and chat history with 7-day expiry)
+    this.tldrCache = loadTLDRCache();
+    const persistentChatSessions = loadChatCache();
+
+    // If a specific story is requested, skip session cache and load fresh
     if (this.requestedStoryId) {
+      this.savedChatSessions = persistentChatSessions;
       await this.loadPosts();
       return;
     }
 
     // Try to restore from cache first
     const cached = loadCache();
     if (cached && cached.posts.length > 0) {
-      await this.restoreFromCache(cached);
+      await this.restoreFromCache(cached, persistentChatSessions);
     } else {
+      // Even if no session cache, restore persistent chat sessions
+      this.savedChatSessions = persistentChatSessions;
       await this.loadPosts();
     }
   }
 
-  private async restoreFromCache(cached: AppCache) {
+  private async restoreFromCache(cached: AppCache, persistentChatSessions?: Map<number, CachedChatSession>) {
     this.posts = cached.posts;
     this.storiesFetchedAt = cached.storiesFetchedAt;
-    this.savedChatSessions = cacheToSessions(cached.chatSessions) as Map<number, SavedChatSession>;
+
+    // Merge session chat cache with persistent chat cache.
+    // Persistent takes precedence because: on reboot, session cache (in tmpdir) is cleared
+    // while persistent cache (in ~/.cache) survives. On clean shutdown, both are identical.
+    const sessionChats = cacheToSessions(cached.chatSessions) as Map<number, SavedChatSession>;
+    this.savedChatSessions = persistentChatSessions
+      ? new Map([...sessionChats, ...persistentChatSessions]) as Map<number, SavedChatSession>
+      : sessionChats;
+
     this.storyViewModes = cached.storyViewModes
       ? cacheToViewModes(cached.storyViewModes)
       : new Map();
@@ -882,6 +905,8 @@ export class HackerNewsApp {
         this.tldrLoadingStoryId = null;
         this.stopTldrLoadingAnimation();
         this.stopAiIndicator(storyIndex);
+        // Persist TLDR cache immediately
+        saveTLDRCache(this.tldrCache);
         // Only rerender if we're viewing the story that just completed
         if (this.selectedPost?.id === storyId) {
           this.rerenderCurrentStory();
@@ -1234,6 +1259,15 @@ export class HackerNewsApp {
             stopTypingIndicator(this.chatPanelState);
           }
           this.stopAiIndicator(storyIndex);
+          // Save current chat session before persisting cache
+          if (this.selectedPost && this.chatPanelState) {
+            this.savedChatSessions.set(this.selectedPost.id, {
+              messages: [...this.chatPanelState.messages],
+              suggestions: [...this.chatPanelState.suggestions.suggestions],
+              originalSuggestions: [...this.chatPanelState.suggestions.originalSuggestions],
+              followUpCount: this.followUpCount,
+            });
+          }
           this.saveToCache();
           this.generateFollowUpQuestionsIfNeeded();
         },

src/cache.ts

@@ -1,22 +1,67 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
-import { tmpdir } from "os";
+import { tmpdir, homedir } from "os";
 import type { HackerNewsPost } from "./types";
+import type { TLDRResult } from "./services/TLDRService";
 
 // Cache lives in temp directory so it persists across hot reloads
 const CACHE_DIR = join(tmpdir(), "hn-cli-cache");
 const CACHE_FILE = join(CACHE_DIR, "state.json");
 
+// Persistent cache for AI-generated content (survives reboots)
+// These can be overridden for testing via setPersistentCachePaths()
+let PERSISTENT_CACHE_DIR = join(homedir(), ".cache", "hn-cli");
+let TLDR_CACHE_FILE = join(PERSISTENT_CACHE_DIR, "tldr-cache.json");
+let CHAT_CACHE_FILE = join(PERSISTENT_CACHE_DIR, "chat-cache.json");
+
+// For testing: allows overriding cache paths
+export function setPersistentCachePaths(cacheDir: string): void {
+  PERSISTENT_CACHE_DIR = cacheDir;
+  TLDR_CACHE_FILE = join(cacheDir, "tldr-cache.json");
+  CHAT_CACHE_FILE = join(cacheDir, "chat-cache.json");
+}
+
+// For testing: resets cache paths to defaults
+export function resetPersistentCachePaths(): void {
+  PERSISTENT_CACHE_DIR = join(homedir(), ".cache", "hn-cli");
+  TLDR_CACHE_FILE = join(PERSISTENT_CACHE_DIR, "tldr-cache.json");
+  CHAT_CACHE_FILE = join(PERSISTENT_CACHE_DIR, "chat-cache.json");
+}
+
 // Stories cache expires after 5 minutes
 const STORIES_TTL_MS = 5 * 60 * 1000;
 
+// TLDR and chat cache expires after 7 days
+export const AI_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+
 export interface CachedChatSession {
   messages: Array<{ role: "user" | "assistant"; content: string }>;
   suggestions: string[];
   originalSuggestions: string[];
   followUpCount: number;
 }
 
+// Persistent TLDR cache entry with timestamp
+export interface CachedTLDR {
+  result: TLDRResult;
+  cachedAt: number;
+}
+
+// Persistent chat session with timestamp
+export interface PersistentChatSession extends CachedChatSession {
+  cachedAt: number;
+}
+
+// Persistent TLDR cache (keyed by story ID as string for JSON)
+export interface TLDRCache {
+  entries: Record<string, CachedTLDR>;
+}
+
+// Persistent chat cache (keyed by story ID as string for JSON)
+export interface ChatCache {
+  sessions: Record<string, PersistentChatSession>;
+}
+
 export type StoryViewMode = "comments" | "chat";
 
 export interface AppCache {
@@ -140,3 +185,144 @@ export function cacheToViewModes(
   }
   return map;
 }
+
+// ============================================
+// Persistent TLDR Cache (7-day expiry)
+// ============================================
+
+function ensurePersistentCacheDir(): void {
+  if (!existsSync(PERSISTENT_CACHE_DIR)) {
+    mkdirSync(PERSISTENT_CACHE_DIR, { recursive: true });
+  }
+}
+
+export function loadTLDRCache(): Map<number, TLDRResult> {
+  const map = new Map<number, TLDRResult>();
+  try {
+    if (!existsSync(TLDR_CACHE_FILE)) {
+      return map;
+    }
+
+    const content = readFileSync(TLDR_CACHE_FILE, "utf-8");
+    const cache: TLDRCache = JSON.parse(content);
+    const now = Date.now();
+
+    // Load only non-expired entries
+    for (const [id, entry] of Object.entries(cache.entries)) {
+      const age = now - entry.cachedAt;
+      if (age <= AI_CACHE_TTL_MS) {
+        map.set(Number(id), entry.result);
+      }
+    }
+  } catch {
+    // Silently fail - caching is optional
+  }
+  return map;
+}
+
+export function saveTLDRCache(tldrCache: Map<number, TLDRResult>): void {
+  try {
+    ensurePersistentCacheDir();
+
+    // Load existing cache to preserve timestamps for existing entries
+    let existingEntries: Record<string, CachedTLDR> = {};
+    if (existsSync(TLDR_CACHE_FILE)) {
+      try {
+        const content = readFileSync(TLDR_CACHE_FILE, "utf-8");
+        const existing: TLDRCache = JSON.parse(content);
+        existingEntries = existing.entries;
+      } catch {
+        // Ignore errors reading existing cache
+      }
+    }
+
+    const now = Date.now();
+    const entries: Record<string, CachedTLDR> = {};
+
+    for (const [id, result] of tldrCache) {
+      const idStr = String(id);
+      // Preserve existing timestamp if entry already exists, otherwise use now
+      const cachedAt = existingEntries[idStr]?.cachedAt ?? now;
+      // Only save if not expired
+      if (now - cachedAt <= AI_CACHE_TTL_MS) {
+        entries[idStr] = { result, cachedAt };
+      }
+    }
+
+    const cache: TLDRCache = { entries };
+    writeFileSync(TLDR_CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+    // Silently fail - caching is optional
+  }
+}
+
+// ============================================
+// Persistent Chat Cache (7-day expiry)
+// ============================================
+
+export function loadChatCache(): Map<number, CachedChatSession> {
+  const map = new Map<number, CachedChatSession>();
+  try {
+    if (!existsSync(CHAT_CACHE_FILE)) {
+      return map;
+    }
+
+    const content = readFileSync(CHAT_CACHE_FILE, "utf-8");
+    const cache: ChatCache = JSON.parse(content);
+    const now = Date.now();
+
+    // Load only non-expired entries
+    for (const [id, session] of Object.entries(cache.sessions)) {
+      const age = now - session.cachedAt;
+      if (age <= AI_CACHE_TTL_MS) {
+        // Strip cachedAt when returning to match CachedChatSession interface
+        const sessionData: CachedChatSession = {
+          messages: session.messages,
+          suggestions: session.suggestions,
+          originalSuggestions: session.originalSuggestions,
+          followUpCount: session.followUpCount,
+        };
+        map.set(Number(id), sessionData);
+      }
+    }
+  } catch {
+    // Silently fail - caching is optional
+  }
+  return map;
+}
+
+export function saveChatCache(sessions: Map<number, CachedChatSession>): void {
+  try {
+    ensurePersistentCacheDir();
+
+    // Load existing cache to preserve timestamps for existing entries
+    let existingEntries: Record<string, PersistentChatSession> = {};
+    if (existsSync(CHAT_CACHE_FILE)) {
+      try {
+        const content = readFileSync(CHAT_CACHE_FILE, "utf-8");
+        const existing: ChatCache = JSON.parse(content);
+        existingEntries = existing.sessions;
+      } catch {
+        // Ignore errors reading existing cache
+      }
+    }
+
+    const now = Date.now();
+    const persistentSessions: Record<string, PersistentChatSession> = {};
+
+    for (const [id, session] of sessions) {
+      const idStr = String(id);
+      // Preserve existing timestamp if entry already exists, otherwise use now
+      const cachedAt = existingEntries[idStr]?.cachedAt ?? now;
+      // Only save if not expired
+      if (now - cachedAt <= AI_CACHE_TTL_MS) {
+        persistentSessions[idStr] = { ...session, cachedAt };
+      }
+    }
+
+    const cache: ChatCache = { sessions: persistentSessions };
+    writeFileSync(CHAT_CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+    // Silently fail - caching is optional
+  }
+}