@ricsam/r5d-worker 0.0.44 → 0.0.46

package/dist/mjs/package.json

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

package/dist/mjs/workspace-sync.mjs

@@ -9,6 +9,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];
@@ -84,6 +87,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) => path.resolve(checkoutPath, gitPath));
+  if (!indexPath || lockPaths.length !== ACTIVE_GIT_LOCK_PATHS.length || lockPaths.some((lockPath) => fs.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 = fs.statSync(indexPath);
+    indexSignature = entrySignature(stat);
+  } catch {
+  }
+  if (lockPaths.some((lockPath) => fs.existsSync(lockPath))) return null;
+  return `${head.exitCode === 0 ? head.stdout.toString().trim() : "unborn"}\0${indexSignature}`;
+}
 function listShadowTrackedFiles(input, relativeRoot) {
   const normalizedRoot = relativeRoot.split(path.sep).join("/").replace(/^\/+|\/+$/g, "");
   const output = runGit(input, input.shadowRoot, ["ls-files", "-z", "--cached", "--", normalizedRoot], "list canonical workspace files");
@@ -213,11 +246,28 @@ function mirrorFileSet(sourceRoot, targetRoot, sourceFiles, targetFiles) {
   }
   removeEmptyDirectories(targetRoot);
 }
+function restoreShadowProjectSnapshot(input, relativeRoot) {
+  const shadowRoot = path.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;
+  }
+  fs.rmSync(shadowRoot, { recursive: true, force: true });
+}
 function mirrorVisibleProjectToShadow(input, manifest, branchName) {
   const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
   if (!fs.existsSync(path.join(visibleRoot, ".git"))) return;
-  const shadowRoot = path.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 = path.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);
@@ -246,29 +296,7 @@ function mirrorShadowPlansToLocal(input, manifest, branchName) {
     listFilesRecursively(targetRoot, planFilter)
   );
 }
-function pruneDirectoryChildren(root, allowedNames) {
-  if (!fs.existsSync(root)) return;
-  for (const entry of fs.readdirSync(root)) {
-    if (allowedNames.has(entry)) continue;
-    const target = path.resolve(root, entry);
-    assertInside(root, target, "Workspace manifest prune path");
-    fs.rmSync(target, { recursive: true, force: true });
-  }
-}
-function pruneShadowToManifest(input) {
-  const projectIds = new Set(input.projects.map((project) => project.projectId));
-  const projectsRoot = path.join(input.shadowRoot, "projects");
-  const plansRoot = path.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(path.join(projectsRoot, manifest.projectId, "branches"), encodedBranches);
-    pruneDirectoryChildren(path.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;
@@ -282,13 +310,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);
@@ -335,11 +363,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",
@@ -442,13 +562,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,
@@ -457,10 +581,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");
@@ -553,7 +690,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}");
@@ -566,27 +706,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;

package/dist/types/main.d.ts

@@ -49,6 +49,11 @@ type WorkerViewFileBytesResult = {
     width: number;
     height: number;
 };
+export type WorkerBuiltInToolPaths = {
+    artifactsDir?: string;
+    plansDir?: string;
+    activePlanFile?: string;
+};
 export declare function isArtifactEnvPath(filePath: string): boolean;
 export declare function syncSessionArtifacts(input: {
     baseUrl: string;
@@ -86,8 +91,14 @@ type ResolvedWorkerFilePath = {
     displayPath: string;
     repoRelativePath: null;
     scope: "host";
+} | {
+    absolutePath: string;
+    displayPath: string;
+    repoRelativePath: null;
+    scope: "virtual";
+    virtualRootPath: string;
 };
-export declare function resolveWorkerFilePath(branchPath: string, inputPath: string): ResolvedWorkerFilePath;
+export declare function resolveWorkerFilePath(branchPath: string, inputPath: string, builtInPaths?: WorkerBuiltInToolPaths): ResolvedWorkerFilePath;
 export declare function githubCliEnv(token: string | null | undefined): Record<string, string>;
 export declare function ensureVisibleGitCheckout(input: {
     projectRoot: string;
@@ -98,27 +109,27 @@ export declare function ensureVisibleGitCheckout(input: {
     defaultBranch: string;
     reconcileExistingOrigin?: boolean;
 }): string;
-export declare function readWorkerTextFile(branchPath: string, filePath: string, offset?: number, limit?: number): WorkerReadFileResult;
-export declare function writeWorkerTextFile(branchPath: string, filePath: string, content: string): WorkerWriteFileResult;
+export declare function readWorkerTextFile(branchPath: string, filePath: string, offset?: number, limit?: number, builtInPaths?: WorkerBuiltInToolPaths): WorkerReadFileResult;
+export declare function writeWorkerTextFile(branchPath: string, filePath: string, content: string, builtInPaths?: WorkerBuiltInToolPaths): WorkerWriteFileResult;
 export declare function editWorkerTextFile(branchPath: string, filePath: string, edits: Array<{
     oldText: string;
     newText: string;
-}>): WorkerEditFileResult;
+}>, builtInPaths?: WorkerBuiltInToolPaths): WorkerEditFileResult;
 export declare function grepWorkerFiles(branchPath: string, input: {
     pattern: string;
     path?: string;
     glob?: string;
     caseSensitive?: boolean;
     limit?: number;
-}): WorkerGrepResult;
+}, builtInPaths?: WorkerBuiltInToolPaths): WorkerGrepResult;
 export declare function findWorkerFiles(branchPath: string, input: {
     pattern?: string;
     path?: string;
     entryType?: string;
     limit?: number;
-}): WorkerFindResult;
-export declare function listWorkerDirectory(branchPath: string, inputPath?: string, inputLimit?: number): WorkerLsResult;
-export declare function readWorkerImageFile(branchPath: string, filePath: string): WorkerViewFileBytesResult;
+}, builtInPaths?: WorkerBuiltInToolPaths): WorkerFindResult;
+export declare function listWorkerDirectory(branchPath: string, inputPath?: string, inputLimit?: number, builtInPaths?: WorkerBuiltInToolPaths): WorkerLsResult;
+export declare function readWorkerImageFile(branchPath: string, filePath: string, builtInPaths?: WorkerBuiltInToolPaths): WorkerViewFileBytesResult;
 export declare function resolveHostShell(command?: string, platform?: NodeJS.Platform): {
     file: string;
     args: string[];

package/dist/types/workspace-sync.d.ts

@@ -68,7 +68,10 @@ export declare function synchronizeWorkspace(rawInput: WorkspaceSyncInput): Prom
 export declare function calculateWorkspaceDiffFingerprint(input: WorkspaceSyncInput): string;
 export declare class WorkspaceSyncSingleFlight {
     private queue;
+    private enqueue;
     run(input: WorkspaceSyncInput): Promise<WorkspaceSyncResult>;
+    runPrepared(prepare: () => WorkspaceSyncInput): Promise<WorkspaceSyncResult>;
     fingerprint(input: WorkspaceSyncInput): Promise<string>;
+    fingerprintPrepared(prepare: () => WorkspaceSyncInput): Promise<string>;
     afterCurrent(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",