workshell 0.0.6 → 0.1.0

package/README.md

@@ -20,7 +20,12 @@
 ## Install
 
 ```bash
-$ npm i -g workshell
+$ npm i -g workshell  # aliases to `wk`
+$ wk --help
+wk v0.0.6 - Open branches in ephemeral subshells
+
+Usage: wk <command> [options]
+# ...
 ```
 
 <br/>
@@ -34,7 +39,7 @@ There have been many attempts to nail a DX for parallel work in the agentic codi
 Here's how it works (key points in **bold**).
 
 - You open a Git branch with `wk open <branch>` or create a new one with `wk new <branch>`.
-- An ephemeral worktree is created for this branch (in `.git/workshell/worktrees`) and **opened in a fresh subshell**.
+- An ephemeral worktree is created for this branch (in `~/.workshell/worktrees`) and **opened in a fresh subshell**.
 - You are now in an fresh checkout of your repo that is isolated on disk. Make changes with your agent/editor of choice and commit them.
 - You close the subshell with `wk close`. **The associated worktree is auto-pruned**.
 - Your changes still exist on the associated branch, as Git commits/branches are shared among all worktrees. The worktree is destroyed—but your commits aren't.
@@ -48,7 +53,7 @@ There have been many attempts to nail a DX for parallel work in the agentic codi
 
 Here's how it works (key points in **bold**).
 
-- **A fresh worktree is created** — The `wk` utility a) creates a new worktree in `.git/workshell/worktrees` and b) opens it in a *subshell*.
+- **A fresh worktree is created** — The `wk` utility a) creates a new worktree in `~/.workshell/worktrees` and b) opens it in a *subshell*.
 - **Make edits and commit** — From the worksh your preferred IDE/agent.
 - **Commit your changes** — Though your file system is isolated, Git commit history (including branches) is still shared among all worktrees. 
 - **Exit the subshell** — Run `wk close` to exit the subshell. As with `git switch`, `wk close` won't let you close the subshell if you have unstaged/uncommitted changes.
@@ -106,7 +111,7 @@ After cloning, the `main` branch is checked out. Let's say we want to start work
 $ wk new feat-1
 
 ✓ feat-1 (from main)
-Opened branch in ephemeral subshell at .git/workshell/worktrees/zod@feat-1
+Opened branch in ephemeral subshell
 Type 'wk close' to return.
 ```
 
@@ -116,7 +121,7 @@ You're now in a workshell. Check where you are:
 
 ```bash
 $ pwd
-/Users/colinmcd94/Documents/repos/zod/.git/workshell/worktrees/zod@feat-1
+~/.workshell/worktrees/{repo-id}/zod@feat-1
 
 $ git branch --show-current
 feat-1
@@ -325,6 +330,6 @@ Currently only one setting is supported: `setup`.
 # the following variable substitutions are supported
 #   `{{ 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. `/path/to/repo/.git/workshell/worktrees/repo@feat`
