@ogpoyraz/wtx 0.8.2 → 0.8.4

package/completions/_wtx.zsh

@@ -137,6 +137,7 @@ _wtx() {
           _arguments \
             ':pr-link:' \
             {-r,--repo}'[Target specific repo(s)]:repo:_wtx_repos' \
+            {-f,--force}'[Override existing local branch/worktree]' \
             {-q,--quiet}'[Suppress output]' \
             '--verbose[Show git commands]' \
             '--dry-run[Show what would happen]'

package/completions/wtx.bash

@@ -97,7 +97,7 @@ _wtx_completions() {
       fetch)   flags="--repo -q --quiet --verbose --dry-run --help" ;;
       sync)    flags="--repo -q --quiet --verbose --dry-run --help" ;;
       deps)    flags="-r --repo --install --symlink --json -q --quiet --verbose --dry-run --help" ;;
-      pull)    flags="-r --repo -q --quiet --verbose --dry-run --help" ;;
+      pull)    flags="-r --repo -f --force -q --quiet --verbose --dry-run --help" ;;
       ls)      flags="-r --repo --pr --json -q --quiet --verbose --dry-run --help" ;;
       status)  flags="-r --repo --base --json -q --quiet --verbose --dry-run --help" ;;
       stack)   flags="-r --repo --json -q --quiet --verbose --dry-run --help" ;;

package/dist/cli.mjs

