@ai-development-environment/control-agent 0.0.57 → 0.0.58

package/dist/control-agent.js

@@ -6026,6 +6026,7 @@ function codebaseGitOperationPayload(value) {
 // ../agent-contract/src/worktrees.ts
 var WORKTREE_INSPECT_JOB_KIND = "worktree.inspect";
 var WORKTREE_OPERATION_JOB_KIND = "worktree.operation";
+var WORKTREE_AUTO_SYNC_JOB_KIND = "worktree.auto-sync";
 var WORKTREE_GIT_INSPECT_JOB_KIND = "worktree.git.inspect";
 var WORKTREE_GIT_OPERATION_JOB_KIND = "worktree.git.operation";
 var WORKTREE_WATCH_JOB_KIND = "worktree.watch";
@@ -6038,6 +6039,7 @@ var WORKTREE_DIFF_ASSET_JOB_KIND = "worktree.diff.asset";
 var WORKTREE_JOB_KINDS = [
   WORKTREE_INSPECT_JOB_KIND,
   WORKTREE_OPERATION_JOB_KIND,
+  WORKTREE_AUTO_SYNC_JOB_KIND,
   WORKTREE_GIT_INSPECT_JOB_KIND,
   WORKTREE_GIT_OPERATION_JOB_KIND,
   WORKTREE_WATCH_JOB_KIND,
@@ -6422,6 +6424,51 @@ function worktreeJobPayload(value) {
     ...editorVariant === void 0 ? {} : { editorVariant }
   };
 }
+function worktreeAutoSyncJobPayload(value) {
+  const payload = objectValue4(value, "worktree auto sync payload");
+  const allowed = /* @__PURE__ */ new Set([
+    "codebaseId",
+    "folder",
+    "gitDirectory",
+    "expectedOrigin",
+    "expectedBranch",
+    "baseBranch",
+    "phase"
+  ]);
+  const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
+  if (unexpected) {
+    throw new Error(
+      `Unexpected worktree auto sync payload field: ${unexpected}`
+    );
+  }
+  if (payload.phase !== "SYNC" && payload.phase !== "FINALIZE") {
+    throw new Error("worktree auto sync payload.phase is invalid");
+  }
+  return {
+    codebaseId: stringValue4(
+      payload.codebaseId,
+      "worktree auto sync payload.codebaseId"
+    ),
+    folder: stringValue4(payload.folder, "worktree auto sync payload.folder"),
+    gitDirectory: stringValue4(
+      payload.gitDirectory,
+      "worktree auto sync payload.gitDirectory"
+    ),
+    expectedOrigin: stringValue4(
+      payload.expectedOrigin,
+      "worktree auto sync payload.expectedOrigin"
+    ),
+    expectedBranch: stringValue4(
+      payload.expectedBranch,
+      "worktree auto sync payload.expectedBranch"
+    ),
+    baseBranch: stringValue4(
+      payload.baseBranch,
+      "worktree auto sync payload.baseBranch"
+    ),
+    phase: payload.phase
+  };
+}
 function worktreeGitInspectPayload(value) {
   const payload = objectValue4(value, "worktree Git inspect payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -15838,6 +15885,230 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
     )
   };
 };
