@cestoliv/wt 0.5.0 → 0.5.1

package/dist/{chunk-GHYUCETL.js → chunk-XOP26UY4.js}

@@ -2,16 +2,88 @@
 import {
   createStore,
   getGlobalConfig
-} from "./chunk-FNAMNRUH.js";
+} from "./chunk-OUWQ6NIV.js";
 
 // src/lib/git.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync, realpathSync, rmSync } from "fs";
 import path from "path";
+
+// src/lib/forge.ts
+import { execFileSync } from "child_process";
+function parseRemoteHost(url) {
+  const u = url.trim();
+  if (!u) return null;
+  const scp = u.match(/^(?:[^@/]+@)?([^:/]+):(?!\/\/)/);
+  if (scp) return scp[1].toLowerCase();
+  const schemed = u.match(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^:/]+)/i);
+  if (schemed) return schemed[1].toLowerCase();
+  return null;
+}
+function selectForgeTool(host) {
+  if (!host) return null;
+  if (host.startsWith("github.") || host.endsWith(".github.com")) return "gh";
+  return "glab";
+}
+function buildMergedQuery(tool, branch) {
+  if (tool === "gh") {
+    return [
+      "pr",
+      "list",
+      "--head",
+      branch,
+      "--state",
+      "merged",
+      "--json",
+      "number"
+    ];
+  }
+  return ["mr", "list", "--merged", "--source-branch", branch, "-F", "json"];
+}
+function parseMergedResult(stdout) {
+  try {
+    const data = JSON.parse(stdout);
+    return Array.isArray(data) && data.length > 0;
+  } catch {
+    return false;
+  }
+}
+var defaultRunner = {
+  remoteUrl(repoRoot, remote) {
+    return execFileSync("git", ["remote", "get-url", remote], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+  },
+  query(repoRoot, tool, args) {
+    return execFileSync(tool, args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "pipe",
+      timeout: 15e3
+    });
+  }
+};
+function hasMergedPullRequest(repoRoot, branch, remote = "origin", runner = defaultRunner) {
+  try {
+    const tool = selectForgeTool(
+      parseRemoteHost(runner.remoteUrl(repoRoot, remote))
+    );
+    if (!tool) return false;
+    return parseMergedResult(
+      runner.query(repoRoot, tool, buildMergedQuery(tool, branch))
+    );
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/git.ts
 function getRepoRoot(cwd = process.cwd()) {
   try {
     const realCwd = realpathSync(cwd);
-    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
+    const output = execFileSync2("git", ["worktree", "list", "--porcelain"], {
       cwd: realCwd,
       encoding: "utf8",
       stdio: "pipe"
@@ -25,7 +97,7 @@ function getRepoRoot(cwd = process.cwd()) {
 function listWorktrees(repoRoot, cwd = process.cwd()) {
   const realRepoRoot = realpathSync(repoRoot);
   const realCwd = realpathSync(cwd);
-  const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
+  const output = execFileSync2("git", ["worktree", "list", "--porcelain"], {
     cwd: realRepoRoot,
     encoding: "utf8"
   });
@@ -35,7 +107,7 @@ function listWorktrees(repoRoot, cwd = process.cwd()) {
   ).join('; echo "---SEP---"; ');
   let commits = [];
   try {
-    const batchOutput = execFileSync("sh", ["-c", script], {
+    const batchOutput = execFileSync2("sh", ["-c", script], {
       encoding: "utf8",
       timeout: 8e3
     });
@@ -48,7 +120,7 @@ function listWorktrees(repoRoot, cwd = process.cwd()) {
   }));
 }
 function parseWorktreeList(output, repoRoot, cwd) {
-  return output.trim().split("\n\n").map((block) => {
+  return output.trim().split("\n\n").map((block, index) => {
     const lines = block.trim().split("\n");
     const wtPath = lines[0].slice("worktree ".length);
     const branchLine = lines.find((l) => l.startsWith("branch "));
@@ -57,13 +129,15 @@ function parseWorktreeList(output, repoRoot, cwd) {
       path: wtPath,
       branch,
       isCurrent: cwd === wtPath || cwd.startsWith(wtPath + path.sep),
+      // The main worktree is always the first entry of `git worktree list`.
+      isMain: index === 0,
       repoRoot
     };
   });
 }
 function addWorktree(repoRoot, worktreePath, branch, baseBranch) {
   if (baseBranch) {
-    execFileSync(
+    execFileSync2(
       "git",
       ["worktree", "add", "-b", branch, worktreePath, baseBranch],
       {
@@ -71,14 +145,24 @@ function addWorktree(repoRoot, worktreePath, branch, baseBranch) {
       }
     );
   } else {
-    execFileSync("git", ["worktree", "add", worktreePath, branch], {
+    execFileSync2("git", ["worktree", "add", worktreePath, branch], {
       cwd: repoRoot
     });
   }
 }
 function removeWorktree(repoRoot, worktreePath, force = false) {
+  const resolve = (p) => {
+    try {
+      return realpathSync(p);
+    } catch {
+      return p;
+    }
+  };
+  if (resolve(worktreePath) === resolve(repoRoot)) {
+    throw new Error("Refusing to remove the main worktree");
+  }
   try {
-    execFileSync(
+    execFileSync2(
       "git",
       ["worktree", "remove", ...force ? ["--force"] : [], worktreePath],
       { cwd: repoRoot, stdio: "pipe" }
@@ -88,7 +172,7 @@ function removeWorktree(repoRoot, worktreePath, force = false) {
     if (existsSync(worktreePath)) {
       rmSync(worktreePath, { recursive: true, force: true });
     }
-    execFileSync("git", ["worktree", "prune"], {
+    execFileSync2("git", ["worktree", "prune"], {
       cwd: repoRoot,
       stdio: "pipe"
     });
@@ -96,7 +180,7 @@ function removeWorktree(repoRoot, worktreePath, force = false) {
 }
 function listWorktreeDirtyFiles(worktreePath) {
   try {
-    const out = execFileSync("git", ["status", "--short"], {
+    const out = execFileSync2("git", ["status", "--short"], {
       cwd: worktreePath,
       encoding: "utf8"
     });
@@ -107,12 +191,12 @@ function listWorktreeDirtyFiles(worktreePath) {
 }
 function branchExists(repoRoot, branch) {
   try {
-    const local = execFileSync("git", ["branch", "--list", branch], {
+    const local = execFileSync2("git", ["branch", "--list", branch], {
       cwd: repoRoot,
       encoding: "utf8"
     }).trim();
     if (local) return true;
-    const remote = execFileSync(
+    const remote = execFileSync2(
       "git",
       ["ls-remote", "--heads", "origin", branch],
       {
@@ -126,9 +210,55 @@ function branchExists(repoRoot, branch) {
     return false;
   }
 }
+function isAncestor(repoRoot, ancestor, descendant) {
+  try {
+    execFileSync2("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+      cwd: repoRoot,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasRemoteTrackingRef(repoRoot, remote, branch) {
+  try {
+    execFileSync2(
+      "git",
+      ["rev-parse", "--verify", "--quiet", `refs/remotes/${remote}/${branch}`],
+      { cwd: repoRoot, stdio: "pipe" }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isBranchMerged(repoRoot, branch, baseBranch, forgeCheck = hasMergedPullRequest) {
+  try {
+    const out = execFileSync2("git", ["cherry", baseBranch, branch], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    const lines = out.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length > 0 && lines.every((l) => l.startsWith("-"))) return true;
+    const revParse = (ref) => execFileSync2("git", ["rev-parse", ref], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: "pipe"
+    }).trim();
+    if (revParse(branch) === revParse(baseBranch)) return false;
+    if (!isAncestor(repoRoot, branch, baseBranch)) return false;
+    const remote = baseBranch.includes("/") ? baseBranch.split("/", 1)[0] : "origin";
+    if (!hasRemoteTrackingRef(repoRoot, remote, branch)) return false;
+    return forgeCheck(repoRoot, branch, remote);
+  } catch {
+    return false;
+  }
+}
 function setUpstreamTracking(worktreePath, branch, remote = "origin") {
   try {
-    execFileSync(
+    execFileSync2(
       "git",
       ["branch", "--set-upstream-to", `${remote}/${branch}`, branch],
       { cwd: worktreePath, stdio: "pipe" }
@@ -137,7 +267,7 @@ function setUpstreamTracking(worktreePath, branch, remote = "origin") {
   }
 }
 function fetchRemote(repoRoot, remote = "origin") {
-  execFileSync("git", ["fetch", remote], {
+  execFileSync2("git", ["fetch", remote], {
     cwd: repoRoot,
     stdio: "pipe",
     timeout: 3e4
@@ -253,8 +383,24 @@ function shortenPath(p) {
   const home = process.env.HOME ?? "";
   return home && p.startsWith(home) ? `~${p.slice(home.length)}` : p;
 }
-function buildListLayout(items, selectedIndex, query, mode) {
+function formatRefreshStatus(lastRefresh, intervalMinutes) {
+  const time = lastRefresh.toLocaleTimeString();
+  return `\u27F3 Last refreshed ${time} \xB7 every ${intervalMinutes}m`;
+}
+function reconcileSelectedIndex(items, prevPath, prevIndex) {
+  if (items.length === 0) return 0;
+  if (prevPath) {
+    const found = items.findIndex((w) => w.path === prevPath);
+    if (found !== -1) return found;
+  }
+  return Math.min(Math.max(0, prevIndex), items.length - 1);
+}
+function buildListLayout(items, selectedIndex, query, mode, lastRefresh = null, intervalMinutes = 0) {
   const header = [];
+  if (lastRefresh && intervalMinutes > 0) {
+    header.push(pc.dim(formatRefreshStatus(lastRefresh, intervalMinutes)));
+    header.push("");
+  }
   if (mode === "global") {
     header.push(
       pc.dim("\u2139 Not in a git repository \u2014 showing all registered worktrees")
@@ -271,7 +417,7 @@ function buildListLayout(items, selectedIndex, query, mode) {
     for (const item of groupItems) {
       const start = body.length;
       const cursor = i === selectedIndex ? pc.cyan("\u25B6") : " ";
-      const branchLabel = item.isCurrent ? pc.dim(`${item.branch} (current)`) : pc.white(item.branch);
+      const branchLabel = item.isCurrent ? pc.dim(`${item.branch} (current)`) : item.isMain ? pc.dim(`${item.branch} (main)`) : pc.white(item.branch);
       const pathLabel = pc.dim(shortenPath(item.path));
       body.push(`  ${cursor} ${branchLabel}  ${pathLabel}`);
       if (item.lastCommit) {
@@ -282,28 +428,33 @@ function buildListLayout(items, selectedIndex, query, mode) {
     }
   }
   const footer = [
-    pc.dim("\u2195 navigate \xB7 Enter open \xB7 D delete \xB7 C create \xB7 A agent \xB7 Q quit")
+    pc.dim(
+      "\u2195 navigate \xB7 Enter open \xB7 D delete \xB7 P prune \xB7 C create \xB7 A agent \xB7 Q quit"
+    )
   ];
   return { header, body, footer, itemSpans };
 }
-function clampScroll(offset, span, viewportHeight, bodyLength) {
-  const maxOffset = Math.max(0, bodyLength - viewportHeight);
+function clampScroll(offset, span, viewportHeight2, bodyLength) {
+  const maxOffset = Math.max(0, bodyLength - viewportHeight2);
   let next = offset;
   if (span.start < next) next = span.start;
-  if (span.end >= next + viewportHeight) next = span.end - viewportHeight + 1;
+  if (span.end >= next + viewportHeight2) next = span.end - viewportHeight2 + 1;
   return Math.max(0, Math.min(next, maxOffset));
 }
-function composeView(layout, offset, viewportHeight) {
+function composeView(layout, offset, viewportHeight2) {
   const { header, body, footer } = layout;
-  const visible = body.slice(offset, offset + viewportHeight);
-  while (visible.length < viewportHeight) visible.push("");
+  const visible = body.slice(offset, offset + viewportHeight2);
+  while (visible.length < viewportHeight2) visible.push("");
   const topSlot = offset > 0 ? pc.dim("  \u2191 more") : "";
-  const bottomSlot = offset + viewportHeight < body.length ? pc.dim("  \u2193 more") : "";
+  const bottomSlot = offset + viewportHeight2 < body.length ? pc.dim("  \u2193 more") : "";
   return [...header, topSlot, ...visible, bottomSlot, ...footer].join("\n");
 }
 function fixedHeight(layout) {
   return layout.header.length + layout.footer.length + 2;
 }
+function viewportHeight(layout, rows) {
+  return Math.max(1, rows - fixedHeight(layout) - 1);
+}
 function setupRawMode() {
   process.stdin.setRawMode(true);
   process.stdin.resume();
@@ -314,6 +465,17 @@ function cleanupRawMode() {
   process.stdin.pause();
   process.stdout.write("\x1B[2J\x1B[H");
 }
+function waitForKeypress() {
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.once("data", () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      resolve();
+    });
+  });
+}
 function renderRepoPicker(repos, selectedIndex, query) {
   const lines = [];
   lines.push(pc.dim("\u2139 Not in a git repository \u2014 select a repo to create in"));
@@ -462,15 +624,25 @@ async function runWizard(steps) {
   }
   return true;
 }
-async function runInteractiveList(allItems, mode, handlers) {
+async function runInteractiveList(allItems, mode, handlers, options = {}) {
+  const { autoRefreshMinutes = 0 } = options;
+  const refreshEnabled = Number.isFinite(autoRefreshMinutes) && autoRefreshMinutes > 0;
   let query = "";
   let selectedIndex = 0;
   let scrollOffset = 0;
   let filtered = allItems;
+  let lastRefresh = refreshEnabled ? /* @__PURE__ */ new Date() : null;
   const render = () => {
     const rows = process.stdout.rows ?? 24;
-    const layout = buildListLayout(filtered, selectedIndex, query, mode);
-    const viewport = Math.max(1, rows - fixedHeight(layout));
+    const layout = buildListLayout(
+      filtered,
+      selectedIndex,
+      query,
+      mode,
+      lastRefresh,
+      autoRefreshMinutes
+    );
+    const viewport = viewportHeight(layout, rows);
     const span = layout.itemSpans[selectedIndex] ?? { start: 0, end: 0 };
     scrollOffset = clampScroll(
       scrollOffset,
@@ -485,6 +657,9 @@ async function runInteractiveList(allItems, mode, handlers) {
   render();
   return new Promise((resolve, reject) => {
     let listenerActive = false;
+    let interacting = false;
+    let refreshing = false;
+    let refreshTimer = null;
     const attachListener = () => {
       if (!listenerActive) {
         process.stdin.on("data", onData);
@@ -497,9 +672,35 @@ async function runInteractiveList(allItems, mode, handlers) {
       process.stdout.removeListener("resize", render);
       listenerActive = false;
     };
+    const stopRefresh = () => {
+      if (refreshTimer !== null) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+      }
+    };
+    const tick = async () => {
+      if (interacting || refreshing) return;
+      refreshing = true;
+      try {
+        const prevPath = filtered[selectedIndex]?.path;
+        allItems = await handlers.refreshItems();
+        filtered = filterItems(allItems, query);
+        selectedIndex = reconcileSelectedIndex(
+          filtered,
+          prevPath,
+          selectedIndex
+        );
+        lastRefresh = /* @__PURE__ */ new Date();
+        if (!interacting) render();
+      } catch {
+      } finally {
+        refreshing = false;
+      }
+    };
     const onData = async (key) => {
       try {
         if (key === "" || key === "q" || key === "Q" || key === "\x1B") {
+          stopRefresh();
           detachListener();
           cleanupRawMode();
           resolve();
@@ -512,6 +713,7 @@ async function runInteractiveList(allItems, mode, handlers) {
         } else if (key === "\r") {
           const item = filtered[selectedIndex];
           if (item) {
+            stopRefresh();
             detachListener();
             cleanupRawMode();
             handlers.onOpen(item);
@@ -520,12 +722,21 @@ async function runInteractiveList(allItems, mode, handlers) {
         } else if (key === "d" || key === "D") {
           const item = filtered[selectedIndex];
           if (item) {
+            if (item.isMain) {
+              process.stdout.write(
+                pc.red(
+                  "\nCannot delete the main repository \u2014 only worktrees can be removed.\n"
+                )
+              );
+              return;
+            }
             if (item.isCurrent) {
               process.stdout.write(
                 pc.red("\nCannot delete the worktree you are currently in.\n")
               );
               return;
             }
+            interacting = true;
             detachListener();
             cleanupRawMode();
             const confirmed = await handlers.onDelete(item);
@@ -539,9 +750,32 @@ async function runInteractiveList(allItems, mode, handlers) {
             );
             setupRawMode();
             attachListener();
+            interacting = false;
             render();
           }
+        } else if (key === "p" || key === "P") {
+          interacting = true;
+          detachListener();
+          cleanupRawMode();
+          const removed = await handlers.onWipe(allItems);
+          if (removed.length > 0) {
+            const removedSet = new Set(removed);
+            allItems = allItems.filter((w) => !removedSet.has(w));
+            filtered = filtered.filter((w) => !removedSet.has(w));
+          } else {
+            process.stdout.write(pc.dim("\nPress any key to continue\u2026"));
+            await waitForKeypress();
+          }
+          selectedIndex = Math.min(
+            selectedIndex,
+            Math.max(0, filtered.length - 1)
+          );
+          setupRawMode();
+          attachListener();
+          interacting = false;
+          render();
         } else if (key === "c" || key === "C") {
+          interacting = true;
           detachListener();
           cleanupRawMode();
           await handlers.onCreate();
@@ -551,10 +785,13 @@ async function runInteractiveList(allItems, mode, handlers) {
             selectedIndex,
             Math.max(0, filtered.length - 1)
           );
+          lastRefresh = refreshEnabled ? /* @__PURE__ */ new Date() : lastRefresh;
           setupRawMode();
           attachListener();
+          interacting = false;
           render();
         } else if (key === "a" || key === "A") {
+          interacting = true;
           detachListener();
           cleanupRawMode();
           await handlers.onAgent();
@@ -564,8 +801,10 @@ async function runInteractiveList(allItems, mode, handlers) {
             selectedIndex,
             Math.max(0, filtered.length - 1)
           );
+          lastRefresh = refreshEnabled ? /* @__PURE__ */ new Date() : lastRefresh;
           setupRawMode();
           attachListener();
+          interacting = false;
           render();
         } else if (key === "\x7F") {
           query = query.slice(0, -1);
@@ -581,12 +820,16 @@ async function runInteractiveList(allItems, mode, handlers) {
           render();
         }
       } catch (err) {
+        stopRefresh();
         detachListener();
         cleanupRawMode();
         reject(err);
       }
     };
     attachListener();
+    if (refreshEnabled) {
+      refreshTimer = setInterval(tick, autoRefreshMinutes * 6e4);
+    }
   });
 }
 
@@ -597,6 +840,7 @@ export {
   removeWorktree,
   listWorktreeDirtyFiles,
   branchExists,
+  isBranchMerged,
   setUpstreamTracking,
   fetchRemote,
   resolveWorktreePath,

package/dist/cli.js

@@ -3,35 +3,40 @@
 // src/cli.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("wt").description("Git worktree manager").version("0.5.0").action(async () => {
-  const { runList } = await import("./list-XHV4ODXW.js");
+program.name("wt").description("Git worktree manager").version("0.5.1").action(async () => {
+  const { runList } = await import("./list-GLLMKIKE.js");
   await runList();
 });
 program.command("create [branch]").description("Create a new worktree").action(async (branch) => {
-  const { createWorktree } = await import("./create-XKF574AL.js");
+  const { createWorktree } = await import("./create-K4OQIX7A.js");
   await createWorktree(branch);
 });
 program.command("agent <branch> <plan_prompt>").description("Create a worktree and auto-start an AI agent in Zed (macOS)").option(
   "--mode <mode>",
-  "Claude Code permission mode (default, plan, auto, etc.)",
-  "plan"
+  "Claude Code permission mode (default, plan, auto, etc.); overrides the configured agent_mode"
 ).action(
   async (branch, planPrompt, options) => {
-    const { createAgentWorktree } = await import("./agent-Z3YCY245.js");
+    const { createAgentWorktree } = await import("./agent-QYE5UNA3.js");
     await createAgentWorktree(branch, planPrompt, { mode: options.mode });
   }
 );
+program.command("prune").description(
+  "Remove worktrees whose branch has been merged into the base branch"
+).action(async () => {
+  const { runPrune } = await import("./prune-HKCDPXQD.js");
+  await runPrune();
+});
 program.command("config").description("Open the config file in $EDITOR").option("--path", "Print the config file path and exit").action(async (options) => {
   if (options.path) {
-    const { printConfigPath } = await import("./config-RFATE2PF.js");
+    const { printConfigPath } = await import("./config-QSYG3JDC.js");
     printConfigPath();
   } else {
-    const { openConfig } = await import("./config-RFATE2PF.js");
+    const { openConfig } = await import("./config-QSYG3JDC.js");
     openConfig();
   }
 });
 program.command("skill").description("Print the wt skill file to stdout").action(async () => {
-  const { printSkill } = await import("./skill-MVKLVB5V.js");
+  const { printSkill } = await import("./skill-T5VOI4ZB.js");
   printSkill();
 });
 await program.parseAsync(process.argv);

package/dist/{config-RFATE2PF.js → config-QSYG3JDC.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getConfigFilePath
-} from "./chunk-FNAMNRUH.js";
+} from "./chunk-OUWQ6NIV.js";
 
 // src/commands/config.ts
 import { spawn } from "child_process";

package/dist/{create-XKF574AL.js → create-K4OQIX7A.js}

@@ -4,9 +4,9 @@ import {
   openConfiguredIde,
   prepareWorktree,
   promptExistingWorktree
-} from "./chunk-QGSJG72F.js";
-import "./chunk-GHYUCETL.js";
-import "./chunk-FNAMNRUH.js";
+} from "./chunk-OA55NRNT.js";
+import "./chunk-XOP26UY4.js";
+import "./chunk-OUWQ6NIV.js";
 export {
   createWorktree,
   openConfiguredIde,

package/dist/list-GLLMKIKE.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  buildMergedPredicate,
+  deleteWorktree,
+  prepareListItems,
+  runList,
+  selectWipeCandidates,
+  wipeWorktrees
+} from "./chunk-BJDZXGOC.js";
+import "./chunk-XOP26UY4.js";
+import "./chunk-OUWQ6NIV.js";
+export {
+  buildMergedPredicate,
+  deleteWorktree,
+  prepareListItems,
+  runList,
+  selectWipeCandidates,
+  wipeWorktrees
+};

package/dist/prune-HKCDPXQD.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import {
+  prepareListItems,
+  wipeWorktrees
+} from "./chunk-BJDZXGOC.js";
+import "./chunk-XOP26UY4.js";
+import {
+  createStore
+} from "./chunk-OUWQ6NIV.js";
+
+// src/commands/prune.ts
+import pc from "picocolors";
+async function runPrune(options = {}) {
+  const { cwd = process.cwd(), store = createStore() } = options;
+  const { items, mode } = await prepareListItems({ cwd, store });
+  if (items.length === 0) {
+    console.log(
+      pc.dim(
+        mode === "global" ? "No repos registered. Run `wt create` inside a repo to get started." : "No worktrees found."
+      )
+    );
+    return;
+  }
+  const removed = await wipeWorktrees(items, store, { fetch: true });
+  if (removed.length > 0) {
+    console.log(pc.green(`\u2713 Pruned ${removed.length} worktree(s).`));
+  }
+}
+export {
+  runPrune
+};