+#   `{{ worktree_path }}` — The absolute path to worktree, e.g. `~/.workshell/worktrees/.../repo@feat`
 setup = "npm install && cp {{ repo_path }}/.env {{ worktree_path }}/.env"
 ```

package/dist/index.js

@@ -5785,13 +5785,15 @@ var require_src = __commonJS({
 var import_picocolors4 = __toESM(require_picocolors(), 1);
 
 // commands/new.ts
-import { basename as basename3, dirname as dirname3, join as join3, relative } from "path";
+import { basename as basename3, dirname as dirname3, join as join3 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 
 // store.ts
 import { execSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { basename, dirname, isAbsolute, join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
 
 // node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -6480,6 +6482,25 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 
 // store.ts
 var STORE_FILE = "store.json";
+function getWorkshellRoot() {
+  const xdgDataHome = process.env.XDG_DATA_HOME;
+  if (xdgDataHome) {
+    return join(xdgDataHome, "workshell");
+  }
+  return join(homedir(), ".workshell");
+}
+function getRepoId() {
+  try {
+    const id = execSync("git config --local workshell.id", { encoding: "utf-8" }).trim();
+    if (id) {
+      return id;
+    }
+  } catch {
+  }
+  const newId = randomUUID().replace(/-/g, "").slice(0, 8);
+  execSync(`git config --local workshell.id "${newId}"`, { encoding: "utf-8" });
+  return newId;
+}
 function getGitRoot() {
   return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
 }
@@ -6494,33 +6515,51 @@ function getMainWorktree() {
   return dirname(getGitCommonDir());
 }
 function getWorktreesDir() {
-  return join(getGitCommonDir(), "workshell", "worktrees");
+  return join(getWorkshellRoot(), "worktrees", getRepoId());
 }
 function getStorePath() {
-  return join(getGitCommonDir(), "workshell");
+  return getWorkshellRoot();
 }
-function loadStore() {
+function loadGlobalStore() {
   const storePath = getStorePath();
   const filePath = join(storePath, STORE_FILE);
   if (!existsSync(filePath)) {
-    return { worktrees: {} };
+    return { repos: {} };
   }
   try {
     const data = readFileSync(filePath, "utf-8");
     const raw = JSON.parse(data);
-    if (Array.isArray(raw.worktrees) || typeof raw.worktrees !== "object") {
-      return { worktrees: {}, auto_merge_prompt: raw.auto_merge_prompt };
+    if (raw.repos && typeof raw.repos === "object") {
+      return raw;
     }
-    return raw;
+    return { repos: {} };
   } catch {
-    return { worktrees: {} };
+    return { repos: {} };
   }
 }
-function saveStore(store) {
+function saveGlobalStore(globalStore) {
   const storePath = getStorePath();
   mkdirSync(storePath, { recursive: true });
   const filePath = join(storePath, STORE_FILE);
-  writeFileSync(filePath, JSON.stringify(store, null, 2));
+  writeFileSync(filePath, JSON.stringify(globalStore, null, 2));
+}
+function loadStore() {
+  const globalStore = loadGlobalStore();
+  const repoId = getRepoId();
+  const repoData = globalStore.repos[repoId];
+  if (!repoData) {
+    return { worktrees: {} };
+  }
+  if (Array.isArray(repoData.worktrees) || typeof repoData.worktrees !== "object") {
+    return { worktrees: {}, auto_merge_prompt: repoData.auto_merge_prompt };
+  }
+  return repoData;
+}
+function saveStore(store) {
+  const globalStore = loadGlobalStore();
+  const repoId = getRepoId();
+  globalStore.repos[repoId] = store;
+  saveGlobalStore(globalStore);
 }
 function getWorktreeMeta(store, id) {
   return store.worktrees[id];
@@ -7043,7 +7082,7 @@ function newCommand(branchName, fromBranch) {
   const parentBranch = getCurrentBranch();
   console.log();
   console.log(success(bold(branch)), dim(`(from ${cyan(baseBranch)})`));
-  console.log(dim(`Opened branch in ephemeral subshell at ${relative(mainWorktree, worktreePath)}`));
+  console.log(dim(`Opened branch in ephemeral subshell`));
   console.log(dim("Type 'wk close' to return."));
   console.log();
   spawnShell(worktreePath, {
@@ -7060,7 +7099,7 @@ function newCommand(branchName, fromBranch) {
 
 // commands/open.ts
 import { mkdirSync as mkdirSync4 } from "fs";
-import { basename as basename4, dirname as dirname4, join as join4, relative as relative2 } from "path";
+import { basename as basename4, dirname as dirname4, join as join4 } from "path";
 function openCommand(branch) {
   if (isInsideWorktree()) {
     const currentBranch = getCurrentBranch();
@@ -7112,7 +7151,7 @@ function openCommand(branch) {
   saveStore(store);
   console.log();
   console.log(success(bold(branch)));
-  console.log(dim(`Opened branch in ephemeral subshell at ${relative2(mainWorktree, worktreePath)}`));
+  console.log(dim(`Opened branch in ephemeral subshell`));
   console.log(dim("Type 'exit' or 'wk close' to return."));
   console.log();
   spawnShell(worktreePath, {
@@ -8182,8 +8221,162 @@ 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.0.6";
+var VERSION = "0.1.0";
 function printHelp() {
   const dim2 = import_picocolors4.default.dim;
   const cyan2 = import_picocolors4.default.cyan;
@@ -8195,6 +8388,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("<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("ls")}              List open branches
   ${green2("status")}          Show current branch
@@ -8350,6 +8544,51 @@ ${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";
 }
@@ -8428,6 +8667,29 @@ 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();

package/package.json

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