@ai-development-environment/control-agent 0.0.79 → 0.0.80

package/dist/control-agent.js

@@ -6106,6 +6106,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_COMMIT_JOB_KIND = "worktree.commit";
 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";
@@ -6119,6 +6120,7 @@ var WORKTREE_DIFF_ASSET_JOB_KIND = "worktree.diff.asset";
 var WORKTREE_JOB_KINDS = [
   WORKTREE_INSPECT_JOB_KIND,
   WORKTREE_OPERATION_JOB_KIND,
+  WORKTREE_COMMIT_JOB_KIND,
   WORKTREE_AUTO_SYNC_JOB_KIND,
   WORKTREE_GIT_INSPECT_JOB_KIND,
   WORKTREE_GIT_OPERATION_JOB_KIND,
@@ -6145,6 +6147,7 @@ var WORKTREE_OPERATIONS = [
   "SYNC",
   "REBASE",
   "CANCEL_REBASE",
+  "PULL",
   "PUSH",
   "RESET",
   "STASH_ALL",
@@ -6463,6 +6466,71 @@ function worktreeDeleteJobPayload(value) {
     expectedHeadSha
   };
 }
+function worktreeCommitJobPayload(value) {
+  const payload = objectValue4(value, "worktree commit payload");
+  const allowed = /* @__PURE__ */ new Set([
+    "codebaseId",
+    "folder",
+    "gitDirectory",
+    "expectedOrigin",
+    "baseBranch",
+    "message",
+    "signed",
+    "stageAll",
+    "paths"
+  ]);
+  const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
+  if (unexpected) {
+    throw new Error(`Unexpected worktree commit payload field: ${unexpected}`);
+  }
+  const message = stringValue4(
+    payload.message,
+    "worktree commit payload.message"
+  );
+  if (!message.trim()) throw new Error("Commit message must not be blank");
+  if (message.length > 5e4) throw new Error("Commit message is too long");
+  if (payload.signed !== null && typeof payload.signed !== "boolean") {
+    throw new Error("worktree commit payload.signed must be a boolean or null");
+  }
+  if (typeof payload.stageAll !== "boolean") {
+    throw new Error("worktree commit payload.stageAll must be a boolean");
+  }
+  if (!Array.isArray(payload.paths) || payload.paths.length > 500) {
+    throw new Error("worktree commit payload.paths is invalid");
+  }
+  const paths = payload.paths.map(
+    (path, index) => safeRelativePath(path, `worktree commit payload.paths[${index}]`)
+  );
+  if (new Set(paths).size !== paths.length) {
+    throw new Error("worktree commit payload.paths must be unique");
+  }
+  if (!payload.stageAll && paths.length === 0) {
+    throw new Error("A partial commit requires at least one path");
+  }
+  return {
+    codebaseId: stringValue4(
+      payload.codebaseId,
+      "worktree commit payload.codebaseId"
+    ),
+    folder: stringValue4(payload.folder, "worktree commit payload.folder"),
+    gitDirectory: stringValue4(
+      payload.gitDirectory,
+      "worktree commit payload.gitDirectory"
+    ),
+    expectedOrigin: stringValue4(
+      payload.expectedOrigin,
+      "worktree commit payload.expectedOrigin"
+    ),
+    baseBranch: nullableString3(
+      payload.baseBranch,
+      "worktree commit payload.baseBranch"
+    ),
+    message,
+    signed: payload.signed,
+    stageAll: payload.stageAll,
+    paths
+  };
+}
 function worktreeJobPayload(value) {
   const payload = objectValue4(value, "worktree payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -15164,10 +15232,16 @@ async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
   return { commits: commits.slice(0, 100), truncated: commits.length > 100 };
 }
 async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
-  const [commitResult, changeResult, branchResult] = await Promise.all([
+  const [commitResult, changeResult, branchResult, signingResult] = await Promise.all([
     inspectCommits(folder, baseBranch, timeoutMs, signal),
     inspectChanges(folder, timeoutMs, signal),
-    inspectBranchChanges(folder, baseBranch, timeoutMs, signal)
+    inspectBranchChanges(folder, baseBranch, timeoutMs, signal),
+    git3(
+      folder,
+      ["config", "--bool", "--get", "commit.gpgsign"],
+      timeoutMs,
+      signal
+    )
   ]);
   return {
     commits: commitResult.commits,
@@ -15175,7 +15249,8 @@ async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
     branchChanges: branchResult.changes,
     commitsTruncated: commitResult.truncated,
     changesTruncated: changeResult.truncated,
-    branchChangesTruncated: branchResult.truncated
+    branchChangesTruncated: branchResult.truncated,
+    commitSigningEnabled: signingResult.exitCode === 0 && signingResult.stdout.trim() === "true"
   };
 }
 async function baseMergeCommit(folder, baseBranch, timeoutMs, signal) {
@@ -15701,6 +15776,97 @@ var inspectWorktreeGit = async (payload, timeoutMs, signal) => {
     )
   };
 };
+var commitWorktree = async (payload, timeoutMs, signal) => {
+  const input = worktreeCommitJobPayload(payload);
+  const folder = await validateWorktree2(input, timeoutMs, signal);
+  const runGit = async (args, fallback) => requireSuccess3(await git3(folder, args, timeoutMs, signal), fallback);
+  if (input.stageAll) {
+    await runGit(["add", "--all"], "Could not stage worktree changes");
+  } else {
+    const current = await inspectChanges(folder, timeoutMs, signal);
+    const byPath = new Map(
+      current.changes.map((change) => [change.path, change])
+    );
+    const selected = input.paths.map((path) => {
+      const change = byPath.get(path);
+      if (!change) throw new Error(`Worktree change no longer exists: ${path}`);
+      return change;
+    });
+    const head = await git3(
+      folder,
+      ["rev-parse", "--verify", "HEAD"],
+      timeoutMs,
+      signal
+    );
+    if (head.exitCode === 0) {
+      await runGit(
+        ["reset", "--mixed", "HEAD", "--"],
+        "Could not reset the Git index"
+      );
+    } else {
+      await runGit(
+        ["rm", "--cached", "-r", "--ignore-unmatch", "."],
+        "Could not reset the Git index"
+      );
+    }
+    const selectedPaths = [
+      ...new Set(
+        selected.flatMap(
+          (change) => change.previousPath ? [change.previousPath, change.path] : [change.path]
+        )
+      )
+    ];
+    await runGit(
+      ["--literal-pathspecs", "add", "--all", "--", ...selectedPaths],
+      "Could not stage selected worktree changes"
+    );
+  }
+  const staged = await git3(
+    folder,
+    ["diff", "--cached", "--quiet", "--exit-code"],
+    timeoutMs,
+    signal
+  );
+  if (staged.exitCode === 0) throw new Error("No staged changes to commit");
+  if (staged.exitCode !== 1)
+    requireSuccess3(staged, "Could not inspect staged changes");
+  let signed = input.signed;
+  if (signed === null) {
+    const configured = await git3(
+      folder,
+      ["config", "--bool", "--get", "commit.gpgsign"],
+      timeoutMs,
+      signal
+    );
+    signed = configured.exitCode === 0 && configured.stdout.trim() === "true";
+  }
+  await runGit(
+    ["commit", signed ? "--gpg-sign" : "--no-gpg-sign", "-m", input.message],
+    "Commit failed"
+  );
+  const sha = runGit(["rev-parse", "HEAD"], "Could not read the new commit");
+  const subject = runGit(
+    ["log", "-1", "--format=%s"],
+    "Could not read the new commit subject"
+  );
+  const [shaResult, subjectResult] = await Promise.all([sha, subject]);
+  return {
+    ...successfulProcess8,
+    commit: {
+      sha: shaResult.stdout.trim(),
+      subject: subjectResult.stdout.trim(),
+      signed
+    },
+    worktree: await inspectWorktreeItem(
+      folder,
+      folder,
+      input.baseBranch,
+      false,
+      Math.min(timeoutMs, 3e4),
+      signal
+    )
+  };
+};
 var operateWorktreeGit = async (payload, timeoutMs, signal) => {
   const input = worktreeGitOperationPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
@@ -16456,6 +16622,14 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       await runGit(["rebase", "--abort"], "Could not cancel rebase");
       break;
     }
+    case "PULL": {
+      if (!branch || !upstream)
+        throw new Error("Pull requires a branch with an upstream");
+      const remote = upstream.split("/")[0] || "origin";
+      await runGit(["fetch", remote], `Could not fetch ${remote}`);
+      await runGit(["merge", "--ff-only", "@{upstream}"], "Pull failed");
+      break;
+    }
     case "PUSH":
       if (!branch) throw new Error("Push requires a branch");
       await runGit(
@@ -16735,6 +16909,7 @@ var handlers = {
   [WORKTREE_INSPECT_JOB_KIND]: inspectWorktree,
   [WORKTREE_AUTO_SYNC_JOB_KIND]: autoSyncWorktree,
   [WORKTREE_BRANCH_JOB_KIND]: branchWorktree,
+  [WORKTREE_COMMIT_JOB_KIND]: commitWorktree,
   [WORKTREE_MOVE_PUSH_JOB_KIND]: pushMovedWorktree,
   [WORKTREE_MOVE_CHECKOUT_JOB_KIND]: checkoutMovedWorktree,
   [WORKTREE_DELETE_JOB_KIND]: deleteWorktree,

package/package.json

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