workshell 0.2.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()
   });
@@ -7185,6 +7305,15 @@ function openBranch(branch, prNumber) {
   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()
   });
@@ -7211,10 +7340,10 @@ function openBranch(branch, prNumber) {
   console.log();
 }
 function openCommand(ref) {
-  if (isInsideWorktree()) {
+  if (isInsideWorkshell()) {
     const currentBranch = getCurrentBranch();
     console.log();
-    console.log(warn(`You're inside a worktree (branch: ${cyan(currentBranch)})`));
+    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?")) {
@@ -8316,7 +8445,7 @@ function promptChoice() {
 }
 
 // index.ts
-var VERSION = "0.2.0";
+var VERSION = "0.4.0";
 function printHelp() {
   const dim2 = import_picocolors4.default.dim;
   const cyan2 = import_picocolors4.default.cyan;
@@ -8328,7 +8457,7 @@ ${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("<ref>")}      Open a branch or PR in an ephemeral subshell
-  ${green2("close")}           Exit current 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
@@ -8459,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]")}
 
@@ -8467,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)
@@ -8575,7 +8704,18 @@ switch (cmd) {
       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.2.0",
+  "version": "0.4.0",
   "description": "Agent- and human-friendly Git multitasking, powered by worktrees",
   "type": "module",
   "license": "MIT",