workon 3.7.0 → 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

@@ -1275,7 +1275,7 @@ var init_tmux = __esm({
       getWorktreeSessionName(projectName, worktreeName) {
         const sanitizedProject = sanitizeForShell(projectName);
         const sanitizedWorktree = sanitizeForShell(worktreeName);
-        return `${this.sessionPrefix}${sanitizedProject}-${sanitizedWorktree}`;
+        return `${this.sessionPrefix}${sanitizedProject}_wt_${sanitizedWorktree}`;
       }
       async killSession(sessionName) {
         try {
@@ -3942,6 +3942,13 @@ async function processProject(projectParam, options, ctx) {
   const projects = config.getProjects();
   const environment = await EnvironmentRecognizer.recognize(File5.cwd());
   if (environment.$isProjectEnvironment && (projectName === "this" || projectName === ".")) {
+    if (worktreeName) {
+      log.error(
+        `Worktree syntax is not supported with '${projectName}'. Use the full project name instead:`
+      );
+      log.info(`  workon ${environment.project.name}::${worktreeName}`);
+      process.exit(1);
+    }
     log.info(`Opening current project: ${environment.project.name}`);
     await switchTo(environment, requestedCommands, options, ctx);
     return;
@@ -3969,7 +3976,7 @@ async function processProject(projectParam, options, ctx) {
       log.debug(`Using worktree path: ${worktree.path}`);
       projectEnv.project.overridePath(worktree.path);
     }
-    await switchTo(projectEnv, requestedCommands, options, ctx);
+    await switchTo(projectEnv, requestedCommands, options, ctx, worktreeName);
   } else {
     log.error(`Project '${projectName}' not found.`);
     log.info(`Run 'workon' without arguments to see available projects or create a new one.`);
@@ -3987,7 +3994,7 @@ Available commands: ${availableCommands}`
     );
   }
 }
-async function switchTo(environment, requestedCommands, options, ctx) {
+async function switchTo(environment, requestedCommands, options, ctx, worktreeName) {
   const { log } = ctx;
   const project = environment.project;
   let events;
@@ -4011,11 +4018,35 @@ async function switchTo(environment, requestedCommands, options, ctx) {
   const hasNpmEvent = events.includes("npm");
   const dryRun = options.dryRun || false;
   if (hasCwd && hasClaudeEvent && hasNpmEvent) {
-    await handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx);
+    await handleThreePaneLayout(
+      project,
+      isShellMode,
+      dryRun,
+      shellCommands,
+      events,
+      ctx,
+      worktreeName
+    );
   } else if (hasCwd && hasNpmEvent) {
-    await handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx);
+    await handleTwoPaneNpmLayout(
+      project,
+      isShellMode,
+      dryRun,
+      shellCommands,
+      events,
+      ctx,
+      worktreeName
+    );
   } else if (hasCwd && hasClaudeEvent) {
-    await handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx);
+    await handleSplitTerminal(
+      project,
+      isShellMode,
+      dryRun,
+      shellCommands,
+      events,
+      ctx,
+      worktreeName
+    );
   } else {
     for (const event of events) {
       if (!dryRun) {
@@ -4049,10 +4080,11 @@ async function getNpmCommand2(project) {
   const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
   return NpmEvent2.getNpmCommand(npmConfig);
 }
-async function handleTmuxLayout(project, layout, options, shellCommands, events, ctx) {
+async function handleTmuxLayout(project, layout, options, shellCommands, events, ctx, worktreeName) {
   const { log } = ctx;
   const tmux = new TmuxManager();
   const { isShellMode, dryRun } = options;
+  const tmuxSessionId = worktreeName ? `${project.name}_wt_${worktreeName}` : project.name;
   let tmuxHandled = false;
   if (isShellMode) {
     if (await tmux.isTmuxAvailable()) {
@@ -4068,7 +4100,7 @@ async function handleTmuxLayout(project, layout, options, shellCommands, events,
           shellCommands.push(...cmds);
         }
       }
-      const commands = buildLayoutShellCommands(tmux, project, layout);
+      const commands = buildLayoutShellCommands(tmux, tmuxSessionId, project, layout);
       shellCommands.push(...commands);
       tmuxHandled = true;
     } else {
@@ -4080,7 +4112,7 @@ async function handleTmuxLayout(project, layout, options, shellCommands, events,
   } else if (!dryRun) {
     if (await tmux.isTmuxAvailable()) {
       try {
-        const sessionName = await createTmuxSession(tmux, project, layout);
+        const sessionName = await createTmuxSession(tmux, tmuxSessionId, project, layout);
         await tmux.attachToSession(sessionName);
         tmuxHandled = true;
       } catch (error) {
@@ -4104,19 +4136,19 @@ async function handleTmuxLayout(project, layout, options, shellCommands, events,
     }
   }
 }
-function buildLayoutShellCommands(tmux, project, layout) {
+function buildLayoutShellCommands(tmux, sessionId, project, layout) {
   switch (layout.type) {
     case "split-claude":
-      return tmux.buildShellCommands(project.name, project.path.path, layout.claudeArgs);
+      return tmux.buildShellCommands(sessionId, project.path.path, layout.claudeArgs);
     case "three-pane":
       return tmux.buildThreePaneShellCommands(
-        project.name,
+        sessionId,
         project.path.path,
         layout.claudeArgs,
         layout.npmCommand
       );
     case "two-pane-npm":
-      return tmux.buildTwoPaneNpmShellCommands(project.name, project.path.path, layout.npmCommand);
+      return tmux.buildTwoPaneNpmShellCommands(sessionId, project.path.path, layout.npmCommand);
   }
 }
 function buildFallbackCommandsWithEvents(shellCommands, project, layout, remainingEvents, _ctx) {
@@ -4134,50 +4166,77 @@ function buildFallbackCommandsWithEvents(shellCommands, project, layout, remaini
     }
   }
 }
-async function createTmuxSession(tmux, project, layout) {
+async function createTmuxSession(tmux, sessionId, project, layout) {
   switch (layout.type) {
     case "split-claude":
-      return tmux.createSplitSession(project.name, project.path.path, layout.claudeArgs);
+      return tmux.createSplitSession(sessionId, project.path.path, layout.claudeArgs);
     case "three-pane":
       return tmux.createThreePaneSession(
-        project.name,
+        sessionId,
         project.path.path,
         layout.claudeArgs,
         layout.npmCommand
       );
     case "two-pane-npm":
-      return tmux.createTwoPaneNpmSession(project.name, project.path.path, layout.npmCommand);
+      return tmux.createTwoPaneNpmSession(sessionId, project.path.path, layout.npmCommand);
   }
 }
-async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx) {
+async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx, worktreeName) {
+  const sessionLabel = worktreeName ? `${project.name}::${worktreeName}` : project.name;
   const layout = {
     type: "split-claude",
     handledEvents: ["cwd", "claude"],
-    dryRunMessage: `Would create split tmux session '${project.name}' with Claude`,
+    dryRunMessage: `Would create split tmux session '${sessionLabel}' with Claude`,
     claudeArgs: getClaudeArgs2(project),
     npmCommand: null
   };
-  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+  await handleTmuxLayout(
+    project,
+    layout,
+    { isShellMode, dryRun },
+    shellCommands,
+    events,
+    ctx,
+    worktreeName
+  );
 }
-async function handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+async function handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx, worktreeName) {
+  const sessionLabel = worktreeName ? `${project.name}::${worktreeName}` : project.name;
   const layout = {
     type: "three-pane",
     handledEvents: ["cwd", "claude", "npm"],
-    dryRunMessage: `Would create three-pane tmux session '${project.name}' with Claude and NPM`,
+    dryRunMessage: `Would create three-pane tmux session '${sessionLabel}' with Claude and NPM`,
     claudeArgs: getClaudeArgs2(project),
     npmCommand: await getNpmCommand2(project)
   };
-  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+  await handleTmuxLayout(
+    project,
+    layout,
+    { isShellMode, dryRun },
+    shellCommands,
+    events,
+    ctx,
+    worktreeName
+  );
 }
-async function handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+async function handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx, worktreeName) {
+  const sessionLabel = worktreeName ? `${project.name}::${worktreeName}` : project.name;
   const layout = {
     type: "two-pane-npm",
     handledEvents: ["cwd", "npm"],
-    dryRunMessage: `Would create two-pane tmux session '${project.name}' with NPM`,
+    dryRunMessage: `Would create two-pane tmux session '${sessionLabel}' with NPM`,
     claudeArgs: [],
     npmCommand: await getNpmCommand2(project)
   };
-  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+  await handleTmuxLayout(
+    project,
+    layout,
+    { isShellMode, dryRun },
+    shellCommands,
+    events,
+    ctx,
+    worktreeName
+  );
 }
 async function processEvent(event, context, ctx) {
   const { log } = ctx;
@@ -4840,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) {
@@ -4880,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();
 }
@@ -5062,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);