@glrs-dev/cli 0.0.1 → 0.1.0

package/dist/chunk-NLPX2KOF.js

@@ -0,0 +1,149 @@
+import {
+  worktreePath
+} from "./chunk-W37UX3U2.js";
+import {
+  multiSelect
+} from "./chunk-P7PRH4I3.js";
+import {
+  gitIn,
+  gitInSafe,
+  gitRoot,
+  listWorktrees
+} from "./chunk-LMRDQ4GW.js";
+import {
+  loadRegistry,
+  unregisterWorktree
+} from "./chunk-VCN7RNLU.js";
+import {
+  bold,
+  dim,
+  ok,
+  red,
+  warn
+} from "./chunk-YBCA3IP6.js";
+
+// src/commands/delete.ts
+import * as readline from "readline";
+import { command, positional, flag, optional, string } from "cmd-ts";
+var del = command({
+  name: "delete",
+  aliases: ["rm"],
+  description: "Remove worktrees and their branches",
+  args: {
+    name: positional({
+      type: optional(string),
+      displayName: "name",
+      description: "Worktree name. Omit for interactive multi-select."
+    }),
+    force: flag({
+      long: "force",
+      short: "f",
+      description: "Remove even if there are uncommitted changes"
+    })
+  },
+  handler: async ({ name, force }) => {
+    if (!name) {
+      await interactiveDelete();
+      return;
+    }
+    const registry = loadRegistry();
+    const match = registry.find((e) => e.branch === name);
+    if (match) {
+      removeWorktree(match.repoPath, match.wtPath, match.branch, force);
+      unregisterWorktree(match.wtPath);
+      return;
+    }
+    let wtPath;
+    try {
+      wtPath = worktreePath(name);
+    } catch {
+      throw new Error(`Worktree '${name}' not found`);
+    }
+    const entries = listWorktrees();
+    const entry = entries.find((e) => e.path === wtPath);
+    if (!entry) {
+      throw new Error(`Worktree '${name}' not found at ${wtPath}`);
+    }
+    removeWorktree(gitRoot(), wtPath, name, force);
+    unregisterWorktree(wtPath);
+  }
+});
+function removeWorktree(repoPath, wtPath, branch, force) {
+  if (force) {
+    gitIn(repoPath, "worktree", "remove", "--force", wtPath);
+  } else {
+    try {
+      gitIn(repoPath, "worktree", "remove", wtPath);
+    } catch {
+      throw new Error(
+        "Worktree has uncommitted changes. Use --force to override."
+      );
+    }
+  }
+  gitInSafe(repoPath, "branch", "-d", branch);
+  ok(`deleted worktree ${bold(branch)}`);
+}
+async function interactiveDelete() {
+  const entries = loadRegistry();
+  if (entries.length === 0) {
+    warn("no worktrees registered");
+    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) => ({
+        label: e.branch,
+        value: e,
+        hint: e.wtPath
+      }))
+    });
+  }
+  const selected = await multiSelect({
+    message: "Select worktrees to delete",
+    groups
+  });
+  if (selected.length === 0) return;
+  console.log();
+  for (const entry of selected) {
+    console.log(`  ${red("\u2715")} ${entry.branch}  ${dim(entry.wtPath)}`);
+  }
+  console.log();
+  const confirmed = await confirm(
+    `Delete ${selected.length} worktree(s)? [y/N] `
+  );
+  if (!confirmed) return;
+  for (const entry of selected) {
+    try {
+      gitIn(entry.repoPath, "worktree", "remove", entry.wtPath);
+      gitInSafe(entry.repoPath, "branch", "-d", entry.branch);
+      unregisterWorktree(entry.wtPath);
+      ok(`deleted ${entry.branch}`);
+    } catch {
+      warn(`failed to delete ${entry.branch} \u2014 may have uncommitted changes`);
+    }
+  }
+}
+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 {
+  del
+};

package/dist/chunk-P7PRH4I3.js

