@dreb/coding-agent 2.67.0 → 2.68.1

package/dist/core/session-manager.js

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { readdir, readFile, stat, unlink } from "node:fs/promises";
 import { randomUUID } from "crypto";
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "fs";
-import { join, resolve } from "path";
+import { dirname, join, resolve, sep } from "path";
 import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
 export const CURRENT_SESSION_VERSION = 3;
@@ -340,78 +340,164 @@ function getSessionCreatedDate(header, statsMtime) {
 function resolveForDeletion(filePath) {
     return resolve(filePath);
 }
+const sessionMetadataCache = new Map();
+const sessionMetadataInflight = new Map();
+function cloneSessionMetadata(metadata) {
+    return {
+        ...metadata,
+        created: new Date(metadata.created),
+        modified: new Date(metadata.modified),
+    };
+}
+function toSessionMetadata(info) {
+    const { allMessagesText: _allMessagesText, ...metadata } = info;
+    return metadata;
+}
+async function parseSessionInfo(filePath, stats, includeAllMessagesText) {
+    const content = await readFile(filePath, "utf8");
+    const entries = [];
+    const lines = content.trim().split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    const header = entries[0];
+    if (header.type !== "session")
+        return null;
+    let messageCount = 0;
+    let firstMessage = "";
+    const allMessages = [];
+    let name;
+    for (const entry of entries) {
+        // Extract session name (use latest, including explicit clears)
+        if (entry.type === "session_info") {
+            const infoEntry = entry;
+            name = infoEntry.name?.trim() || undefined;
+        }
+        if (entry.type !== "message")
+            continue;
+        messageCount++;
+        const message = entry.message;
+        if (!isMessageWithContent(message))
+            continue;
+        if (message.role !== "user" && message.role !== "assistant")
+            continue;
+        const textContent = extractTextContent(message);
+        if (!textContent)
+            continue;
+        if (includeAllMessagesText)
+            allMessages.push(textContent);
+        if (!firstMessage && message.role === "user") {
+            firstMessage = textContent;
+        }
+    }
+    const cwd = typeof header.cwd === "string" ? header.cwd : "";
+    const parentSessionPath = header.parentSession;
+    const modified = getSessionModifiedDate(entries, header, stats.mtime);
+    const created = getSessionCreatedDate(header, stats.mtime);
+    return {
+        path: filePath,
+        id: header.id,
+        cwd,
+        name,
+        parentSessionPath,
+        created,
+        modified,
+        messageCount,
+        firstMessage: firstMessage || "(no messages)",
+        allMessagesText: allMessages.join(" "),
+    };
+}
+function isFilesystemError(error) {
+    return typeof error?.code === "string";
+}
 async function buildSessionInfo(filePath, throwOnFilesystemError = false) {
     try {
-        const content = await readFile(filePath, "utf8");
-        const entries = [];
-        const lines = content.trim().split("\n");
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                entries.push(JSON.parse(line));
-            }
-            catch {
-                // Skip malformed lines
-            }
-        }
-        if (entries.length === 0)
-            return null;
-        const header = entries[0];
-        if (header.type !== "session")
-            return null;
         const stats = await stat(filePath);
-        let messageCount = 0;
-        let firstMessage = "";
-        const allMessages = [];
-        let name;
-        for (const entry of entries) {
-            // Extract session name (use latest, including explicit clears)
-            if (entry.type === "session_info") {
-                const infoEntry = entry;
-                name = infoEntry.name?.trim() || undefined;
-            }
-            if (entry.type !== "message")
-                continue;
-            messageCount++;
-            const message = entry.message;
-            if (!isMessageWithContent(message))
-                continue;
-            if (message.role !== "user" && message.role !== "assistant")
-                continue;
-            const textContent = extractTextContent(message);
-            if (!textContent)
-                continue;
-            allMessages.push(textContent);
-            if (!firstMessage && message.role === "user") {
-                firstMessage = textContent;
-            }
-        }
-        const cwd = typeof header.cwd === "string" ? header.cwd : "";
-        const parentSessionPath = header.parentSession;
-        const modified = getSessionModifiedDate(entries, header, stats.mtime);
-        const created = getSessionCreatedDate(header, stats.mtime);
-        return {
-            path: filePath,
-            id: header.id,
-            cwd,
-            name,
-            parentSessionPath,
-            created,
-            modified,
-            messageCount,
-            firstMessage: firstMessage || "(no messages)",
-            allMessagesText: allMessages.join(" "),
-        };
+        return await parseSessionInfo(filePath, stats, true);
     }
     catch (error) {
-        if (throwOnFilesystemError && typeof error?.code === "string") {
+        if (throwOnFilesystemError && isFilesystemError(error))
             throw error;
+        /* Corrupt session file — exclude from listing */
+        return null;
+    }
+}
+async function buildSessionMetadata(filePath, throwOnFilesystemError = false) {
+    try {
+        const stats = await stat(filePath);
+        const cached = sessionMetadataCache.get(filePath);
+        if (cached?.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+            return cached.metadata ? cloneSessionMetadata(cached.metadata) : null;
+        }
+        const inflight = sessionMetadataInflight.get(filePath);
+        if (inflight?.mtimeMs === stats.mtimeMs && inflight.size === stats.size) {
+            const metadata = await inflight.promise;
+            return metadata ? cloneSessionMetadata(metadata) : null;
+        }
+        const promise = parseSessionInfo(filePath, stats, false).then((info) => {
+            const metadata = info ? toSessionMetadata(info) : null;
+            sessionMetadataCache.set(filePath, {
+                mtimeMs: stats.mtimeMs,
+                size: stats.size,
+                metadata: metadata ? cloneSessionMetadata(metadata) : null,
+            });
+            return metadata;
+        });
+        const current = { mtimeMs: stats.mtimeMs, size: stats.size, promise };
+        sessionMetadataInflight.set(filePath, current);
+        try {
+            const metadata = await promise;
+            return metadata ? cloneSessionMetadata(metadata) : null;
         }
+        finally {
+            if (sessionMetadataInflight.get(filePath) === current)
+                sessionMetadataInflight.delete(filePath);
+        }
+    }
+    catch (error) {
+        if (throwOnFilesystemError && isFilesystemError(error))
+            throw error;
         /* Corrupt session file — exclude from listing */
         return null;
     }
 }