+var autoSyncWorktree = async (payload, timeoutMs, signal) => {
+  const input = worktreeAutoSyncJobPayload(payload);
+  const folder = await validateWorktree2(input, timeoutMs, signal);
+  const runGit = async (args, fallback) => requireSuccess3(await git3(folder, args, timeoutMs, signal), fallback);
+  const branchResult = await git3(
+    folder,
+    ["symbolic-ref", "--short", "-q", "HEAD"],
+    timeoutMs,
+    signal
+  );
+  const symbolicBranch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : null;
+  const branch = symbolicBranch ?? (input.phase === "FINALIZE" ? await rebaseBranch(folder, timeoutMs, signal) : null);
+  if (branch !== input.expectedBranch) {
+    throw new Error(
+      `Auto Sync expected branch ${input.expectedBranch}, but found ${branch ?? "detached HEAD"}`
+    );
+  }
+  const upstreamResult = branch ? await git3(
+    folder,
+    ["rev-parse", "--abbrev-ref", "@{upstream}"],
+    timeoutMs,
+    signal
+  ) : null;
+  const upstream = upstreamResult?.exitCode === 0 ? upstreamResult.stdout.trim() : null;
+  if (input.phase === "SYNC" && (!branch || !upstream)) {
+    throw new Error("Auto Sync requires a branch with an upstream");
+  }
+  if (input.phase === "FINALIZE") {
+    let status3 = await runGit(
+      ["status", "--porcelain=v1", "-z"],
+      "Could not inspect worktree changes"
+    );
+    let changes = statusChangeState(status3.stdout);
+    const continuingRebase = await rebaseInProgress(folder, timeoutMs, signal);
+    if (changes.hasConflicts && !continuingRebase) {
+      return {
+        ...successfulProcess7,
+        outcome: "UNRESOLVED",
+        worktree: await inspectWorktreeItem(
+          folder,
+          folder,
+          input.baseBranch,
+          false,
+          Math.min(timeoutMs, 3e4),
+          signal
+        )
+      };
+    }
+    if (continuingRebase) {
+      await runGit(["add", "--all"], "Could not stage resolved conflicts");
+      const continued = await command2(
+        "git",
+        ["-C", folder, "rebase", "--continue"],
+        timeoutMs,
+        signal,
+        {
+          ...process.env,
+          GIT_EDITOR: "true",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_OPTIONAL_LOCKS: "0"
+        }
+      );
+      if (continued.exitCode !== 0) {
+        return {
+          ...successfulProcess7,
+          outcome: "UNRESOLVED",
+          worktree: await inspectWorktreeItem(
+            folder,
+            folder,
+            input.baseBranch,
+            false,
+            Math.min(timeoutMs, 3e4),
+            signal
+          )
+        };
+      }
+      status3 = await runGit(
+        ["status", "--porcelain=v1", "-z"],
+        "Could not inspect resolved worktree changes"
+      );
+      changes = statusChangeState(status3.stdout);
+    }
+    if (changes.hasConflicts || changes.hasStagedChanges || changes.hasUnstagedChanges || await rebaseInProgress(folder, timeoutMs, signal)) {
+      return {
+        ...successfulProcess7,
+        outcome: "UNRESOLVED",
+        worktree: await inspectWorktreeItem(
+          folder,
+          folder,
+          input.baseBranch,
+          false,
+          Math.min(timeoutMs, 3e4),
+          signal
+        )
+      };
+    }
+    const finalBranch = await git3(
+      folder,
+      ["symbolic-ref", "--short", "-q", "HEAD"],
+      timeoutMs,
+      signal
+    );
+    const finalUpstream = finalBranch.exitCode === 0 ? await git3(
+      folder,
+      ["rev-parse", "--abbrev-ref", "@{upstream}"],
+      timeoutMs,
+      signal
+    ) : null;
+    if (finalBranch.exitCode !== 0 || finalBranch.stdout.trim() !== input.expectedBranch || finalUpstream?.exitCode !== 0 || !finalUpstream.stdout.trim()) {
+      throw new Error(
+        `Auto Sync expected branch ${input.expectedBranch} with an upstream`
+      );
+    }
+    await runGit(["push", "--force-with-lease"], "Auto Sync push failed");
+    return {
+      ...successfulProcess7,
+      outcome: "SYNCED",
+      worktree: await inspectWorktreeItem(
+        folder,
+        folder,
+        input.baseBranch,
+        false,
+        Math.min(timeoutMs, 3e4),
+        signal
+      )
+    };
+  }
+  const status2 = await runGit(
+    ["status", "--porcelain"],
+    "Could not inspect worktree changes"
+  );
+  if (status2.stdout.trim()) {
+    throw new Error("Stash or commit changes before Auto Sync can continue");
+  }
+  await runGit(["fetch", "origin"], "Could not fetch origin");
+  const remoteBase = `refs/remotes/origin/${input.baseBranch}`;
+  const isCurrent = await git3(
+    folder,
+    ["merge-base", "--is-ancestor", remoteBase, "HEAD"],
+    timeoutMs,
+    signal
+  );
+  if (isCurrent.exitCode === 0) {
+    const upstreamContainsHead = await git3(
+      folder,
+      ["merge-base", "--is-ancestor", "HEAD", "@{upstream}"],
+      timeoutMs,
+      signal
+    );
+    if (upstreamContainsHead.exitCode !== 0 && upstreamContainsHead.exitCode !== 1) {
+      throw new Error(
+        cleanError3(
+          upstreamContainsHead.stderr || "Could not compare the upstream branch"
+        )
+      );
+    }
+    if (upstreamContainsHead.exitCode !== 0) {
+      await runGit(["push", "--force-with-lease"], "Auto Sync push failed");
+      return {
+        ...successfulProcess7,
+        outcome: "SYNCED",
+        worktree: await inspectWorktreeItem(
+          folder,
+          folder,
+          input.baseBranch,
+          false,
+          Math.min(timeoutMs, 3e4),
+          signal
+        )
+      };
+    }
+    return {
+      ...successfulProcess7,
+      outcome: "NO_CHANGE",
+      worktree: await inspectWorktreeItem(
+        folder,
+        folder,
+        input.baseBranch,
+        false,
+        Math.min(timeoutMs, 3e4),
+        signal
+      )
+    };
+  }
+  const rebase = await git3(folder, ["rebase", remoteBase], timeoutMs, signal);
+  if (rebase.exitCode !== 0) {
+    const conflictStatus = await git3(
+      folder,
+      ["status", "--porcelain=v1", "-z"],
+      timeoutMs,
+      signal
+    );
+    const conflicts = conflictStatus.exitCode === 0 && statusChangeState(conflictStatus.stdout).hasConflicts;
+    if (conflicts && await rebaseInProgress(folder, timeoutMs, signal)) {
+      return {
+        ...successfulProcess7,
+        outcome: "CONFLICT",
+        worktree: await inspectWorktreeItem(
+          folder,
+          folder,
+          input.baseBranch,
+          false,
+          Math.min(timeoutMs, 3e4),
+          signal
+        )
+      };
+    }
+    await git3(folder, ["rebase", "--abort"], timeoutMs, signal);
+    throw new Error(cleanError3(rebase.stderr || "Auto Sync rebase failed"));
+  }
+  await runGit(["push", "--force-with-lease"], "Auto Sync push failed");
+  return {
+    ...successfulProcess7,
+    outcome: "SYNCED",
+    worktree: await inspectWorktreeItem(
+      folder,
+      folder,
+      input.baseBranch,
+      false,
+      Math.min(timeoutMs, 3e4),
+      signal
+    )
+  };
+};
 
 // src/handlers/index.ts
 var handlers = {
@@ -15853,6 +16124,7 @@ var handlers = {
   [CODEBASE_GIT_INSPECT_JOB_KIND]: inspectCodebaseGit,
   [CODEBASE_GIT_OPERATION_JOB_KIND]: operateCodebaseGit,
   [WORKTREE_INSPECT_JOB_KIND]: inspectWorktree,
+  [WORKTREE_AUTO_SYNC_JOB_KIND]: autoSyncWorktree,
   [WORKTREE_BRANCH_JOB_KIND]: branchWorktree,
   [WORKTREE_MOVE_PUSH_JOB_KIND]: pushMovedWorktree,
   [WORKTREE_MOVE_CHECKOUT_JOB_KIND]: checkoutMovedWorktree,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-development-environment/control-agent",
-  "version": "0.0.57",
+  "version": "0.0.58",
   "description": "Control agent for the AI Development Environment",
   "license": "MIT",
   "repository": {