@glrs-dev/cli 0.0.1 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @glrs-dev/cli
 
+## 0.1.1
+
+### Patch Changes
+
+- [`050f4b9`](https://github.com/iceglober/glrs/commit/050f4b9bf2304dd5fb5031c38e7fe247b68ead07) Thanks [@iceglober](https://github.com/iceglober)! - **Rename `@glrs-dev/harness-opencode` → `@glrs-dev/harness-plugin-opencode` and republish.**
+
+  ## Why
+
+  OpenCode resolves plugins by npm-installing them into `~/.cache/opencode/packages/<plugin>@<version>/` at plugin-load time. The previous plan — marking `@glrs-dev/harness-opencode` as `private: true` and vendoring it only into `@glrs-dev/cli` — broke OpenCode's plugin loader because the package wasn't published on npm, causing `ETARGET: No matching version found for @glrs-dev/harness-opencode@1.0.0`.
+
+  The fix: publish the plugin under a new name (`@glrs-dev/harness-plugin-opencode`) so OpenCode can resolve it normally. The old name stays deprecated at its last published version (`0.16.2`).
+
+  ## What changed
+
+  - `packages/harness-opencode/package.json`: renamed from `@glrs-dev/harness-opencode` to `@glrs-dev/harness-plugin-opencode`, `private: true` removed, `publishConfig.access: public` + `provenance: true` added, version reset to `0.1.0` (fresh name on npm).
+  - The `install` / `uninstall` / `doctor` flows now write the new name to `opencode.json`'s plugin array.
+  - `@glrs-dev/cli` still bundles a vendored copy of the plugin for standalone subprocess dispatch (`glrs oc`), but the npm-resolved copy is what OpenCode's plugin runtime loads.
+  - Bin names unchanged — `harness-opencode` and `glrs-oc` still work.
+
+  ## Migration for existing users
+
+  Re-run `glrs oc install` to update your `opencode.json` plugin array from `@glrs-dev/harness-opencode` to `@glrs-dev/harness-plugin-opencode`. The old entry will be replaced; no data loss.
+
+## 0.1.0
+
+### Minor Changes
+
+- [`37da38d`](https://github.com/iceglober/glrs/commit/37da38d0c0ffebf6758ef696644be3c79203eb4d) Thanks [@iceglober](https://github.com/iceglober)! - **First release of `@glrs-dev/cli` as the unified entry point for the @glrs-dev ecosystem.**
+
+  ## What's included
+
+  - `glrs oc <args>` — dispatches to a vendored copy of `@glrs-dev/harness-opencode` (the OpenCode agent harness). The harness-opencode bin is bundled inside this tarball at `dist/vendor/harness-opencode/`; no separate install needed.
+  - `glrs wt <args>` — worktree management (create, list, switch, delete, cleanup). Stores worktrees under `~/.glorious/worktrees/<repo>/<name>/`.
+
+  ## Install
+
+  ```bash
+  npm i -g @glrs-dev/cli
+  ```
+
+  Requires Bun >= 1.2.0 on PATH — the CLI and the vendored harness use Bun-native APIs (`bun:sqlite`, `Bun.spawn`).
+
+  ## Migration
+
+  - `@glrs-dev/harness-opencode` on npm is being deprecated. Its final published version (`0.16.2` or later) should be the last. Users should migrate to `glrs oc <args>`.
+  - `@glrs-dev/agentic` has been removed from the repo. Its worktree-management commands live natively under `glrs wt`.
+  - `@glrs-dev/assume` remains a separate, standalone package — install it independently if you need the SSO credential manager.
+
+- [`b3ff224`](https://github.com/iceglober/glrs/commit/b3ff2249da36abb6669588ddf08d57c2d3b00464) Thanks [@iceglober](https://github.com/iceglober)! - Add `@research` agent and four bundled research skills (`research`, `research-web`, `research-local`, `research-auto`) to the vendored harness-opencode. `@research` is an Opus-class, `mode: all` orchestrator that decomposes research queries into parallel workstreams, dispatches per-workstream sub-agents using one of the four skills (multi-round umbrella, local codebase, web, or autonomous `.lab/` experimentation), reviews findings for gaps, iterates, and synthesizes. The existing `/research` slash command is rewritten as a thin delegator to `@research`; PRIME's subagent-reference recap gains an `@research` entry so its task-tool picker surfaces the agent alongside `@plan`, `@build`, `@code-searcher`, `@qa-reviewer`, etc.
+
 ## 0.0.1
 
 ### Patch Changes

package/README.md

@@ -1,35 +1,34 @@
 # `@glrs-dev/cli`
 
-Unified CLI for the [@glrs-dev](https://www.npmjs.com/org/glrs-dev) ecosystem. One binary, three subcommands:
+Unified CLI for the [@glrs-dev](https://www.npmjs.com/org/glrs-dev) ecosystem. One binary, two subcommands:
 
 ```bash
 npm i -g @glrs-dev/cli
 ```
 
 ```bash
-glrs oc install              # → harness-opencode install
-glrs agentic wt new feature  # → gs-agentic wt new feature
-glrs assume login aws        # → gs-assume login aws
+glrs oc install       # → OpenCode harness install
+glrs wt new feature   # create a worktree
+glrs wt list          # list worktrees across repos
+glrs wt switch        # interactive picker
 ```
 
-Each subtool still ships its own direct bin — `harness-opencode`, `gs-agentic` / `gsag`, `gs-assume` / `gsa` — if you prefer typing those. The dispatcher exists to give new users one install command and one entry point to remember.
+Requires [Bun](https://bun.sh) on PATH at runtime.
 
-## How it works
+The `harness-opencode` bin remains available directly for power users who prefer the untagged entry point.
 
-The `glrs` binary is a thin dispatcher. It:
+## How it works
 
-1. Reads the first positional arg as the subcommand (`oc`, `agentic`, `assume`)
-2. Resolves the underlying binary via `require.resolve(<package>/package.json)` → reads the `bin` field
-3. Spawns the binary with the remaining argv forwarded, inheriting stdio
-4. Exits with the child's exit code
+The `glrs` binary has two subcommands:
 
-For the `assume` subcommand, the dispatcher imports `@glrs-dev/assume`'s exported `getBinaryPath()` directly and execs the prebuilt Rust binary — skipping the TS shim middle-layer for interactive credential operations.
+- **`glrs oc <args>`** — dispatches to [`@glrs-dev/harness-plugin-opencode`](../harness-opencode/) (bundled as a dependency). Resolves the bin via `require.resolve(<package>/package.json)` → reads the `bin` field → spawns with argv forwarded.
+- **`glrs wt <args>`** — worktree management, handled natively. Commands: `new`, `list`, `switch`, `delete`, `cleanup`. Worktrees are stored in `~/.glorious/worktrees/<repo>/<name>/`.
 
 ## Philosophy
 
-- **Don't duplicate CLI logic.** Every flag, every subcommand, every option lives in the underlying tool. The dispatcher adds no behavior.
-- **Don't fragment muscle memory.** `harness-opencode` / `gsag` / `gsa` keep working forever. `glrs` is additive, not a replacement.
-- **One install, one thing to remember.** For new users in the @glrs-dev ecosystem, `npm i -g @glrs-dev/cli` gets them everything.
+- **Don't duplicate CLI logic.** `glrs oc` is a thin spawn wrapper around `harness-opencode`.
+- **One install, one thing to remember** for the harness + worktree workflow.
+- **Separate concerns stay separate.** The SSO credential tool [`@glrs-dev/assume`](../assume/) is a standalone Rust binary installed separately.
 
 ## Docs
 

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-6RHN2EDH.js

@@ -0,0 +1,93 @@
+import {
+  go
+} from "./chunk-DEODG2LC.js";
+import {
+  currentBranchIn,
+  gitInSafe,
+  gitRoot,
+  gitSafe,
+  listWorktrees
+} from "./chunk-LMRDQ4GW.js";
+import {
+  loadRegistry
+} from "./chunk-VCN7RNLU.js";
+import {
+  bold,
+  dim
+} from "./chunk-YBCA3IP6.js";
+
+// src/commands/list.ts
+import * as path from "path";
+import { command, flag } from "cmd-ts";
+var list = command({
+  name: "list",
+  aliases: ["ls"],
+  description: "List all worktrees across repos",
+  args: {
+    interactive: flag({
+      long: "interactive",
+      short: "i",
+      description: "Interactively pick a worktree to switch into (same as `wt switch`)."
+    })
+  },
+  handler: async ({ interactive }) => {
+    if (interactive) {
+      await go();
+      return;
+    }
+    const entries = loadRegistry();
+    if (entries.length === 0) {
+      if (gitSafe("rev-parse", "--git-dir")) {
+        showLocalWorktrees();
+        return;
+      }
+      console.log(
+        dim("No worktrees registered. Create one with: glrs wt new")
+      );
+      return;
+    }
+    const byRepo = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const list2 = byRepo.get(entry.repo) ?? [];
+      list2.push(entry);
+      byRepo.set(entry.repo, list2);
+    }
+    for (const [repo, repoEntries] of byRepo) {
+      console.log(`
+${bold(repo)} ${dim(repoEntries[0].repoPath)}`);
+      for (const entry of repoEntries) {
+        const current = currentBranchIn(entry.wtPath);
+        const branchCol = current && current !== entry.branch ? `${entry.branch} ${dim(`\u2192 ${current}`)}` : current ?? entry.branch;
+        const commit = gitInSafe(entry.wtPath, "rev-parse", "--short", "HEAD") ?? dim("?");
+        console.log(
+          `  ${pad(branchCol, 45)} ${pad(commit, 10)} ${dim(entry.wtPath)}`
+        );
+      }
+    }
+    console.log();
+  }
+});
+function showLocalWorktrees() {
+  const entries = listWorktrees();
+  const root = gitRoot();
+  console.log(bold(pad("NAME", 40) + pad("BRANCH", 30) + "COMMIT"));
+  console.log(pad("\u2500\u2500\u2500\u2500", 40) + pad("\u2500\u2500\u2500\u2500\u2500\u2500", 30) + "\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const entry of entries) {
+    let displayName = path.basename(entry.path);
+    if (entry.path === root) {
+      displayName += ` ${dim("(main)")}`;
+    }
+    const branch = entry.branch ? entry.branch.replace("refs/heads/", "") : "(detached)";
+    const shortCommit = entry.commit.slice(0, 7);
+    console.log(pad(displayName, 40) + pad(branch, 30) + shortCommit);
+  }
+}
+function pad(s, width) {
+  const visible = s.replace(/\x1b\[[0-9;]*m/g, "");
+  const padding = Math.max(0, width - visible.length);
+  return s + " ".repeat(padding);
+}
+
+export {
+  list
+};

package/dist/chunk-DEODG2LC.js

@@ -0,0 +1,55 @@
+import {
+  select
+} from "./chunk-P7PRH4I3.js";
+import {
+  currentBranchIn,
+  spawnShell
+} from "./chunk-LMRDQ4GW.js";
+import {
+  loadRegistry
+} from "./chunk-VCN7RNLU.js";
+import {
+  bold,
+  dim,
+  info,
+  warn
+} from "./chunk-YBCA3IP6.js";
+
+// src/commands/go.ts
+async function go() {
+  const entries = loadRegistry();
+  if (entries.length === 0) {
+    warn(
+      "no worktrees registered \u2014 create one with: glrs wt new"
+    );
+    return;
+  }
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list = byRepo.get(entry.repo) ?? [];
+    list.push(entry);
+    byRepo.set(entry.repo, list);
+  }
+  const groups = [];
+  for (const [repo, repoEntries] of byRepo) {
+    groups.push({
+      title: repo,
+      choices: repoEntries.map((e) => {
+        const current = currentBranchIn(e.wtPath);
+        const label = current && current !== e.branch ? `${e.branch} ${dim(`\u2192 ${current}`)}` : e.branch;
+        return { label, value: e, hint: e.wtPath };
+      })
+    });
+  }
+  const selected = await select({
+    message: "Select a worktree",
+    groups
+  });
+  if (!selected) return;
+  info(`opening shell in ${bold(selected.branch)}...`);
+  spawnShell(selected.wtPath);
+}
+
+export {
+  go
+};

package/dist/chunk-FSAGM22T.js

@@ -0,0 +1,17 @@
+import {
+  go
+} from "./chunk-DEODG2LC.js";
+
+// src/commands/switch.ts
+import { command } from "cmd-ts";
+var switchCmd = command({
+  name: "switch",
+  aliases: ["sw"],
+  description: "Interactive worktree picker \u2014 select a worktree to open a shell in",
+  args: {},
+  handler: go
+});
+
+export {
+  switchCmd
+};

package/dist/chunk-GQBZREK5.js

@@ -0,0 +1,136 @@
+import {
+  createWorktree
+} from "./chunk-VJFNIKQJ.js";
+import {
+  spawnShell
+} from "./chunk-LMRDQ4GW.js";
+import {
+  loadRegistry
+} from "./chunk-VCN7RNLU.js";
+import {
+  info
+} from "./chunk-YBCA3IP6.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/commands/create.ts
+import { command, positional, option, optional, string } from "cmd-ts";
+import * as path from "path";
+import * as os from "os";
+var INDEX_DIR = path.join(os.homedir(), ".glorious");
+var INDEX_FILE = path.join(INDEX_DIR, "repos.json");
+function existsSync(filePath) {
+  return Bun.file(filePath).existsSync();
+}
+function readTextSync(filePath) {
+  try {
+    return Bun.file(filePath).textSync();
+  } catch {
+    return null;
+  }
+}
+function loadRepoIndex() {
+  if (!existsSync(INDEX_FILE)) return {};
+  try {
+    const raw = readTextSync(INDEX_FILE);
+    if (!raw) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function lookupRepo(name) {
+  return loadRepoIndex()[name] ?? null;
+}
+function scanRoots() {
+  return ["~/repos", "~/code", "~/src"].map((p) => p.replace("~", os.homedir())).filter((p) => existsSync(p));
+}
+function findRepoByScan(name, maxDepth = 4) {
+  const skip = /* @__PURE__ */ new Set(["node_modules", "target", "dist", "vendor"]);
+  for (const root of scanRoots()) {
+    const hit = walk(root, name, skip, maxDepth, 0);
+    if (hit) return hit;
+  }
+  return null;
+}
+function walk(dir, name, skip, maxDepth, depth) {
+  if (depth > maxDepth) return null;
+  if (path.basename(dir) === name && existsSync(path.join(dir, ".git"))) {
+    return dir;
+  }
+  let children;
+  try {
+    children = __require("fs").readdirSync(dir);
+  } catch {
+    return null;
+  }
+  if (existsSync(path.join(dir, ".git"))) return null;
+  for (const child of children) {
+    if (skip.has(child) || child.startsWith(".")) continue;
+    const full = path.join(dir, child);
+    let stat;
+    try {
+      stat = __require("fs").statSync(full);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    const found = walk(full, name, skip, maxDepth, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+function resolveRepoPath(repo) {
+  if (!repo) return void 0;
+  const wt = loadRegistry().find((e) => e.repo === repo);
+  if (wt) {
+    if (!existsSync(wt.repoPath)) {
+      throw new Error(
+        `Registered repo '${repo}' points to ${wt.repoPath}, which no longer exists.`
+      );
+    }
+    return wt.repoPath;
+  }
+  const indexed = lookupRepo(repo);
+  if (indexed) return indexed;
+  const scanned = findRepoByScan(repo);
+  if (scanned) return scanned;
+  throw new Error(
+    `No repo named '${repo}' found.
+  Looked in worktree registry, ~/.glorious/repos.json, and scan roots.
+  Fix: run 'glrs wt new' from inside the repo once.`
+  );
+}
+var create = command({
+  name: "new",
+  aliases: ["create"],
+  description: "Create a worktree from the latest origin default branch. Name is auto-generated.",
+  args: {
+    repo: positional({
+      type: optional(string),
+      displayName: "repo",
+      description: "Optional repo name. Required when running outside a git repo; looked up in the worktree registry, the repo index, or under repo.scan-roots."
+    }),
+    from: option({
+      type: optional(string),
+      long: "from",
+      description: "Base branch override (default: remote default branch). Rare \u2014 prefer default."
+    })
+  },
+  handler: ({ repo, from }) => {
+    const repoPath = resolveRepoPath(repo);
+    const { wtPath } = createWorktree({ from, repoPath, repo });
+    console.log(`
+  cd ${wtPath}
+`);
+    if (process.stdin.isTTY) {
+      info("spawning shell in worktree (exit to return)...");
+      spawnShell(wtPath);
+    }
+  }
+});
+
+export {
+  create
+};

package/dist/chunk-HWMRY35D.js

@@ -0,0 +1,139 @@
+import {
+  isProtected
+} from "./chunk-W37UX3U2.js";
+import {
+  defaultBranch,
+  git,
+  gitInSafe,
+  gitRoot,
+  gitSafe,
+  listWorktrees
+} from "./chunk-LMRDQ4GW.js";
+import {
+  unregisterWorktree
+} from "./chunk-VCN7RNLU.js";
+import {
+  bold,
+  dim,
+  info,
+  ok,
+  red,
+  warn
+} from "./chunk-YBCA3IP6.js";
+
+// src/commands/cleanup.ts
+import * as readline from "readline";
+import { command, option, flag, optional, string } from "cmd-ts";
+var cleanup = command({
+  name: "cleanup",
+  description: "Delete worktrees whose branches are merged or stale",
+  args: {
+    base: option({
+      type: optional(string),
+      long: "base",
+      description: "Base branch to check against (default: auto-detect)"
+    }),
+    dryRun: flag({
+      long: "dry-run",
+      description: "Show candidates without deleting"
+    }),
+    yes: flag({ long: "yes", short: "y", description: "Skip confirmation" })
+  },
+  handler: async ({ base: baseOpt, dryRun, yes }) => {
+    const base = baseOpt ?? defaultBranch();
+    info(`checking worktrees against ${bold(base)}...`);
+    gitSafe("fetch", "origin", base, "--quiet");
+    const entries = listWorktrees();
+    const root = gitRoot();
+    const candidates = [];
+    for (const entry of entries) {
+      if (entry.path === root) continue;
+      const branch = entry.branch?.replace("refs/heads/", "");
+      if (!branch) continue;
+      if (isProtected(branch)) continue;
+      const merged = gitSafe(
+        "merge-base",
+        "--is-ancestor",
+        entry.branch,
+        `origin/${base}`
+      ) !== null;
+      const remoteDeleted = gitSafe(
+        "show-ref",
+        "--verify",
+        "--quiet",
+        `refs/remotes/origin/${branch}`
+      ) === null;
+      if (!merged && !remoteDeleted) continue;
+      const status = gitInSafe(entry.path, "status", "--porcelain");
+      if (status === null || status !== "") {
+        if (status !== null && status !== "") {
+          warn(`skipping ${branch} -- has uncommitted changes`);
+        }
+        continue;
+      }
+      if (!remoteDeleted) {
+        const unpushed = gitInSafe(
+          entry.path,
+          "log",
+          "--oneline",
+          `origin/${base}..HEAD`
+        );
+        const count = unpushed ? unpushed.split("\n").filter(Boolean).length : 0;
+        if (count > 0) {
+          warn(`skipping ${branch} -- has ${count} unpushed commit(s)`);
+          continue;
+        }
+      }
+      candidates.push({ path: entry.path, branch });
+    }
+    if (candidates.length === 0) {
+      ok("no worktrees to clean up");
+      return;
+    }
+    console.log(`
+${bold("Candidates for cleanup:")}`);
+    for (const c of candidates) {
+      console.log(`  ${red("\u2715")} ${c.branch}  ${dim(`(${c.path})`)}`);
+    }
+    console.log();
+    if (dryRun) {
+      info("dry run -- no worktrees deleted");
+      return;
+    }
+    if (!yes) {
+      const confirmed = await confirm(
+        `Delete ${candidates.length} worktree(s)? [y/N] `
+      );
+      if (!confirmed) {
+        info("aborted");
+        return;
+      }
+    }
+    for (const c of candidates) {
+      try {
+        git("worktree", "remove", c.path);
+        gitSafe("branch", "-d", c.branch);
+        unregisterWorktree(c.path);
+        ok(`deleted ${c.branch}`);
+      } catch {
+        warn(`failed to delete ${c.branch}`);
+      }
+    }
+  }
+});
+function confirm(prompt) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(/^[Yy]$/.test(answer.trim()));
+    });
+  });
+}
+
+export {
+  cleanup
+};

package/dist/chunk-LMRDQ4GW.js

@@ -0,0 +1,129 @@
+// src/lib/git.ts
+import * as path from "path";
+function git(...args) {
+  const result = Bun.spawnSync(["git", ...args], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (!result.success) {
+    const err = new TextDecoder().decode(result.stderr);
+    throw new Error(err || `git ${args.join(" ")} failed`);
+  }
+  return new TextDecoder().decode(result.stdout).trim();
+}
+function gitSafe(...args) {
+  const result = Bun.spawnSync(["git", ...args], {
+    stdout: "pipe",
+    stderr: "ignore"
+  });
+  if (!result.success) return null;
+  return new TextDecoder().decode(result.stdout).trim();
+}
+function gitIn(cwd, ...args) {
+  const result = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (!result.success) {
+    const err = new TextDecoder().decode(result.stderr);
+    throw new Error(err || `git ${args.join(" ")} failed in ${cwd}`);
+  }
+  return new TextDecoder().decode(result.stdout).trim();
+}
+function gitInSafe(cwd, ...args) {
+  const result = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "ignore"
+  });
+  if (!result.success) return null;
+  return new TextDecoder().decode(result.stdout).trim();
+}
+function spawnShell(cwd) {
+  const shell = process.env.SHELL || "bash";
+  Bun.spawnSync([shell], {
+    cwd,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+}
+function gitRoot() {
+  const commonDir = git("rev-parse", "--git-common-dir");
+  if (!path.isAbsolute(commonDir)) {
+    return git("rev-parse", "--show-toplevel");
+  }
+  return path.dirname(commonDir);
+}
+function defaultBranch() {
+  return defaultBranchIn(process.cwd());
+}
+function defaultBranchIn(repoPath) {
+  const ref = gitInSafe(repoPath, "symbolic-ref", "refs/remotes/origin/HEAD");
+  if (ref) return ref.replace("refs/remotes/origin/", "");
+  for (const name of ["main", "master"]) {
+    if (gitInSafe(
+      repoPath,
+      "show-ref",
+      "--verify",
+      `refs/remotes/origin/${name}`
+    ) !== null) {
+      return name;
+    }
+  }
+  for (const name of ["main", "master"]) {
+    if (gitInSafe(repoPath, "show-ref", "--verify", `refs/heads/${name}`) !== null) {
+      return name;
+    }
+  }
+  throw new Error(
+    "Cannot detect default branch. Set it with: git remote set-head origin <branch>"
+  );
+}
+function currentBranchIn(wtPath) {
+  const out = gitInSafe(wtPath, "branch", "--show-current");
+  return out && out.length > 0 ? out : null;
+}
+function listWorktrees() {
+  const raw = git("worktree", "list", "--porcelain");
+  const entries = [];
+  let current = {};
+  for (const line of raw.split("\n")) {
+    if (line === "") {
+      if (current.path) {
+        entries.push({
+          path: current.path,
+          commit: current.commit ?? "",
+          branch: current.branch ?? null
+        });
+      }
+      current = {};
+      continue;
+    }
+    if (line.startsWith("worktree ")) current.path = line.slice(9);
+    else if (line.startsWith("HEAD ")) current.commit = line.slice(5);
+    else if (line.startsWith("branch ")) current.branch = line.slice(7);
+  }
+  if (current.path) {
+    entries.push({
+      path: current.path,
+      commit: current.commit ?? "",
+      branch: current.branch ?? null
+    });
+  }
+  return entries;
+}
+
+export {
+  git,
+  gitSafe,
+  gitIn,
+  gitInSafe,
+  spawnShell,
+  gitRoot,
+  defaultBranch,
+  defaultBranchIn,
+  currentBranchIn,
+  listWorktrees
+};