@mduan/paseo-cli 0.11.0-fork.1 → 0.11.0-fork.2

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/snapshot.js

@@ -15,10 +15,14 @@ async function git(args, options) {
 }
 async function resolveRepo(cwd) {
     try {
-        const [repoRoot, indexPath] = (await git(["rev-parse", "--show-toplevel", "--git-path", "index"], { cwd }))
+        const [repoRoot, indexPath, headLogPath] = (await git(["rev-parse", "--show-toplevel", "--git-path", "index", "--git-path", "logs/HEAD"], { cwd }))
             .trim()
             .split("\n");
-        return { repoRoot, indexPath: path.resolve(cwd, indexPath) };
+        return {
+            repoRoot,
+            indexPath: path.resolve(cwd, indexPath),
+            headLogPath: path.resolve(cwd, headLogPath),
+        };
     }
     catch {
         // Not a git repository (or git is missing): turn diffs are git-only.
@@ -43,6 +47,19 @@ export async function snapshotWorkingTree(cwd) {
     const repo = await resolveRepo(cwd);
     if (!repo)
         return null;
+    return { repoRoot: repo.repoRoot, tree: await writeWorkingTree(repo) };
+}
+/** A working tree snapshot plus where HEAD and its reflog stood, to separate out branch moves. */
+export async function snapshotTurnStart(cwd) {
+    const repo = await resolveRepo(cwd);
+    if (!repo)
+        return null;
+    const headLogSize = await fs.stat(repo.headLogPath).then((stat) => stat.size, () => 0);
+    const head = await readHead(repo.repoRoot);
+    const tree = await writeWorkingTree(repo);
+    return { repoRoot: repo.repoRoot, tree, head, headLogPath: repo.headLogPath, headLogSize };
+}
+async function writeWorkingTree(repo) {
     const tempIndex = path.join(os.tmpdir(), `paseo-turn-index-${randomUUID()}`);
     try {
         const stat = await fs.stat(repo.indexPath).catch(() => null);
@@ -61,13 +78,83 @@ export async function snapshotWorkingTree(cwd) {
                 input: untracked.map((file) => `${file}\0`).join(""),
             });
         }
-        const tree = (await git(["write-tree"], { cwd: repo.repoRoot, env })).trim();
-        return { repoRoot: repo.repoRoot, tree };
+        return (await git(["write-tree"], { cwd: repo.repoRoot, env })).trim();
     }
     finally {
         await fs.rm(tempIndex, { force: true });
     }
 }
