@ai-development-environment/control-agent 0.0.142 → 0.0.143

package/dist/control-agent.js

@@ -7617,22 +7617,31 @@ var AgentGraphQLClient = class {
   health() {
     return this.request(`query Health { health }`);
   }
+  async requestDefaultBranchConfiguration(query) {
+    try {
+      return await this.request(query);
+    } catch (error) {
+      if (!(error instanceof Error) || !/Cannot query field "defaultBranchPatterns"/.test(error.message))
+        throw error;
+      return this.request(query.replace(/\sdefaultBranchPatterns\b/g, ""));
+    }
+  }
   async agentCodebases() {
-    const data = await this.request(`query AgentCodebases {
+    const data = await this.requestDefaultBranchConfiguration(`query AgentCodebases {
       agentCodebases {
-        id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate lastFetchedAt lastFetchAttemptAt
+        id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate defaultBranchPatterns lastFetchedAt lastFetchAttemptAt
         worktrees { id folder branch gitDirectory baseBranchOverride }
       }
     }`);
     return data.agentCodebases;
   }
   async agentCodebaseConfiguration() {
-    const data = await this.request(`query AgentCodebaseConfiguration {
+    const data = await this.requestDefaultBranchConfiguration(`query AgentCodebaseConfiguration {
       agentCodebaseConfiguration {
         refreshIntervalSeconds
         fetchIntervalSeconds
         codebases {
-          id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate lastFetchedAt lastFetchAttemptAt
+          id folder canonicalOrigin defaultBranch keepBaseBranchUpToDate defaultBranchPatterns lastFetchedAt lastFetchAttemptAt
           worktrees { id folder branch gitDirectory baseBranchOverride }
         }
       }
@@ -8134,6 +8143,50 @@ var CODEBASE_GIT_INSPECT_JOB_KIND = "codebase.git.inspect";
 var CODEBASE_GIT_OPERATION_JOB_KIND = "codebase.git.operation";
 var CODEBASE_BRANCHES_DELETE_JOB_KIND = "codebase.branches.delete";
 var CODEBASE_RECONCILE_EVENT_CAPABILITY = "codebase.reconcile.requested";
+var CODEBASE_DEFAULT_BRANCHES_CAPABILITY = "codebase.default-branches.v1";
+function normalizeDefaultBranchPatterns(value) {
+  if (!Array.isArray(value) || value.length > 100)
+    throw new Error(
+      "Default branch patterns must be a list of at most 100 entries"
+    );
+  const patterns = value.map((entry) => {
+    if (typeof entry !== "string" || entry.trim().length > 255)
+      throw new Error(
+        "Default branch patterns must be strings of at most 255 characters"
+      );
+    const pattern = entry.trim();
+    if (pattern && /[\s\x00-\x1f\x7f]/.test(pattern))
+      throw new Error(
+        "Default branch patterns cannot contain whitespace or control characters"
+      );
+    return pattern;
+  });
+  return [...new Set(patterns.filter(Boolean))];
+}
+function isDefaultBranch(branch, remoteDefaultBranch, patterns = []) {
+  if (!branch) return false;
+  if (branch === remoteDefaultBranch) return true;
+  return patterns.some((pattern) => {
+    let position = 0;
+    let patternPosition = 0;
+    let star = -1;
+    let resume = 0;
+    while (position < branch.length) {
+      if (pattern[patternPosition] === "*") {
+        star = patternPosition++;
+        resume = position;
+      } else if (pattern[patternPosition] === branch[position]) {
+        patternPosition++;
+        position++;
+      } else if (star >= 0) {
+        patternPosition = star + 1;
+        position = ++resume;
+      } else return false;
+    }
+    while (pattern[patternPosition] === "*") patternPosition++;
+    return patternPosition === pattern.length;
+  });
+}
 var MAX_CODEBASE_GIT_BRANCHES = 1e3;
 var MAX_CODEBASE_STASHES = 200;
 var MAX_CODEBASE_STASH_PATCH_BYTES = 256 * 1024;
@@ -8439,7 +8492,8 @@ function codebaseJobPayload(value) {
     "codebaseId",
     "expectedOrigin",
     "baseBranch",
-    "keepBaseBranchUpToDate"
+    "keepBaseBranchUpToDate",
+    "defaultBranchPatterns"
   ]);
   const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
   if (unexpected)
@@ -8461,6 +8515,11 @@ function codebaseJobPayload(value) {
         payload.keepBaseBranchUpToDate,
         "payload.keepBaseBranchUpToDate"
       )
+    },
+    ...payload.defaultBranchPatterns === void 0 ? {} : {
+      defaultBranchPatterns: normalizeDefaultBranchPatterns(
+        payload.defaultBranchPatterns
+      )
     }
   };
 }
@@ -11683,7 +11742,7 @@ function tailscaleServeRemovePayload(value) {
 // package.json
 var package_default = {
   name: "@ai-development-environment/control-agent",
-  version: "0.0.142",
+  version: "0.0.143",
   description: "Control agent for the AI Development Environment",
   license: "MIT",
   repository: {
@@ -11753,6 +11812,7 @@ var PORTABLE_AGENT_CAPABILITIES = [
   CCUSAGE_REPORT_JOB_KIND,
   ...CODEBASE_JOB_KINDS,
   CODEBASE_RECONCILE_EVENT_CAPABILITY,
+  CODEBASE_DEFAULT_BRANCHES_CAPABILITY,
   ...WORKTREE_JOB_KINDS,
   WORKTREE_REVIEWED_SYNC_CAPABILITY,
   ...SKILL_JOB_KINDS,
@@ -45725,76 +45785,165 @@ var refreshCodebase = async (payload, timeoutMs, signal2) => {
     )
   };
 };
-async function updateBaseBranchAfterFetch(folder, baseBranch, timeoutMs, signal2) {
-  const localRef = `refs/heads/${baseBranch}`;
-  const remoteRef = `refs/remotes/origin/${baseBranch}`;
+async function updateBaseBranchAfterFetch(folder, baseBranch, timeoutMs, signal2, expectedOrigin, expectedGitDirectory) {
   try {
-    const validRef = await git2(
-      folder,
-      ["check-ref-format", localRef],
-      timeoutMs,
-      signal2
-    );
-    if (validRef.exitCode !== 0) return false;
-    const staged = await git2(
-      folder,
-      ["diff", "--cached", "--quiet"],
-      timeoutMs,
-      signal2
-    );
-    if (staged.exitCode !== 0) return false;
-    const remoteExists = await git2(
+    return await withRepositoryMetadata(
       folder,
-      ["show-ref", "--verify", "--quiet", remoteRef],
-      timeoutMs,
-      signal2
-    );
-    if (remoteExists.exitCode !== 0) return false;
-    const remoteTip = requireSuccess(
-      await git2(folder, ["rev-parse", remoteRef], timeoutMs, signal2),
-      "Could not pin the fetched base branch"
-    ).stdout.trim();
-    const currentBranch2 = await git2(
-      folder,
-      ["symbolic-ref", "--short", "-q", "HEAD"],
-      timeoutMs,
+      async () => {
+        if (expectedGitDirectory) {
+          const directory = await git2(
+            folder,
+            ["rev-parse", "--path-format=absolute", "--git-dir"],
+            timeoutMs,
+            signal2
+          );
+          if (directory.exitCode !== 0 || await realpath3(directory.stdout.trim()) !== expectedGitDirectory)
+            return false;
+        }
+        const current = await git2(
+          folder,
+          ["symbolic-ref", "--short", "-q", "HEAD"],
+          timeoutMs,
+          signal2
+        );
+        if (current.exitCode !== 0 || current.stdout.trim() !== baseBranch)
+          return false;
+        if (expectedOrigin) {
+          const remote = await git2(
+            folder,
+            ["remote", "get-url", "origin"],
+            timeoutMs,
+            signal2
+          );
+          if (remote.exitCode !== 0 || normalizeGitOrigin(remote.stdout.trim()).canonicalOrigin !== expectedOrigin)
+            return false;
+        }
+        const status2 = await git2(
+          folder,
+          [
+            "status",
+            "--porcelain=v1",
+            "-z",
+            "--untracked-files=all",
+            "--ignore-submodules=none"
+          ],
+          timeoutMs,
+          signal2
+        );
+        if (status2.exitCode !== 0 || status2.outputTruncated || status2.stdout)
+          return false;
+        for (const name of [
+          "MERGE_HEAD",
+          "rebase-merge",
+          "rebase-apply",
+          "CHERRY_PICK_HEAD",
+          "REVERT_HEAD"
+        ]) {
+          const path = await git2(
+            folder,
+            ["rev-parse", "--path-format=absolute", "--git-path", name],
+            timeoutMs,
+            signal2
+          );
+          if (path.exitCode !== 0) return false;
+          try {
+            await stat4(path.stdout.trim());
+            return false;
+          } catch (error) {
+            if (error.code !== "ENOENT") throw error;
+          }
+        }
+        const remoteRef = `refs/remotes/origin/${baseBranch}`;
+        const valid = await git2(
+          folder,
+          ["check-ref-format", remoteRef],
+          timeoutMs,
+          signal2
+        );
+        if (valid.exitCode !== 0) return false;
+        const tip = await git2(
+          folder,
+          ["rev-parse", "--verify", remoteRef],
+          timeoutMs,
+          signal2
+        );
+        if (tip.exitCode !== 0) return false;
+        const ancestor = await git2(
+          folder,
+          ["merge-base", "--is-ancestor", "HEAD", tip.stdout.trim()],
+          timeoutMs,
+          signal2
+        );
+        if (ancestor.exitCode !== 0) return false;
+        const branch = await git2(
+          folder,
+          ["symbolic-ref", "--short", "-q", "HEAD"],
+          timeoutMs,
+          signal2
+        );
+        if (branch.exitCode !== 0 || branch.stdout.trim() !== baseBranch)
+          return false;
+        return (await git2(
+          folder,
+          ["merge", "--ff-only", tip.stdout.trim()],
+          timeoutMs,
+          signal2
+        )).exitCode === 0;
+      },
       signal2
     );
-    if (currentBranch2.exitCode === 0 && currentBranch2.stdout.trim() === baseBranch) {
-      const merged = await git2(
-        folder,
-        ["merge", "--ff-only", remoteTip],
-        timeoutMs,
-        signal2
-      );
-      return merged.exitCode === 0;
-    }
-    const localExists = await git2(
+  } catch (error) {
+    if (signal2.aborted) throw error;
+    return false;
+  }
+}
+async function updateDefaultBranchesAfterFetch(folder, defaultBranch, patterns, timeoutMs, signal2, withCheckout, expectedOrigin) {
+  const listed = requireSuccess(
+    await git2(
       folder,
-      ["show-ref", "--verify", "--quiet", localRef],
+      ["worktree", "list", "--porcelain", "-z"],
       timeoutMs,
       signal2
-    );
-    if (localExists.exitCode === 0) {
-      const fastForward = await git2(
-        folder,
-        ["merge-base", "--is-ancestor", localRef, remoteTip],
-        timeoutMs,
-        signal2
+    ),
+    "Could not list worktrees"
+  );
+  if (listed.outputTruncated) return;
+  for (const block of listed.stdout.split("\0\0")) {
+    signal2.throwIfAborted();
+    const fields = block.split("\0");
+    if (fields.some((field) => field.startsWith("prunable")) || fields.includes("bare"))
+      continue;
+    const checkout = fields.find((field) => field.startsWith("worktree "))?.slice(9);
+    const branch = fields.find((field) => field.startsWith("branch refs/heads/"))?.slice(18);
+    if (!checkout || !isDefaultBranch(branch, defaultBranch, patterns))
+      continue;
+    try {
+      const path = await realpath3(checkout);
+      const directory = requireSuccess(
+        await git2(
+          path,
+          ["rev-parse", "--path-format=absolute", "--git-dir"],
+          timeoutMs,
+          signal2
+        ),
+        "Could not resolve worktree"
+      ).stdout.trim();
+      const expectedGitDirectory = await realpath3(directory);
+      await withCheckout(
+        path,
+        expectedGitDirectory,
+        () => updateBaseBranchAfterFetch(
+          path,
+          branch,
+          timeoutMs,
+          signal2,
+          expectedOrigin,
+          expectedGitDirectory
+        )
       );
-      if (fastForward.exitCode !== 0) return false;
-    } else if (localExists.exitCode !== 1) {
-      return false;
+    } catch (error) {
+      if (signal2.aborted) throw error;
     }
-    const updated = await git2(
-      folder,
-      ["branch", "--force", baseBranch, remoteTip],
-      timeoutMs,
-      signal2
-    );
-    return updated.exitCode === 0;
-  } catch {
-    return false;
   }
 }
 var fetchCodebase = async (payload, timeoutMs, signal2, onLog, context) => {
@@ -45833,46 +45982,37 @@ var fetchCodebase = async (payload, timeoutMs, signal2, onLog, context) => {
     if (error instanceof InterruptedGitInspection) return error.result;
     throw error;
   }
-  if (result.exitCode === 0 && input.keepBaseBranchUpToDate && input.baseBranch) {
-    await log2("Updating the base branch where it can be fast-forwarded");
-    const update = () => updateBaseBranchAfterFetch(
+  if (result.exitCode === 0 && input.keepBaseBranchUpToDate) {
+    await log2(
+      "Updating clean default branch worktrees from their matching origin branches"
+    );
+    await updateDefaultBranchesAfterFetch(
       input.folder,
-      input.baseBranch,
+      input.baseBranch ?? null,
+      input.defaultBranchPatterns ?? [],
       timeoutMs,
-      signal2
-    );
-    const gitDirectory2 = requireSuccess(
-      await git2(
-        input.folder,
-        ["rev-parse", "--path-format=absolute", "--git-dir"],
-        timeoutMs,
-        signal2
-      ),
-      "Could not resolve base worktree"
-    ).stdout.trim();
-    const grant = context?.tryWithOperationResources ? await context.tryWithOperationResources(
-      [
-        {
-          kind: "WORKTREE",
-          key: `${context.agentId}:worktree:${await realpath3(gitDirectory2)}`,
-          agentId: context.agentId,
-          codebaseId: input.codebaseId,
-          mode: "WRITE"
-        },
-        {
-          kind: "PATH",
-          key: input.folder,
-          path: input.folder,
-          agentId: context.agentId,
-          codebaseId: input.codebaseId,
-          mode: "WRITE"
-        }
-      ],
-      update
-    ) : { ran: true, result: await update() };
-    const updated = grant.ran && grant.result;
-    await log2(
-      updated ? "Base branch updated" : "Base branch left unchanged because it could not be safely fast-forwarded"
+      signal2,
+      (folder, gitDirectory2, update) => context?.tryWithOperationResources ? context.tryWithOperationResources(
+        [
+          {
+            kind: "WORKTREE",
+            key: `${context.agentId}:worktree:${gitDirectory2}`,
+            agentId: context.agentId,
+            codebaseId: input.codebaseId,
+            mode: "WRITE"
+          },
+          {
+            kind: "PATH",
+            key: folder,
+            path: folder,
+            agentId: context.agentId,
+            codebaseId: input.codebaseId,
+            mode: "WRITE"
+          }
+        ],
+        update
+      ) : update(),
+      input.expectedOrigin
     );
   }
   const afterResult = await inspectCodebaseProcess(
@@ -57465,22 +57605,43 @@ var CodebaseMonitor = class {
                   signal2
                 );
                 if (fetchResult.exitCode === 0) {
-                  if (codebase.keepBaseBranchUpToDate && codebase.defaultBranch) {
-                    const baseBranch = codebase.defaultBranch;
-                    await runExclusive(
-                      () => updateBaseBranchAfterFetch(
-                        codebase.folder,
-                        baseBranch,
-                        INSPECTION_TIMEOUT_MS,
-                        signal2
-                      )
-                    );
-                  }
                   snapshot = await this.inspectRoot(codebase, signal2);
                 } else {
                   fetchError = (fetchResult.stderr || "Git fetch failed").replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1").slice(0, 2e3);
                 }
               }
+              if (snapshot.availability === "AVAILABLE" && codebase.keepBaseBranchUpToDate && !signal2.aborted) {
+                await updateDefaultBranchesAfterFetch(
+                  codebase.folder,
+                  codebase.defaultBranch,
+                  codebase.defaultBranchPatterns ?? [],
+                  INSPECTION_TIMEOUT_MS,
+                  signal2,
+                  (folder, gitDirectory2, update) => this.agentId ? this.repositoryCoordinator.tryWithResources(
+                    [
+                      {
+                        kind: "WORKTREE",
+                        key: `${this.agentId}:worktree:${gitDirectory2}`,
+                        agentId: this.agentId,
+                        codebaseId: codebase.id,
+                        mode: "WRITE"
+                      },
+                      {
+                        kind: "PATH",
+                        key: folder,
+                        path: folder,
+                        agentId: this.agentId,
+                        codebaseId: codebase.id,
+                        mode: "WRITE"
+                      }
+                    ],
+                    update,
+                    signal2
+                  ) : runExclusive(update),
+                  codebase.canonicalOrigin
+                );
+                snapshot = await this.inspectRoot(codebase, signal2);
+              }
               let inventory;
               try {
                 inventory = await discoverWorktrees(

package/package.json

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