@@ -0,0 +1,177 @@
+import {
+  bold,
+  cyan,
+  dim,
+  green
+} from "./chunk-YBCA3IP6.js";
+
+// src/lib/select.ts
+function flatten(groups) {
+  const items = [];
+  for (const group of groups) {
+    items.push({ type: "header", label: group.title });
+    for (const choice of group.choices) {
+      items.push({
+        type: "choice",
+        label: choice.label,
+        hint: choice.hint,
+        value: choice.value
+      });
+    }
+  }
+  return items;
+}
+function selectableIndices(items) {
+  return items.reduce((acc, item, i) => {
+    if (item.type === "choice") acc.push(i);
+    return acc;
+  }, []);
+}
+function select(opts) {
+  const items = flatten(opts.groups);
+  const selectable = selectableIndices(items);
+  if (selectable.length === 0) return Promise.resolve(null);
+  let cursor = 0;
+  return new Promise((resolve) => {
+    const { stdin, stdout } = process;
+    if (!stdin.isTTY) {
+      resolve(null);
+      return;
+    }
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdout.write("\x1B[?25l");
+    let lineCount = 0;
+    function render() {
+      let out = "";
+      if (lineCount > 0) out += `\x1B[${lineCount}A`;
+      const lines = [];
+      lines.push(`${cyan("?")} ${bold(opts.message)}`);
+      lines.push("");
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item.type === "header") {
+          lines.push(`  ${bold(item.label)}`);
+        } else {
+          const active = selectable[cursor] === i;
+          const prefix = active ? cyan("> ") : "  ";
+          const label = active ? item.label : dim(item.label);
+          const hint = item.hint ? `  ${dim(item.hint)}` : "";
+          lines.push(`${prefix}${label}${hint}`);
+        }
+      }
+      out += lines.map((l) => `\x1B[2K${l}`).join("\n") + "\n";
+      stdout.write(out);
+      lineCount = lines.length;
+    }
+    function cleanup() {
+      stdin.removeListener("data", onKey);
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdout.write("\x1B[?25h");
+    }
+    function onKey(data) {
+      if (data === "") {
+        cleanup();
+        process.exit(130);
+        return;
+      }
+      if (data === "\r" || data === "\n") {
+        cleanup();
+        resolve(items[selectable[cursor]].value);
+        return;
+      }
+      if (data === "\x1B[A" || data === "k") {
+        cursor = Math.max(0, cursor - 1);
+        render();
+      } else if (data === "\x1B[B" || data === "j") {
+        cursor = Math.min(selectable.length - 1, cursor + 1);
+        render();
+      }
+    }
+    stdin.on("data", onKey);
+    render();
+  });
+}
+function multiSelect(opts) {
+  const items = flatten(opts.groups);
+  const selectable = selectableIndices(items);
+  if (selectable.length === 0) return Promise.resolve([]);
+  let cursor = 0;
+  const selected = /* @__PURE__ */ new Set();
+  return new Promise((resolve) => {
+    const { stdin, stdout } = process;
+    if (!stdin.isTTY) {
+      resolve([]);
+      return;
+    }
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdout.write("\x1B[?25l");
+    let lineCount = 0;
+    function render() {
+      let out = "";
+      if (lineCount > 0) out += `\x1B[${lineCount}A`;
+      const lines = [];
+      lines.push(
+        `${cyan("?")} ${bold(opts.message)} ${dim("(space = toggle, enter = confirm)")}`
+      );
+      lines.push("");
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item.type === "header") {
+          lines.push(`  ${bold(item.label)}`);
+        } else {
+          const idx = selectable.indexOf(i);
+          const active = cursor === idx;
+          const checked = selected.has(idx);
+          const box = checked ? green("[x]") : dim("[ ]");
+          const prefix = active ? cyan("> ") : "  ";
+          const hint = item.hint ? `  ${dim(item.hint)}` : "";
+          lines.push(`${prefix}${box} ${item.label}${hint}`);
+        }
+      }
+      out += lines.map((l) => `\x1B[2K${l}`).join("\n") + "\n";
+      stdout.write(out);
+      lineCount = lines.length;
+    }
+    function cleanup() {
+      stdin.removeListener("data", onKey);
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdout.write("\x1B[?25h");
+    }
+    function onKey(data) {
+      if (data === "") {
+        cleanup();
+        process.exit(130);
+        return;
+      }
+      if (data === "\r" || data === "\n") {
+        cleanup();
+        resolve([...selected].map((idx) => items[selectable[idx]].value));
+        return;
+      }
+      if (data === " ") {
+        if (selected.has(cursor)) selected.delete(cursor);
+        else selected.add(cursor);
+        render();
+      } else if (data === "\x1B[A" || data === "k") {
+        cursor = Math.max(0, cursor - 1);
+        render();
+      } else if (data === "\x1B[B" || data === "j") {
+        cursor = Math.min(selectable.length - 1, cursor + 1);
+        render();
+      }
+    }
+    stdin.on("data", onKey);
+    render();
+  });
+}
+
+export {
+  select,
+  multiSelect
+};

