@ai-development-environment/control-agent 0.0.114 → 0.0.115

package/dist/control-agent.js

@@ -5265,6 +5265,14 @@ var AgentGraphQLClient = class {
       { jobId, logs: [log2] }
     );
   }
+  reportBranchDeletionResult(jobId, result) {
+    return this.request(
+      `mutation ReportBranchDeletionResult($jobId: ID!, $result: BranchDeletionResultInput!) {
+        reportBranchDeletionResult(jobId: $jobId, result: $result) { id }
+      }`,
+      { jobId, result }
+    );
+  }
   appendCommandOutput(jobId, attemptId, chunks) {
     return this.request(
       `mutation AppendCommandRunOutput($jobId: ID!, $attemptId: ID!, $chunks: [CommandRunOutputInput!]!) {
@@ -6175,6 +6183,7 @@ var CODEBASE_CLONE_JOB_KIND = "codebase.clone";
 var CODEBASE_CLONE_INSPECT_JOB_KIND = "codebase.clone.inspect";
 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 MAX_CODEBASE_GIT_BRANCHES = 1e3;
 var MAX_CODEBASE_STASHES = 200;
@@ -6198,8 +6207,99 @@ var CODEBASE_JOB_KINDS = [
   CODEBASE_CLONE_JOB_KIND,
   CODEBASE_CLONE_INSPECT_JOB_KIND,
   CODEBASE_GIT_INSPECT_JOB_KIND,
-  CODEBASE_GIT_OPERATION_JOB_KIND
+  CODEBASE_GIT_OPERATION_JOB_KIND,
+  CODEBASE_BRANCHES_DELETE_JOB_KIND
 ];
+function branchHeadSha(value) {
+  if (typeof value !== "string" || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(value)) {
+    throw new Error("Invalid branch tip SHA");
+  }
+  return value.toLowerCase();
+}
+function parseCodebaseBranchTarget(value) {
+  const target2 = objectValue3(value, "branch target");
+  const branch = stringValue3(target2.branch, "branch target.branch");
+  if (!validCodebaseGitBranchName(branch))
+    throw new Error("Invalid Git branch name");
+  return {
+    codebaseId: stringValue3(target2.codebaseId, "branch target.codebaseId"),
+    branch,
+    expectedHeadSha: branchHeadSha(target2.expectedHeadSha)
+  };
+}
+function parseLocalBranchInventory(value) {
+  const inventory = objectValue3(value, "local branch inventory");
+  const scannedAt = stringValue3(inventory.scannedAt, "inventory.scannedAt");
+  if (!Number.isFinite(Date.parse(scannedAt)) || !Array.isArray(inventory.branches)) {
+    throw new Error("Invalid local branch inventory");
+  }
+  const names = /* @__PURE__ */ new Set();
+  return {
+    scannedAt: new Date(scannedAt).toISOString(),
+    branches: inventory.branches.map((value2) => {
+      const branch = objectValue3(value2, "local branch");
+      const name = stringValue3(branch.name, "local branch.name");
+      if (!validCodebaseGitBranchName(name) || names.has(name))
+        throw new Error("Invalid or duplicate local branch");
+      names.add(name);
+      const lastCommitAt = nullableString2(
+        branch.lastCommitAt,
+        "local branch.lastCommitAt"
+      );
+      if (lastCommitAt && !Number.isFinite(Date.parse(lastCommitAt)))
+        throw new Error("Invalid local commit date");
+      return {
+        name,
+        headSha: branchHeadSha(branch.headSha),
+        lastCommitAt,
+        lastCommitMessage: nullableString2(
+          branch.lastCommitMessage,
+          "local branch.lastCommitMessage"
+        ),
+        current: booleanValue(branch.current, "local branch.current"),
+        checkedOutPath: nullableString2(
+          branch.checkedOutPath,
+          "local branch.checkedOutPath"
+        )
+      };
+    })
+  };
+}
+function codebaseBranchesDeletePayload(value) {
+  const payload = objectValue3(value, "local branch deletion payload");
+  const allowed = /* @__PURE__ */ new Set([
+    "codebaseId",
+    "folder",
+    "expectedOrigin",
+    "defaultBranch",
+    "force",
+    "targets"
+  ]);
+  if (Object.keys(payload).some((key) => !allowed.has(key)))
+    throw new Error("Unexpected local branch deletion field");
+  const codebaseId = stringValue3(payload.codebaseId, "payload.codebaseId");
+  if (!Array.isArray(payload.targets) || !payload.targets.length)
+    throw new Error("Branch targets are required");
+  const targets = payload.targets.map(parseCodebaseBranchTarget);
+  if (targets.some((target2) => target2.codebaseId !== codebaseId))
+    throw new Error("Branch target belongs to another codebase");
+  if (new Set(targets.map((target2) => target2.branch)).size !== targets.length)
+    throw new Error("Duplicate branch target");
+  return {
+    codebaseId,
+    folder: stringValue3(payload.folder, "payload.folder"),
+    expectedOrigin: stringValue3(
+      payload.expectedOrigin,
+      "payload.expectedOrigin"
+    ),
+    defaultBranch: nullableString2(
+      payload.defaultBranch,
+      "payload.defaultBranch"
+    ),
+    force: booleanValue(payload.force, "payload.force"),
+    targets
+  };
+}
 function objectValue3(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`${name} must be an object`);
@@ -9964,46 +10064,82 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
   }
 };
 
-// src/handlers/codebase-clone.ts
-import {
-  lstat,
-  mkdir as mkdir2,
-  mkdtemp as mkdtemp2,
-  realpath as realpath3,
-  rename as rename2,
-  rm as rm3,
-  rmdir
-} from "node:fs/promises";
-import {
-  dirname as dirname3,
-  isAbsolute as isAbsolute2,
-  join as join4,
-  parse,
-  relative as relative2,
-  resolve as resolve3,
-  sep as sep2
-} from "node:path";
-
-// src/repository-coordinator.ts
-var RepositoryCoordinator = class {
-  tails = /* @__PURE__ */ new Map();
-  async run(key, task) {
-    const previous = this.tails.get(key) ?? Promise.resolve();
-    let release2;
-    const current = new Promise((resolve11) => {
-      release2 = resolve11;
-    });
-    const tail = previous.then(() => current);
-    this.tails.set(key, tail);
-    await previous;
-    try {
-      return await task();
-    } finally {
-      release2();
-      if (this.tails.get(key) === tail) this.tails.delete(key);
-    }
+// src/handlers/local-branches.ts
+var branchError = (error) => (error instanceof Error ? error.message : String(error)).replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1").slice(0, 2e3);
+async function branchGit(folder, args, timeoutMs, signal) {
+  const result = await captureCommand({
+    command: "git",
+    args: ["-C", folder, ...args],
+    timeoutMs,
+    signal,
+    maxOutputBytes: 16 * 1024 * 1024,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.cancelled || result.timedOut)
+    throw new Error(
+      result.cancelled ? "Branch operation cancelled" : "Branch operation timed out"
+    );
+  if (result.outputTruncated)
+    throw new Error(
+      "Local branch inventory exceeded the output limit; the previous inventory was retained"
+    );
+  return result;
+}
+async function scanLocalBranches(folder, timeoutMs, signal, branch) {
+  const [current, refs] = await Promise.all([
+    branchGit(
+      folder,
+      ["symbolic-ref", "--short", "-q", "HEAD"],
+      timeoutMs,
+      signal
+    ),
+    branchGit(
+      folder,
+      [
+        "for-each-ref",
+        "--format=%(refname:strip=2)%00%(objectname)%00%(committerdate:iso-strict)%00%(contents:subject)%00%(worktreepath)",
+        branch ? `refs/heads/${branch}` : "refs/heads"
+      ],
+      timeoutMs,
+      signal
+    )
+  ]);
+  if (refs.exitCode !== 0)
+    throw new Error(
+      branchError(refs.stderr || "Could not inspect local branches")
+    );
+  return parseLocalBranchInventory({
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    branches: refs.stdout.split("\n").filter(Boolean).map((line) => {
+      const [name, headSha, date, subject, path] = line.split("\0");
+      return {
+        name,
+        headSha,
+        lastCommitAt: date && Number.isFinite(Date.parse(date)) ? new Date(date).toISOString() : null,
+        lastCommitMessage: subject?.slice(0, 2e3) || null,
+        current: current.exitCode === 0 && name === current.stdout.trim(),
+        checkedOutPath: path || null
+      };
+    }).filter((item) => !branch || item.name === branch)
+  });
+}
+async function localBranchReport(folder, timeoutMs, signal, unavailable) {
+  const localBranchInventoryAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    if (unavailable) throw new Error(unavailable);
+    return {
+      localBranchInventoryAttemptedAt,
+      localBranchInventory: await scanLocalBranches(folder, timeoutMs, signal),
+      localBranchInventoryError: null
+    };
+  } catch (error) {
+    return {
+      localBranchInventoryAttemptedAt,
+      localBranchInventory: null,
+      localBranchInventoryError: branchError(error)
+    };
   }
-};
+}
 
 // src/handlers/codebases.ts
 import { readdir, realpath as realpath2, stat as stat2 } from "node:fs/promises";
@@ -10305,7 +10441,26 @@ var inspectCodebaseFolder = async (payload, timeoutMs, signal) => {
   const input = codebaseJobPayload(payload);
   return inspectCodebaseProcess(input.folder, timeoutMs, signal);
 };
-var refreshCodebase = inspectCodebaseFolder;
+var refreshCodebase = async (payload, timeoutMs, signal) => {
+  const input = codebaseJobPayload(payload);
+  const result = await inspectCodebaseProcess(
+    input.folder,
+    timeoutMs,
+    signal,
+    input.expectedOrigin
+  );
+  if (!("snapshot" in result)) return result;
+  const snapshot = result.snapshot;
+  return {
+    ...result,
+    ...await localBranchReport(
+      snapshot.folder,
+      Math.min(timeoutMs, 3e4),
+      signal,
+      snapshot.availability === "AVAILABLE" ? void 0 : snapshot.error || "Codebase is unavailable"
+    )
+  };
+};
 async function updateBaseBranchAfterFetch(folder, baseBranch, timeoutMs, signal) {
   const localRef = `refs/heads/${baseBranch}`;
   const remoteRef = `refs/remotes/origin/${baseBranch}`;
@@ -10462,6 +10617,12 @@ var fetchCodebase = async (payload, timeoutMs, signal, onLog, context) => {
     cancelled: result.cancelled || signal.aborted,
     snapshot,
     ...worktreesRefreshedAt ? { worktreesRefreshedAt } : {},
+    ...await localBranchReport(
+      snapshot.folder,
+      Math.min(timeoutMs, 3e4),
+      signal,
+      snapshot.availability === "AVAILABLE" ? void 0 : snapshot.error || "Codebase is unavailable"
+    ),
     ...worktreeRefreshError ? { worktreeRefreshError } : {}
   };
 };
@@ -10914,10 +11075,162 @@ var operateCodebaseGit = async (payload, timeoutMs, signal) => {
       folder,
       Math.min(timeoutMs, 3e4),
       signal
-    )
+    ),
+    ...await localBranchReport(folder, Math.min(timeoutMs, 3e4), signal)
+  };
+};
+
+// src/handlers/branches.ts
+var deleteLocalBranches = async (payload, timeoutMs, signal, _onLog, context) => {
+  const input = codebaseBranchesDeletePayload(payload);
+  const deadline = Date.now() + timeoutMs;
+  const remaining = () => Math.max(0, Math.min(3e4, deadline - Date.now()));
+  const branchDeletionResults = [];
+  for (const target2 of input.targets) {
+    const outcome = {
+      codebaseId: input.codebaseId,
+      branch: target2.branch,
+      outcome: "SKIPPED",
+      reason: null
+    };
+    try {
+      if (signal.aborted || remaining() <= 0)
+        throw new Error(
+          "Branch operation interrupted; refresh before retrying"
+        );
+      const snapshot2 = await inspectCodebase(
+        input.folder,
+        remaining(),
+        signal,
+        input.expectedOrigin
+      );
+      if (snapshot2.availability !== "AVAILABLE")
+        throw new Error(snapshot2.error || "Codebase is unavailable");
+      const inventory = await scanLocalBranches(
+        snapshot2.folder,
+        remaining(),
+        signal,
+        target2.branch
+      );
+      const selected = inventory.branches.find(
+        (branch) => branch.name === target2.branch
+      );
+      const remoteHead = await branchGit(
+        snapshot2.folder,
+        ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+        remaining(),
+        signal
+      );
+      const localDefault = remoteHead.exitCode === 0 ? remoteHead.stdout.trim().replace(/^origin\//, "") : null;
+      if (!selected) outcome.reason = "Local branch no longer exists";
+      else if (selected.headSha !== target2.expectedHeadSha)
+        outcome.reason = "Branch tip changed; refresh and select it again";
+      else if (selected.current)
+        outcome.reason = "The current branch cannot be deleted";
+      else if (selected.name === input.defaultBranch || selected.name === localDefault)
+        outcome.reason = "The default branch cannot be deleted";
+      else if (selected.checkedOutPath)
+        outcome.reason = `Branch is checked out at ${selected.checkedOutPath}`;
+      else if (!input.defaultBranch && !localDefault)
+        outcome.reason = "The default branch is unknown; configure it before cleanup";
+      else {
+        const deleted = await branchGit(
+          snapshot2.folder,
+          ["branch", input.force ? "-D" : "--delete", "--", selected.name],
+          remaining(),
+          signal
+        );
+        outcome.outcome = deleted.exitCode === 0 ? "DELETED" : "FAILED";
+        outcome.reason = deleted.exitCode === 0 ? null : branchError(
+          deleted.stderr || "Could not safely delete local branch"
+        );
+      }
+    } catch (error) {
+      outcome.outcome = "FAILED";
+      outcome.reason = branchError(error);
+    }
+    branchDeletionResults.push(outcome);
+    try {
+      if (!signal.aborted && remaining() > 0)
+        await context?.reportBranchDeletionResult?.(outcome);
+    } catch {
+    }
+  }
+  const localBranchInventoryAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let localBranchInventory = null;
+  let localBranchInventoryError = null;
+  let snapshot;
+  try {
+    snapshot = await inspectCodebase(
+      input.folder,
+      remaining(),
+      signal,
+      input.expectedOrigin
+    );
+    if (snapshot.availability !== "AVAILABLE")
+      throw new Error(snapshot.error || "Codebase is unavailable");
+    localBranchInventory = await scanLocalBranches(
+      snapshot.folder,
+      remaining(),
+      signal
+    );
+  } catch (error) {
+    localBranchInventoryError = branchError(error);
+  }
+  return {
+    exitCode: 0,
+    signal: null,
+    cancelled: signal.aborted,
+    timedOut: !signal.aborted && Date.now() >= deadline,
+    ...snapshot ? { snapshot } : {},
+    branchDeletionResults,
+    localBranchInventory,
+    localBranchInventoryError,
+    localBranchInventoryAttemptedAt
   };
 };
 
+// src/handlers/codebase-clone.ts
+import {
+  lstat,
+  mkdir as mkdir2,
+  mkdtemp as mkdtemp2,
+  realpath as realpath3,
+  rename as rename2,
+  rm as rm3,
+  rmdir
+} from "node:fs/promises";
+import {
+  dirname as dirname3,
+  isAbsolute as isAbsolute2,
+  join as join4,
+  parse,
+  relative as relative2,
+  resolve as resolve3,
+  sep as sep2
+} from "node:path";
+
+// src/repository-coordinator.ts
+var RepositoryCoordinator = class {
+  tails = /* @__PURE__ */ new Map();
+  async run(key, task) {
+    const previous = this.tails.get(key) ?? Promise.resolve();
+    let release2;
+    const current = new Promise((resolve11) => {
+      release2 = resolve11;
+    });
+    const tail = previous.then(() => current);
+    this.tails.set(key, tail);
+    await previous;
+    try {
+      return await task();
+    } finally {
+      release2();
+      if (this.tails.get(key) === tail) this.tails.delete(key);
+    }
+  }
+};
+
 // src/handlers/codebase-clone.ts
 var destinations = new RepositoryCoordinator();
 var success = {
@@ -20432,6 +20745,7 @@ var handlers = {
   [CODEBASE_FETCH_JOB_KIND]: fetchCodebase,
   [CODEBASE_GIT_INSPECT_JOB_KIND]: inspectCodebaseGit,
   [CODEBASE_GIT_OPERATION_JOB_KIND]: operateCodebaseGit,
+  [CODEBASE_BRANCHES_DELETE_JOB_KIND]: deleteLocalBranches,
   [WORKTREE_INSPECT_JOB_KIND]: inspectWorktree,
   [WORKTREE_AUTO_SYNC_JOB_KIND]: autoSyncWorktree,
   [WORKTREE_BRANCH_JOB_KIND]: branchWorktree,
@@ -20579,6 +20893,7 @@ var JobExecutor = class {
         (log2) => this.client.appendLog(claimed.id, log2).then(() => void 0),
         {
           agentId: claimed.agentId,
+          reportBranchDeletionResult: (result2) => this.client.reportBranchDeletionResult(claimed.id, result2),
           reportWorktreeActivity: (input) => this.client.reportWorktreeActivity(input),
           refreshFetchedCodebase: (input) => refreshFetchedCodebase(
             this.client,
@@ -20727,8 +21042,29 @@ var CodebaseMonitor = class {
                 };
                 fetchError ??= error instanceof Error ? error.message.slice(0, 2e3) : String(error);
               }
+              const localBranchInventoryAttemptedAt = (/* @__PURE__ */ new Date()).toISOString();
+              let localBranchInventory = null;
+              let localBranchInventoryError = null;
+              try {
+                if (snapshot.availability !== "AVAILABLE")
+                  throw new Error(snapshot.error || "Codebase is unavailable");
+                localBranchInventory = await scanLocalBranches(
+                  codebase.folder,
+                  INSPECTION_TIMEOUT_MS,
+                  signal
+                );
+              } catch (error) {
+                localBranchInventoryError = error instanceof Error ? error.message.slice(0, 2e3) : String(error).slice(0, 2e3);
+              }
+              if (signal.aborted) return;
               await this.client.reportCodebaseStatuses([
-                { codebaseId: codebase.id, snapshot }
+                {
+                  codebaseId: codebase.id,
+                  snapshot,
+                  localBranchInventory,
+                  localBranchInventoryError,
+                  localBranchInventoryAttemptedAt
+                }
               ]);
               await this.client.reportWorktrees([
                 {

package/package.json

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