workshell 0.1.0 → 0.4.0

package/README.md

@@ -68,6 +68,7 @@ This approach has some nice properties.
 
 - 🖥️ **Tab-local workspaces** — Normally a `git checkout`/`git switch` changes your active branch for all terminals. With workshells, you can functionality open branches *in the current tab only*.
 - 🌳 **Full isolation** — Each workshell is isolated on disk, so the changes you make don't interfere anything else you're doing.
+- 📦 **Instant setup** — Untracked files (`.env.*`, etc) are automatically copied using [copy-on-write](https://notes.billmill.org/blog/2024/03/How_I_use_git_worktrees.html). For JS projects, the package manager is auto-detected and `npm/yarn/pnpm/bun install` runs automatically.
 - 🙅‍♂️ **Never stash again** — You can `wk open` a branch even with uncommitted changes. When you exit the subshell, things will be exactly the same as they were. ☕️
 - 🪾 **Consistent with branch semantics** — As with regular `git switch`, `wk close` won't let you close the subshell if you have unstaged/uncommitted changes. This is a feature, not a bug! Regular worktrees make it easy to lose your work in a forgotten corner of your file system.
 - 🤖 **Agent-ready** — Spin up parallel workshells so multiple agents can work simultaneously without conflicts.
@@ -310,9 +311,48 @@ Choice (1/2): 1
 
 <br />
 
+## Automatic file copying
+
+When you create a workshell, `wk` automatically copies all gitignored files from your repo root to the new worktree using **copy-on-write**. This means:
+
+- `.env`, `.venv`, etc. are instantly available
+- Copy-on-write is near-instant and uses zero extra disk space (until files are modified)
+
+This works automatically on macOS (APFS) and Linux (Btrfs/XFS). On other filesystems, files are copied normally.
+
+### JS package manager detection
+
+For JavaScript projects, `wk` auto-detects your package manager from lockfiles:
+
+| Lockfile | Package Manager |
+|----------|-----------------|
+| `pnpm-lock.yaml` | pnpm |
+| `yarn.lock` | yarn |
+| `bun.lockb` / `bun.lock` | bun |
+| `package-lock.json` | npm |
+
+When detected, `node_modules` is skipped during copying and `<pm> install` runs automatically. This is faster than copying large `node_modules` directories.
+
+### Python package manager detection
+
+For Python projects, `wk` auto-detects your package manager from lockfiles:
+
+| Lockfile | Package Manager | Install Command |
+|----------|-----------------|-----------------|
+| `uv.lock` | uv | `uv sync` |
+| `poetry.lock` | poetry | `poetry install` |
+| `Pipfile.lock` | pipenv | `pipenv install` |
+| `pdm.lock` | pdm | `pdm install` |
+
+When detected, `.venv` and `venv` are skipped during copying and the install command runs automatically. Mixed JS+Python projects are supported: both ecosystems are detected and their installs run in sequence.
+
+To disable auto-detection, add a custom `setup` script in `workshell.toml`.
+
+<br />
+
 ## `workshell.toml`
 
-You can configure `wk` with a `workshell.toml` file. This is useful for running setup scripts when opening a workshell (e.g., `npm install`).
+You can optionally configure `wk` with a `workshell.toml` file.
 
 `wk` looks for config files in the following order:
 
@@ -323,13 +363,15 @@ You can configure `wk` with a `workshell.toml` file. This is useful for running
 
 <br />
 
-Currently only one setting is supported: `setup`.
+### Options
 
 ```toml
-# setup script executed in subshell after initialization
-# the following variable substitutions are supported
+# Optional: setup script executed in subshell after initialization
+# Variable substitutions:
 #   `{{ branch }}` — The name of the opened branch, e.g. `feature/auth` 
 #   `{{ repo_path }}` — The absolute path to main repo, e.g. `/path/to/repo`
 #   `{{ worktree_path }}` — The absolute path to worktree, e.g. `~/.workshell/worktrees/.../repo@feat`
-setup = "npm install && cp {{ repo_path }}/.env {{ worktree_path }}/.env"
+setup = "nvm use"
 ```
+
+Note: Setting `setup` disables automatic package manager detection. If you want both, include the install command in your setup script.

package/dist/index.js

@@ -5783,6 +5783,7 @@ var require_src = __commonJS({
 
 // index.ts
 var import_picocolors4 = __toESM(require_picocolors(), 1);
+import { spawnSync as spawnSync2 } from "child_process";
 
 // commands/new.ts
 import { basename as basename3, dirname as dirname3, join as join3 } from "path";
@@ -6604,7 +6605,7 @@ function loadConfig() {
 
 // utils.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
-import { execSync as execSync2, spawnSync } from "child_process";
+import { execSync as execSync2, execFileSync, spawnSync } from "child_process";
 import { existsSync as existsSync2, readSync, openSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, rmSync, lstatSync, readdirSync, readlinkSync } from "fs";
 import { basename as basename2, dirname as dirname2, join as join2 } from "path";
 import { tmpdir } from "os";
@@ -6749,6 +6750,9 @@ function isInsideWorktree() {
     return false;
   }
 }
+function isInsideWorkshell() {
+  return process.env.WK_WORKSHELL === "1";
+}
 function hasUncommittedChanges() {
   try {
     const status = execSync2("git status --porcelain", { encoding: "utf-8" }).trim();
@@ -6942,13 +6946,14 @@ end
 # wk setup script
 ${setupCommand}
 ` : "";
+  const workshellEnv = { ...process.env, WK_WORKSHELL: "1" };
   if (shell.endsWith("zsh")) {
     const tmpDir = join2(tmpdir(), `wk-${process.pid}`);
     mkdirSync2(tmpDir, { recursive: true });
     try {
       writeFileSync2(join2(tmpDir, ".zshrc"), `[[ -f "$HOME/.zshrc" ]] && source "$HOME/.zshrc"
 ${zshScript}${setupSection}`);
-      spawnSync(shell, ["-l"], { cwd, stdio: "inherit", env: { ...process.env, ZDOTDIR: tmpDir } });
+      spawnSync(shell, ["-l"], { cwd, stdio: "inherit", env: { ...workshellEnv, ZDOTDIR: tmpDir } });
     } finally {
       rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -6959,7 +6964,7 @@ ${zshScript}${setupSection}`);
       const rcFile = join2(tmpDir, ".bashrc");
       writeFileSync2(rcFile, `[[ -f "$HOME/.bashrc" ]] && source "$HOME/.bashrc"
 ${bashScript}${setupSection}`);
-      spawnSync(shell, ["--rcfile", rcFile, "-il"], { cwd, stdio: "inherit" });
+      spawnSync(shell, ["--rcfile", rcFile, "-il"], { cwd, stdio: "inherit", env: workshellEnv });
     } finally {
       rmSync(tmpDir, { recursive: true, force: true });
     }
@@ -6967,7 +6972,7 @@ ${bashScript}${setupSection}`);
     const fishInit = setupCommand ? `${fishScript}
 # wk setup script
 ${setupCommand}` : fishScript;
-    spawnSync(shell, ["--init-command", fishInit], { cwd, stdio: "inherit" });
+    spawnSync(shell, ["--init-command", fishInit], { cwd, stdio: "inherit", env: workshellEnv });
   } else {
     console.error(`Error: Unsupported shell '${shell}'`);
     console.error("wk requires bash, zsh, or fish.");
@@ -6976,6 +6981,47 @@ ${setupCommand}` : fishScript;
 }
 var success = (text) => import_picocolors.default.green(import_picocolors.default.bold("\u2713")) + " " + text;
 var warn = (text) => import_picocolors.default.yellow(import_picocolors.default.bold("\u26A0")) + " " + text;
+function hasBinary(name) {
+  try {
+    execSync2(`command -v ${name}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectJsPackageManager(cwd) {
+  if (existsSync2(join2(cwd, "pnpm-lock.yaml")) && hasBinary("pnpm")) return "pnpm";
+  if (existsSync2(join2(cwd, "yarn.lock")) && hasBinary("yarn")) return "yarn";
+  if ((existsSync2(join2(cwd, "bun.lockb")) || existsSync2(join2(cwd, "bun.lock"))) && hasBinary("bun")) return "bun";
+  if (existsSync2(join2(cwd, "package-lock.json")) && hasBinary("npm")) return "npm";
+  return null;
+}
+function detectPythonPackageManager(cwd) {
+  if (existsSync2(join2(cwd, "uv.lock")) && hasBinary("uv")) return "uv";
+  if (existsSync2(join2(cwd, "poetry.lock")) && hasBinary("poetry")) return "poetry";
+  if (existsSync2(join2(cwd, "Pipfile.lock")) && hasBinary("pipenv")) return "pipenv";
+  if (existsSync2(join2(cwd, "pdm.lock")) && hasBinary("pdm")) return "pdm";
+  return null;
+}
+var installCmds = {
+  npm: "npm install",
+  yarn: "yarn install",
+  pnpm: "pnpm install",
+  bun: "bun install",
+  uv: "uv sync",
+  poetry: "poetry install",
+  pipenv: "pipenv install",
+  pdm: "pdm install"
+};
+function runPackageManagerInstall(pm, cwd) {
+  const cmd2 = installCmds[pm];
+  console.log(dim(`Running ${cmd2}...`));
+  try {
+    execSync2(cmd2, { cwd, stdio: "inherit" });
+  } catch {
+    console.error(warn(`${cmd2} failed \u2014 you may need to run it manually`));
+  }
+}
 var fail = (text) => import_picocolors.default.red(import_picocolors.default.bold("\u2717")) + " " + text;
 var dim = (text) => import_picocolors.default.dim(text);
 var bold = (text) => import_picocolors.default.bold(text);
@@ -6983,6 +7029,71 @@ var green = (text) => import_picocolors.default.green(text);
 var cyan = (text) => import_picocolors.default.cyan(text);
 var yellow = (text) => import_picocolors.default.yellow(text);
 var red = (text) => import_picocolors.default.red(text);
+function cpCow(src, dest) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("cp", ["-RPc", src, dest], { stdio: "ignore" });
+    } else if (process.platform === "linux") {
+      execFileSync("cp", ["-RP", "--reflink=auto", src, dest], { stdio: "ignore" });
+    } else {
+      execFileSync("cp", ["-RP", src, dest], { stdio: "ignore" });
+    }
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return;
+    }
+    if (process.platform === "darwin") {
+      try {
+        execFileSync("cp", ["-RP", src, dest], { stdio: "ignore" });
+        return;
+      } catch {
+      }
+    }
+    console.error(warn(`Failed to copy ${src}: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+function getIgnoredPaths(repoPath) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory"],
+      { cwd: repoPath, encoding: "utf-8" }
+    );
+    const paths = output.split("\n").map((p) => p.replace(/\/$/, "")).filter((p) => p.length > 0 && p !== ".git").sort();
+    const minimal = [];
+    let prev = "";
+    for (const path of paths) {
+      if (prev && path.startsWith(prev + "/")) continue;
+      minimal.push(path);
+      prev = path;
+    }
+    return minimal;
+  } catch {
+    return [];
+  }
+}
+var JUNK_FILES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db", "desktop.ini"]);
+function isJunkFile(item) {
+  const base = item.includes("/") ? item.slice(item.lastIndexOf("/") + 1) : item;
+  return JUNK_FILES.has(base);
+}
+function copyIgnoredFiles(repoPath, worktreePath, skipDirs) {
+  let items = getIgnoredPaths(repoPath);
+  items = items.filter((item) => !isJunkFile(item));
+  if (skipDirs && skipDirs.length > 0) {
+    items = items.filter(
+      (item) => !skipDirs.some((dir) => item.split("/").includes(dir))
+    );
+  }
+  if (items.length === 0) return;
+  console.log(dim(`Copying untracked files:`));
+  for (const item of items) {
+    console.log(dim(`  ${item}`));
+    const dest = join2(worktreePath, item);
+    mkdirSync2(dirname2(dest), { recursive: true });
+    cpCow(join2(repoPath, item), dest);
+  }
+}
 function autoCleanupWorktree(worktreeId, path, store, saveStore2) {
   const branch = getWorktreeBranch(path);
   const status = getWorktreeStatus(path);
@@ -7075,6 +7186,15 @@ function newCommand(branchName, fromBranch) {
   mkdirSync3(dirname3(worktreePath), { recursive: true });
   createWorktree(branch, worktreePath, fromBranch);
   initSubmodules(worktreePath);
+  const config = loadConfig();
+  const jsPm = config?.setup ? null : detectJsPackageManager(mainWorktree);
+  const pyPm = config?.setup ? null : detectPythonPackageManager(mainWorktree);
+  const skipDirs = [];
+  if (jsPm) skipDirs.push("node_modules");
+  if (pyPm) skipDirs.push(".venv", "venv");
+  copyIgnoredFiles(mainWorktree, worktreePath, skipDirs);
+  if (jsPm) runPackageManagerInstall(jsPm, worktreePath);
+  if (pyPm) runPackageManagerInstall(pyPm, worktreePath);
   setWorktreeMeta(store, worktreeId, {
     created_at: (/* @__PURE__ */ new Date()).toISOString()
   });
@@ -7098,37 +7218,78 @@ function newCommand(branchName, fromBranch) {
 }
 
 // commands/open.ts
+import { execSync as execSync3 } from "child_process";
 import { mkdirSync as mkdirSync4 } from "fs";
 import { basename as basename4, dirname as dirname4, join as join4 } from "path";
-function openCommand(branch) {
-  if (isInsideWorktree()) {
-    const currentBranch = getCurrentBranch();
-    console.log();
-    console.log(warn(`You're inside a worktree (branch: ${cyan(currentBranch)})`));
-    console.log(`  This will nest subshells (subshell inside subshell).`);
-    console.log();
-    if (!confirm("Continue?")) {
-      process.exit(0);
+function isGhInstalled() {
+  try {
+    execSync3("gh --version", { stdio: "pipe", encoding: "utf-8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGhAuthenticated() {
+  try {
+    execSync3("gh auth status", { stdio: "pipe", encoding: "utf-8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getPRInfo(prRef) {
+  try {
+    const output = execSync3(
+      `gh pr view ${prRef} --json number,headRefName`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return JSON.parse(output);
+  } catch {
+    return null;
+  }
+}
+function fetchPRBranch(prRef, prInfo) {
+  try {
+    execSync3(`git fetch origin ${prInfo.headRefName}:${prInfo.headRefName}`, { stdio: "pipe" });
+    return true;
+  } catch {
+  }
+  const currentBranch = getCurrentBranch();
+  try {
+    execSync3(`gh pr checkout ${prRef}`, { stdio: "pipe" });
+    execSync3(`git checkout "${currentBranch}"`, { stdio: "pipe" });
+    return true;
+  } catch {
+    try {
+      execSync3(`git checkout "${currentBranch}"`, { stdio: "pipe" });
+    } catch {
     }
-    console.log();
   }
-  if (!branchExists(branch)) {
-    console.error(`Error: branch '${branch}' not found`);
-    process.exit(1);
+  try {
+    execSync3(`git fetch origin pull/${prInfo.number}/head:${prInfo.headRefName}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
   }
+}
+function openBranch(branch, prNumber) {
   const parentBranch = getCurrentBranch();
+  const mainWorktree = getMainWorktree();
   const existingWorktreePath = getWorktreeForBranch(branch);
   if (existingWorktreePath) {
     const worktreeId2 = getWorktreeId(existingWorktreePath);
-    const mainWorktree2 = getMainWorktree();
     console.log();
-    console.log(success(bold(branch)), dim(`(existing worktree)`));
+    if (prNumber) {
+      console.log(success(bold(`PR #${prNumber}`)), dim(`branch: ${cyan(branch)} (existing worktree)`));
+    } else {
+      console.log(success(bold(branch)), dim(`(existing worktree)`));
+    }
     console.log(dim("Type 'wk close' to return."));
     console.log();
     spawnShell(existingWorktreePath, {
       branch,
       worktreePath: existingWorktreePath,
-      repoPath: mainWorktree2
+      repoPath: mainWorktree
     });
     console.log();
     console.log(success(`Back in ${bold(parentBranch)}`));
@@ -7138,20 +7299,33 @@ function openCommand(branch) {
     return;
   }
   const store = loadStore();
-  const mainWorktree = getMainWorktree();
   const repoName = basename4(mainWorktree);
   const worktreeId = `${repoName}@${slugify(branch)}`;
   const worktreePath = join4(getWorktreesDir(), worktreeId);
   mkdirSync4(dirname4(worktreePath), { recursive: true });
   createWorktreeForExistingBranch(branch, worktreePath);
   initSubmodules(worktreePath);
+  const config = loadConfig();
+  const jsPm = config?.setup ? null : detectJsPackageManager(mainWorktree);
+  const pyPm = config?.setup ? null : detectPythonPackageManager(mainWorktree);
+  const skipDirs = [];
+  if (jsPm) skipDirs.push("node_modules");
+  if (pyPm) skipDirs.push(".venv", "venv");
+  copyIgnoredFiles(mainWorktree, worktreePath, skipDirs);
+  if (jsPm) runPackageManagerInstall(jsPm, worktreePath);
+  if (pyPm) runPackageManagerInstall(pyPm, worktreePath);
   setWorktreeMeta(store, worktreeId, {
     created_at: (/* @__PURE__ */ new Date()).toISOString()
   });
   saveStore(store);
   console.log();
-  console.log(success(bold(branch)));
-  console.log(dim(`Opened branch in ephemeral subshell`));
+  if (prNumber) {
+    console.log(success(bold(`PR #${prNumber}`)), dim(`branch: ${cyan(branch)}`));
+    console.log(dim(`Opened PR in ephemeral subshell`));
+  } else {
+    console.log(success(bold(branch)));
+    console.log(dim(`Opened branch in ephemeral subshell`));
+  }
   console.log(dim("Type 'exit' or 'wk close' to return."));
   console.log();
   spawnShell(worktreePath, {
@@ -7165,6 +7339,55 @@ function openCommand(branch) {
   autoCleanupWorktree(worktreeId, worktreePath, currentStore, saveStore);
   console.log();
 }
+function openCommand(ref) {
+  if (isInsideWorkshell()) {
+    const currentBranch = getCurrentBranch();
+    console.log();
+    console.log(warn(`You're inside a workshell (branch: ${cyan(currentBranch)})`));
+    console.log(`  This will nest subshells (subshell inside subshell).`);
+    console.log();
+    if (!confirm("Continue?")) {
+      process.exit(0);
+    }
+    console.log();
+  }
+  if (branchExists(ref)) {
+    openBranch(ref);
+    return;
+  }
+  if (!isGhInstalled()) {
+    console.error(fail(`Branch '${ref}' not found.`));
+    console.error(dim("  Install GitHub CLI (gh) to open PRs: https://cli.github.com/"));
+    process.exit(1);
+  }
+  if (!isGhAuthenticated()) {
+    console.error(fail(`Branch '${ref}' not found.`));
+    console.error(dim("  Run 'gh auth login' to open PRs from GitHub."));
+    process.exit(1);
+  }
+  const prInfo = getPRInfo(ref);
+  if (!prInfo) {
+    console.error(fail(`'${ref}' is not a local branch or GitHub PR.`));
+    process.exit(1);
+  }
+  const branch = prInfo.headRefName;
+  const prNumber = prInfo.number;
+  if (branchExists(branch)) {
+    console.log(dim(`PR #${prNumber} \u2192 ${branch}`));
+    openBranch(branch, prNumber);
+    return;
+  }
+  console.log(dim(`Fetching PR #${prNumber}...`));
+  if (!fetchPRBranch(ref, prInfo)) {
+    console.error(fail(`Failed to fetch branch '${branch}' for PR #${prNumber}`));
+    process.exit(1);
+  }
+  if (!branchExists(branch)) {
+    console.error(fail(`Failed to fetch branch '${branch}' for PR #${prNumber}`));
+    process.exit(1);
+  }
+  openBranch(branch, prNumber);
+}
 
 // commands/ls.ts
 var import_table = __toESM(require_src(), 1);
@@ -8015,7 +8238,7 @@ function lsCommand(plain = false) {
 }
 
 // commands/rm.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import { resolve as resolve2 } from "path";
 function rmCommand(branch, force = false) {
   const mainWorktree = getMainWorktree();
@@ -8046,8 +8269,8 @@ function rmCommand(branch, force = false) {
   }
   if (isDirty && force) {
     try {
-      execSync3(`git -C "${worktreePath}" reset --hard HEAD`, { stdio: "ignore" });
-      execSync3(`git -C "${worktreePath}" clean -fd`, { stdio: "ignore" });
+      execSync4(`git -C "${worktreePath}" reset --hard HEAD`, { stdio: "ignore" });
+      execSync4(`git -C "${worktreePath}" clean -fd`, { stdio: "ignore" });
     } catch {
     }
   }
@@ -8065,7 +8288,7 @@ function rmCommand(branch, force = false) {
 }
 
 // commands/status.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import { existsSync as existsSync4, readdirSync as readdirSync3 } from "fs";
 import { resolve as resolve3 } from "path";
 function getDetailedStatus(path) {
@@ -8073,7 +8296,7 @@ function getDetailedStatus(path) {
     return [];
   }
   try {
-    const status = execSync4(`git -C "${path}" status --short`, { encoding: "utf-8" }).trim();
+    const status = execSync5(`git -C "${path}" status --short`, { encoding: "utf-8" }).trim();
     if (!status) {
       return [];
     }
@@ -8139,17 +8362,17 @@ function statusCommand() {
 }
 
 // commands/preclose.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 function precloseCommand(force) {
   if (!hasUncommittedChanges()) {
     process.exit(0);
   }
   if (force) {
     try {
-      execSync5("git reset --hard HEAD", { stdio: "ignore" });
-      execSync5("git clean -ffd", { stdio: "ignore" });
-      execSync5("git submodule foreach --recursive 'git reset --hard HEAD; git clean -ffd'", { stdio: "ignore" });
-      execSync5("git submodule update --init --recursive --force", { stdio: "ignore" });
+      execSync6("git reset --hard HEAD", { stdio: "ignore" });
+      execSync6("git clean -ffd", { stdio: "ignore" });
+      execSync6("git submodule foreach --recursive 'git reset --hard HEAD; git clean -ffd'", { stdio: "ignore" });
+      execSync6("git submodule update --init --recursive --force", { stdio: "ignore" });
     } catch {
     }
     process.exit(0);
@@ -8221,162 +8444,8 @@ function promptChoice() {
   }
 }
 
-// commands/pr.ts
-import { execSync as execSync6 } from "child_process";
-import { mkdirSync as mkdirSync5 } from "fs";
-import { basename as basename5, dirname as dirname5, join as join6 } from "path";
-function checkGhInstalled() {
-  try {
-    execSync6("gh --version", { stdio: "pipe", encoding: "utf-8" });
-  } catch {
-    console.error(fail("GitHub CLI (gh) is not installed."));
-    console.error(dim("  Install it from: https://cli.github.com/"));
-    process.exit(1);
-  }
-}
-function checkGhAuthenticated() {
-  try {
-    execSync6("gh auth status", { stdio: "pipe", encoding: "utf-8" });
-  } catch {
-    console.error(fail("Not authenticated with GitHub CLI."));
-    console.error(dim("  Run: gh auth login"));
-    process.exit(1);
-  }
-}
-function getPRInfo(prRef) {
-  try {
-    const output = execSync6(
-      `gh pr view ${prRef} --json number,headRefName,headRepository,headRepositoryOwner,isCrossRepository`,
-      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    );
-    return JSON.parse(output);
-  } catch (err) {
-    const message = err instanceof Error && "stderr" in err ? err.stderr : String(err);
-    if (message.includes("Could not resolve")) {
-      console.error(fail(`PR '${prRef}' not found.`));
-      console.error(dim("  Make sure you're in a GitHub repository and the PR exists."));
-    } else if (message.includes("no pull requests found")) {
-      console.error(fail(`No pull request found for '${prRef}'.`));
-    } else {
-      console.error(fail(`Failed to get PR info: ${message}`));
-    }
-    process.exit(1);
-  }
-}
-function fetchPRBranch(prRef, prInfo) {
-  try {
-    execSync6(`git fetch origin ${prInfo.headRefName}:${prInfo.headRefName}`, { stdio: "pipe" });
-    return;
-  } catch {
-  }
-  const currentBranch = getCurrentBranch();
-  try {
-    execSync6(`gh pr checkout ${prRef}`, { stdio: "pipe" });
-    execSync6(`git checkout "${currentBranch}"`, { stdio: "pipe" });
-    return;
-  } catch {
-    try {
-      execSync6(`git checkout "${currentBranch}"`, { stdio: "pipe" });
-    } catch {
-    }
-  }
-  try {
-    execSync6(`git fetch origin pull/${prInfo.number}/head:${prInfo.headRefName}`, { stdio: "pipe" });
-    return;
-  } catch (fetchErr) {
-    const message = fetchErr instanceof Error ? fetchErr.message : String(fetchErr);
-    console.error(fail(`Failed to fetch PR branch: ${message}`));
-    process.exit(1);
-  }
-}
-function branchExistsLocally(branch) {
-  try {
-    execSync6(`git show-ref --verify --quiet refs/heads/${branch}`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function createWorktreeForPR(branch, path) {
-  execSync6(`git worktree add "${path}" "${branch}"`, { stdio: "ignore" });
-}
-function prOpenCommand(prRef) {
-  checkGhInstalled();
-  checkGhAuthenticated();
-  const prInfo = getPRInfo(prRef);
-  const branch = prInfo.headRefName;
-  const prNumber = prInfo.number;
-  if (isInsideWorktree()) {
-    const currentBranch = getCurrentBranch();
-    console.log();
-    console.log(warn(`You're inside a worktree (branch: ${cyan(currentBranch)})`));
-    console.log(`  This will nest subshells (subshell inside subshell).`);
-    console.log();
-    if (!confirm("Continue?")) {
-      process.exit(0);
-    }
-    console.log();
-  }
-  const parentBranch = getCurrentBranch();
-  const existingWorktreePath = getWorktreeForBranch(branch);
-  if (existingWorktreePath) {
-    const worktreeId2 = getWorktreeId(existingWorktreePath);
-    const mainWorktree2 = getMainWorktree();
-    console.log();
-    console.log(success(bold(`PR #${prNumber}`)), dim(`branch: ${cyan(branch)} (existing worktree)`));
-    console.log(dim("Type 'wk close' to return."));
-    console.log();
-    spawnShell(existingWorktreePath, {
-      branch,
-      worktreePath: existingWorktreePath,
-      repoPath: mainWorktree2
-    });
-    console.log();
-    console.log(success(`Back in ${bold(parentBranch)}`));
-    const currentStore2 = loadStore();
-    autoCleanupWorktree(worktreeId2, existingWorktreePath, currentStore2, saveStore);
-    console.log();
-    return;
-  }
-  if (!branchExistsLocally(branch)) {
-    console.log(dim(`Fetching PR #${prNumber}...`));
-    fetchPRBranch(prRef, prInfo);
-  }
-  if (!branchExistsLocally(branch)) {
-    console.error(fail(`Failed to fetch branch '${branch}' for PR #${prNumber}`));
-    process.exit(1);
-  }
-  const store = loadStore();
-  const mainWorktree = getMainWorktree();
-  const repoName = basename5(mainWorktree);
-  const worktreeId = `${repoName}@${slugify(branch)}`;
-  const worktreePath = join6(getWorktreesDir(), worktreeId);
-  mkdirSync5(dirname5(worktreePath), { recursive: true });
-  createWorktreeForPR(branch, worktreePath);
-  initSubmodules(worktreePath);
-  setWorktreeMeta(store, worktreeId, {
-    created_at: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  saveStore(store);
-  console.log();
-  console.log(success(bold(`PR #${prNumber}`)), dim(`branch: ${cyan(branch)}`));
-  console.log(dim(`Opened PR in ephemeral subshell`));
-  console.log(dim("Type 'exit' or 'wk close' to return."));
-  console.log();
-  spawnShell(worktreePath, {
-    branch,
-    worktreePath,
-    repoPath: mainWorktree
-  });
-  console.log();
-  console.log(success(`Back in ${bold(parentBranch)}`));
-  const currentStore = loadStore();
-  autoCleanupWorktree(worktreeId, worktreePath, currentStore, saveStore);
-  console.log();
-}
-
 // index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.4.0";
 function printHelp() {
   const dim2 = import_picocolors4.default.dim;
   const cyan2 = import_picocolors4.default.cyan;
@@ -8387,9 +8456,8 @@ ${import_picocolors4.default.bold("Usage:")} ${cyan2("wk")} ${dim2("<command>")}
 
 ${import_picocolors4.default.bold("Commands:")}
   ${green2("new")} ${dim2("[branch]")}    Create a branch and open it ${dim2("[--from <branch>]")}
-  ${green2("open")} ${dim2("<branch>")}   Open a branch in an ephemeral subshell
-  ${green2("pr open")} ${dim2("<ref>")}   Open a GitHub PR in an ephemeral subshell
-  ${green2("close")}           Exit current subshell
+  ${green2("open")} ${dim2("<ref>")}      Open a branch or PR in an ephemeral subshell
+  ${green2("close")}           Exit current workshell
   ${green2("ls")}              List open branches
   ${green2("status")}          Show current branch
   ${green2("rm")} ${dim2("<branch>")}     Remove a branch's worktree
@@ -8453,15 +8521,24 @@ ${import_picocolors4.default.bold("Description:")}
 function printOpenHelp() {
   const dim2 = import_picocolors4.default.dim;
   const cyan2 = import_picocolors4.default.cyan;
-  console.log(`${import_picocolors4.default.bold("wk open")} - Open a branch in an ephemeral subshell
+  console.log(`${import_picocolors4.default.bold("wk open")} - Open a branch or PR in an ephemeral subshell
 
-${import_picocolors4.default.bold("Usage:")} ${cyan2("wk open")} ${dim2("<branch>")}
+${import_picocolors4.default.bold("Usage:")} ${cyan2("wk open")} ${dim2("<ref>")}
 
 ${import_picocolors4.default.bold("Arguments:")}
-  ${dim2("<branch>")}  Branch name ${dim2("(required)")}
+  ${dim2("<ref>")}  Branch name, PR number, or PR URL ${dim2("(required)")}
+
+${import_picocolors4.default.bold("Examples:")}
+  ${dim2("$")} ${cyan2("wk open feature-branch")}           ${dim2("# Open local branch")}
+  ${dim2("$")} ${cyan2("wk open 123")}                      ${dim2("# Open PR #123")}
+  ${dim2("$")} ${cyan2("wk open https://github.com/o/r/pull/123")}
 
 ${import_picocolors4.default.bold("Description:")}
-  Opens the specified branch in an ephemeral subshell.
+  Opens the specified ref in an ephemeral subshell.
+  
+  First tries to open as a local branch. If not found, tries to fetch
+  as a GitHub PR (requires gh CLI to be installed and authenticated).
+  
   If a worktree already exists for the branch, uses that.
   Otherwise, creates a new worktree automatically.
   Type 'wk close' to return.`);
@@ -8511,7 +8588,7 @@ ${import_picocolors4.default.bold("Description:")}
 function printCloseHelp() {
   const dim2 = import_picocolors4.default.dim;
   const cyan2 = import_picocolors4.default.cyan;
-  console.log(`${import_picocolors4.default.bold("wk close")} - Exit current subshell
+  console.log(`${import_picocolors4.default.bold("wk close")} - Exit current workshell
 
 ${import_picocolors4.default.bold("Usage:")} ${cyan2("wk close")} ${dim2("[options]")}
 
@@ -8519,7 +8596,7 @@ ${import_picocolors4.default.bold("Options:")}
   ${cyan2("-f")}, ${cyan2("--force")}  Discard uncommitted changes and exit
 
 ${import_picocolors4.default.bold("Description:")}
-  Exits the current subshell and returns to the parent.
+  Exits the current workshell and returns to the parent.
   
   On exit, if the branch is clean:
     - Worktree is pruned (branch is kept)
@@ -8544,51 +8621,6 @@ ${import_picocolors4.default.bold("Config locations")} ${dim2("(in precedence or
   ${cyan2(".git/workshell.toml")}  Local only, not committed
   ${cyan2("workshell.toml")}       Project root, can be committed`);
 }
-function printPrHelp() {
-  const dim2 = import_picocolors4.default.dim;
-  const cyan2 = import_picocolors4.default.cyan;
-  console.log(`${import_picocolors4.default.bold("wk pr")} - Work with GitHub Pull Requests
-
-${import_picocolors4.default.bold("Usage:")} ${cyan2("wk pr")} ${dim2("<subcommand>")} ${dim2("[options]")}
-
-${import_picocolors4.default.bold("Subcommands:")}
-  ${cyan2("open")} ${dim2("<ref>")}  Open a PR in an ephemeral subshell
-
-${import_picocolors4.default.bold("Examples:")}
-  ${dim2("$")} ${cyan2("wk pr open 123")}                      ${dim2("# Open PR by number")}
-  ${dim2("$")} ${cyan2("wk pr open https://github.com/o/r/pull/123")}  ${dim2("# Open PR by URL")}
-
-${import_picocolors4.default.bold("Requirements:")}
-  Requires GitHub CLI (gh) to be installed and authenticated.
-  ${dim2("Install: https://cli.github.com/")}
-  ${dim2("Auth:    gh auth login")}`);
-}
-function printPrOpenHelp() {
-  const dim2 = import_picocolors4.default.dim;
-  const cyan2 = import_picocolors4.default.cyan;
-  console.log(`${import_picocolors4.default.bold("wk pr open")} - Open a GitHub PR in an ephemeral subshell
-
-${import_picocolors4.default.bold("Usage:")} ${cyan2("wk pr open")} ${dim2("<ref>")}
-
-${import_picocolors4.default.bold("Arguments:")}
-  ${dim2("<ref>")}  PR number, URL, or branch name ${dim2("(required)")}
-
-${import_picocolors4.default.bold("Examples:")}
-  ${dim2("$")} ${cyan2("wk pr open 123")}
-  ${dim2("$")} ${cyan2("wk pr open https://github.com/owner/repo/pull/123")}
-  ${dim2("$")} ${cyan2("wk pr open feature-branch")}
-
-${import_picocolors4.default.bold("Description:")}
-  Fetches the PR branch and opens it in an ephemeral subshell.
-  If a worktree already exists for the branch, uses that.
-  Otherwise, creates a new worktree automatically.
-  Type 'wk close' to return.
-
-${import_picocolors4.default.bold("Requirements:")}
-  Requires GitHub CLI (gh) to be installed and authenticated.
-  ${dim2("Install: https://cli.github.com/")}
-  ${dim2("Auth:    gh auth login")}`);
-}
 function isHelp(arg) {
   return arg === "--help" || arg === "-h";
 }
@@ -8630,7 +8662,7 @@ switch (cmd) {
       process.exit(0);
     }
     if (!args[1]) {
-      console.error("Usage: wk open <branch>");
+      console.error("Usage: wk open <branch|pr-number|pr-url>");
       process.exit(1);
     }
     openCommand(args[1]);
@@ -8667,35 +8699,23 @@ switch (cmd) {
     }
     configCommand();
     break;
-  case "pr": {
-    const subCmd = args[1];
-    if (!subCmd || isHelp(subCmd)) {
-      printPrHelp();
-      process.exit(0);
-    }
-    if (subCmd === "open") {
-      if (isHelp(args[2])) {
-        printPrOpenHelp();
-        process.exit(0);
-      }
-      if (!args[2]) {
-        console.error("Usage: wk pr open <pr-number|url|branch>");
-        process.exit(1);
-      }
-      prOpenCommand(args[2]);
-    } else {
-      console.error(`Unknown pr subcommand: ${subCmd}`);
-      console.error("Run 'wk pr --help' for usage.");
-      process.exit(1);
-    }
-    break;
-  }
   case "close":
     if (isHelp(args[1])) {
       printCloseHelp();
       process.exit(0);
     }
-    console.error(fail("'wk close' only works inside a wk subshell."));
+    if (!isInsideWorkshell() && isInsideWorktree()) {
+      const currentBranch = getCurrentBranch();
+      const mainWorktree = getMainWorktree();
+      const shell = process.env.SHELL || "/bin/bash";
+      console.log();
+      console.log(dim(`You're in a worktree (branch: ${cyan(currentBranch)}) but not a workshell.`));
+      console.log(dim(`Opening repo root in a fresh shell...`));
+      console.log();
+      spawnSync2(shell, [], { cwd: mainWorktree, stdio: "inherit" });
+      process.exit(0);
+    }
+    console.error(fail("'wk close' only works inside a workshell."));
     process.exit(1);
     break;
   case "__preclose":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workshell",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "Agent- and human-friendly Git multitasking, powered by worktrees",
   "type": "module",
   "license": "MIT",