workon 3.7.1 → 3.8.0

package/README.md

@@ -219,6 +219,9 @@ workon worktree status
 # Merge this worktree's branch into main/master
 workon worktree merge
 
+# Recycle worktree for the next task (ff to latest main)
+workon worktree recycle
+
 # Remove this worktree (shows instructions to exit first)
 workon worktree remove
 ```
@@ -359,6 +362,8 @@ workon myproject::feat-x              # all events in worktree
 | `worktree merge` | `-i, --into <branch>` | Sets target branch explicitly |
 | `worktree merge` | `-s, --squash` | Uses squash merge (default: regular merge) |
 | `worktree merge` | `--delete-branch` | Deletes merged branch (avoids prompt) |
+| `worktree recycle` | `[branch]` | Remote branch to fast-forward to (auto-detects main/master/develop/dev) |
+| `worktree recycle` | `-y, --yes` | Skips confirmation prompt |
 | `worktree remove` | `-y, --yes` | Skips confirmation prompt |
 | `worktree remove` | `-f, --force` | Force-removes with uncommitted changes |
 
@@ -386,8 +391,11 @@ workon worktrees add my-feature
 
 # 4. Push, create a PR, get it reviewed and merged
 
-# 5. Tear down the worktree
+# 5a. Tear down the worktree
 workon worktrees remove my-feature
+
+# 5b. Or recycle for the next task (ff to latest main, keep worktree)
+workon worktree recycle
 ```
 
 **Automated workflow (non-interactive, agent-friendly):**
@@ -407,8 +415,11 @@ workon worktrees add my-feature -b main -y -o
 workon worktrees branch my-feature pr-branch -y -p
 # ... PR merged via gh/API ...
 
-# 5. Tear down: remove worktree and delete the branch
+# 5a. Tear down: remove worktree and delete the branch
 workon worktrees remove my-feature -y
+
+# 5b. Or recycle: ff to latest main and reuse for the next task
+workon worktree recycle -y
 ```
 
 The key difference is that every step in the automated version completes without waiting for user input, making it safe to chain together in scripts or have an AI agent drive the entire flow.

package/dist/cli.js

@@ -4899,6 +4899,20 @@ function createWorktreeCommand(ctx) {
     }
     await removeCurrentWorktree(worktreeInfo, options, ctx);
   });
+  command.command("recycle").description(
+    "Recycle this worktree for the next task: switch to its original branch and fast-forward to a remote branch"
+  ).argument("[branch]", "Remote branch to fast-forward to (auto-detects default)").option("-y, --yes", "Skip confirmation prompt").action(async (branch, options) => {
+    const worktreeInfo = await detectWorktreeContext();
+    if (!worktreeInfo) {
+      log.error("Not in a git repository.");
+      process.exit(1);
+    }
+    if (!worktreeInfo.isWorktree) {
+      log.error("You're in the main repository, not a worktree.");
+      process.exit(1);
+    }
+    await recycleCurrentWorktree(worktreeInfo, branch, options, ctx);
+  });
   return command;
 }
 async function showWorktreeStatus(worktreeInfo, log) {
@@ -4939,6 +4953,7 @@ ${chalk8.bold("Changes:")}`);
   console.log(`
 ${chalk8.bold("Commands:")}`);
   console.log(`  workon worktree merge   - Merge this branch and remove worktree`);
+  console.log(`  workon worktree recycle - Reset worktree for the next task`);
   console.log(`  workon worktree remove  - Remove this worktree`);
   console.log();
 }
