@dreb/coding-agent 2.66.3 → 2.68.0

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,99 +340,197 @@ function getSessionCreatedDate(header, statsMtime) {
 function resolveForDeletion(filePath) {
     return resolve(filePath);
 }
-async function buildSessionInfo(filePath) {
-    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
-            }
+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));
         }
-        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;
+        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;
-            }
+        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 stats = await stat(filePath);
+        return await parseSessionInfo(filePath, stats, true);
+    }
+    catch (error) {
+        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);
         }
-        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(" "),
-        };
     }
-    catch {
+    catch (error) {
+        if (throwOnFilesystemError && isFilesystemError(error))
+            throw error;
         /* Corrupt session file — exclude from listing */
         return null;
     }
 }
-async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
+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 (!existsSync(dir)) {
+    if (!throwOnFilesystemError && !existsSync(dir)) {
         return sessions;
     }
+    let dirEntries;
+    try {
+        dirEntries = await readdir(dir);
+    }
+    catch (error) {
+        if (throwOnFilesystemError && error?.code !== "ENOENT")
+            throw error;
+        return sessions;
+    }
+    const files = dirEntries.filter((file) => file.endsWith(".jsonl")).map((file) => join(dir, file));
+    const total = progressTotal ?? files.length;
     try {
-        const dirEntries = await readdir(dir);
-        const files = dirEntries.filter((f) => f.endsWith(".jsonl")).map((f) => join(dir, f));
-        const total = progressTotal ?? files.length;
         let loaded = 0;
         const results = await Promise.all(files.map(async (file) => {
-            const info = await buildSessionInfo(file);
+            const info = await buildSessionInfo(file, throwOnFilesystemError);
             loaded++;
             onProgress?.(progressOffset + loaded, total);
             return info;
         }));
         for (const info of results) {
-            if (info) {
+            if (info)
                 sessions.push(info);
-            }
         }
     }
-    catch {
-        /* Session directory read failed — return partial results */
+    catch (error) {
+        if (throwOnFilesystemError)
+            throw error;
+        /* Session file read failed — return partial results */
     }
     return sessions;
 }
@@ -451,6 +549,7 @@ export class SessionManager {
     sessionId = "";
     sessionFile;
     sessionDir;
+    customSessionInventoryRoot;
     cwd;
     persist;
     flushed = false;
@@ -458,9 +557,10 @@ export class SessionManager {
     byId = new Map();
     labelsById = new Map();
     leafId = null;
-    constructor(cwd, sessionDir, sessionFile, persist) {
+    constructor(cwd, sessionDir, sessionFile, persist, customSessionInventoryRoot) {
         this.cwd = cwd;
         this.sessionDir = sessionDir;
+        this.customSessionInventoryRoot = customSessionInventoryRoot;
         this.persist = persist;
         if (persist && sessionDir && !existsSync(sessionDir)) {
             mkdirSync(sessionDir, { recursive: true });
@@ -588,6 +688,13 @@ export class SessionManager {
     getSessionDir() {
         return this.sessionDir;
     }
+    /**
+     * Flat inventory root selected explicitly for this manager, if any.
+     * Built-in per-project managers and in-memory managers return undefined.
+     */
+    getCustomSessionInventoryRoot() {
+        return this.customSessionInventoryRoot;
+    }
     getSessionId() {
         return this.sessionId;
     }
@@ -1050,9 +1157,10 @@ export class SessionManager {
      * @param cwd Working directory (stored in session header)
      * @param sessionDir Optional session directory. If omitted, uses default (~/.dreb/agent/sessions/<encoded-cwd>/).
      */
-    static create(cwd, sessionDir) {
+    static create(cwd, sessionDir, options = {}) {
         const dir = sessionDir ?? getDefaultSessionDir(cwd);
-        return new SessionManager(cwd, dir, undefined, true);
+        const customInventoryRoot = sessionDir !== undefined && options.customSessionInventory !== false ? sessionDir : undefined;
+        return new SessionManager(cwd, dir, undefined, true, customInventoryRoot);
     }
     /**
      * Open a specific session file.
@@ -1066,7 +1174,7 @@ export class SessionManager {
         const cwd = header?.cwd ?? process.cwd();
         // If no sessionDir provided, derive from file's parent directory
         const dir = sessionDir ?? resolve(path, "..");
-        return new SessionManager(cwd, dir, path, true);
+        return new SessionManager(cwd, dir, path, true, sessionDir);
     }
     /**
      * Continue the most recent session, or create new if none.
@@ -1077,13 +1185,13 @@ export class SessionManager {
         const dir = sessionDir ?? getDefaultSessionDir(cwd);
         const mostRecent = findMostRecentSession(dir);
         if (mostRecent) {
-            return new SessionManager(cwd, dir, mostRecent, true);
+            return new SessionManager(cwd, dir, mostRecent, true, sessionDir);
         }
-        return new SessionManager(cwd, dir, undefined, true);
+        return new SessionManager(cwd, dir, undefined, true, sessionDir);
     }
-    /** Create an in-memory session (no file persistence) */
-    static inMemory(cwd = process.cwd()) {
-        return new SessionManager(cwd, "", undefined, false);
+    /** Create an in-memory session (no active-file persistence), optionally retaining a flat inventory root. */
+    static inMemory(cwd = process.cwd(), customSessionInventoryRoot) {
+        return new SessionManager(cwd, "", undefined, false, customSessionInventoryRoot);
     }
     /**
      * Fork a session from another project directory into the current project.
@@ -1126,7 +1234,7 @@ export class SessionManager {
                 appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
             }
         }
-        return new SessionManager(targetCwd, dir, newSessionFile, true);
+        return new SessionManager(targetCwd, dir, newSessionFile, true, sessionDir);
     }
     /**
      * Delete a session file, trying the `trash` CLI first, then falling back to unlink.
@@ -1201,46 +1309,64 @@ export class SessionManager {
         sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
         return sessions;
     }
+    /**
+     * List every session stored directly in one explicit flat directory.
+     * This is intentionally separate from listAll(), whose default contract scans
+     * the built-in nested all-project tree.
+     */
+    static async listAllFromDir(dir, onProgress) {
+        const sessions = await listSessionsFromDir(dir, onProgress, 0, undefined, true);
+        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