@posthog/agent 2.3.510 → 2.3.513

package/dist/handoff-checkpoint.js

@@ -5955,6 +5955,7 @@ async function getGitBusyState(git) {
   }
   return { busy: false };
 }
+var MAX_WORKTREE_FILE_BYTES = 1024 * 1024;
 async function createWorktreeTree(git, baseDir, head) {
   const { tempGit, tempIndexPath } = await createTempIndexGit(git, baseDir, "checkpoint-worktree");
   try {
@@ -5964,6 +5965,7 @@ async function createWorktreeTree(git, baseDir, head) {
       await tempGit.raw(["read-tree", "--empty"]);
     }
     await tempGit.raw(["add", "-A", "--", "."]);
+    await reconcileLargeBlobs(tempGit, head, MAX_WORKTREE_FILE_BYTES);
     const treeHash = await tempGit.raw(["write-tree"]);
     return treeHash.trim();
   } finally {
@@ -5971,6 +5973,77 @@ async function createWorktreeTree(git, baseDir, head) {
     });
   }
 }
+async function reconcileLargeBlobs(tempGit, head, maxBytes) {
+  const intermediateTree = (await tempGit.raw(["write-tree"])).trim();
+  const largePaths = await listLargeBlobPaths(tempGit, intermediateTree, maxBytes);
+  if (largePaths.length === 0)
+    return;
+  const headEntries = head ? await readHeadBlobEntries(tempGit, head, largePaths) : /* @__PURE__ */ new Map();
+  for (const filePath of largePaths) {
+    const headEntry = headEntries.get(filePath);
+    if (headEntry) {
+      await tempGit.raw([
+        "update-index",
+        "--cacheinfo",
+        `${headEntry.mode},${headEntry.hash},${filePath}`
+      ]);
+    } else {
+      await tempGit.raw(["update-index", "--force-remove", filePath]).catch(() => {
+      });
+    }
+  }
+}
+async function listLargeBlobPaths(tempGit, tree, maxBytes) {
+  const output = await tempGit.raw(["ls-tree", "-r", "-l", tree]);
+  const result = [];
+  for (const line of output.split("\n")) {
+    if (!line)
+      continue;
+    const tabIndex = line.indexOf("	");
+    if (tabIndex < 0)
+      continue;
+    const meta = line.slice(0, tabIndex);
+    const filePath = line.slice(tabIndex + 1);
+    const parts = meta.split(/\s+/);
+    if (parts.length < 4)
+      continue;
+    const [, type, , sizeStr] = parts;
+    if (type !== "blob")
+      continue;
+    if (sizeStr === "-")
+      continue;
+    const size = Number.parseInt(sizeStr, 10);
+    if (Number.isFinite(size) && size > maxBytes) {
+      result.push(filePath);
+    }
+  }
+  return result;
+}
+async function readHeadBlobEntries(tempGit, head, paths) {
+  const result = /* @__PURE__ */ new Map();
+  const CHUNK_SIZE = 100;
+  for (let i = 0; i < paths.length; i += CHUNK_SIZE) {
+    const chunk = paths.slice(i, i + CHUNK_SIZE);
+    const output = await tempGit.raw(["ls-tree", "-r", head, "--", ...chunk]).catch(() => "");
+    for (const line of output.split("\n")) {
+      if (!line)
+        continue;
+      const tabIndex = line.indexOf("	");
+      if (tabIndex < 0)
+        continue;
+      const meta = line.slice(0, tabIndex);
+      const filePath = line.slice(tabIndex + 1);
+      const parts = meta.split(/\s+/);
+      if (parts.length < 3)
+        continue;
+      const [mode, type, hash] = parts;
+      if (type !== "blob")
+        continue;
+      result.set(filePath, { mode, hash });
+    }
+  }
+  return result;
+}
 async function createMetaTree(git, baseDir, indexTree, worktreeTree) {
   const { tempGit, tempIndexPath } = await createTempIndexGit(git, baseDir, "checkpoint-meta");
   try {
@@ -6043,6 +6116,7 @@ async function deleteCheckpoint(git, checkpointId) {
 // ../git/dist/handoff.js
 var HANDOFF_HEAD_REF_PREFIX = "refs/posthog-code-handoff/head/";
 var CHECKPOINT_REF_PREFIX2 = "refs/posthog-code-checkpoint/";
+var MAX_HANDOFF_FILE_BYTES = 1024 * 1024;
 var GitHandoffTracker = class {
   repositoryPath;
   logger;
@@ -6050,7 +6124,7 @@ var GitHandoffTracker = class {
     this.repositoryPath = config.repositoryPath;
     this.logger = config.logger;
   }
-  async captureForHandoff(_localGitState) {
+  async captureForHandoff(localGitState) {
     const captureSaga = new CaptureCheckpointSaga(this.logger);
     const result = await captureSaga.run({ baseDir: this.repositoryPath });
     if (!result.success) {
@@ -6060,17 +6134,20 @@ var GitHandoffTracker = class {
     const git = createGitClient(this.repositoryPath);
     const tempDir = await this.createTempDir(checkpoint.checkpointId);
     const checkpointRef = `${CHECKPOINT_REF_PREFIX2}${checkpoint.checkpointId}`;
-    const packRefs = [
-      checkpoint.head,
-      checkpoint.indexTree,
-      checkpoint.worktreeTree
-    ].filter((ref) => !!ref);
-    const headRef = checkpoint.head ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
-    const packPrefix = path3.join(tempDir, checkpoint.checkpointId);
     try {
+      const reconciledIndex = await this.reconcileHandoffIndex(git, checkpoint.head, checkpoint.indexTree, tempDir, checkpoint.checkpointId);
+      const packBaseline = localGitState?.upstreamHead ?? null;
+      const packRefs = [
+        checkpoint.head,
+        reconciledIndex.indexTree,
+        checkpoint.worktreeTree,
+        packBaseline ? `^${packBaseline}` : null
+      ].filter((ref) => !!ref);
+      const headRef = checkpoint.head ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
+      const packPrefix = path3.join(tempDir, checkpoint.checkpointId);
       const [headPack, indexFile, tracking] = await Promise.all([
         this.captureObjectPack(packPrefix, packRefs),
-        this.copyIndexFile(git, checkpoint.checkpointId, tempDir),
+        this.statFileArtifact(reconciledIndex.indexFilePath),
         getTrackingMetadata(git, checkpoint.branch)
       ]);
       return {
@@ -6081,7 +6158,7 @@ var GitHandoffTracker = class {
           headRef,
           head: checkpoint.head,
           branch: checkpoint.branch,
-          indexTree: checkpoint.indexTree,
+          indexTree: reconciledIndex.indexTree,
           worktreeTree: checkpoint.worktreeTree,
           timestamp: checkpoint.timestamp,
           upstreamRemote: tracking.upstreamRemote,
@@ -6101,6 +6178,7 @@ var GitHandoffTracker = class {
     const { checkpoint, headPackPath, indexPath, localGitState, onDivergedBranch } = input;
     const git = createGitClient(this.repositoryPath);
     if (headPackPath) {
+      await this.ensureBaselineForApply(git, checkpoint, localGitState);
       await this.unpackPackFile(headPackPath);
     }
     if (checkpoint.branch && checkpoint.head) {
@@ -6139,14 +6217,89 @@ var GitHandoffTracker = class {
     });
     return { path: packPath, rawBytes };
   }
-  async copyIndexFile(git, checkpointId, tempDir) {
-    const indexPath = await this.getGitPath(git, "index");
-    const copiedIndexPath = path3.join(tempDir, `${checkpointId}.index`);
-    await copyFile(indexPath, copiedIndexPath);
-    return {
-      path: copiedIndexPath,
-      rawBytes: await this.getFileSize(copiedIndexPath)
-    };
+  async reconcileHandoffIndex(git, head, indexTree, tempDir, checkpointId) {
+    const realIndexPath = await this.getGitPath(git, "index");
+    const tempIndexPath = path3.join(tempDir, `${checkpointId}.index`);
+    await copyFile(realIndexPath, tempIndexPath);
+    const largePaths = await this.listLargeBlobsInTree(indexTree, MAX_HANDOFF_FILE_BYTES);
+    if (largePaths.length === 0) {
+      return { indexTree, indexFilePath: tempIndexPath };
+    }
+    const headBlobs = head ? await this.readHeadBlobsForPaths(head, largePaths) : /* @__PURE__ */ new Map();
+    const env = { ...process.env, GIT_INDEX_FILE: tempIndexPath };
+    for (const filePath of largePaths) {
+      const headBlob = headBlobs.get(filePath);
+      if (headBlob) {
+        await this.runGitWithEnv(env, [
+          "update-index",
+          "--cacheinfo",
+          `${headBlob.mode},${headBlob.hash},${filePath}`
+        ]);
+      } else {
+        await this.runGitWithEnv(env, [
+          "update-index",
+          "--force-remove",
+          filePath
+        ]).catch(() => {
+        });
+      }
+    }
+    const reconciledTree = (await this.runGitWithEnv(env, ["write-tree"])).trim();
+    return { indexTree: reconciledTree, indexFilePath: tempIndexPath };
+  }
+  async listLargeBlobsInTree(tree, maxBytes) {
+    const { stdout } = await this.runGitProcess(["ls-tree", "-r", "-l", tree], "");
+    const result = [];
+    for (const line of stdout.split("\n")) {
+      if (!line)
+        continue;
+      const tabIndex = line.indexOf("	");
+      if (tabIndex < 0)
+        continue;
+      const meta = line.slice(0, tabIndex);
+      const filePath = line.slice(tabIndex + 1);
+      const parts = meta.split(/\s+/);
+      if (parts.length < 4)
+        continue;
+      const [, type, , sizeStr] = parts;
+      if (type !== "blob")
+        continue;
+      if (sizeStr === "-")
+        continue;
+      const size = Number.parseInt(sizeStr, 10);
+      if (Number.isFinite(size) && size > maxBytes) {
+        result.push(filePath);
+      }
+    }
+    return result;
+  }
+  async readHeadBlobsForPaths(head, paths) {
+    const result = /* @__PURE__ */ new Map();
+    const CHUNK_SIZE = 100;
+    for (let i = 0; i < paths.length; i += CHUNK_SIZE) {
+      const chunk = paths.slice(i, i + CHUNK_SIZE);
+      const { stdout } = await this.runGitProcess(["ls-tree", "-r", head, "--", ...chunk], "").catch(() => ({ stdout: "", stderr: "" }));
+      for (const line of stdout.split("\n")) {
+        if (!line)
+          continue;
+        const tabIndex = line.indexOf("	");
+        if (tabIndex < 0)
+          continue;
+        const meta = line.slice(0, tabIndex);
+        const filePath = line.slice(tabIndex + 1);
+        const parts = meta.split(/\s+/);
+        if (parts.length < 3)
+          continue;
+        const [mode, type, hash] = parts;
+        if (type !== "blob")
+          continue;
+        result.set(filePath, { mode, hash });
+      }
+    }
+    return result;
+  }
+  async statFileArtifact(filePath) {
+    return { path: filePath, rawBytes: await this.getFileSize(filePath) };
   }
   async restoreIndexFile(git, indexPath) {
     const gitIndexPath = await this.getGitPath(git, "index");
@@ -6174,6 +6327,20 @@ var GitHandoffTracker = class {
   shouldRestoreTracking(branchStatus2, localGitState, tracking) {
     return branchStatus2.kind === "missing" || !hasTrackingConfig(localGitState) && (tracking.upstreamRemote !== null || tracking.upstreamMergeRef !== null);
   }
+  async ensureBaselineForApply(git, checkpoint, localGitState) {
+    const tracking = this.getPreferredTracking(localGitState, checkpoint);
+    if (!tracking.upstreamRemote || !tracking.upstreamMergeRef)
+      return;
+    await this.ensureRemoteForTracking(git, tracking).catch(() => {
+    });
+    await git.raw(["fetch", tracking.upstreamRemote, tracking.upstreamMergeRef]).catch((err) => {
+      this.logger?.error("Handoff baseline fetch failed; if the pack excludes commits the receiver does not already have, the subsequent unpack/read-tree will fail with an object-missing error", {
+        err: String(err),
+        remote: tracking.upstreamRemote,
+        ref: tracking.upstreamMergeRef
+      });
+    });
+  }
   async ensureRemoteForTracking(git, tracking) {
     if (!tracking.upstreamRemote || !tracking.remoteUrl)
       return;
@@ -6310,6 +6477,31 @@ var GitHandoffTracker = class {
       });
     });
   }
+  async runGitWithEnv(env, args) {
+    return new Promise((resolve2, reject) => {
+      const child = spawn2("git", args, {
+        cwd: this.repositoryPath,
+        stdio: ["ignore", "pipe", "pipe"],
+        env
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("error", reject);
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve2(stdout);
+          return;
+        }
+        reject(new Error(stderr || `git ${args.join(" ")} failed with code ${code}`));
+      });
+    });
+  }
   runGitProcess(args, input) {
     return new Promise((resolve2, reject) => {
       const child = spawn2("git", args, {
@@ -6332,6 +6524,8 @@ var GitHandoffTracker = class {
         }
         reject(new Error(stderr || `git ${args.join(" ")} failed with code ${code}`));
       });
+      child.stdin.on("error", () => {
+      });
       child.stdin.end(input);
     });
   }