@@ -26378,6 +26378,7 @@ var init_HelpOverlay = __esm(() => {
     ["n", "Create new worktree (pick dependency strategy)"],
     ["f", "Fetch main for selected repo(s)"],
     ["p", "Pull latest changes for selected branch(es)"],
+    ["P (shift+p)", "Pull PR by link (force-override if exists)"],
     ["b", "Rebase selected onto base (or main)"],
     ["s", "Sync selected (env files + hooks)"],
     ["i", "Install dependencies in selection (worktrees and main)"],
@@ -26558,7 +26559,7 @@ var init_ActionLogModal = __esm(() => {
 });
 
 // src/lib/history.ts
-import fs31 from "fs";
+import fs32 from "fs";
 import path36 from "path";
 import os4 from "os";
 function getHistoryDir() {
@@ -26572,24 +26573,24 @@ function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_
   const historyPath = getHistoryPath();
   let size = 0;
   try {
-    size = fs31.statSync(historyPath).size;
+    size = fs32.statSync(historyPath).size;
   } catch {
     return;
   }
   if (size <= maxBytes)
     return;
-  const lines = fs31.readFileSync(historyPath, "utf-8").split(`
+  const lines = fs32.readFileSync(historyPath, "utf-8").split(`
 `).filter(Boolean);
   const kept = lines.slice(-keepLines);
   const tmpPath = `${historyPath}.tmp.${process.pid}`;
   try {
-    fs31.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
+    fs32.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
 `)}
 ` : "", "utf-8");
-    fs31.renameSync(tmpPath, historyPath);
+    fs32.renameSync(tmpPath, historyPath);
   } catch (err) {
-    if (fs31.existsSync(tmpPath)) {
-      fs31.unlinkSync(tmpPath);
+    if (fs32.existsSync(tmpPath)) {
+      fs32.unlinkSync(tmpPath);
     }
     throw err;
   }
@@ -26597,18 +26598,18 @@ function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_
 function appendHistory(entry) {
   try {
     const dir = getHistoryDir();
-    if (!fs31.existsSync(dir)) {
-      fs31.mkdirSync(dir, { recursive: true });
+    if (!fs32.existsSync(dir)) {
+      fs32.mkdirSync(dir, { recursive: true });
     }
     rotateHistory();
-    fs31.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
+    fs32.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
 `, "utf-8");
   } catch {}
 }
 function readRecentHistory(limit = 50) {
   let content;
   try {
-    content = fs31.readFileSync(getHistoryPath(), "utf-8");
+    content = fs32.readFileSync(getHistoryPath(), "utf-8");
   } catch {
     return [];
   }
@@ -26739,7 +26740,7 @@ var init_HistoryOverlay = __esm(() => {
 // src/tui/components/InputModal.tsx
 import { useState as useState3 } from "react";
 import { jsx as jsx9, jsxs as jsxs8 } from "@opentui/react/jsx-runtime";
-function InputModal({ title, placeholder, initialValue, errorMessage, onSubmit }) {
+function InputModal({ title, placeholder, initialValue, errorMessage: errorMessage2, onSubmit }) {
   const [value, setValue] = useState3(initialValue ?? "");
   return /* @__PURE__ */ jsx9(Overlay, {
     title,
@@ -26754,10 +26755,10 @@ function InputModal({ title, placeholder, initialValue, errorMessage, onSubmit }
           onInput: (val) => setValue(val),
           onSubmit: () => onSubmit(value)
         }),
-        errorMessage ? /* @__PURE__ */ jsx9("text", {
+        errorMessage2 ? /* @__PURE__ */ jsx9("text", {
           fg: tokens.error,
           style: { marginTop: 1 },
-          children: errorMessage
+          children: errorMessage2
         }) : /* @__PURE__ */ jsx9("text", {
           fg: tokens.dim,
           style: { marginTop: 1 },
@@ -27278,6 +27279,7 @@ var init_useSpinnerFrame = __esm(() => {
 
 // src/tui/components/App.tsx
 import { useState as useState7, useEffect as useEffect6, useMemo, useRef as useRef4, useCallback as useCallback3 } from "react";
+import { existsSync as existsSync4 } from "node:fs";
 import { useKeyboard as useKeyboard3, useRenderer, useSelectionHandler } from "@opentui/react";
 import { jsx as jsx13, jsxs as jsxs12 } from "@opentui/react/jsx-runtime";
 function getWorktreePathFor(repoName, branch) {
@@ -27304,6 +27306,9 @@ function App({ opts }) {
   const [createBaseModal, setCreateBaseModal] = useState7(null);
   const [createBaseError, setCreateBaseError] = useState7();
   const [createDepsChoice, setCreateDepsChoice] = useState7(null);
+  const [pullPrModal, setPullPrModal] = useState7(false);
+  const [pullPrError, setPullPrError] = useState7();
+  const [pullForceChoice, setPullForceChoice] = useState7(null);
   const [renameModal, setRenameModal] = useState7(false);
   const [renameError, setRenameError] = useState7();
   const [configOpen, setConfigOpen] = useState7(false);
@@ -27487,6 +27492,22 @@ function App({ opts }) {
       args.push("--deps", deps);
     executeOp(op, args, [repoName]);
   };
+  const startPullPr = (link, repoName, force) => {
+    const op = {
+      id: nextOpId.current++,
+      kind: "pull",
+      repoNames: [repoName],
+      label: `PR ${link.split("/").pop()}`,
+      title: `Pull ${link}`,
+      status: "queued",
+      lines: []
+    };
+    setOps((prev) => [...prev, op]);
+    const args = ["pull", link, "--repo", repoName];
+    if (force)
+      args.push("--force");
+    executeOp(op, args, [repoName]);
+  };
   useKeyboard3((key) => {
     if (isFiltering) {
       if (key.name === "escape") {
@@ -27520,6 +27541,15 @@ function App({ opts }) {
     }
     if (createDepsChoice)
       return;
+    if (pullPrModal) {
+      if (key.name === "escape") {
+        setPullPrModal(false);
+        setPullPrError(undefined);
+      }
+      return;
+    }
+    if (pullForceChoice)
+      return;
     if (renameModal) {
       if (key.name === "escape") {
         setRenameModal(false);
@@ -27544,7 +27574,8 @@ function App({ opts }) {
           if (action === "confirm_remove") {
             startBatchActions("remove", rows, (r) => {
               const args = ["remove", r.branch, "--repo", r.repoName, "--yes"];
-              if (r.dirtyFiles.length > 0)
+              const needsForce = r.dirtyFiles.length > 0 || !existsSync4(r.path);
+              if (needsForce)
                 args.push("--force");
               return args;
             });
@@ -27633,6 +27664,20 @@ function App({ opts }) {
       setCreateError(undefined);
       return;
     }
+    if (key.name === "P" || key.name === "p" && key.shift) {
+      const repoName = selectedRow?.repoName ?? getSelectedRows()[0]?.repoName;
+      if (!repoName) {
+        flash("No repo selected");
+        return;
+      }
+      if (busyRepos.has(repoName)) {
+        flash(`${repoName} is busy`);
+        return;
+      }
+      setPullPrModal(true);
+      setPullPrError(undefined);
+      return;
+    }
     if (key.name === "p") {
       const targets = getSelectedRows();
       if (targets.length === 0)
@@ -27938,6 +27983,47 @@ function App({ opts }) {
         },
         onCancel: () => setCreateDepsChoice(null)
       }),
+      pullPrModal && /* @__PURE__ */ jsx13(InputModal, {
+        title: `Pull PR into ${selectedRow?.repoName ?? ""}`,
+        placeholder: "https://github.com/owner/repo/pull/123",
+        errorMessage: pullPrError,
+        onSubmit: (value) => {
+          const link = value.trim();
+          if (!link) {
+            setPullPrModal(false);
+            return;
+          }
+          if (!link.includes("github.com") || !link.includes("/pull/")) {
+            setPullPrError("Invalid PR link: expected https://github.com/{owner}/{repo}/pull/{N}");
+            return;
+          }
+          const repoName = selectedRow?.repoName;
+          if (!repoName) {
+            setPullPrError("No repo selected");
+            return;
+          }
+          if (busyRepos.has(repoName)) {
+            setPullPrError(`${repoName} is busy`);
+            return;
+          }
+          setPullPrModal(false);
+          setPullPrError(undefined);
+          setPullForceChoice({ link, repoName });
+        }
+      }),
+      pullForceChoice && /* @__PURE__ */ jsx13(ChoiceModal, {
+        title: `Pull ${pullForceChoice.link.split("/").pop()}?`,
+        options: [
+          { value: "normal", label: "Pull (skip if exists)", desc: "Fails if branch already exists" },
+          { value: "force", label: "Force Override", desc: "Remove existing branch/worktree and recreate" }
+        ],
+        onSubmit: (choice) => {
+          const { link, repoName } = pullForceChoice;
+          setPullForceChoice(null);
+          startPullPr(link, repoName, choice === "force");
+        },
+        onCancel: () => setPullForceChoice(null)
+      }),
       renameModal && selectedRow && /* @__PURE__ */ jsx13(InputModal, {
         title: `Rename branch ${selectedRow.branch}`,
         initialValue: selectedRow.branch,
@@ -27971,7 +28057,7 @@ function App({ opts }) {
           `Branch will be renamed and the checkout moved to:`,
           getWorktreePathFor(modal.row.repoName, modal.to),
           "",
-          "The old directory will be removed.",
+          "Uncommitted changes and synced files move with it.",
           "Proceed?"
         ].join(`
 `)
@@ -30642,7 +30728,7 @@ import path28 from "path";
 init_forge();
 init_stack();
 function registerPullCommand(program2) {
-  program2.command("pull <link>").description("Fetch a forge PR and create its worktree").option("-r, --repo <repos...>", "Target specific repo").action(async (link, options) => {
+  program2.command("pull <link>").description("Fetch a forge PR and create its worktree").option("-r, --repo <repos...>", "Target specific repo").option("-f, --force", "Override existing local branch/worktree if it exists").action(async (link, options) => {
     const globalOpts = program2.opts();
     const config2 = loadConfig();
     const repoFilter = parseRepoFlag(options.repo);
@@ -30753,12 +30839,45 @@ function registerPullCommand(program2) {
       }
       const wtPath = getWorktreePath(target, branch);
       const worktrees = await getWorktreeList(target.mainPath);
+      const existingWorktree = worktrees.find((w) => w.path === wtPath || w.branch === branch);
       const localBranchFound = await localBranchExists(target.mainPath, branch, globalOpts);
-      const dirExists = worktrees.some((w) => w.path === wtPath || w.branch === branch);
+      const dirExists = Boolean(existingWorktree) || fs22.existsSync(wtPath);
       if (localBranchFound || dirExists) {
-        stepWarning(`Branch '${branch}' already exists`, dirExists ? wtPath : "local branch exists");
-        summaryWarning(`Nothing pulled — branch '${branch}' already exists`);
-        return;
+        if (options.force) {
+          stepWarning(`Branch '${branch}' already exists — --force: will override`, dirExists ? wtPath : "local branch exists");
+        } else {
+          stepWarning(`Branch '${branch}' already exists`, dirExists ? wtPath : "local branch exists");
+          summaryWarning(`Nothing pulled — branch '${branch}' already exists`);
+          return;
+        }
+      }
+      if (options.force && (localBranchFound || dirExists)) {
+        if (existingWorktree) {
+          try {
+            await gitExec(["-C", target.mainPath, "worktree", "remove", "--force", existingWorktree.path], { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!message.includes("not a working tree")) {
+              stepWarning("Worktree removal failed", message.split(`
+`)[0] ?? message);
+            }
+          }
+        }
+        if (!globalOpts.dryRun && fs22.existsSync(wtPath)) {
+          fs22.rmSync(wtPath, { recursive: true, force: true });
+        }
+        if (localBranchFound) {
+          try {
+            await gitExec(["-C", target.mainPath, "branch", "-D", branch], { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!message.includes("branch not found") && !message.includes("not found")) {
+              stepWarning("Branch deletion failed", message.split(`
+`)[0] ?? message);
+            }
+          }
+        }
+        stepSuccess("Existing branch/worktree removed", branch);
       }
       const mainBranch = await resolveMainBranch(target, config2);
       const baseRemote = await resolveBaseRemote(target.mainPath, mainBranch);
@@ -30792,7 +30911,8 @@ function registerPullCommand(program2) {
         fs22.mkdirSync(path28.dirname(wtPath), { recursive: true });
       }
       try {
-        await gitExec(["-C", target.mainPath, "worktree", "add", "-b", branch, wtPath, "FETCH_HEAD"], { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun });
+        const createBranchFlag = options.force ? "-B" : "-b";
+        await gitExec(["-C", target.mainPath, "worktree", "add", createBranchFlag, branch, wtPath, "FETCH_HEAD"], { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun });
       } catch (err) {
         const msg = err.message || "";
         if (msg.includes("already exists") || msg.includes("not a working tree")) {
@@ -30924,6 +31044,7 @@ init_log();
 init_git();
 init_resolver();
 init_path_safety();
+import fs23 from "fs";
 import path29 from "path";
 
 // src/lib/prompts.ts
@@ -30968,6 +31089,69 @@ async function confirm(message, io) {
 
 // src/commands/remove.ts
 init_stack();
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isMissingWorktreePathError(message) {
+  return message.includes("ENOENT") || message.includes("No such file") || message.includes("does not exist") || message.includes("not a git repository") || message.includes("cannot change to");
+}
+function isRecoverableWorktreeRemoveError(message) {
+  return message.includes("not a working tree") || message.includes("already removed") || isMissingWorktreePathError(message);
+}
+function removeExistingPath(wtPath, opts) {
+  if (!opts.dryRun && fs23.existsSync(wtPath)) {
+    fs23.rmSync(wtPath, { recursive: true, force: true });
+  }
+}
+async function removeLocalBranchIfExists(repoPath, branch, opts) {
+  if (await localBranchExists(repoPath, branch, opts)) {
+    await gitExec(["-C", repoPath, "branch", "-D", branch], opts);
+  }
+}
+async function removeLocalBranchBestEffort(repoPath, branch, opts) {
+  try {
+    await removeLocalBranchIfExists(repoPath, branch, opts);
+  } catch (err) {
+    stepWarning("Local branch not removed", errorMessage(err));
+  }
+}
+async function finishCleanup(repo, wtPath, branch, opts) {
+  if (!opts.dryRun) {
+    const removedDirs = cleanupEmptyParents(repo.wtRoot, repo.mainPath, wtPath);
+    for (const dir of removedDirs) {
+      stepSuccess("Cleaned up empty directory", path29.relative(repo.wtRoot, dir) + "/");
+    }
+  }
+  try {
+    await removeStackEntry(repo.mainPath, branch, opts);
+  } catch (err) {
+    stepWarning("Stack metadata not removed", errorMessage(err));
+  }
+}
+async function confirmDeletionIfNeeded(repo, wtPath, options, globalOpts) {
+  if (globalOpts.dryRun)
+    return true;
+  const interactive = isInteractive();
+  const yesFlag = !!options.yes;
+  const envYes = process.env.WTX_YES === "1";
+  if (!canProceedDeletion({ interactive, yesFlag, envYes })) {
+    stepError("Non-interactive terminal requires --yes flag or WTX_YES=1 for scripts");
+    process.exit(1);
+  }
+  if (interactive && !yesFlag && !envYes) {
+    const toClean = planEmptyParentRemoval(repo.wtRoot, repo.mainPath, wtPath);
+    indented(`Will remove worktree: ${wtPath}`);
+    for (const dir of toClean) {
+      indented(`Will clean up empty dir: ${path29.relative(repo.wtRoot, dir)}/`);
+    }
+    const proceed = await confirm("Are you sure you want to delete these?");
+    if (!proceed) {
+      stepWarning("Skipped by user", wtPath);
+      return false;
+    }
+  }
+  return true;
+}
 function registerRemoveCommand(program2) {
   program2.command("remove <branch>").description("Remove worktree(s)").option("-r, --repo <repos...>", "Target specific repo(s)").option("-f, --force", "Force removal even if there are uncommitted changes").option("-y, --yes", "Skip confirmation prompt").action(async (branch, options) => {
     const globalOpts = program2.opts();
@@ -30987,6 +31171,18 @@ function registerRemoveCommand(program2) {
         const worktrees = await getWorktreeList(repo.mainPath);
         const target = findWorktreeForBranch(worktrees, branch, repo.mainPath, candidatePath);
         if (!target) {
+          if (options.force && (fs23.existsSync(candidatePath) || await localBranchExists(repo.mainPath, branch, globalOpts))) {
+            if (!await confirmDeletionIfNeeded(repo, candidatePath, options, globalOpts)) {
+              skipCount++;
+              continue;
+            }
+            removeExistingPath(candidatePath, globalOpts);
+            await removeLocalBranchBestEffort(repo.mainPath, branch, globalOpts);
+            await finishCleanup(repo, candidatePath, branch, globalOpts);
+            stepSuccess("Worktree removed", candidatePath);
+            successCount++;
+            continue;
+          }
           stepWarning("No worktree found", `${branch} (skipped)`);
           skipCount++;
           continue;
@@ -31015,32 +31211,38 @@ function registerRemoveCommand(program2) {
               continue;
             }
           } catch (err) {
-            stepError("Failed to check for uncommitted changes", err.message);
+            const msg = errorMessage(err);
+            if (isMissingWorktreePathError(msg) || !fs23.existsSync(wtPath)) {
+              stepWarning("Worktree path missing", "continuing with removal cleanup");
+            } else {
+              stepError("Failed to check for uncommitted changes", msg);
+              skipCount++;
+              continue;
+            }
+          }
+        }
+        if (options.force && !globalOpts.dryRun && !fs23.existsSync(wtPath)) {
+          if (!await confirmDeletionIfNeeded(repo, wtPath, options, globalOpts)) {
             skipCount++;
             continue;
           }
-        }
-        if (!globalOpts.dryRun) {
-          const interactive = isInteractive();
-          const yesFlag = !!options.yes;
-          const envYes = process.env.WTX_YES === "1";
-          if (!canProceedDeletion({ interactive, yesFlag, envYes })) {
-            stepError("Non-interactive terminal requires --yes flag or WTX_YES=1 for scripts");
-            process.exit(1);
+          try {
+            await gitExec(["-C", repo.mainPath, "worktree", "prune"], globalOpts);
+          } catch (err) {
+            stepWarning("Worktree prune failed", errorMessage(err));
           }
-          if (interactive && !yesFlag && !envYes) {
-            const toClean = planEmptyParentRemoval(repo.wtRoot, repo.mainPath, wtPath);
-            indented(`Will remove worktree: ${wtPath}`);
-            for (const dir of toClean) {
-              indented(`Will clean up empty dir: ${path29.relative(repo.wtRoot, dir)}/`);
-            }
-            const proceed = await confirm("Are you sure you want to delete these?");
-            if (!proceed) {
-              stepWarning("Skipped by user", wtPath);
-              skipCount++;
-              continue;
-            }
+          await removeLocalBranchBestEffort(repo.mainPath, branch, globalOpts);
+          await finishCleanup(repo, wtPath, branch, globalOpts);
+          stepSuccess("Worktree removed", wtPath);
+          if (children.length > 0) {
+            stepWarning("Dependent base metadata retained", children.join(", "));
           }
+          successCount++;
+          continue;
+        }
+        if (!await confirmDeletionIfNeeded(repo, wtPath, options, globalOpts)) {
+          skipCount++;
+          continue;
         }
         const args = ["-C", repo.mainPath, "worktree", "remove", wtPath];
         if (options.force) {
@@ -31050,33 +31252,28 @@ function registerRemoveCommand(program2) {
           await gitExec(args, globalOpts);
           stepSuccess("Worktree removed", wtPath);
         } catch (err) {
-          const msg = err.message || "";
-          if (msg.includes("not a working tree") || msg.includes("already removed")) {
+          const msg = errorMessage(err);
+          if (isRecoverableWorktreeRemoveError(msg)) {
             stepWarning("Worktree already removed or invalid", msg);
-            skipCount++;
-            continue;
+            try {
+              await gitExec(["-C", repo.mainPath, "worktree", "prune"], globalOpts);
+            } catch (pruneErr) {
+              stepWarning("Worktree prune failed", errorMessage(pruneErr));
+            }
+            removeExistingPath(wtPath, globalOpts);
+            await removeLocalBranchBestEffort(repo.mainPath, branch, globalOpts);
+            stepSuccess("Worktree removed", wtPath);
           } else {
             throw err;
           }
         }
-        if (!globalOpts.dryRun) {
-          const removedDirs = cleanupEmptyParents(repo.wtRoot, repo.mainPath, wtPath);
-          for (const dir of removedDirs) {
-            stepSuccess("Cleaned up empty directory", path29.relative(repo.wtRoot, dir) + "/");
-          }
-        }
-        try {
-          await removeStackEntry(repo.mainPath, branch, globalOpts);
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          stepWarning("Stack metadata not removed", message);
-        }
+        await finishCleanup(repo, wtPath, branch, globalOpts);
         if (children.length > 0) {
           stepWarning("Dependent base metadata retained", children.join(", "));
         }
         successCount++;
       } catch (err) {
-        stepError("Failed to remove worktree", err.message);
+        stepError("Failed to remove worktree", errorMessage(err));
         skipCount++;
       }
     }
@@ -31331,7 +31528,7 @@ init_source();
 init_stack();
 init_stack();
 import path31 from "path";
-import fs23 from "fs";
+import fs24 from "fs";
 function buildLsJson(reposData) {
   const result = [];
   for (const repo of reposData) {
@@ -31441,7 +31638,7 @@ function registerLsCommand(program2) {
               statusStr = source_default.blue("[main checkout]");
             } else if (wt.isLocked) {
               statusStr = source_default.red("locked \uD83D\uDD12");
-            } else if (fs23.existsSync(wt.path)) {
+            } else if (fs24.existsSync(wt.path)) {
               try {
                 dirtyFiles = await getDirtyFiles(wt.path);
                 if (dirtyFiles.length > 0) {
@@ -31567,7 +31764,7 @@ end
 init_config();
 init_log();
 init_git();
-import fs24 from "fs";
+import fs25 from "fs";
 init_resolver();
 init_stack();
 function registerRebaseCommand(program2) {
@@ -31582,7 +31779,7 @@ function registerRebaseCommand(program2) {
       repoHeader(repo.name);
       const mainBranch = await resolveMainBranch(repo, config2);
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs24.existsSync(wtPath)) {
+      if (!fs25.existsSync(wtPath)) {
         stepError("No worktree found", `${wtPath} (skipped)`);
         failCount++;
         continue;
@@ -31708,7 +31905,7 @@ init_execa();
 init_config();
 init_log();
 init_resolver();
-import fs25 from "fs";
+import fs26 from "fs";
 import path32 from "path";
 function registerSyncCommand(program2) {
   program2.command("sync <branch>").description("re-copy sync files + run post_sync").option("--repo <repos...>", "comma-separated list of repos to target").action(async (branch, _options, cmd) => {
@@ -31720,14 +31917,14 @@ function registerSyncCommand(program2) {
     for (const repo of repos) {
       repoHeader(repo.name);
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs25.existsSync(wtPath)) {
+      if (!fs26.existsSync(wtPath)) {
         stepWarning("No worktree found", `${wtPath} (skipped)`);
         continue;
       }
       try {
         if (repo.config.sync_files) {
           for (const file2 of repo.config.sync_files) {
-            if (fs25.existsSync(path32.join(repo.mainPath, file2))) {
+            if (fs26.existsSync(path32.join(repo.mainPath, file2))) {
               if (!opts.dryRun) {
                 syncEntry(repo.mainPath, wtPath, file2);
               }
@@ -31780,14 +31977,14 @@ function registerSyncCommand(program2) {
           }
         }
         const wtNodeModules = path32.join(wtPath, "node_modules");
-        if (fs25.existsSync(wtNodeModules) && fs25.lstatSync(wtNodeModules).isSymbolicLink()) {
+        if (fs26.existsSync(wtNodeModules) && fs26.lstatSync(wtNodeModules).isSymbolicLink()) {
           const lockfiles = ["yarn.lock", "package-lock.json", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
           for (const lock of lockfiles) {
             const mainLock = path32.join(repo.mainPath, lock);
             const wtLock = path32.join(wtPath, lock);
-            if (fs25.existsSync(mainLock) && fs25.existsSync(wtLock)) {
-              const mainContent = fs25.readFileSync(mainLock);
-              const wtContent = fs25.readFileSync(wtLock);
+            if (fs26.existsSync(mainLock) && fs26.existsSync(wtLock)) {
+              const mainContent = fs26.readFileSync(mainLock);
+              const wtContent = fs26.readFileSync(wtLock);
               if (!mainContent.equals(wtContent)) {
                 stepWarning(`${lock} differs from main — node_modules is symlinked`);
                 indented(`Run: wtx deps ${branch} --repo ${repo.name} --install`);
@@ -31816,7 +32013,7 @@ init_config();
 init_log();
 init_resolver();
 init_deps();
-import fs26 from "fs";
+import fs27 from "fs";
 function registerDepsCommand(program2) {
   program2.command("deps [branch]").description("Manage node_modules strategy per worktree").option("-r, --repo <repos...>", "Target specific repo(s)").option("--install", "Switch to independent node_modules (run install)").option("--symlink", "Switch to legacy symlinked node_modules").option("--json", "Output machine-readable JSON state").action(async (branch, options) => {
     const globalOpts = program2.opts();
@@ -31853,7 +32050,7 @@ function registerDepsCommand(program2) {
         continue;
       }
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs26.existsSync(wtPath)) {
+      if (!fs27.existsSync(wtPath)) {
         if (options.json) {
           jsonResults[repo.name] = { error: "No worktree found", branch };
         } else {
@@ -31911,7 +32108,7 @@ function registerDepsCommand(program2) {
 init_config();
 init_log();
 init_resolver();
-import fs27 from "fs";
+import fs28 from "fs";
 init_git();
 async function resolveMainCheckoutPath(repoCtx, branch) {
   try {
@@ -31936,7 +32133,7 @@ function registerOpenCommand(program2) {
     for (const repo of repos) {
       const wtPath = getWorktreePath(repo, branch);
       let targetPath = wtPath;
-      if (!fs27.existsSync(wtPath)) {
+      if (!fs28.existsSync(wtPath)) {
         const mainCheckoutPath = await resolveMainCheckoutPath(repo, branch);
         if (!mainCheckoutPath) {
           continue;
@@ -31972,7 +32169,7 @@ import path34 from "path";
 init_git();
 init_resolver();
 init_path_safety();
-import fs28 from "fs";
+import fs29 from "fs";
 import path33 from "path";
 async function getUpstream(wtPath) {
   try {
@@ -31982,6 +32179,27 @@ async function getUpstream(wtPath) {
     return null;
   }
 }
+async function getDirtyEntries(wtPath) {
+  try {
+    const out = await gitExec(["-C", wtPath, "status", "--porcelain"], {});
+    return out.split(`
+`).map((line) => line.trimEnd()).filter((line) => line.length > 0);
+  } catch {
+    return [];
+  }
+}
+function touchesEntry(porcelainLine, entry) {
+  const entryPath = porcelainLine.slice(3);
+  return entryPath === entry || entryPath.startsWith(`${entry}/`);
+}
+async function isTrackedInWorktree(wtPath, entry) {
+  try {
+    await gitExec(["-C", wtPath, "ls-files", "--error-unmatch", "--", entry], {});
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function planRename(repo, oldBranch, newBranch, opts) {
   const list = await getWorktreeList(repo.mainPath);
   const candidatePath = getWorktreePath(repo, oldBranch);
@@ -31993,7 +32211,7 @@ async function planRename(repo, oldBranch, newBranch, opts) {
     throw new Error(`Worktree '${oldBranch}' is locked — unlock it before renaming`);
   }
   const newPath = `${repo.wtRoot}/${newBranch}`;
-  if (fs28.existsSync(newPath)) {
+  if (fs29.existsSync(newPath)) {
     throw new Error(`Target path already exists: ${newPath}`);
   }
   if (!opts.dryRun && await localBranchExists(repo.mainPath, newBranch, opts)) {
@@ -32005,6 +32223,7 @@ async function renameWorktree(params) {
   const { repo, oldBranch, newBranch, opts } = params;
   const planned = await planRename(repo, oldBranch, newBranch, opts);
   const cleanedDirs = [];
+  const dirtyBefore = await getDirtyEntries(planned.worktreePath);
   if (opts.dryRun) {
     return {
       oldBranch,
@@ -32012,12 +32231,16 @@ async function renameWorktree(params) {
       oldPath: planned.worktreePath,
       newPath: planned.newPath,
       upstream: planned.upstream,
-      cleanedDirs
+      cleanedDirs,
+      dirtyFiles: dirtyBefore,
+      lostDirtyFiles: [],
+      resyncedFiles: [],
+      keptLocalSyncFiles: []
     };
   }
   await gitExec(["-C", planned.worktreePath, "branch", "-m", oldBranch, newBranch], opts);
   try {
-    fs28.mkdirSync(path33.dirname(planned.newPath), { recursive: true });
+    fs29.mkdirSync(path33.dirname(planned.newPath), { recursive: true });
     await gitExec(["-C", repo.mainPath, "worktree", "move", planned.worktreePath, planned.newPath], opts);
   } catch (err) {
     try {
@@ -32030,13 +32253,40 @@ async function renameWorktree(params) {
   for (const dir of cleanupEmptyParents(repo.wtRoot, repo.mainPath, planned.worktreePath)) {
     cleanedDirs.push(dir);
   }
+  const dirtyAfter = await getDirtyEntries(planned.newPath);
+  const lostDirtyFiles = dirtyBefore.filter((line) => !dirtyAfter.includes(line));
+  const resyncedFiles = [];
+  const keptLocalSyncFiles = [];
+  for (const entry of repo.config.sync_files ?? []) {
+    if (!fs29.existsSync(path33.join(repo.mainPath, entry)))
+      continue;
+    const destPath = path33.join(planned.newPath, entry);
+    if (!fs29.existsSync(destPath)) {
+      if (syncEntry(repo.mainPath, planned.newPath, entry)) {
+        resyncedFiles.push(entry);
+      }
+      continue;
+    }
+    const tracked = await isTrackedInWorktree(planned.newPath, entry);
+    if (tracked && !dirtyAfter.some((line) => touchesEntry(line, entry))) {
+      if (syncEntry(repo.mainPath, planned.newPath, entry)) {
+        resyncedFiles.push(entry);
+      }
+      continue;
+    }
+    keptLocalSyncFiles.push(entry);
+  }
   return {
     oldBranch,
     newBranch,
     oldPath: planned.worktreePath,
     newPath: planned.newPath,
     upstream: planned.upstream,
-    cleanedDirs
+    cleanedDirs,
+    dirtyFiles: dirtyAfter,
+    lostDirtyFiles,
+    resyncedFiles,
+    keptLocalSyncFiles
   };
 }
 
@@ -32082,6 +32332,18 @@ function registerRenameCommand(program2) {
         stepSuccess("Cleaned up empty directory", path34.relative(repo.wtRoot, dir) + "/");
       }
       stepSuccess("Renamed", `${outcome.oldPath} → ${outcome.newPath}`);
+      if (outcome.dirtyFiles.length > 0) {
+        stepSuccess("Carried uncommitted files", `${outcome.dirtyFiles.length} entr${outcome.dirtyFiles.length === 1 ? "y" : "ies"} moved with the checkout`);
+      }
+      if (outcome.lostDirtyFiles.length > 0) {
+        stepError("Uncommitted changes missing after rename", outcome.lostDirtyFiles.join(", "));
+      }
+      if (outcome.resyncedFiles.length > 0) {
+        stepSuccess("Synced files", outcome.resyncedFiles.join(", "));
+      }
+      for (const entry of outcome.keptLocalSyncFiles) {
+        indented(`Kept local version of ${entry} — it has uncommitted edits`);
+      }
       if (outcome.upstream) {
         indented(`Upstream still tracks '${outcome.upstream}' — after pushing run: git push -u origin ${newBranch}`);
       }
@@ -32108,7 +32370,7 @@ init_resolver();
 init_deps();
 init_forge();
 init_types2();
-import fs29 from "fs";
+import fs30 from "fs";
 init_owner();
 init_stack();
 init_source();
@@ -32158,7 +32420,7 @@ function registerStatusCommand(program2) {
     const jsonOutputs = [];
     for (const repo of repos) {
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs29.existsSync(wtPath)) {
+      if (!fs30.existsSync(wtPath)) {
         continue;
       }
       found++;
@@ -32458,7 +32720,7 @@ function registerPrsCommand(program2) {
 
 // src/commands/skill.ts
 init_log();
-import fs30 from "fs";
+import fs31 from "fs";
 import path35 from "path";
 import { URL as URL2 } from "url";
 var __dirname2 = new URL2(".", import.meta.url).pathname;
@@ -32615,7 +32877,7 @@ function registerSkillCommand(program2) {
     }
     let projectRoot = path35.resolve(__dirname2, "..", "..");
     let skillPath = path35.join(projectRoot, "skills", `${platform2}.md`);
-    if (fs30.existsSync(skillPath)) {
+    if (fs31.existsSync(skillPath)) {
       process.stdout.write(skillPath + `
 `);
     } else {
@@ -32662,7 +32924,7 @@ init_deps();
 import readline3 from "readline";
 init_path_safety();
 init_stack();
-import fs32 from "fs";
+import fs33 from "fs";
 async function runMcpServer(opts = {}) {
   const input = opts.input ?? process.stdin;
   const output = opts.output ?? process.stdout;
@@ -32845,7 +33107,7 @@ async function handleToolCall(name, args, config2, _opts) {
         for (const wt of wts) {
           if (!wt.path.startsWith(repo.wtRoot))
             continue;
-          const dirtyCount = fs32.existsSync(wt.path) ? (await getDirtyFiles(wt.path)).length : 0;
+          const dirtyCount = fs33.existsSync(wt.path) ? (await getDirtyFiles(wt.path)).length : 0;
           items.push({
             repo: repo.name,
             branch: wt.branch || null,
@@ -32873,7 +33135,7 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs32.existsSync(wtPath)) {
+      if (!fs33.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
@@ -32992,7 +33254,7 @@ async function handleToolCall(name, args, config2, _opts) {
       if (children.length > 0 && args.force !== true) {
         throw { isToolError: true, message: `Branch has dependent worktrees: ${children.join(", ")}. Use force:true to override.` };
       }
-      if (!args.force && fs32.existsSync(wtPath)) {
+      if (!args.force && fs33.existsSync(wtPath)) {
         const dirty = await getDirtyFiles(wtPath);
         if (dirty.length > 0) {
           throw { isToolError: true, message: `Worktree is dirty. Use force:true to remove it.` };
@@ -33011,7 +33273,7 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs32.existsSync(wtPath)) {
+      if (!fs33.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
@@ -33233,7 +33495,7 @@ init_config();
 init_resolver();
 init_log();
 init_history();
-import fs33 from "fs";
+import fs34 from "fs";
 var program2 = new Command;
 program2.name("wtx").description("Multi-repo git worktree manager").version(VERSION).option("-q, --quiet", "Suppress progress indicators", false).option("--verbose", "Show git commands as they run", false).option("--dry-run", "Show what would happen", false);
 var MUTATING_COMMANDS = new Set([
@@ -33337,7 +33599,7 @@ program2.command("_resolve-path <repo> <branch>", { hidden: true }).description(
     }
     const repo = repos[0];
     const wtPath = getWorktreePath(repo, branch);
-    if (!fs33.existsSync(wtPath)) {
+    if (!fs34.existsSync(wtPath)) {
       process.stderr.write(`✗ No worktree at ${wtPath}
 `);
       process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogpoyraz/wtx",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Multi-repo git worktree manager",
   "type": "module",
   "bin": {