opencode-worktree 0.1.3 → 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 arturosdg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# opencode-worktree
+
+Terminal UI for managing git worktrees and launching `opencode` in the selected worktree.
+
+## Features
+
+- Lists all worktrees with branch, path, and short HEAD
+- Create new worktrees directly from the TUI
+- Unlink worktrees (remove directory, keep branch)
+- Delete worktrees and local branches (never remote)
+- Launches `opencode` in the selected worktree
+- Refresh list on demand
+
+## Requirements
+
+- Git
+- `opencode` available on your PATH
+
+## Install (npm)
+
+```bash
+npm i -g opencode-worktree
+```
+
+## Run
+
+```bash
+opencode-worktree
+```
+
+Or specify a repo path:
+
+```bash
+opencode-worktree /path/to/your/repo
+```
+
+## Keybindings
+
+- `Up`/`Down` or `j`/`k`: navigate
+- `Enter`: open selected worktree
+- `d`: unlink/delete menu
+- `n`: create new worktree
+- `r`: refresh list
+- `q` or `Esc`: quit (or cancel dialogs)
+
+## Update notifications
+
+When a new version is published to npm, the CLI will show a non-intrusive update message on the next run.
+
+## Development
+
+```bash
+bun install
+bun run dev
+```
+
+## Build (local)
+
+```bash
+bun run build:single
+```
+
+Build all platforms (release only):
+
+```bash
+bun run build:all
+```

package/bin/opencode-worktree