+async function readHead(repoRoot) {
+    try {
+        return (await git(["rev-parse", "--verify", "-q", "HEAD"], { cwd: repoRoot })).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readFileFrom(filePath, offset) {
+    const handle = await fs.open(filePath, "r").catch(() => null);
+    if (!handle)
+        return undefined;
+    try {
+        const { size } = await handle.stat();
+        if (size < offset)
+            return undefined;
+        const buffer = Buffer.alloc(size - offset);
+        await handle.read(buffer, 0, buffer.length, offset);
+        return buffer.toString("utf8");
+    }
+    finally {
+        await handle.close();
+    }
+}
+const OWN_COMMIT_MESSAGE = /^commit( \((initial|amend)\))?: /;
+/**
+ * The commit HEAD landed on after the turn's last branch move (checkout, reset, pull, merge,
+ * rebase, cherry-pick), read from the reflog lines the turn appended. Undefined when HEAD only
+ * moved by the agent's own commits; null when the reflog can't tell.
+ */
+async function findLastBranchMove(start) {
+    const appended = await readFileFrom(start.headLogPath, start.headLogSize);
+    if (appended === undefined)
+        return null;
+    let landing;
+    for (const line of appended.split("\n")) {
+        // <old> <new> <identity> <time> <tz>\t<message>
+        const [header, message = ""] = line.split("\t", 2);
+        const [oldHead, newHead] = header.split(" ");
+        if (!newHead || oldHead === newHead || OWN_COMMIT_MESSAGE.test(message))
+            continue;
+        landing = newHead;
+    }
+    return landing;
+}
+/**
+ * The tree to diff a turn from. When the turn moved HEAD to another commit, the start snapshot's
+ * uncommitted changes are replayed onto where HEAD landed, so the diff holds the agent's edits and
+ * commits and none of the content the move brought in. Undefined when that can't be worked out
+ * (no reflog, unborn branch, replay conflict); the turn then gets no diff.
+ */
+export async function resolveTurnFromTree(start) {
+    const head = await readHead(start.repoRoot);
+    if (head === start.head)
+        return start.tree;
+    if (!head || !start.head)
+        return undefined;
+    const landing = await findLastBranchMove(start);
+    if (landing === null)
+        return undefined;
+    if (landing === undefined || landing === start.head)
+        return start.tree;
+    try {
+        const output = await git(["merge-tree", "--write-tree", `--merge-base=${start.head}`, landing, start.tree], { cwd: start.repoRoot });
+        return output.split("\n")[0];
+    }
+    catch {
+        // Exit code 1: the start's uncommitted changes conflict with where HEAD landed.
+        return undefined;
+    }
+}
 export async function diffTreeStats(params) {
     if (params.fromTree === params.toTree)
         return [];

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/store.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "pino";
 import { type AgentTurnDiffTarget, type TurnDiffSummary } from "../../messages.js";
-import { type WorkingTreeSnapshot } from "./snapshot.js";
+import { type TurnStartSnapshot } from "./snapshot.js";
 export interface TurnDiffRange {
     repoRoot: string;
     fromTree: string;
@@ -8,7 +8,7 @@ export interface TurnDiffRange {
 }
 export interface RecordTurnInput {
     agentId: string;
-    start: WorkingTreeSnapshot;
+    start: TurnStartSnapshot;
     turnId: string;
     userMessageIds: string[];
 }
@@ -21,7 +21,7 @@ export declare class TurnDiffStore {
     private readonly logger;
     private readonly queues;
     constructor(dir: string, logger: Logger);
-    captureStart(cwd: string): Promise<WorkingTreeSnapshot | null>;
+    captureStart(cwd: string): Promise<TurnStartSnapshot | null>;
     recordTurn(input: RecordTurnInput): Promise<void>;
     list(agentId: string): Promise<TurnDiffSummary[]>;
     resolveRange(agentId: string, target: AgentTurnDiffTarget): Promise<TurnDiffRange | null>;

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/store.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { withTimeout } from "../../../utils/promise-timeout.js";
 import { writeJsonFileAtomic } from "../../atomic-file.js";
 import { TurnDiffFileStatSchema, } from "../../messages.js";
-import { diffTreeStats, snapshotWorkingTree, syncTreeRefs, } from "./snapshot.js";
+import { diffTreeStats, resolveTurnFromTree, snapshotTurnStart, snapshotWorkingTree, syncTreeRefs, } from "./snapshot.js";
 // The prompt waits for the start snapshot; past this, the turn goes without a diff.
 const START_SNAPSHOT_TIMEOUT_MS = 2000;
 const MAX_STORED_TURNS = 200;
@@ -17,15 +17,18 @@ const StoredTurnSchema = TreeRangeSchema.extend({
 });
 const TurnDiffRecordSchema = z.object({
     repoRoot: z.string(),
-    // First snapshot of the chat; "Chat Session" diffs from here. Never trimmed.
-    sessionFromTree: z.string(),
-    // Most recent finished turn, kept even when it changed nothing.
-    lastTurn: TreeRangeSchema,
+    // Most recent finished turn, kept even when it changed nothing. Absent when the turn moved HEAD
+    // in a way its diff couldn't be separated from.
+    lastTurn: TreeRangeSchema.optional(),
     // Turns that changed files, oldest first.
     turns: z.array(StoredTurnSchema),
 });
 function referencedTrees(record) {
-    const trees = new Set([record.sessionFromTree, record.lastTurn.fromTree, record.lastTurn.toTree]);
+    const trees = new Set();
+    if (record.lastTurn) {
+        trees.add(record.lastTurn.fromTree);
+        trees.add(record.lastTurn.toTree);
+    }
     for (const turn of record.turns) {
         trees.add(turn.fromTree);
         trees.add(turn.toTree);
@@ -53,7 +56,7 @@ export class TurnDiffStore {
     async captureStart(cwd) {
         try {
             return await withTimeout({
-                promise: snapshotWorkingTree(cwd),
+                promise: snapshotTurnStart(cwd),
                 timeoutMs: START_SNAPSHOT_TIMEOUT_MS,
                 label: "Turn start snapshot",
             });
@@ -77,9 +80,11 @@ export class TurnDiffStore {
         const { repoRoot } = record;
         switch (target.kind) {
             case "last_turn":
-                return { repoRoot, ...record.lastTurn };
+                return record.lastTurn ? { repoRoot, ...record.lastTurn } : null;
+            // COMPAT(turnDiffSession): added in v0.11.0-beta.3, remove after 2027-01-04. Older clients
+            // can still ask for the removed Chat Session diff; it is always unavailable.
             case "session":
-                return { repoRoot, fromTree: record.sessionFromTree, toTree: record.lastTurn.toTree };
+                return null;
             case "turn": {
                 const turn = record.turns.find((candidate) => candidate.turnId === target.turnId);
                 return turn ? { repoRoot, fromTree: turn.fromTree, toTree: turn.toTree } : null;
@@ -99,26 +104,27 @@ export class TurnDiffStore {
         const end = await snapshotWorkingTree(start.repoRoot);
         if (!end)
             return;
-        const files = await diffTreeStats({
-            repoRoot: start.repoRoot,
-            fromTree: start.tree,
-            toTree: end.tree,
-        });
+        const fromTree = await resolveTurnFromTree(start);
+        if (!fromTree) {
+            this.logger.info({ agentId, turnId }, "Turn moved HEAD in a way its diff can't separate");
+        }
+        const files = fromTree
+            ? await diffTreeStats({ repoRoot: start.repoRoot, fromTree, toTree: end.tree })
+            : [];
         const previous = await this.read(agentId);
         const isSameRepo = previous?.repoRoot === start.repoRoot;
         const record = {
             repoRoot: start.repoRoot,
-            sessionFromTree: isSameRepo ? previous.sessionFromTree : start.tree,
-            lastTurn: { fromTree: start.tree, toTree: end.tree },
+            lastTurn: fromTree ? { fromTree, toTree: end.tree } : undefined,
             turns: isSameRepo ? previous.turns : [],
         };
-        if (files.length > 0) {
+        if (fromTree && files.length > 0) {
             const completedAt = new Date().toISOString();
             const turn = {
                 turnId,
                 userMessageIds,
                 completedAt,
-                fromTree: start.tree,
+                fromTree,
                 toTree: end.tree,
                 files,
             };