package/dist/chunk-VCN7RNLU.js

@@ -0,0 +1,60 @@
+// src/lib/registry.ts
+import * as path from "path";
+import * as os from "os";
+var REGISTRY_DIR = path.join(os.homedir(), ".glorious");
+var REGISTRY_FILE = path.join(REGISTRY_DIR, "worktrees.json");
+function ensureDir() {
+  Bun.mkdir(REGISTRY_DIR, { recursive: true });
+}
+function existsSync(filePath) {
+  return Bun.file(filePath).existsSync();
+}
+function readTextSync(filePath) {
+  try {
+    return Bun.file(filePath).textSync();
+  } catch {
+    return null;
+  }
+}
+function writeTextSync(filePath, content) {
+  Bun.file(filePath).writer().write(content);
+}
+function loadRegistry() {
+  if (!existsSync(REGISTRY_FILE)) return [];
+  try {
+    const raw = readTextSync(REGISTRY_FILE);
+    if (!raw) return [];
+    const entries = JSON.parse(raw);
+    const valid = entries.filter((e) => existsSync(e.wtPath));
+    if (valid.length !== entries.length) {
+      saveRegistry(valid);
+    }
+    return valid;
+  } catch {
+    return [];
+  }
+}
+function saveRegistry(entries) {
+  ensureDir();
+  writeTextSync(REGISTRY_FILE, JSON.stringify(entries, null, 2) + "\n");
+}
+function registerWorktree(entry) {
+  const entries = loadRegistry();
+  const filtered = entries.filter((e) => e.wtPath !== entry.wtPath);
+  filtered.push(entry);
+  saveRegistry(filtered);
+}
+function unregisterWorktree(wtPath) {
+  const entries = loadRegistry();
+  const filtered = entries.filter((e) => e.wtPath !== wtPath);
+  if (filtered.length !== entries.length) {
+    saveRegistry(filtered);
+  }
+}
+
+export {
+  loadRegistry,
+  saveRegistry,
+  registerWorktree,
+  unregisterWorktree
+};

package/dist/chunk-VJFNIKQJ.js