@@ -44,24 +44,17 @@ const detectPlatformAndArch = () => {
 };
 
 const resolveBinaryPath = () => {
-  const { platform, arch } = detectPlatformAndArch();
-  const packageName = `${pkg.name}-${platform}-${arch}`;
-  const binaryName = platform === 'windows' ? 'opencode-worktree.exe' : 'opencode-worktree';
+  const { platform } = detectPlatformAndArch();
+  const binaryName = platform === 'windows' ? 'opencode-worktree.exe' : 'opencode-worktree-bin';
+  const binaryPath = path.join(__dirname, 'bin', binaryName);
 
-  try {
-    const packageJsonPath = require.resolve(`${packageName}/package.json`);
-    const packageDir = path.dirname(packageJsonPath);
-    const binaryPath = path.join(packageDir, 'bin', binaryName);
-
-    if (!fs.existsSync(binaryPath)) {
-      throw new Error(`Binary not found at ${binaryPath}`);
-    }
-
-    return binaryPath;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not find ${packageName}: ${message}`);
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(
+      `Binary not found at ${binaryPath}. Run npm install -g ${pkg.name} again to re-download.`,
+    );
   }
+
+  return binaryPath;
 };
 
 const run = () => {

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "opencode-worktree",
-  "version": "0.1.3",
+  "version": "0.2.2",
+  "private": false,
+  "type": "module",
   "description": "TUI for managing git worktrees with opencode integration.",
-  "license": "MIT",
   "author": "arturosdg",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/arturosdg/opencode-worktree.git"
@@ -12,27 +14,39 @@
     "url": "https://github.com/arturosdg/opencode-worktree/issues"
   },
   "homepage": "https://github.com/arturosdg/opencode-worktree#readme",
+  "keywords": [
+    "git",
+    "worktree",
+    "tui",
+    "opencode",
+    "cli"
+  ],
   "bin": {
-    "opencode-worktree": "./bin/opencode-worktree"
+    "opencode-worktree": "bin/opencode-worktree"
   },
   "scripts": {
-    "postinstall": "node ./postinstall.mjs"
-  },
-  "dependencies": {
-    "update-notifier": "^7.3.1"
-  },
-  "optionalDependencies": {
-    "opencode-worktree-darwin-arm64": "0.1.3",
-    "opencode-worktree-darwin-x64": "0.1.3",
-    "opencode-worktree-linux-x64": "0.1.3",
-    "opencode-worktree-linux-arm64": "0.1.3",
-    "opencode-worktree-windows-x64": "0.1.3"
+    "dev": "bun src/cli.ts",
+    "build:single": "bun run script/build.ts --single",
+    "build:all": "bun run script/build.ts",
+    "publish": "bun run script/publish.ts"
   },
   "files": [
     "bin",
-    "postinstall.mjs"
+    "script",
+    "src",
+    "README.md",
+    "LICENSE"
   ],
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.1.75",
+    "update-notifier": "^7.3.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "@types/node": "^24.2.0",
+    "typescript": "^5.9.3"
   }
-}
+}

package/script/build.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env bun
+
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { $ } from "bun";
+
+type Target = {
+  os: "darwin" | "linux" | "win32";
+  arch: "arm64" | "x64";
+  bunTarget: string;
+  packagePlatform: "darwin" | "linux" | "windows";
+  binaryName: string;
+};
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, "..");
+const distDir = path.join(rootDir, "dist");
+const releaseDir = path.join(distDir, "release");
+
+const pkg = JSON.parse(
+  await Bun.file(path.join(rootDir, "package.json")).text(),
+);
+
+const packageName = "opencode-worktree";
+const version = pkg.version as string;
+
+export const targets: Target[] = [
+  {
+    os: "darwin",
+    arch: "arm64",
+    bunTarget: "bun-darwin-arm64",
+    packagePlatform: "darwin",
+    binaryName: "opencode-worktree",
+  },
+  {
+    os: "darwin",
+    arch: "x64",
+    bunTarget: "bun-darwin-x64",
+    packagePlatform: "darwin",
+    binaryName: "opencode-worktree",
+  },
+  {
+    os: "linux",
+    arch: "x64",
+    bunTarget: "bun-linux-x64",
+    packagePlatform: "linux",
+    binaryName: "opencode-worktree",
+  },
+  {
+    os: "linux",
+    arch: "arm64",
+    bunTarget: "bun-linux-arm64",
+    packagePlatform: "linux",
+    binaryName: "opencode-worktree",
+  },
+  {
+    os: "win32",
+    arch: "x64",
+    bunTarget: "bun-windows-x64",
+    packagePlatform: "windows",
+    binaryName: "opencode-worktree.exe",
+  },
+];
+
+const ensureCleanDist = () => {
+  fs.rmSync(distDir, { recursive: true, force: true });
+  fs.mkdirSync(distDir, { recursive: true });
+  fs.mkdirSync(releaseDir, { recursive: true });
+};
+
+const installPlatformDependencies = async () => {
+  const opentuiVersion = pkg.dependencies?.["@opentui/core"] ?? "^0.1.75";
+  await $`bun install --os="*" --cpu="*" @opentui/core@${opentuiVersion}`;
+};
+
+const buildBinary = async (target: Target) => {
+  const name = `${packageName}-${target.packagePlatform}-${target.arch}`;
+  const outDir = path.join(releaseDir);
+
+  const parserWorker = fs.realpathSync(
+    path.join(rootDir, "node_modules/@opentui/core/parser.worker.js"),
+  );
+  const bunfsRoot = target.os === "win32" ? "B:/~BUN/root/" : "/$bunfs/root/";
+  const workerRelativePath = path
+    .relative(rootDir, parserWorker)
+    .replace(/\\/g, "/");
+
+  let result: Bun.BuildOutput;
+  try {
+    result = await Bun.build({
+      entrypoints: [path.join(rootDir, "src/cli.ts"), parserWorker],
+      minify: true,
+      compile: {
+        target: target.bunTarget as Bun.Build.Target,
+        outfile: path.join(
+          outDir,
+          name + (target.os === "win32" ? ".exe" : ""),
+        ),
+        autoloadBunfig: false,
+        autoloadDotenv: false,
+        autoloadPackageJson: true,
+        autoloadTsconfig: true,
+      },
+      define: {
+        OTUI_TREE_SITTER_WORKER_PATH: JSON.stringify(
+          bunfsRoot + workerRelativePath,
+        ),
+      },
+    });
+  } catch (error) {
+    console.error(`Bundle threw for ${name}`);
+    if (error instanceof Error && error.stack) {
+      console.error(error.stack);
+    } else {
+      console.error(error);
+    }
+    throw error;
+  }
+
+  if (!result.success) {
+    const logs = result.logs
+      .map((log) => `${log.level}: ${log.message}`)
+      .join("\n");
+    throw new Error(`Bundle failed for ${name}:\n${logs}`);
+  }
+
+  return name;
+};
+
+export const buildAll = async ({ single = false } = {}) => {
+  await installPlatformDependencies();
+  ensureCleanDist();
+
+  const selectedTargets = single
+    ? targets.filter(
+        (item) => item.os === process.platform && item.arch === process.arch,
+      )
+    : targets;
+
+  for (const target of selectedTargets) {
+    await buildBinary(target);
+  }
+};
+
+if (import.meta.main) {
+  const single = process.argv.includes("--single");
+  await buildAll({ single });
+}

package/script/postinstall.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+  fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"),
+);
+
+const detectPlatformAndArch = () => {
+  let platform;
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin";
+      break;
+    case "linux":
+      platform = "linux";
+      break;
+    case "win32":
+      platform = "windows";
+      break;
+    default:
+      platform = os.platform();
+      break;
+  }
+
+  let arch;
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      break;
+    default:
+      arch = os.arch();
+      break;
+  }
+
+  return { platform, arch };
+};
+
+const downloadFile = async (url, targetPath) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${url} (${response.status})`);
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer());
+  fs.writeFileSync(targetPath, buffer);
+};
+
+const installBinary = async () => {
+  const { platform, arch } = detectPlatformAndArch();
+  const isWindows = platform === "windows";
+  const binaryName = isWindows
+    ? "opencode-worktree.exe"
+    : "opencode-worktree-bin";
+  const downloadName = `opencode-worktree-${platform}-${arch}${isWindows ? ".exe" : ""}`;
+  const version = pkg.version;
+  const downloadUrl = `https://github.com/arturosdg/opencode-worktree/releases/download/v${version}/${downloadName}`;
+
+  const binDir = path.join(__dirname, "..", "bin");
+  const binaryPath = path.join(binDir, binaryName);
+
+  fs.mkdirSync(binDir, { recursive: true });
+  await downloadFile(downloadUrl, binaryPath);
+
+  if (!isWindows) {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+
+  return binaryPath;
+};
+
+try {
+  const binaryPath = await installBinary();
+  console.log(`opencode-worktree binary installed at: ${binaryPath}`);
+} catch (error) {
+  console.error("Failed to install opencode-worktree binary.");
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}

package/script/publish.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun";
+
+try {
+  await $`npm publish --access public`;
+} catch (error) {
+  console.error("Publish failed.");
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}

package/src/cli.ts

@@ -0,0 +1,10 @@
+import { runApp } from "./ui.js";
+
+// Accept optional path argument: opencode-worktree [path]
+const targetPath = process.argv[2] || process.cwd();
+
+runApp(targetPath).catch((error: unknown) => {
+  console.error("Failed to start OpenTUI worktree selector.");
+  console.error(error);
+  process.exit(1);
+});

package/src/git.ts

@@ -0,0 +1,209 @@
+import { execFileSync } from "node:child_process";
+import { WorktreeInfo } from "./types.js";
+
+export const resolveRepoRoot = (cwd: string): string | null => {
+  try {
+    const output = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+};
+
+export const parseWorktreeList = (output: string): WorktreeInfo[] => {
+  const lines = output.split(/\r?\n/);
+  const worktrees: WorktreeInfo[] = [];
+  let current: WorktreeInfo | null = null;
+
+  const pushCurrent = (): void => {
+    if (current?.path) {
+      worktrees.push(current);
+    }
+  };
+
+  for (const line of lines) {
+    if (line.startsWith("worktree ")) {
+      pushCurrent();
+      current = {
+        path: line.slice("worktree ".length).trim(),
+        head: "",
+        branch: null,
+        isDetached: false,
+      };
+      continue;
+    }
+
+    if (!current) continue;
+
+    if (line.startsWith("HEAD ")) {
+      current.head = line.slice("HEAD ".length).trim();
+      continue;
+    }
+
+    if (line.startsWith("branch ")) {
+      const ref = line.slice("branch ".length).trim();
+      if (ref.startsWith("refs/heads/")) {
+        current.branch = ref.replace("refs/heads/", "");
+      }
+      continue;
+    }
+
+    if (line.trim() === "detached") {
+      current.isDetached = true;
+      continue;
+    }
+  }
+
+  pushCurrent();
+  return worktrees;
+};
+
+export const listWorktrees = (cwd: string): WorktreeInfo[] => {
+  const repoRoot = resolveRepoRoot(cwd);
+  if (!repoRoot) return [];
+
+  const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
+    cwd: repoRoot,
+    stdio: ["ignore", "pipe", "ignore"],
+    encoding: "utf8",
+  });
+  return parseWorktreeList(output);
+};
+
+export type CreateWorktreeResult =
+  | { success: true; path: string }
+  | { success: false; error: string };
+
+export const createWorktree = (
+  repoRoot: string,
+  branchName: string,
+  worktreesDir: string,
+): CreateWorktreeResult => {
+  const worktreePath = `${worktreesDir}/${branchName}`;
+
+  try {
+    // Try to create worktree with new branch
+    execFileSync("git", ["worktree", "add", "-b", branchName, worktreePath], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    return { success: true, path: worktreePath };
+  } catch {
+    // Branch might already exist, try without -b
+    try {
+      execFileSync("git", ["worktree", "add", worktreePath, branchName], {
+        cwd: repoRoot,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf8",
+      });
+      return { success: true, path: worktreePath };
+    } catch (e) {
+      const error = e instanceof Error ? e.message : String(e);
+      return { success: false, error };
+    }
+  }
+};
+
+export const getDefaultWorktreesDir = (repoRoot: string): string => {
+  // Place worktrees in a sibling 'worktrees' folder
+  const parentDir = repoRoot.replace(/\/[^/]+$/, "");
+  const repoName = repoRoot.split("/").pop() || "repo";
+  return `${parentDir}/${repoName}-worktrees`;
+};
+
+/**
+ * Check if a worktree has uncommitted changes (dirty state)
+ */
+export const hasUncommittedChanges = (worktreePath: string): boolean => {
+  try {
+    const output = execFileSync("git", ["status", "--porcelain"], {
+      cwd: worktreePath,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8",
+    });
+    return output.trim().length > 0;
+  } catch {
+    // If we can't check, assume it's clean to avoid blocking
+    return false;
+  }
+};
+
+/**
+ * Check if a worktree is the main worktree (the original repo clone)
+ */
+export const isMainWorktree = (
+  repoRoot: string,
+  worktreePath: string,
+): boolean => {
+  // The main worktree path matches the repo root
+  return repoRoot === worktreePath;
+};
+
+export type UnlinkResult =
+  | { success: true }
+  | { success: false; error: string };
+
+/**
+ * Unlink a worktree - removes the worktree directory but keeps the branch
+ */
+export const unlinkWorktree = (
+  repoRoot: string,
+  worktreePath: string,
+  force: boolean = false,
+): UnlinkResult => {
+  try {
+    const args = ["worktree", "remove"];
+    if (force) {
+      args.push("--force");
+    }
+    args.push(worktreePath);
+
+    execFileSync("git", args, {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    return { success: true };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    return { success: false, error };
+  }
+};
+
+export type DeleteResult =
+  | { success: true }
+  | { success: false; error: string; step: "unlink" | "branch" };
+
+/**
+ * Delete a worktree AND its local branch (never touches remote)
+ */
+export const deleteWorktree = (
+  repoRoot: string,
+  worktreePath: string,
+  branchName: string,
+  force: boolean = false,
+): DeleteResult => {
+  // First unlink the worktree
+  const unlinkResult = unlinkWorktree(repoRoot, worktreePath, force);
+  if (!unlinkResult.success) {
+    return { success: false, error: unlinkResult.error, step: "unlink" };
+  }
+
+  // Then delete the local branch (never remote!)
+  try {
+    execFileSync("git", ["branch", "-D", branchName], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    return { success: true };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    return { success: false, error, step: "branch" };
+  }
+};

package/src/opencode.ts

@@ -0,0 +1,20 @@
+import { spawn, spawnSync } from "node:child_process";
+
+export const isOpenCodeAvailable = (): boolean => {
+  const result = spawnSync("opencode", ["--version"], {
+    stdio: "ignore",
+  });
+  return result.status === 0;
+};
+
+export const launchOpenCode = (cwd: string): void => {
+  const child = spawn("opencode", [], {
+    cwd,
+    stdio: "inherit",
+  });
+
+  child.on("exit", (code: number | null) => {
+    const exitCode = typeof code === "number" ? code : 0;
+    process.exit(exitCode);
+  });
+};

package/src/types.ts

@@ -0,0 +1,6 @@
+export type WorktreeInfo = {
+  path: string;
+  head: string;
+  branch: string | null;
+  isDetached: boolean;
+};