@ricsam/r5d-worker 0.0.44 → 0.0.46

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "type": "commonjs"
 }

package/dist/cjs/workspace-sync.cjs

@@ -53,6 +53,9 @@ const MAX_REPORTED_WORKSPACE_PATHS = 2e3;
 const MAX_REPORTED_WORKSPACE_STATUS_BYTES = 256 * 1024;
 const MAX_MIRROR_COMPARISON_CACHE_ENTRIES = 2e5;
 const MIRROR_COMPARE_BUFFER_BYTES = 64 * 1024;
+const DESTRUCTIVE_CHECKOUT_MIN_TRACKED_FILES = 20;
+const DESTRUCTIVE_CHECKOUT_REMOVAL_RATIO = 0.8;
+const ACTIVE_GIT_LOCK_PATHS = ["index.lock", "HEAD.lock", "packed-refs.lock", "shallow.lock"];
 const mirrorComparisonCache = /* @__PURE__ */ new Map();
 function gitArgs(input, args) {
   return input.authHeader ? ["git", "-c", `http.extraHeader=${input.authHeader}`, ...args] : ["git", ...args];
@@ -128,6 +131,36 @@ function listGitEligibleFiles(checkoutPath) {
     }
   }).sort();
 }
+function checkoutGitSnapshot(checkoutPath) {
+  const gitPaths = Bun.spawnSync(
+    ["git", "rev-parse", "--git-path", "index", ...ACTIVE_GIT_LOCK_PATHS.flatMap((lock) => ["--git-path", lock])],
+    {
+      cwd: checkoutPath,
+      stdout: "pipe",
+      stderr: "ignore",
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    }
+  );
+  if (gitPaths.exitCode !== 0) return null;
+  const [indexPath, ...lockPaths] = gitPaths.stdout.toString().trim().split(/\r?\n/).map((gitPath) => import_node_path.default.resolve(checkoutPath, gitPath));
+  if (!indexPath || lockPaths.length !== ACTIVE_GIT_LOCK_PATHS.length || lockPaths.some((lockPath) => import_node_fs.default.existsSync(lockPath))) {
+    return null;
+  }
+  const head = Bun.spawnSync(["git", "rev-parse", "--verify", "HEAD"], {
+    cwd: checkoutPath,
+    stdout: "pipe",
+    stderr: "ignore",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  let indexSignature = "missing";
+  try {
+    const stat = import_node_fs.default.statSync(indexPath);
+    indexSignature = entrySignature(stat);
+  } catch {
+  }
+  if (lockPaths.some((lockPath) => import_node_fs.default.existsSync(lockPath))) return null;
+  return `${head.exitCode === 0 ? head.stdout.toString().trim() : "unborn"}\0${indexSignature}`;
+}
 function listShadowTrackedFiles(input, relativeRoot) {
   const normalizedRoot = relativeRoot.split(import_node_path.default.sep).join("/").replace(/^\/+|\/+$/g, "");
   const output = runGit(input, input.shadowRoot, ["ls-files", "-z", "--cached", "--", normalizedRoot], "list canonical workspace files");
@@ -257,11 +290,28 @@ function mirrorFileSet(sourceRoot, targetRoot, sourceFiles, targetFiles) {
   }
   removeEmptyDirectories(targetRoot);
 }
+function restoreShadowProjectSnapshot(input, relativeRoot) {
+  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
+  const headFiles = runGitResult(input, input.shadowRoot, ["ls-tree", "-r", "--name-only", "-z", "HEAD", "--", relativeRoot]);
+  if (headFiles.exitCode === 0 && headFiles.stdout) {
+    runGit(input, input.shadowRoot, ["restore", "--source=HEAD", "--worktree", "--", relativeRoot], "restore deferred checkout scan");
+    runGit(input, input.shadowRoot, ["clean", "-fd", "--", relativeRoot], "clean deferred checkout scan");
+    return;
+  }
+  import_node_fs.default.rmSync(shadowRoot, { recursive: true, force: true });
+}
 function mirrorVisibleProjectToShadow(input, manifest, branchName) {
   const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
   if (!import_node_fs.default.existsSync(import_node_path.default.join(visibleRoot, ".git"))) return;
-  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...workspaceProjectBranchRelativePath(manifest.projectId, branchName).split("/"));
-  mirrorFileSet(visibleRoot, shadowRoot, listGitEligibleFiles(visibleRoot), listFilesRecursively(shadowRoot));
+  const beforeSnapshot = checkoutGitSnapshot(visibleRoot);
+  if (!beforeSnapshot) return;
+  const visibleFiles = listGitEligibleFiles(visibleRoot);
+  const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
+  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
+  mirrorFileSet(visibleRoot, shadowRoot, visibleFiles, listFilesRecursively(shadowRoot));
+  if (checkoutGitSnapshot(visibleRoot) !== beforeSnapshot) {
+    restoreShadowProjectSnapshot(input, relativeRoot);
+  }
 }
 function mirrorShadowProjectToVisible(input, manifest, branchName) {
   const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
@@ -290,29 +340,7 @@ function mirrorShadowPlansToLocal(input, manifest, branchName) {
     listFilesRecursively(targetRoot, planFilter)
   );
 }
-function pruneDirectoryChildren(root, allowedNames) {
-  if (!import_node_fs.default.existsSync(root)) return;
-  for (const entry of import_node_fs.default.readdirSync(root)) {
-    if (allowedNames.has(entry)) continue;
-    const target = import_node_path.default.resolve(root, entry);
-    assertInside(root, target, "Workspace manifest prune path");
-    import_node_fs.default.rmSync(target, { recursive: true, force: true });
-  }
-}
-function pruneShadowToManifest(input) {
-  const projectIds = new Set(input.projects.map((project) => project.projectId));
-  const projectsRoot = import_node_path.default.join(input.shadowRoot, "projects");
-  const plansRoot = import_node_path.default.join(input.shadowRoot, "plans");
-  pruneDirectoryChildren(projectsRoot, projectIds);
-  pruneDirectoryChildren(plansRoot, projectIds);
-  for (const manifest of input.projects) {
-    const encodedBranches = new Set(manifest.branches.map(encodeWorkspaceBranch));
-    pruneDirectoryChildren(import_node_path.default.join(projectsRoot, manifest.projectId, "branches"), encodedBranches);
-    pruneDirectoryChildren(import_node_path.default.join(plansRoot, manifest.projectId), encodedBranches);
-  }
-}
 function mirrorVisibleWorkspaceToShadow(input, excludedCheckouts = /* @__PURE__ */ new Set()) {
-  pruneShadowToManifest(input);
   for (const manifest of [...input.projects].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
     for (const branchName of [...new Set(manifest.branches)].sort()) {
       if (excludedCheckouts.has(`${manifest.projectId}\0${branchName}`)) continue;
@@ -326,13 +354,13 @@ function reconcileNewVisibleCheckouts(input) {
     const manifest = input.projects.find((project) => project.projectId === target.projectId);
     if (!manifest || !manifest.branches.includes(target.branchName)) continue;
     const projectRoot = workspaceProjectBranchRelativePath(target.projectId, target.branchName);
-    if (listShadowTrackedFiles(input, projectRoot).length > 0) {
+    if (listShadowTrackedFiles(input, projectRoot).length > 0 || restoreShadowRootFromRemote(input, projectRoot)) {
       mirrorShadowProjectToVisible(input, manifest, target.branchName);
     } else {
       mirrorVisibleProjectToShadow(input, manifest, target.branchName);
     }
     const plansRoot = workspacePlansRelativePath(target.projectId, target.branchName);
-    if (listShadowTrackedFiles(input, plansRoot).length > 0) {
+    if (listShadowTrackedFiles(input, plansRoot).length > 0 || restoreShadowRootFromRemote(input, plansRoot)) {
       mirrorShadowPlansToLocal(input, manifest, target.branchName);
     } else {
       mirrorLocalPlansToShadow(input, manifest, target.branchName);
@@ -379,11 +407,103 @@ function revParse(input, revision) {
 function gitStatus(input) {
   return runGit(input, input.shadowRoot, ["status", "--porcelain=v1", "--untracked-files=all"], "read workspace status");
 }
-function stagedPaths(input) {
-  return runGit(input, input.shadowRoot, ["diff", "--cached", "--name-only", "-z"], "list workspace changes").split("\0").filter(Boolean).sort();
+function resetUncommittedShadowSnapshot(input) {
+  if (!gitStatus(input)) return;
+  if (tryGit(input, input.shadowRoot, ["rev-parse", "--verify", "HEAD"])) {
+    runGit(input, input.shadowRoot, ["reset", "--hard", "HEAD"], "reset interrupted workspace snapshot");
+  } else {
+    runGit(input, input.shadowRoot, ["read-tree", "--empty"], "reset interrupted unborn workspace snapshot");
+  }
+  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean interrupted workspace snapshot");
+}
+function fastForwardCleanShadowForNewCheckouts(input) {
+  if (!input.newVisibleCheckouts?.length) return;
+  runGit(input, input.shadowRoot, ["add", "-A"], "stage existing workspace changes before checkout hydration");
+  if (gitStatus(input)) return;
+  const localHead = revParse(input, "HEAD");
+  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+  if (!localHead || !remoteHead || localHead === remoteHead) return;
+  if (!tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", localHead, remoteHead])) return;
+  runGit(input, input.shadowRoot, ["reset", "--hard", remoteHead], "fast-forward before checkout hydration");
+}
+function restoreShadowRootFromRemote(input, relativeRoot) {
+  const remoteRevision = `origin/${WORKSPACE_BRANCH}`;
+  const remoteFiles = runGitResult(input, input.shadowRoot, ["ls-tree", "-r", "--name-only", "-z", remoteRevision, "--", relativeRoot]);
+  if (remoteFiles.exitCode !== 0 || !remoteFiles.stdout) return false;
+  runGit(
+    input,
+    input.shadowRoot,
+    ["restore", `--source=${remoteRevision}`, "--staged", "--worktree", "--", relativeRoot],
+    `hydrate ${relativeRoot} from canonical workspace`
+  );
+  return true;
 }
-async function stagedDiffSizeBytes(input) {
-  const subprocess = Bun.spawn(gitArgs(input, ["diff", "--cached", "--binary", "--no-ext-diff"]), {
+function candidateBaseRevision(input) {
+  const localHead = revParse(input, "HEAD");
+  if (!localHead) return null;
+  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+  if (!remoteHead) {
+    const emptyTree = Bun.spawnSync(gitArgs(input, ["mktree"]), {
+      cwd: input.shadowRoot,
+      stdin: Buffer.alloc(0),
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    });
+    if (emptyTree.exitCode !== 0) {
+      throw new Error(
+        `create empty workspace comparison tree: ${emptyTree.stderr.toString().trim() || `git exited ${emptyTree.exitCode}`}`
+      );
+    }
+    return emptyTree.stdout.toString().trim();
+  }
+  const mergeBase = runGitResult(input, input.shadowRoot, ["merge-base", localHead, remoteHead]);
+  return mergeBase.exitCode === 0 && mergeBase.stdout ? mergeBase.stdout : remoteHead;
+}
+function stagedPaths(input, baseRevision) {
+  return runGit(
+    input,
+    input.shadowRoot,
+    ["diff", "--cached", "--name-only", "-z", ...baseRevision ? [baseRevision] : []],
+    "list workspace changes"
+  ).split("\0").filter(Boolean).sort();
+}
+function stagedDeletedPaths(input, baseRevision) {
+  return runGit(
+    input,
+    input.shadowRoot,
+    ["diff", "--cached", "--diff-filter=D", "--name-only", "-z", ...baseRevision ? [baseRevision] : []],
+    "list workspace deletions"
+  ).split("\0").filter(Boolean).sort();
+}
+function managedCheckoutRoot(filePath) {
+  const projectMatch = /^projects\/([^/]+)\/branches\/([^/]+)\//.exec(filePath);
+  return projectMatch ? `projects/${projectMatch[1]}/branches/${projectMatch[2]}` : null;
+}
+function revisionTrackedFileCount(input, revision, relativeRoot) {
+  if (!revision) return 0;
+  const result = runGitResult(input, input.shadowRoot, ["ls-tree", "-r", "--name-only", "-z", revision, "--", relativeRoot]);
+  if (result.exitCode !== 0) return 0;
+  return result.stdout.split("\0").filter(Boolean).length;
+}
+function destructiveCheckoutReductions(input, baseRevision) {
+  const roots = new Set(
+    stagedDeletedPaths(input, baseRevision).map(managedCheckoutRoot).filter((root) => Boolean(root))
+  );
+  const destructive = [];
+  for (const root of roots) {
+    const trackedBefore = revisionTrackedFileCount(input, baseRevision, root);
+    if (trackedBefore === 0) continue;
+    const trackedAfter = listShadowTrackedFiles(input, root).length;
+    const removedRatio = (trackedBefore - trackedAfter) / trackedBefore;
+    if (trackedAfter === 0 || trackedBefore >= DESTRUCTIVE_CHECKOUT_MIN_TRACKED_FILES && removedRatio >= DESTRUCTIVE_CHECKOUT_REMOVAL_RATIO) {
+      destructive.push({ root, trackedBefore, trackedAfter });
+    }
+  }
+  return destructive.sort((left, right) => left.root.localeCompare(right.root));
+}
+async function stagedDiffSizeBytes(input, baseRevision) {
+  const subprocess = Bun.spawn(gitArgs(input, ["diff", "--cached", "--binary", "--no-ext-diff", ...baseRevision ? [baseRevision] : []]), {
     cwd: input.shadowRoot,
     stdout: "pipe",
     stderr: "pipe",
@@ -486,13 +606,17 @@ async function synchronizeWorkspace(rawInput) {
       };
     }
     if (!input.skipVisibleMirror) {
+      resetUncommittedShadowSnapshot(input);
       const newCheckoutKeys = new Set((input.newVisibleCheckouts ?? []).map((target) => `${target.projectId}\0${target.branchName}`));
       mirrorVisibleWorkspaceToShadow(input, newCheckoutKeys);
+      fastForwardCleanShadowForNewCheckouts(input);
       reconcileNewVisibleCheckouts(input);
     }
     runGit(input, input.shadowRoot, ["add", "-A"], "stage workspace changes");
-    const paths = stagedPaths(input);
-    const diffSizeBytes = await stagedDiffSizeBytes(input);
+    const stagedWorkingPaths = stagedPaths(input);
+    const baseRevision = candidateBaseRevision(input);
+    const paths = stagedPaths(input, baseRevision);
+    const diffSizeBytes = await stagedDiffSizeBytes(input, baseRevision);
     const statusBeforeCommit = reportedStatus(gitStatus(input));
     const observed = {
       ...result,
@@ -501,10 +625,23 @@ async function synchronizeWorkspace(rawInput) {
       affectedPaths: reportedPaths(paths),
       affectedProjects: affectedProjects(paths)
     };
+    const destructiveReductions = destructiveCheckoutReductions(input, baseRevision);
+    if (destructiveReductions.length > 0 && !input.confirmedLargeDiff) {
+      const summary = destructiveReductions.map(({ root, trackedBefore, trackedAfter }) => `${root} (${trackedBefore} -> ${trackedAfter} tracked files)`).join(", ");
+      return {
+        ...observed,
+        outcome: "large_diff_blocked",
+        error: `Workspace safety guard blocked a destructive checkout reduction: ${summary}`
+      };
+    }
     if (paths.length > 0 && diffSizeBytes > MAX_WORKSPACE_SYNC_DIFF_BYTES && !input.confirmedLargeDiff) {
-      return { ...observed, outcome: "large_diff_blocked" };
+      return {
+        ...observed,
+        outcome: "large_diff_blocked",
+        error: `Workspace safety guard blocked a ${diffSizeBytes}-byte diff above the ${MAX_WORKSPACE_SYNC_DIFF_BYTES}-byte automatic publication limit.`
+      };
     }
-    if (paths.length > 0) {
+    if (stagedWorkingPaths.length > 0) {
       runGit(input, input.shadowRoot, ["commit", "-m", commitMessage(input)], "commit workspace changes");
     }
     const candidateHead = revParse(input, "HEAD");
@@ -597,7 +734,10 @@ async function synchronizeWorkspace(rawInput) {
 }
 function calculateWorkspaceDiffFingerprint(input) {
   ensureShadowWorkspace(input);
-  if (!input.skipVisibleMirror) mirrorVisibleWorkspaceToShadow(input);
+  if (!input.skipVisibleMirror) {
+    resetUncommittedShadowSnapshot(input);
+    mirrorVisibleWorkspaceToShadow(input);
+  }
   runGit(input, input.shadowRoot, ["add", "-A"], "stage workspace fingerprint");
   const stagedTree = runGit(input, input.shadowRoot, ["write-tree"], "write workspace fingerprint tree");
   const headTree = revParse(input, "HEAD^{tree}");
@@ -610,27 +750,25 @@ function calculateWorkspaceDiffFingerprint(input) {
 }
 class WorkspaceSyncSingleFlight {
   queue = Promise.resolve();
-  run(input) {
-    const queued = this.queue.then(
-      () => synchronizeWorkspace(input),
-      () => synchronizeWorkspace(input)
-    );
+  enqueue(task) {
+    const queued = this.queue.then(task, task);
     this.queue = queued.then(
       () => void 0,
       () => void 0
     );
     return queued;
   }
+  run(input) {
+    return this.enqueue(() => synchronizeWorkspace(input));
+  }
+  runPrepared(prepare) {
+    return this.enqueue(() => synchronizeWorkspace(prepare()));
+  }
   fingerprint(input) {
-    const queued = this.queue.then(
-      () => calculateWorkspaceDiffFingerprint(input),
-      () => calculateWorkspaceDiffFingerprint(input)
-    );
-    this.queue = queued.then(
-      () => void 0,
-      () => void 0
-    );
-    return queued;
+    return this.enqueue(() => calculateWorkspaceDiffFingerprint(input));
+  }
+  fingerprintPrepared(prepare) {
+    return this.enqueue(() => calculateWorkspaceDiffFingerprint(prepare()));
   }
   afterCurrent() {
     return this.queue;