+async function collectSessionMetadata(files, isInScope, onProgress, throwOnFilesystemError = false) {
+    // Prune cache entries for deleted files, but only within the scanned scope so
+    // default and custom-directory listings don't evict each other's entries.
+    const currentFiles = new Set(files);
+    for (const cachedPath of sessionMetadataCache.keys()) {
+        if (isInScope(cachedPath) && !currentFiles.has(cachedPath))
+            sessionMetadataCache.delete(cachedPath);
+    }
+    let loaded = 0;
+    const results = await Promise.all(files.map(async (file) => {
+        const metadata = await buildSessionMetadata(file, throwOnFilesystemError);
+        loaded++;
+        onProgress?.(loaded, files.length);
+        return metadata;
+    }));
+    const sessions = results.filter((metadata) => metadata !== null);
+    sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    return sessions;
+}
+async function listAllSessionFiles() {
+    const sessionsDir = getSessionsDir();
+    if (!existsSync(sessionsDir))
+        return [];
+    const entries = await readdir(sessionsDir, { withFileTypes: true });
+    const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => join(sessionsDir, entry.name));
+    const dirFiles = await Promise.all(dirs.map(async (dir) => (await readdir(dir)).filter((file) => file.endsWith(".jsonl")).map((file) => join(dir, file))));
+    return dirFiles.flat();
+}
 async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal, throwOnFilesystemError = false) {
     const sessions = [];
     if (!throwOnFilesystemError && !existsSync(dir)) {
@@ -1233,46 +1319,54 @@ export class SessionManager {
         sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
         return sessions;
     }
+    /**
+     * List lightweight metadata for every session stored directly in one explicit flat directory.
+     * Uses the same mtime/size cache as listAllMetadata(); filesystem errors propagate.
+     */
+    static async listAllMetadataFromDir(dir, onProgress) {
+        let dirEntries;
+        try {
+            dirEntries = await readdir(dir);
+        }
+        catch (error) {
+            if (error?.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const files = dirEntries.filter((file) => file.endsWith(".jsonl")).map((file) => join(dir, file));
+        const scope = resolve(dir);
+        return collectSessionMetadata(files, (cachedPath) => dirname(resolve(cachedPath)) === scope, onProgress, true);
+    }
     /**
      * List all sessions across all project directories.
      * @param onProgress Optional callback for progress updates (loaded, total)
      */
     static async listAll(onProgress) {
-        const sessionsDir = getSessionsDir();
         // A missing sessions directory is a legitimate empty state (fresh install), not a
-        // failure — return []. Any actual I/O failure below propagates loudly so callers can
-        // distinguish "no sessions" from "listing failed" (RPC responds success:false; the TUI
-        // selector surfaces "Failed to load sessions"). No silent catch-and-return-[].
-        if (!existsSync(sessionsDir)) {
-            return [];
-        }
-        const entries = await readdir(sessionsDir, { withFileTypes: true });
-        const dirs = entries.filter((e) => e.isDirectory()).map((e) => join(sessionsDir, e.name));
-        // Count total files first for accurate progress
-        let totalFiles = 0;
-        const dirFiles = [];
-        for (const dir of dirs) {
-            const files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
-            dirFiles.push(files.map((f) => join(dir, f)));
-            totalFiles += files.length;
-        }
-        // Process all files with progress tracking
+        // failure. Actual I/O failures propagate so callers can distinguish "no sessions"
+        // from "listing failed".
+        const allFiles = await listAllSessionFiles();
         let loaded = 0;
-        const sessions = [];
-        const allFiles = dirFiles.flat();
         const results = await Promise.all(allFiles.map(async (file) => {
             const info = await buildSessionInfo(file);
             loaded++;
-            onProgress?.(loaded, totalFiles);
+            onProgress?.(loaded, allFiles.length);
             return info;
         }));
-        for (const info of results) {
-            if (info) {
-                sessions.push(info);
-            }
-        }
+        const sessions = results.filter((info) => info !== null);
         sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
         return sessions;
     }
+    /**
+     * List lightweight metadata across all project directories.
+     *
+     * Results are cached by file mtime and size, so dashboard inventory refreshes
+     * stat every session but only reread and parse files that changed.
+     */
+    static async listAllMetadata(onProgress) {
+        const allFiles = await listAllSessionFiles();
+        const scope = resolve(getSessionsDir()) + sep;
+        return collectSessionMetadata(allFiles, (cachedPath) => resolve(cachedPath).startsWith(scope), onProgress);
+    }
 }
 //# sourceMappingURL=session-manager.js.map