@@ -0,0 +1,120 @@
+import {
+  repoName,
+  worktreePath
+} from "./chunk-W37UX3U2.js";
+import {
+  defaultBranchIn,
+  gitIn,
+  gitInSafe,
+  gitRoot
+} from "./chunk-LMRDQ4GW.js";
+import {
+  registerWorktree
+} from "./chunk-VCN7RNLU.js";
+import {
+  bold,
+  info,
+  ok,
+  warn
+} from "./chunk-YBCA3IP6.js";
+
+// src/lib/worktree.ts
+import * as path from "path";
+function existsSync(filePath) {
+  return Bun.file(filePath).existsSync();
+}
+function mkdirSync(dirPath, opts) {
+  Bun.mkdir(dirPath, opts);
+}
+function autoName(now = /* @__PURE__ */ new Date(), suffix = randomSuffix()) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const yy = now.getFullYear().toString().slice(2);
+  const mm = pad(now.getMonth() + 1);
+  const dd = pad(now.getDate());
+  const hh = pad(now.getHours());
+  const mi = pad(now.getMinutes());
+  const ss = pad(now.getSeconds());
+  return `wt-${yy}${mm}${dd}-${hh}${mi}${ss}-${suffix}`;
+}
+function randomSuffix() {
+  return Math.random().toString(36).slice(2, 5).padEnd(3, "0");
+}
+function assertPrimaryClone(srcRepo) {
+  const commonDir = gitInSafe(srcRepo, "rev-parse", "--git-common-dir");
+  if (!commonDir) return;
+  if (!path.isAbsolute(commonDir)) return;
+  const primary = path.dirname(commonDir);
+  if (path.resolve(primary) === path.resolve(srcRepo)) return;
+  throw new Error(
+    `Refusing to create a nested worktree.
+  '${srcRepo}' is itself a worktree of '${primary}'.
+  Create worktrees from the primary clone, or pass a repo name:
+    glrs wt new <repo>`
+  );
+}
+function createWorktree(opts = {}) {
+  const srcRepo = opts.repoPath ?? gitRoot();
+  assertPrimaryClone(srcRepo);
+  const repo = opts.repo ?? path.basename(srcRepo);
+  const name = opts.name ?? autoName();
+  const wtPath = worktreePath(name, repo);
+  if (existsSync(wtPath)) {
+    throw new Error(`Worktree already exists: ${wtPath}`);
+  }
+  mkdirSync(path.dirname(wtPath), { recursive: true });
+  const base = opts.from ?? defaultBranchIn(srcRepo);
+  info(`fetching origin/${base}...`);
+  gitIn(srcRepo, "fetch", "origin", base, "--quiet");
+  const branchExists = gitInSafe(srcRepo, "show-ref", "--verify", `refs/heads/${name}`) !== null;
+  if (branchExists) {
+    warn(`branch ${bold(name)} already exists, resetting to origin/${base}`);
+    gitIn(srcRepo, "branch", "-D", name);
+  }
+  info(`creating worktree ${bold(name)} from origin/${base}...`);
+  gitIn(
+    srcRepo,
+    "worktree",
+    "add",
+    "-b",
+    name,
+    wtPath,
+    `origin/${base}`,
+    "--quiet"
+  );
+  try {
+    gitIn(wtPath, "branch", "--set-upstream-to", `origin/${base}`, name);
+  } catch {
+  }
+  registerWorktree({
+    repo,
+    repoPath: srcRepo,
+    wtPath,
+    branch: name,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  ok(`worktree created at ${bold(wtPath)}`);
+  return { wtPath, name, base };
+}
+function ensureWorktree(name, from) {
+  const repo = repoName();
+  const wtPath = worktreePath(name, repo);
+  if (existsSync(wtPath)) {
+    info(`worktree already exists at ${bold(wtPath)}, reusing...`);
+    registerWorktree({
+      repo,
+      repoPath: gitRoot(),
+      wtPath,
+      branch: name,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return wtPath;
+  }
+  return createWorktree({ name, from }).wtPath;
+}
+
+export {
+  autoName,
+  assertPrimaryClone,
+  createWorktree,
+  ensureWorktree
+};

package/dist/chunk-W37UX3U2.js

@@ -0,0 +1,35 @@
+import {
+  gitRoot
+} from "./chunk-LMRDQ4GW.js";
+
+// src/lib/config.ts
+import * as path from "path";
+import * as os from "os";
+var PROTECTED_BRANCHES = /* @__PURE__ */ new Set([
+  "main",
+  "master",
+  "next",
+  "prerelease"
+]);
+function isProtected(branch) {
+  return PROTECTED_BRANCHES.has(branch);
+}
+function repoName() {
+  return path.basename(gitRoot());
+}
+function worktreesRoot(repo) {
+  const override = process.env.GLORIOUS_DIR;
+  if (override) return path.resolve(override, repo);
+  return path.join(os.homedir(), ".glorious", "worktrees", repo);
+}
+function worktreePath(name, repo) {
+  const repoKey = repo ?? repoName();
+  return path.join(worktreesRoot(repoKey), name);
+}
+
+export {
+  isProtected,
+  repoName,
+  worktreesRoot,
+  worktreePath
+};

package/dist/chunk-YBCA3IP6.js

@@ -0,0 +1,25 @@
+// src/lib/fmt.ts
+var isTTY = process.stdout.isTTY;
+var bold = (s) => isTTY ? `\x1B[1m${s}\x1B[0m` : s;
+var dim = (s) => isTTY ? `\x1B[2m${s}\x1B[0m` : s;
+var red = (s) => isTTY ? `\x1B[31m${s}\x1B[0m` : s;
+var green = (s) => isTTY ? `\x1B[32m${s}\x1B[0m` : s;
+var yellow = (s) => isTTY ? `\x1B[33m${s}\x1B[0m` : s;
+var cyan = (s) => isTTY ? `\x1B[36m${s}\x1B[0m` : s;
+var ok = (msg) => console.log(`${green("\u2713")} ${msg}`);
+var okErr = (msg) => console.error(`${green("\u2713")} ${msg}`);
+var info = (msg) => console.log(`${cyan("\u25B8")} ${msg}`);
+var warn = (msg) => console.error(`${yellow("warning:")} ${msg}`);
+
+export {
+  bold,
+  dim,
+  red,
+  green,
+  yellow,
+  cyan,
+  ok,
+  okErr,
+  info,
+  warn
+};

package/dist/chunk-YGNDPKIW.js

@@ -0,0 +1,99 @@
+// src/index.ts
+import { readFileSync } from "fs";
+import { dirname, resolve as pathResolve } from "path";
+import { fileURLToPath } from "url";
+function resolveVendoredHarness(binKey) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const vendorPkgJson = pathResolve(here, "vendor", "harness-opencode", "package.json");
+  let pkgJsonPath;
+  try {
+    readFileSync(vendorPkgJson, "utf8");
+    pkgJsonPath = vendorPkgJson;
+  } catch {
+    throw new Error(
+      `[@glrs-dev/cli] Vendored harness-opencode not found at ${vendorPkgJson}.
+  This means the cli package was built incorrectly or the tarball is incomplete.
+  Report at https://github.com/iceglober/glrs/issues.`
+    );
+  }
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+  const bin = pkgJson.bin;
+  let relative;
+  if (typeof bin === "string") {
+    relative = bin;
+  } else if (bin && typeof bin === "object" && typeof bin[binKey] === "string") {
+    relative = bin[binKey];
+  } else {
+    throw new Error(
+      `[@glrs-dev/cli] Vendored harness-opencode has no bin entry for '${binKey}'. This shouldn't happen \u2014 report at https://github.com/iceglober/glrs/issues.`
+    );
+  }
+  const binPath = pathResolve(dirname(pkgJsonPath), relative);
+  return { executable: "bun", preArgs: [binPath] };
+}
+function resolveSubcommand(sub) {
+  switch (sub) {
+    case "oc":
+      return resolveVendoredHarness("harness-opencode");
+    case "wt":
+      throw new Error("Worktree commands should be handled natively");
+    default: {
+      const exhaustive = sub;
+      throw new Error(`Unknown subcommand: ${exhaustive}`);
+    }
+  }
+}
+var SUBCOMMANDS = ["oc", "wt"];
+var HELP_TEXT = `glrs \u2014 unified CLI for the @glrs-dev ecosystem
+
+USAGE
+  glrs <subcommand> [args...]
+
+SUBCOMMANDS
+  oc         OpenCode agent harness (install, pilot, etc.)
+  wt         Worktree management (create, list, switch, delete, cleanup)
+
+Run 'glrs <subcommand> --help' for per-command help.
+
+EXAMPLES
+  glrs oc install
+  glrs wt new
+  glrs wt list
+  glrs wt switch
+
+REQUIREMENTS
+  Bun >= 1.2.0 on PATH (install: https://bun.sh)
+
+DOCS  https://glrs.dev
+ISSUES https://github.com/iceglober/glrs/issues
+`;
+var WORKTREE_HELP_TEXT = `glrs wt \u2014 worktree management
+
+USAGE
+  glrs wt <command> [args...]
+
+COMMANDS
+  new              Create a new worktree (auto-named from origin/default)
+  list, ls         List all worktrees across repos
+  switch, sw       Interactively select and switch to a worktree
+  delete, rm       Remove worktrees (interactive or by name)
+  cleanup          Delete merged/stale worktrees
+
+EXAMPLES
+  glrs wt new                    # Create worktree in current repo
+  glrs wt new myrepo             # Create worktree for named repo
+  glrs wt list                   # Show all worktrees
+  glrs wt list -i                # Interactive picker
+  glrs wt switch                 # Interactive switcher
+  glrs wt delete my-branch       # Delete specific worktree
+  glrs wt cleanup                # Clean up merged worktrees
+
+Worktrees are stored in ~/.glorious/worktrees/<repo>/<name>/
+`;
+
+export {
+  resolveSubcommand,
+  SUBCOMMANDS,
+  HELP_TEXT,
+  WORKTREE_HELP_TEXT
+};

package/dist/cli.d.ts

@@ -1 +1 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun