@bastani/atomic 0.8.27 → 0.8.28-alpha.2

package/dist/core/session-manager.js

@@ -1,10 +1,11 @@
 import { randomBytes, randomUUID } from "crypto";
-import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
 import { readdir, readFile, stat } from "fs/promises";
 import { join, resolve } from "path";
+import { StringDecoder } from "string_decoder";
 import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
-import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
+import { createBranchSummaryMessage, createCustomMessage, } from "./messages.js";
 export const CURRENT_SESSION_VERSION = 3;
 function createUuidV7() {
     const bytes = randomBytes(16);
@@ -23,6 +24,11 @@ function createUuidV7() {
 function createSessionId() {
     return createUuidV7();
 }
+export function assertValidSessionId(id) {
+    if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) {
+        throw new Error("Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character");
+    }
+}
 /** Generate a unique short ID (8 hex chars, collision-checked) */
 function generateId(byId) {
     for (let i = 0; i < 100; i++) {
@@ -110,18 +116,10 @@ export function parseSessionEntries(content) {
     }
     return entries;
 }
-export function getLatestCompactionEntry(entries) {
-    for (let i = entries.length - 1; i >= 0; i--) {
-        if (entries[i].type === "compaction") {
-            return entries[i];
-        }
-    }
-    return null;
-}
 export function getLatestCompactionBoundaryEntry(entries) {
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
-        if (entry.type === "compaction" || entry.type === "context_compaction") {
+        if (entry.type === "context_compaction") {
             return entry;
         }
     }
@@ -184,7 +182,6 @@ function filterMessageContentBlocks(message, deletedBlocks) {
         }
         case "bashExecution":
         case "branchSummary":
-        case "compactionSummary":
             return message;
     }
 }
@@ -222,7 +219,7 @@ export function buildContextDeletionFilteredPath(path, filters = buildContextDel
 /**
  * Build the session context from entries using tree traversal.
  * If leafId is provided, walks from that entry to root.
- * Handles compaction and branch summaries along the path.
+ * Applies context-deletion filtering and includes branch summaries along the path.
  */
 export function buildSessionContext(entries, leafId, byId) {
     // Build uuid index if not available
@@ -255,10 +252,9 @@ export function buildSessionContext(entries, leafId, byId) {
         path.unshift(current);
         current = current.parentId ? byId.get(current.parentId) : undefined;
     }
-    // Extract settings and find compaction
+    // Extract settings
     let thinkingLevel = "off";
     let model = null;
-    let compaction = null;
     for (const entry of path) {
         if (entry.type === "thinking_level_change") {
             thinkingLevel = entry.thinkingLevel;
@@ -269,25 +265,12 @@ export function buildSessionContext(entries, leafId, byId) {
         else if (entry.type === "message" && entry.message.role === "assistant") {
             model = { provider: entry.message.provider, modelId: entry.message.model };
         }
-        else if (entry.type === "compaction") {
-            compaction = entry;
-        }
     }
-    const latestCompactionIndex = compaction
-        ? path.findIndex((e) => e.type === "compaction" && e.id === compaction.id)
-        : -1;
     const filteredPath = buildContextDeletionFilteredPath(path);
-    const filteredEntryById = new Map(filteredPath.map((entry) => [entry.id, entry]));
-    // Build messages and collect corresponding entries
-    // When there's a compaction, we need to:
-    // 1. Emit summary first (entry = compaction)
-    // 2. Emit kept messages (from firstKeptEntryId up to compaction)
-    // 3. Emit messages after compaction
+    // Build active context messages from the filtered path. Legacy "compaction"
+    // entries are archival metadata and intentionally inert here.
     const messages = [];
-    const appendMessage = (rawEntry) => {
-        const entry = filteredEntryById.get(rawEntry.id);
-        if (!entry)
-            return;
+    const appendMessage = (entry) => {
         let message;
         if (entry.type === "message") {
             message = entry.message;
@@ -301,33 +284,8 @@ export function buildSessionContext(entries, leafId, byId) {
         if (message)
             messages.push(message);
     };
-    if (compaction) {
-        // Emit summary first. Summary compaction entries are not deletion targets for
-        // logical context compaction, so existing /compact rebuild behavior is preserved.
-        messages.push(createCompactionSummaryMessage(compaction.summary, compaction.tokensBefore, compaction.timestamp));
-        const compactionIdx = latestCompactionIndex;
-        // Emit kept messages (before compaction, starting from firstKeptEntryId)
-        let foundFirstKept = false;
-        for (let i = 0; i < compactionIdx; i++) {
-            const entry = path[i];
-            if (entry.id === compaction.firstKeptEntryId) {
-                foundFirstKept = true;
-            }
-            if (foundFirstKept) {
-                appendMessage(entry);
-            }
-        }
-        // Emit messages after compaction
-        for (let i = compactionIdx + 1; i < path.length; i++) {
-            const entry = path[i];
-            appendMessage(entry);
-        }
-    }
-    else {
-        // No compaction - emit all messages, handle branch summaries and custom messages
-        for (const entry of path) {
-            appendMessage(entry);
-        }
+    for (const entry of filteredPath) {
+        appendMessage(entry);
     }
     return { messages, thinkingLevel, model };
 }
@@ -335,34 +293,64 @@ export function buildSessionContext(entries, leafId, byId) {
  * Compute the default session directory for a cwd.
  * Encodes cwd into a safe directory name under ~/.atomic/agent/sessions/.
  */
-export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
+function getDefaultSessionDirPath(cwd, agentDir = getDefaultAgentDir()) {
     const resolvedCwd = resolvePath(cwd);
     const resolvedAgentDir = resolvePath(agentDir);
     const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-    const sessionDir = join(resolvedAgentDir, "sessions", safePath);
+    return join(resolvedAgentDir, "sessions", safePath);
+}
+export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
+    const sessionDir = getDefaultSessionDirPath(cwd, agentDir);
     if (!existsSync(sessionDir)) {
         mkdirSync(sessionDir, { recursive: true });
     }
     return sessionDir;
 }
+const SESSION_READ_BUFFER_SIZE = 1024 * 1024;
+function parseSessionEntryLine(line) {
+    if (!line.trim())
+        return null;
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
 /** Exported for testing */
 export function loadEntriesFromFile(filePath) {
     const resolvedFilePath = normalizePath(filePath);
     if (!existsSync(resolvedFilePath))
         return [];
-    const content = readFileSync(resolvedFilePath, "utf8");
     const entries = [];
-    const lines = content.trim().split("\n");
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        try {
-            const entry = JSON.parse(line);
-            entries.push(entry);
-        }
-        catch {
-            // Skip malformed lines
+    const fd = openSync(resolvedFilePath, "r");
+    try {
+        const decoder = new StringDecoder("utf8");
+        const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
+        let pending = "";
+        while (true) {
+            const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            pending += decoder.write(buffer.subarray(0, bytesRead));
+            let lineStart = 0;
+            let newlineIndex = pending.indexOf("\n", lineStart);
+            while (newlineIndex !== -1) {
+                const entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex));
+                if (entry)
+                    entries.push(entry);
+                lineStart = newlineIndex + 1;
+                newlineIndex = pending.indexOf("\n", lineStart);
+            }
+            pending = pending.slice(lineStart);
         }
+        pending += decoder.end();
+        const finalEntry = parseSessionEntryLine(pending);
+        if (finalEntry)
+            entries.push(finalEntry);
+    }
+    finally {
+        closeSync(fd);
     }
     // Validate session header
     if (entries.length === 0)
@@ -373,7 +361,7 @@ export function loadEntriesFromFile(filePath) {
     }
     return entries;
 }
-function isValidSessionFile(filePath) {
+function readSessionHeader(filePath) {
     try {
         const fd = openSync(filePath, "r");
         const buffer = Buffer.alloc(512);
@@ -381,23 +369,36 @@ function isValidSessionFile(filePath) {
         closeSync(fd);
         const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
         if (!firstLine)
-            return false;
+            return null;
         const header = JSON.parse(firstLine);
-        return header.type === "session" && typeof header.id === "string";
+        if (header.type !== "session" || typeof header.id !== "string") {
+            return null;
+        }
+        return header;
     }
     catch {
-        return false;
+        return null;
     }
 }
+function getSessionHeaderCwd(header) {
+    const cwd = header.cwd;
+    return typeof cwd === "string" ? cwd : undefined;
+}
+function sessionCwdMatches(cwd, resolvedCwd) {
+    return cwd !== undefined && cwd !== "" && resolvePath(cwd) === resolvedCwd;
+}
 /** Exported for testing */
-export function findMostRecentSession(sessionDir) {
+export function findMostRecentSession(sessionDir, cwd) {
     const resolvedSessionDir = normalizePath(sessionDir);
+    const resolvedCwd = cwd ? resolvePath(cwd) : undefined;
     try {
         const files = readdirSync(resolvedSessionDir)
             .filter((f) => f.endsWith(".jsonl"))
             .map((f) => join(resolvedSessionDir, f))
-            .filter(isValidSessionFile)
-            .map((path) => ({ path, mtime: statSync(path).mtime }))
+            .map((path) => ({ path, header: readSessionHeader(path) }))
+            .filter((file) => file.header !== null &&
+            (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)))
+            .map(({ path }) => ({ path, mtime: statSync(path).mtime }))
             .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         return files[0]?.path || null;
     }
@@ -554,10 +555,10 @@ async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progress
  * modifying history.
  *
  * Use buildSessionContext() to get the resolved message list for the LLM, which
- * handles compaction summaries and follows the path from root to current leaf.
+ * applies context-deletion filtering and follows the path from root to current leaf.
  */
 export class SessionManager {
-    constructor(cwd, sessionDir, sessionFile, persist) {
+    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
         this.sessionId = "";
         this.flushed = false;
         this.fileEntries = [];
@@ -575,7 +576,7 @@ export class SessionManager {
             this.setSessionFile(sessionFile);
         }
         else {
-            this.newSession();
+            this.newSession(newSessionOptions);
         }
     }
     /** Switch to a different session file (used for resume and branching) */
@@ -608,6 +609,9 @@ export class SessionManager {
         }
     }
     newSession(options) {
+        if (options?.id !== undefined) {
+            assertValidSessionId(options.id);
+        }
         this.sessionId = options?.id ?? createSessionId();
         const timestamp = new Date().toISOString();
         const header = {
@@ -666,6 +670,9 @@ export class SessionManager {
     getSessionDir() {
         return this.sessionDir;
     }
+    usesDefaultSessionDir() {
+        return this.sessionDir === getDefaultSessionDirPath(this.cwd);
+    }
     getSessionId() {
         return this.sessionId;
     }
@@ -698,10 +705,10 @@ export class SessionManager {
         this._persist(entry);
     }
     /** Append a message as child of current leaf, then advance leaf. Returns entry id.
-     * Does not allow writing CompactionSummaryMessage and BranchSummaryMessage directly.
+     * Does not allow writing branch summaries or context compaction metadata as regular messages.
      * Reason: we want these to be top-level entries in the session, not message session entries,
      * so it is easier to find them.
-     * These need to be appended via appendCompaction() and appendBranchSummary() methods.
+     * Branch summaries are appended via appendBranchSummary(), and context compaction metadata via appendContextCompaction().
      */
     appendMessage(message) {
         const entry = {
@@ -739,22 +746,6 @@ export class SessionManager {
         this._appendEntry(entry);
         return entry.id;
     }
-    /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
-    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
-        const entry = {
-            type: "compaction",
-            id: generateId(this.byId),
-            parentId: this.leafId,
-            timestamp: new Date().toISOString(),
-            summary,
-            firstKeptEntryId,
-            tokensBefore,
-            details,
-            fromHook,
-        };
-        this._appendEntry(entry);
-        return entry.id;
-    }
     /** Append logical deletion metadata for deletion-only context compaction. */
     appendContextCompaction(deletedTargets, protectedEntryIds, stats, backupPath) {
         const entry = {
@@ -1122,9 +1113,9 @@ export class SessionManager {
      * @param cwd Working directory (stored in session header)
      * @param sessionDir Optional session directory. If omitted, uses default (~/.atomic/agent/sessions/<encoded-cwd>/).
      */
-    static create(cwd, sessionDir) {
+    static create(cwd, sessionDir, options) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        return new SessionManager(cwd, dir, undefined, true);
+        return new SessionManager(cwd, dir, undefined, true, options);
     }
     /**
      * Open a specific session file.
@@ -1149,7 +1140,8 @@ export class SessionManager {
      */
     static continueRecent(cwd, sessionDir) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        const mostRecent = findMostRecentSession(dir);
+        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+        const mostRecent = findMostRecentSession(dir, filterCwd ? cwd : undefined);
         if (mostRecent) {
             return new SessionManager(cwd, dir, mostRecent, true);
         }
@@ -1166,7 +1158,7 @@ export class SessionManager {
      * @param targetCwd Target working directory (where the new session will be stored)
      * @param sessionDir Optional session directory. If omitted, uses default for targetCwd.
      */
-    static forkFrom(sourcePath, targetCwd, sessionDir) {
+    static forkFrom(sourcePath, targetCwd, sessionDir, options) {
         const resolvedSourcePath = resolvePath(sourcePath);
         const resolvedTargetCwd = resolvePath(targetCwd);
         const sourceEntries = loadEntriesFromFile(resolvedSourcePath);
@@ -1182,7 +1174,10 @@ export class SessionManager {
             mkdirSync(dir, { recursive: true });
         }
         // Create new session file with new ID but forked content
-        const newSessionId = createSessionId();
+        if (options?.id !== undefined) {
+            assertValidSessionId(options.id);
+        }
+        const newSessionId = options?.id ?? createSessionId();
         const timestamp = new Date().toISOString();
         const fileTimestamp = timestamp.replace(/[:.]/g, "-");
         const newSessionFile = join(dir, `${fileTimestamp}_${newSessionId}.jsonl`);
@@ -1212,15 +1207,20 @@ export class SessionManager {
      */
     static async list(cwd, sessionDir, onProgress) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        const sessions = await listSessionsFromDir(dir, onProgress);
+        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+        const resolvedCwd = resolvePath(cwd);
+        const sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
         sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
         return sessions;
     }
-    /**
-     * List all sessions across all project directories.
-     * @param onProgress Optional callback for progress updates (loaded, total)
-     */
-    static async listAll(onProgress) {
+    static async listAll(sessionDirOrOnProgress, onProgress) {
+        const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : undefined;
+        const progress = typeof sessionDirOrOnProgress === "function" ? sessionDirOrOnProgress : onProgress;
+        if (customSessionDir) {
+            const sessions = await listSessionsFromDir(customSessionDir, progress);
+            sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+            return sessions;
+        }
         const sessionsDir = getSessionsDir();
         try {
             if (!existsSync(sessionsDir)) {
@@ -1248,7 +1248,7 @@ export class SessionManager {
             const results = await Promise.all(allFiles.map(async (file) => {
                 const info = await buildSessionInfo(file);
                 loaded++;
-                onProgress?.(loaded, totalFiles);
+                progress?.(loaded, totalFiles);
                 return info;
             }));
             for (const info of results) {