@entelligentsia/forgecli 1.0.3 → 1.0.10

package/node_modules/@earendil-works/pi-coding-agent/dist/core/session-manager.js

@@ -10,6 +10,11 @@ export const CURRENT_SESSION_VERSION = 3;
 function createSessionId() {
     return uuidv7();
 }
+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++) {
@@ -210,11 +215,14 @@ export function buildSessionContext(entries, leafId, byId) {
  * Compute the default session directory for a cwd.
  * Encodes cwd into a safe directory name under ~/.pi/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 });
     }
@@ -248,7 +256,7 @@ export function loadEntriesFromFile(filePath) {
     }
     return entries;
 }
-function isValidSessionFile(filePath) {
+function readSessionHeader(filePath) {
     try {
         const fd = openSync(filePath, "r");
         const buffer = Buffer.alloc(512);
@@ -256,23 +264,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;
     }
@@ -475,7 +496,7 @@ export class SessionManager {
     labelsById = new Map();
     labelTimestampsById = new Map();
     leafId = null;
-    constructor(cwd, sessionDir, sessionFile, persist) {
+    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
         this.persist = persist;
@@ -486,7 +507,7 @@ export class SessionManager {
             this.setSessionFile(sessionFile);
         }
         else {
-            this.newSession();
+            this.newSession(newSessionOptions);
         }
     }
     /** Switch to a different session file (used for resume and branching) */
@@ -519,6 +540,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 = {
@@ -577,6 +601,9 @@ export class SessionManager {
     getSessionDir() {
         return this.sessionDir;
     }
+    usesDefaultSessionDir() {
+        return this.sessionDir === getDefaultSessionDirPath(this.cwd);
+    }
     getSessionId() {
         return this.sessionId;
     }
@@ -588,13 +615,24 @@ export class SessionManager {
             return;
         const hasAssistant = this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant");
         if (!hasAssistant) {
-            // Mark as not flushed so when assistant arrives, all entries get written
-            this.flushed = false;
+            if (this.flushed) {
+                appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
+            }
+            else {
+                // Mark as not flushed so when assistant arrives, all entries get written
+                this.flushed = false;
+            }
             return;
         }
         if (!this.flushed) {
-            for (const e of this.fileEntries) {
-                appendFileSync(this.sessionFile, `${JSON.stringify(e)}\n`);
+            const fd = openSync(this.sessionFile, "wx");
+            try {
+                for (const e of this.fileEntries) {
+                    writeFileSync(fd, `${JSON.stringify(e)}\n`);
+                }
+            }
+            finally {
+                closeSync(fd);
             }
             this.flushed = true;
         }
@@ -1004,9 +1042,9 @@ export class SessionManager {
      * @param cwd Working directory (stored in session header)
      * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/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.
@@ -1031,7 +1069,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);
         }
@@ -1048,7 +1087,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);
@@ -1064,7 +1103,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`);
@@ -1077,7 +1119,7 @@ export class SessionManager {
             cwd: resolvedTargetCwd,
             parentSession: resolvedSourcePath,
         };
-        appendFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`);
+        writeFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`, { flag: "wx" });
         // Copy all non-header entries from source
         for (const entry of sourceEntries) {
             if (entry.type !== "session") {
@@ -1094,15 +1136,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)) {
@@ -1129,7 +1176,7 @@ export class SessionManager {
             const allFiles = dirFiles.flat();
             const results = await buildSessionInfosWithConcurrency(allFiles, () => {
                 loaded++;
-                onProgress?.(loaded, totalFiles);
+                progress?.(loaded, totalFiles);
             });
             for (const info of results) {
                 if (info) {