@dyyz1993/pi-coding-agent 0.70.6 → 0.74.4

package/dist/core/session-manager.js

@@ -3,7 +3,7 @@ import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync
 import { readdir, readFile, stat } from "fs/promises";
 import { join, resolve } from "path";
 import { v7 as uuidv7 } from "uuid";
-import { findCanonicalGitRoot, getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
+import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, createFoldSummaryMessage, } from "./messages.js";
 export const CURRENT_SESSION_VERSION = 3;
 function createSessionId() {
@@ -158,27 +158,97 @@ export function buildSessionContext(entries, leafId, byId) {
             compaction = entry;
         }
     }
-    // Build fold index: targetId -> FoldEntry
     const folds = new Map();
     for (const entry of path) {
         if (entry.type === "fold") {
             folds.set(entry.targetId, 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
+    const deletedIds = new Set();
+    for (const entry of path) {
+        if (entry.type === "deletion") {
+            for (const targetId of entry.targetIds) {
+                deletedIds.add(targetId);
+            }
+        }
+    }
+    const deletedToolCallIds = new Set();
+    for (const entry of path) {
+        if (entry.type === "message" && deletedIds.has(entry.id)) {
+            const msg = entry.message;
+            if (msg.role === "assistant" && Array.isArray(msg.content)) {
+                for (const part of msg.content) {
+                    if (part.type === "toolCall" && part.id) {
+                        deletedToolCallIds.add(part.id);
+                    }
+                }
+            }
+        }
+    }
+    for (const entry of path) {
+        if (entry.type === "message" && entry.message.role === "toolResult") {
+            if (deletedToolCallIds.has(entry.message.toolCallId)) {
+                deletedIds.add(entry.id);
+            }
+        }
+    }
+    const strippedToolCallIds = new Set();
+    for (const entry of path) {
+        if (entry.type === "message" && deletedIds.has(entry.id) && entry.message.role === "toolResult") {
+            strippedToolCallIds.add(entry.message.toolCallId);
+        }
+    }
+    const segmentTargets = new Map();
+    for (const entry of path) {
+        if (entry.type === "segment_summary") {
+            const seg = entry;
+            if (seg.targetIds.length === 0)
+                continue;
+            for (let i = 0; i < seg.targetIds.length; i++) {
+                const targetId = seg.targetIds[i];
+                if (deletedIds.has(targetId))
+                    continue;
+                if (segmentTargets.has(targetId))
+                    continue;
+                segmentTargets.set(targetId, {
+                    summary: seg.summary,
+                    isFirst: i === 0,
+                    timestamp: entry.timestamp,
+                });
+            }
+        }
+    }
     const messages = [];
     const appendMessage = (entry) => {
         if (entry.type === "message") {
+            if (deletedIds.has(entry.id))
+                return;
+            const segInfo = segmentTargets.get(entry.id);
+            if (segInfo) {
+                if (segInfo.isFirst) {
+                    messages.push({
+                        role: "segmentSummary",
+                        summary: segInfo.summary,
+                        timestamp: new Date(segInfo.timestamp).getTime(),
+                    });
+                }
+                return;
+            }
             const fold = folds.get(entry.id);
             if (fold) {
                 messages.push(createFoldSummaryMessage(fold.summary, fold.originalTokens, entry.timestamp));
             }
             else {
-                messages.push(entry.message);
+                let msg = entry.message;
+                if (msg.role === "assistant" && Array.isArray(msg.content) && strippedToolCallIds.size > 0) {
+                    const content = msg.content;
+                    const needsStrip = content.some((part) => part.type === "toolCall" && part.id !== undefined && strippedToolCallIds.has(part.id));
+                    if (needsStrip) {
+                        const filteredContent = content.filter((part) => !(part.type === "toolCall" && part.id !== undefined && strippedToolCallIds.has(part.id)));
+                        msg = { ...msg, content: filteredContent };
+                    }
+                }
+                messages.push(msg);
             }
         }
         else if (entry.type === "custom_message") {
@@ -221,12 +291,9 @@ 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/.
- * If the cwd is inside a git worktree, uses the canonical git root
- * so all worktrees of the same repo share session history.
  */
 export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
-    const projectRoot = findCanonicalGitRoot(cwd) ?? cwd;
-    const safePath = `--${projectRoot.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
     const sessionDir = join(agentDir, "sessions", safePath);
     if (!existsSync(sessionDir)) {
         mkdirSync(sessionDir, { recursive: true });
@@ -362,15 +429,11 @@ async function buildSessionInfo(filePath) {
         let firstMessage = "";
         const allMessages = [];
         let name;
-        let effectiveCwd;
         for (const entry of entries) {
-            // Extract session name and cwd override (use latest, including explicit clears)
+            // Extract session name (use latest, including explicit clears)
             if (entry.type === "session_info") {
                 const infoEntry = entry;
                 name = infoEntry.name?.trim() || undefined;
-                if (infoEntry.cwd) {
-                    effectiveCwd = infoEntry.cwd;
-                }
             }
             if (entry.type !== "message")
                 continue;
@@ -388,7 +451,7 @@ async function buildSessionInfo(filePath) {
                 firstMessage = textContent;
             }
         }
-        const cwd = effectiveCwd ?? (typeof header.cwd === "string" ? header.cwd : "");
+        const cwd = typeof header.cwd === "string" ? header.cwd : "";
         const parentSessionPath = header.parentSession;
         const modified = getSessionModifiedDate(entries, header, stats.mtime);
         return {
@@ -554,14 +617,8 @@ export class SessionManager {
     isPersisted() {
         return this.persist;
     }
-    flush() {
-        if (!this.persist || !this.sessionFile)
-            return;
-        this._rewriteFile();
-        this.flushed = true;
-    }
     getCwd() {
-        return this.getEffectiveCwd();
+        return this.cwd;
     }
     getSessionDir() {
         return this.sessionDir;
@@ -591,6 +648,15 @@ export class SessionManager {
             appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
         }
     }
+    /** Force-flush all pending file entries to disk. */
+    flush() {
+        if (!this.persist || !this.sessionFile || this.flushed)
+            return;
+        for (const e of this.fileEntries) {
+            appendFileSync(this.sessionFile, `${JSON.stringify(e)}\n`);
+        }
+        this.flushed = true;
+    }
     _appendEntry(entry) {
         this.fileEntries.push(entry);
         this.byId.set(entry.id, entry);
@@ -639,6 +705,18 @@ export class SessionManager {
         this._appendEntry(entry);
         return entry.id;
     }
+    /** Append a tier models change as child of current leaf, then advance leaf. Returns entry id. */
+    appendTierModelsChange(tierModels) {
+        const entry = {
+            type: "tier_models_change",
+            id: generateId(this.byId),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            tierModels,
+        };
+        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 = {
@@ -656,12 +734,11 @@ export class SessionManager {
         return entry.id;
     }
     /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
-    appendCustomEntry(customType, data, options) {
+    appendCustomEntry(customType, data, _options) {
         const entry = {
             type: "custom",
             customType,
             data,
-            display: options?.display,
             id: generateId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
@@ -683,8 +760,33 @@ export class SessionManager {
         this._appendEntry(entry);
         return entry.id;
     }
-    /** Append a session info entry (e.g., display name, cwd override). Returns entry id. */
-    appendSessionInfo(name, cwd) {
+    /** Append a deletion entry that excludes target messages from LLM context. Returns entry id. */
+    appendDeletion(targetIds) {
+        const entry = {
+            type: "deletion",
+            targetIds,
+            id: generateId(this.byId),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+        };
+        this._appendEntry(entry);
+        return entry.id;
+    }
+    /** Append a segment summary entry that replaces target messages with a summary in LLM context. Returns entry id. */
+    appendSegmentSummary(targetIds, summary) {
+        const entry = {
+            type: "segment_summary",
+            targetIds,
+            summary,
+            id: generateId(this.byId),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+        };
+        this._appendEntry(entry);
+        return entry.id;
+    }
+    /** Append a session info entry (e.g., display name). Returns entry id. */
+    appendSessionInfo(name) {
         const entry = {
             type: "session_info",
             id: generateId(this.byId),
@@ -694,26 +796,9 @@ export class SessionManager {
         if (name !== undefined) {
             entry.name = name.trim();
         }
-        if (cwd !== undefined) {
-            entry.cwd = cwd;
-        }
         this._appendEntry(entry);
         return entry.id;
     }
-    /** Get the effective cwd, considering session_info overrides. */
-    getEffectiveCwd() {
-        const entries = this.getEntries();
-        for (let i = entries.length - 1; i >= 0; i--) {
-            const entry = entries[i];
-            if (entry.type === "session_info") {
-                const infoEntry = entry;
-                if (infoEntry.cwd) {
-                    return infoEntry.cwd;
-                }
-            }
-        }
-        return this.cwd;
-    }
     /** Get the current session name from the latest session_info entry, if any. */
     getSessionName() {
         // Walk entries in reverse to find the latest session_info entry.
@@ -938,7 +1023,7 @@ export class SessionManager {
      * Returns the new session file path, or undefined if not persisting.
      */
     createBranchedSession(leafId) {
-        const _previousSessionFile = this.sessionFile;
+        const previousSessionFile = this.sessionFile;
         const path = this.getBranch(leafId);
         if (path.length === 0) {
             throw new Error(`Entry ${leafId} not found`);
@@ -955,6 +1040,7 @@ export class SessionManager {
             id: newSessionId,
             timestamp,
             cwd: this.cwd,
+            parentSession: this.persist ? previousSessionFile : undefined,
         };
         // Collect labels for entries in the path
         const pathEntryIds = new Set(pathWithoutLabels.map((e) => e.id));