claude-yes 1.30.0 → 1.31.0

package/ts/codexSessionManager.ts

@@ -1,13 +1,22 @@
-import { mkdir, readFile, writeFile } from 'fs/promises';
+import { mkdir, readdir, readFile, writeFile } from 'fs/promises';
 import { homedir } from 'os';
 import path from 'path';
 
-const SESSIONS_FILE = path.join(
-  homedir(),
-  '.config',
-  'cli-yes',
-  'codex-sessions.json',
-);
+// Allow overriding for testing
+export const getSessionsFile = () =>
+  process.env.CLI_YES_TEST_HOME
+    ? path.join(
+        process.env.CLI_YES_TEST_HOME,
+        '.config',
+        'cli-yes',
+        'codex-sessions.json',
+      )
+    : path.join(homedir(), '.config', 'cli-yes', 'codex-sessions.json');
+
+export const getCodexSessionsDir = () =>
+  process.env.CLI_YES_TEST_HOME
+    ? path.join(process.env.CLI_YES_TEST_HOME, '.codex', 'sessions')
+    : path.join(homedir(), '.codex', 'sessions');
 
 export interface CodexSessionMap {
   [cwd: string]: {
@@ -16,12 +25,24 @@ export interface CodexSessionMap {
   };
 }
 
+export interface CodexSession {
+  id: string;
+  timestamp: string;
+  cwd: string;
+  filePath: string;
+  git?: {
+    commit_hash: string;
+    branch: string;
+    repository_url: string;
+  };
+}
+
 /**
  * Load the session map from the config file
  */
 export async function loadSessionMap(): Promise<CodexSessionMap> {
   try {
-    const content = await readFile(SESSIONS_FILE, 'utf-8');
+    const content = await readFile(getSessionsFile(), 'utf-8');
     return JSON.parse(content);
   } catch (error) {
     // File doesn't exist or is invalid, return empty map
@@ -36,9 +57,10 @@ export async function saveSessionMap(
   sessionMap: CodexSessionMap,
 ): Promise<void> {
   try {
+    const sessionsFile = getSessionsFile();
     // Ensure the directory exists
-    await mkdir(path.dirname(SESSIONS_FILE), { recursive: true });
-    await writeFile(SESSIONS_FILE, JSON.stringify(sessionMap, null, 2));
+    await mkdir(path.dirname(sessionsFile), { recursive: true });
+    await writeFile(sessionsFile, JSON.stringify(sessionMap, null, 2));
   } catch (error) {
     console.warn('Failed to save codex session map:', error);
   }
@@ -59,10 +81,122 @@ export async function storeSessionForCwd(
   await saveSessionMap(sessionMap);
 }
 
+/**
+ * Parse a codex session file to extract session metadata
+ */
+async function parseCodexSessionFile(
+  filePath: string,
+): Promise<CodexSession | null> {
+  try {
+    const content = await readFile(filePath, 'utf-8');
+    const lines = content.trim().split('\n');
+
+    // Find the session_meta line
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      const data = JSON.parse(line);
+      if (data.type === 'session_meta' && data.payload) {
+        const payload = data.payload;
+        return {
+          id: payload.id,
+          timestamp: payload.timestamp || data.timestamp,
+          cwd: payload.cwd,
+          filePath,
+          git: payload.git,
+        };
+      }
+    }
+
+    return null;
+  } catch (error) {
+    // Ignore files that can't be parsed
+    return null;
+  }
+}
+
+/**
+ * Get all codex sessions from the .codex/sessions directory
+ */
+async function getAllCodexSessions(): Promise<CodexSession[]> {
+  const sessions: CodexSession[] = [];
+  const codexSessionsDir = getCodexSessionsDir();
+
+  try {
+    // Walk through year/month/day structure
+    const years = await readdir(codexSessionsDir);
+
+    for (const year of years) {
+      const yearPath = path.join(codexSessionsDir, year);
+      try {
+        const months = await readdir(yearPath);
+
+        for (const month of months) {
+          const monthPath = path.join(yearPath, month);
+          try {
+            const days = await readdir(monthPath);
+
+            for (const day of days) {
+              const dayPath = path.join(monthPath, day);
+              try {
+                const files = await readdir(dayPath);
+
+                for (const file of files) {
+                  if (file.endsWith('.jsonl')) {
+                    const sessionPath = path.join(dayPath, file);
+                    const session = await parseCodexSessionFile(sessionPath);
+                    if (session) {
+                      sessions.push(session);
+                    }
+                  }
+                }
+              } catch (error) {
+                // Skip directories we can't read
+              }
+            }
+          } catch (error) {
+            // Skip directories we can't read
+          }
+        }
+      } catch (error) {
+        // Skip directories we can't read
+      }
+    }
+  } catch (error) {
+    // .codex/sessions directory doesn't exist or can't be read
+    return [];
+  }
+
+  return sessions.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime(),
+  );
+}
+
+/**
+ * Get the most recent session for a specific working directory from actual codex files
+ */
+async function getMostRecentCodexSessionForCwd(
+  targetCwd: string,
+): Promise<CodexSession | null> {
+  const allSessions = await getAllCodexSessions();
+  const sessionsForCwd = allSessions.filter(
+    (session) => session.cwd === targetCwd,
+  );
+  return sessionsForCwd[0] || null;
+}
+
 /**
  * Get the last session ID for a specific working directory
+ * Now checks actual codex session files first, falls back to stored mapping
  */
 export async function getSessionForCwd(cwd: string): Promise<string | null> {
+  // First try to get the most recent session from actual codex files
+  const recentSession = await getMostRecentCodexSessionForCwd(cwd);
+  if (recentSession) {
+    return recentSession.id;
+  }
+
+  // Fall back to stored mapping
   const sessionMap = await loadSessionMap();
   return sessionMap[cwd]?.sessionId || null;
 }
@@ -101,6 +235,52 @@ export function extractSessionIdFromSessionMeta(
   return extractSessionId(sessionContent);
 }
 
+/**
+ * Get recent sessions for a specific working directory from actual codex files
+ */
+export async function getRecentSessionsForCwd(
+  targetCwd: string,
+  limit = 5,
+): Promise<CodexSession[]> {
+  const allSessions = await getAllCodexSessions();
+  const sessionsForCwd = allSessions.filter(
+    (session) => session.cwd === targetCwd,
+  );
+  return sessionsForCwd.slice(0, limit);
+}
+
+/**
+ * Get all working directories with session counts from actual codex files
+ */
+export async function getAllWorkingDirectories(): Promise<
+  { cwd: string; count: number; lastSession: string }[]
+> {
+  const allSessions = await getAllCodexSessions();
+  const cwdMap = new Map<string, { count: number; lastSession: string }>();
+
+  for (const session of allSessions) {
+    const existing = cwdMap.get(session.cwd);
+    if (existing) {
+      existing.count++;
+      if (new Date(session.timestamp) > new Date(existing.lastSession)) {
+        existing.lastSession = session.timestamp;
+      }
+    } else {
+      cwdMap.set(session.cwd, {
+        count: 1,
+        lastSession: session.timestamp,
+      });
+    }
+  }
+
+  return Array.from(cwdMap.entries())
+    .map(([cwd, data]) => ({ cwd, ...data }))
+    .sort(
+      (a, b) =>
+        new Date(b.lastSession).getTime() - new Date(a.lastSession).getTime(),
+    );
+}
+
 /**
  * Clean up old sessions (keep only the most recent 10 per directory)
  */