@@ -5121,6 +5136,127 @@ To remove this worktree:`);
     )
   );
 }
+async function getWorktreeOriginalBranch(mainRepoPath, worktreeName) {
+  try {
+    const manager = new WorktreeManager(mainRepoPath);
+    const worktree = await manager.get(worktreeName);
+    if (worktree && worktree.branch && worktree.branch !== "(detached)") {
+      return worktree.branch;
+    }
+    const git = simpleGit5(mainRepoPath);
+    const branches = await git.branchLocal();
+    for (const branchName of branches.all) {
+      if (branchName.replace(/\//g, "-") === worktreeName) {
+        return branchName;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function detectDefaultRemoteBranch(git) {
+  const candidates = ["main", "master", "develop", "dev"];
+  try {
+    const remoteRefs = await git.raw(["ls-remote", "--heads", "origin"]);
+    const refNames = new Set(
+      remoteRefs.trim().split("\n").filter((line) => line.includes("refs/heads/")).map((line) => line.replace(/.*refs\/heads\//, ""))
+    );
+    for (const candidate of candidates) {
+      if (refNames.has(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function recycleCurrentWorktree(worktreeInfo, targetBranch, options, ctx) {
+  const { log } = ctx;
+  if (!worktreeInfo.worktreePath || !worktreeInfo.worktreeName) {
+    log.error("Unable to determine worktree info.");
+    process.exit(1);
+  }
+  if (worktreeInfo.branch === "(detached)") {
+    log.error("Worktree is in detached HEAD state.");
+    log.info("Use 'git checkout <branch>' to switch to a branch first.");
+    process.exit(1);
+  }
+  const git = simpleGit5(worktreeInfo.worktreePath);
+  const originalBranch = await getWorktreeOriginalBranch(
+    worktreeInfo.mainRepoPath,
+    worktreeInfo.worktreeName
+  );
+  if (!originalBranch) {
+    log.error("Unable to determine the branch associated with this worktree.");
+    process.exit(1);
+  }
+  if (!targetBranch) {
+    const detected = await detectDefaultRemoteBranch(git);
+    if (!detected) {
+      log.error("Could not detect default remote branch (tried main, master, develop, dev).");
+      log.info("Specify the branch explicitly: workon worktree recycle <branch>");
+      process.exit(1);
+    }
+    targetBranch = detected;
+  }
+  const status = await git.status();
+  const hasChanges = status.modified.length > 0 || status.not_added.length > 0 || status.deleted.length > 0 || status.staged.length > 0 || status.created.length > 0 || status.renamed.length > 0 || status.conflicted.length > 0;
+  if (hasChanges) {
+    log.error("This worktree has uncommitted changes.");
+    log.info("Please commit, stash, or discard your changes before recycling.");
+    process.exit(1);
+  }
+  const alreadyOnBranch = worktreeInfo.branch === originalBranch;
+  if (!options.yes) {
+    console.log(`
+${chalk8.bold("Recycle worktree:")}`);
+    console.log(`  Worktree:  ${chalk8.cyan(worktreeInfo.worktreeName)}`);
+    if (alreadyOnBranch) {
+      console.log(`  Branch:    ${chalk8.green(originalBranch)} (already on it)`);
+    } else {
+      console.log(`  Current:   ${chalk8.yellow(worktreeInfo.branch)}`);
+      console.log(`  Switch to: ${chalk8.green(originalBranch)}`);
+    }
+    console.log(`  FF from:   ${chalk8.green(`origin/${targetBranch}`)}`);
+    console.log();
+    const shouldProceed = await confirm11({
+      message: "Proceed?",
+      default: true
+    });
+    if (!shouldProceed) {
+      log.info("Recycle cancelled.");
+      return;
+    }
+  }
+  const spinner = ora5("Fetching latest from remote...").start();
+  try {
+    await git.fetch("origin", targetBranch);
+    if (!alreadyOnBranch) {
+      spinner.text = `Switching to branch '${originalBranch}'...`;
+      await git.checkout(originalBranch);
+    }
+    spinner.text = `Fast-forwarding '${originalBranch}' to origin/${targetBranch}...`;
+    await git.merge([`origin/${targetBranch}`, "--ff-only"]);
+    spinner.succeed(`Recycled! '${originalBranch}' is now at the tip of origin/${targetBranch}`);
+    console.log(chalk8.green("\nWorktree is ready for the next task."));
+  } catch (error) {
+    const message = error.message;
+    spinner.fail("Recycle failed.");
+    if (message.includes("ff-only")) {
+      log.error(
+        `Cannot fast-forward '${originalBranch}' to origin/${targetBranch}. The branch has diverged.`
+      );
+      log.info("You may need to reset or rebase manually.");
+    } else if (message.includes("did not match any")) {
+      log.error(`Remote branch 'origin/${targetBranch}' not found.`);
+    } else {
+      log.error(message);
+    }
+    process.exit(1);
+  }
+}
 
 // src/commands/index.ts
 var __filename = fileURLToPath(import.meta.url);