@zenobius/pi-worktrees 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 zenobi.us
+
+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,37 @@
+# pi-worktrees
+
+Worktrees extension for Pi Coding Agent
+
+> A Bun module created from the [bun-module](https://github.com/zenobi-us/bun-module) template
+
+## Features
+
+- Git worktree management commands for Pi
+- Interactive setup for worktree settings
+- Automatic worktree listing, creation, removal, and pruning
+
+## Usage
+
+Run in Pi:
+
+```
+/worktree init
+/worktree create <feature-name>
+/worktree list
+/worktree status
+/worktree cd <name>
+/worktree remove <name>
+/worktree prune
+```
+
+## Development
+
+- `mise run build` - Build the module
+- `mise run test` - Run tests
+- `mise run lint` - Lint code
+- `mise run lint:fix` - Fix linting issues
+- `mise run format` - Format code with Prettier
+
+## License
+
+MIT License. See the [LICENSE](LICENSE) file for details.

package/dist/index.js

@@ -0,0 +1,615 @@
+// @bun
+// src/index.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync, appendFileSync, writeFileSync, mkdirSync, statSync } from "fs";
+import { dirname, basename, join, resolve, relative } from "path";
+import { homedir } from "os";
+var HELP_TEXT = `
+/worktree - Git worktree management
+
+Commands:
+  /worktree init                   Configure worktree settings interactively
+  /worktree settings [key] [val]   Get/set individual settings
+  /worktree create <feature-name>  Create new worktree with branch
+  /worktree list                   List all worktrees
+  /worktree remove <name>          Remove a worktree
+  /worktree status                 Show current worktree info
+  /worktree cd <name>              Print path to worktree
+  /worktree prune                  Clean up stale references
+
+Settings:
+  /worktree settings               Show all settings
+  /worktree settings parentDir     Get parentDir value
+  /worktree settings parentDir ~   Set parentDir value
+  /worktree settings onCreate      Get onCreate value  
+  /worktree settings onCreate ""   Clear onCreate value
+
+Configuration (~/.pi/settings.json):
+  {
+    "worktree": {
+      "parentDir": "...",        // Override default parent directory
+      "onCreate": "mise setup"   // Command to run after creation
+    }
+  }
+
+Template vars: {{path}}, {{name}}, {{branch}}, {{project}}
+
+Examples:
+  /worktree init
+  /worktree settings parentDir "~/.worktrees/{{project}}"
+  /worktree create auth-feature
+  /worktree list
+  /worktree cd auth-feature
+  /worktree remove auth-feature
+`.trim();
+function git(args, cwd) {
+  try {
+    return execSync(`git ${args.join(" ")}`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (error) {
+    throw new Error(`git ${args[0]} failed: ${error.message}`);
+  }
+}
+function isGitRepo(cwd) {
+  try {
+    git(["rev-parse", "--git-dir"], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getMainWorktreePath(cwd) {
+  const gitCommonDir = git(["rev-parse", "--path-format=absolute", "--git-common-dir"], cwd);
+  return dirname(gitCommonDir);
+}
+function getProjectName(cwd) {
+  return basename(getMainWorktreePath(cwd));
+}
+function isWorktree(cwd) {
+  try {
+    const gitDir = git(["rev-parse", "--git-dir"], cwd);
+    const gitPath = join(cwd, ".git");
+    if (existsSync(gitPath)) {
+      const stat = statSync(gitPath);
+      return stat.isFile();
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function getCurrentBranch(cwd) {
+  try {
+    return git(["branch", "--show-current"], cwd) || "HEAD (detached)";
+  } catch {
+    return "unknown";
+  }
+}
+function listWorktrees(cwd) {
+  const output = git(["worktree", "list", "--porcelain"], cwd);
+  const worktrees = [];
+  const currentPath = resolve(cwd);
+  const mainPath = getMainWorktreePath(cwd);
+  let current = {};
+  for (const line of output.split(`
+`)) {
+    if (line.startsWith("worktree ")) {
+      current.path = line.slice(9);
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.slice(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.slice(7).replace("refs/heads/", "");
+    } else if (line === "detached") {
+      current.branch = "HEAD (detached)";
+    } else if (line === "") {
+      if (current.path) {
+        worktrees.push({
+          path: current.path,
+          branch: current.branch || "unknown",
+          head: current.head || "unknown",
+          isMain: current.path === mainPath,
+          isCurrent: current.path === currentPath
+        });
+      }
+      current = {};
+    }
+  }
+  if (current.path) {
+    worktrees.push({
+      path: current.path,
+      branch: current.branch || "unknown",
+      head: current.head || "unknown",
+      isMain: current.path === mainPath,
+      isCurrent: current.path === currentPath
+    });
+  }
+  return worktrees;
+}
+function getSettingsPath() {
+  return join(homedir(), ".pi", "settings.json");
+}
+function loadFullSettings() {
+  const settingsPath = getSettingsPath();
+  try {
+    if (existsSync(settingsPath)) {
+      const content = readFileSync(settingsPath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {}
+  return {};
+}
+function loadSettings() {
+  const settings = loadFullSettings();
+  return settings.worktree || {};
+}
+function saveSettings(worktreeSettings) {
+  const settingsPath = getSettingsPath();
+  const settingsDir = dirname(settingsPath);
+  if (!existsSync(settingsDir)) {
+    mkdirSync(settingsDir, { recursive: true });
+  }
+  const fullSettings = loadFullSettings();
+  fullSettings.worktree = worktreeSettings;
+  writeFileSync(settingsPath, JSON.stringify(fullSettings, null, 2) + `
+`, "utf-8");
+}
+function expandTemplate(template, ctx) {
+  return template.replace(/\{\{path\}\}/g, ctx.path).replace(/\{\{name\}\}/g, ctx.name).replace(/\{\{branch\}\}/g, ctx.branch).replace(/\{\{project\}\}/g, ctx.project).replace(/^~/, homedir());
+}
+function getWorktreeParentDir(cwd, settings) {
+  const project = getProjectName(cwd);
+  const mainWorktree = getMainWorktreePath(cwd);
+  if (settings.parentDir) {
+    return expandTemplate(settings.parentDir, {
+      path: "",
+      name: "",
+      branch: "",
+      project,
+      mainWorktree
+    });
+  }
+  return join(dirname(mainWorktree), `${project}.worktrees`);
+}
+function isPathInsideRepo(repoPath, targetPath) {
+  const relPath = relative(repoPath, targetPath);
+  return !relPath.startsWith("..") && !relPath.startsWith("/");
+}
+function ensureExcluded(cwd, worktreeParentDir) {
+  const mainWorktree = getMainWorktreePath(cwd);
+  if (!isPathInsideRepo(mainWorktree, worktreeParentDir)) {
+    return;
+  }
+  const excludePath = join(mainWorktree, ".git", "info", "exclude");
+  const relPath = relative(mainWorktree, worktreeParentDir);
+  const excludePattern = `/${relPath}/`;
+  try {
+    let content = "";
+    if (existsSync(excludePath)) {
+      content = readFileSync(excludePath, "utf-8");
+    }
+    if (content.includes(excludePattern) || content.includes(relPath)) {
+      return;
+    }
+    const newEntry = `
+# Worktree directory (added by worktree extension)
+${excludePattern}
+`;
+    appendFileSync(excludePath, newEntry);
+  } catch {}
+}
+async function runOnCreateHook(ctx, settings, notify) {
+  const { onCreate } = settings;
+  if (!onCreate) {
+    return;
+  }
+  if (typeof onCreate === "string") {
+    const command = expandTemplate(onCreate, ctx);
+    notify(`Running: ${command}`, "info");
+    return new Promise((resolve2, reject) => {
+      const child = spawn(command, {
+        cwd: ctx.path,
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          if (stdout.trim()) {
+            notify(stdout.trim().slice(0, 200), "info");
+          }
+          resolve2();
+        } else {
+          notify(`onCreate failed (exit ${code}): ${stderr.slice(0, 200)}`, "error");
+          resolve2();
+        }
+      });
+      child.on("error", (err) => {
+        notify(`onCreate error: ${err.message}`, "error");
+        resolve2();
+      });
+    });
+  } else if (typeof onCreate === "function") {
+    try {
+      await onCreate(ctx);
+    } catch (err) {
+      notify(`onCreate error: ${err.message}`, "error");
+    }
+  }
+}
+async function handleInit(_args, ctx) {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("init requires interactive mode", "error");
+    return;
+  }
+  const currentSettings = loadSettings();
+  const settingsPath = getSettingsPath();
+  ctx.ui.notify(`Worktree Extension Setup
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`, "info");
+  if (currentSettings.parentDir || currentSettings.onCreate) {
+    const current = [
+      "Current settings:",
+      currentSettings.parentDir ? `  parentDir: ${currentSettings.parentDir}` : null,
+      currentSettings.onCreate ? `  onCreate: ${currentSettings.onCreate}` : null
+    ].filter(Boolean).join(`
+`);
+    ctx.ui.notify(current, "info");
+  }
+  const PARENT_DIR_DEFAULT = "Default (../{{project}}.worktrees/)";
+  const PARENT_DIR_GLOBAL = "Global (~/.local/share/worktrees/{{project}})";
+  const PARENT_DIR_CUSTOM = "Custom path...";
+  const PARENT_DIR_KEEP = "Keep current";
+  const parentDirOptions = [
+    PARENT_DIR_DEFAULT,
+    PARENT_DIR_GLOBAL,
+    PARENT_DIR_CUSTOM,
+    currentSettings.parentDir ? PARENT_DIR_KEEP : null
+  ].filter(Boolean);
+  const parentDirChoice = await ctx.ui.select("Where should worktrees be created?", parentDirOptions);
+  if (parentDirChoice === undefined) {
+    ctx.ui.notify("Setup cancelled", "info");
+    return;
+  }
+  let parentDir;
+  if (parentDirChoice === PARENT_DIR_DEFAULT) {
+    parentDir = undefined;
+  } else if (parentDirChoice === PARENT_DIR_GLOBAL) {
+    parentDir = "~/.local/share/worktrees/{{project}}";
+  } else if (parentDirChoice === PARENT_DIR_CUSTOM) {
+    const customPath = await ctx.ui.input("Enter custom path (supports {{project}}, {{name}}):", currentSettings.parentDir || "../{{project}}.worktrees");
+    if (customPath === undefined) {
+      ctx.ui.notify("Setup cancelled", "info");
+      return;
+    }
+    parentDir = customPath || undefined;
+  } else if (parentDirChoice === PARENT_DIR_KEEP) {
+    parentDir = currentSettings.parentDir;
+  }
+  const onCreate = await ctx.ui.input(`Enter command to run after creating worktree (or leave empty):
+Supports: {{path}}, {{name}}, {{branch}}, {{project}}`, currentSettings.onCreate && typeof currentSettings.onCreate === "string" ? currentSettings.onCreate : "mise setup");
+  if (onCreate === undefined) {
+    ctx.ui.notify("Setup cancelled", "info");
+    return;
+  }
+  const newSettings = {};
+  if (parentDir) {
+    newSettings.parentDir = parentDir;
+  }
+  if (onCreate && onCreate.trim()) {
+    newSettings.onCreate = onCreate.trim();
+  }
+  const preview = [
+    "Settings to save:",
+    "",
+    newSettings.parentDir ? `  parentDir: "${newSettings.parentDir}"` : "  parentDir: (default)",
+    newSettings.onCreate ? `  onCreate: "${newSettings.onCreate}"` : "  onCreate: (none)",
+    "",
+    `File: ${settingsPath}`
+  ].join(`
+`);
+  const confirmed = await ctx.ui.confirm("Save settings?", preview);
+  if (!confirmed) {
+    ctx.ui.notify("Setup cancelled", "info");
+    return;
+  }
+  try {
+    saveSettings(newSettings);
+    ctx.ui.notify(`\u2713 Settings saved to ${settingsPath}`, "info");
+    const finalConfig = JSON.stringify({ worktree: newSettings }, null, 2);
+    ctx.ui.notify(`Configuration:
+${finalConfig}`, "info");
+  } catch (err) {
+    ctx.ui.notify(`Failed to save settings: ${err.message}`, "error");
+  }
+}
+var VALID_SETTING_KEYS = ["parentDir", "onCreate"];
+async function handleSettings(args, ctx) {
+  const currentSettings = loadSettings();
+  const settingsPath = getSettingsPath();
+  const parts = args.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+  const key = parts[0]?.trim();
+  const value = parts.slice(1).join(" ").replace(/^"(.*)"$/, "$1");
+  if (!key) {
+    const lines = [
+      "Worktree Settings:",
+      "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+      "",
+      `parentDir: ${currentSettings.parentDir || "(default: ../<project>.worktrees/)"}`,
+      `onCreate:  ${currentSettings.onCreate || "(none)"}`,
+      "",
+      `File: ${settingsPath}`
+    ];
+    ctx.ui.notify(lines.join(`
+`), "info");
+    return;
+  }
+  if (!VALID_SETTING_KEYS.includes(key)) {
+    ctx.ui.notify(`Invalid setting key: "${key}"
+Valid keys: ${VALID_SETTING_KEYS.join(", ")}`, "error");
+    return;
+  }
+  if (!value && parts.length === 1) {
+    const currentValue = currentSettings[key];
+    if (currentValue) {
+      ctx.ui.notify(`${key}: ${currentValue}`, "info");
+    } else {
+      const defaults = {
+        parentDir: "(default: ../<project>.worktrees/)",
+        onCreate: "(none)"
+      };
+      ctx.ui.notify(`${key}: ${defaults[key]}`, "info");
+    }
+    return;
+  }
+  const newSettings = { ...currentSettings };
+  if (value === "" || value === '""' || value === "null" || value === "clear") {
+    delete newSettings[key];
+    ctx.ui.notify(`\u2713 Cleared ${key}`, "info");
+  } else {
+    newSettings[key] = value;
+    ctx.ui.notify(`\u2713 Set ${key} = "${value}"`, "info");
+  }
+  try {
+    saveSettings(newSettings);
+  } catch (err) {
+    ctx.ui.notify(`Failed to save settings: ${err.message}`, "error");
+  }
+}
+async function handleCreate(args, ctx) {
+  const featureName = args.trim();
+  if (!featureName) {
+    ctx.ui.notify("Usage: /worktree create <feature-name>", "error");
+    return;
+  }
+  if (!isGitRepo(ctx.cwd)) {
+    ctx.ui.notify("Not in a git repository", "error");
+    return;
+  }
+  const settings = loadSettings();
+  const project = getProjectName(ctx.cwd);
+  const mainWorktree = getMainWorktreePath(ctx.cwd);
+  const parentDir = getWorktreeParentDir(ctx.cwd, settings);
+  const worktreePath = join(parentDir, featureName);
+  const branchName = `feature/${featureName}`;
+  const existing = listWorktrees(ctx.cwd);
+  if (existing.some((w) => w.path === worktreePath)) {
+    ctx.ui.notify(`Worktree already exists at: ${worktreePath}`, "error");
+    return;
+  }
+  try {
+    git(["rev-parse", "--verify", branchName], ctx.cwd);
+    ctx.ui.notify(`Branch '${branchName}' already exists. Use a different name.`, "error");
+    return;
+  } catch {}
+  ensureExcluded(ctx.cwd, parentDir);
+  ctx.ui.notify(`Creating worktree: ${featureName}`, "info");
+  try {
+    git(["worktree", "add", "-b", branchName, worktreePath], mainWorktree);
+  } catch (err) {
+    ctx.ui.notify(`Failed to create worktree: ${err.message}`, "error");
+    return;
+  }
+  const createdCtx = {
+    path: worktreePath,
+    name: featureName,
+    branch: branchName,
+    project,
+    mainWorktree
+  };
+  await runOnCreateHook(createdCtx, settings, ctx.ui.notify.bind(ctx.ui));
+  ctx.ui.notify(`\u2713 Worktree created!
+  Path: ${worktreePath}
+  Branch: ${branchName}`, "info");
+}
+async function handleList(_args, ctx) {
+  if (!isGitRepo(ctx.cwd)) {
+    ctx.ui.notify("Not in a git repository", "error");
+    return;
+  }
+  const worktrees = listWorktrees(ctx.cwd);
+  if (worktrees.length === 0) {
+    ctx.ui.notify("No worktrees found", "info");
+    return;
+  }
+  const lines = worktrees.map((w) => {
+    const markers = [
+      w.isMain ? "[main]" : "",
+      w.isCurrent ? "[current]" : ""
+    ].filter(Boolean).join(" ");
+    return `${w.branch}${markers ? " " + markers : ""}
+    ${w.path}`;
+  });
+  ctx.ui.notify(`Worktrees:
+
+${lines.join(`
+
+`)}`, "info");
+}
+async function handleRemove(args, ctx) {
+  const worktreeName = args.trim();
+  if (!worktreeName) {
+    ctx.ui.notify("Usage: /worktree remove <name>", "error");
+    return;
+  }
+  if (!isGitRepo(ctx.cwd)) {
+    ctx.ui.notify("Not in a git repository", "error");
+    return;
+  }
+  const worktrees = listWorktrees(ctx.cwd);
+  const settings = loadSettings();
+  const parentDir = getWorktreeParentDir(ctx.cwd, settings);
+  const target = worktrees.find((w) => basename(w.path) === worktreeName || w.path === worktreeName || w.path === join(parentDir, worktreeName));
+  if (!target) {
+    ctx.ui.notify(`Worktree not found: ${worktreeName}`, "error");
+    return;
+  }
+  if (target.isMain) {
+    ctx.ui.notify("Cannot remove the main worktree", "error");
+    return;
+  }
+  if (target.isCurrent) {
+    ctx.ui.notify("Cannot remove the current worktree. Switch to another first.", "error");
+    return;
+  }
+  const confirmed = await ctx.ui.confirm(`Remove worktree?`, `This will remove:
+  Path: ${target.path}
+  Branch: ${target.branch}
+
+The branch will NOT be deleted.`);
+  if (!confirmed) {
+    ctx.ui.notify("Cancelled", "info");
+    return;
+  }
+  try {
+    git(["worktree", "remove", target.path], ctx.cwd);
+    ctx.ui.notify(`\u2713 Worktree removed: ${target.path}`, "info");
+  } catch (err) {
+    const forceConfirmed = await ctx.ui.confirm("Force remove?", `Worktree has uncommitted changes. Force remove anyway?`);
+    if (forceConfirmed) {
+      try {
+        git(["worktree", "remove", "--force", target.path], ctx.cwd);
+        ctx.ui.notify(`\u2713 Worktree force removed: ${target.path}`, "info");
+      } catch (forceErr) {
+        ctx.ui.notify(`Failed to remove: ${forceErr.message}`, "error");
+      }
+    } else {
+      ctx.ui.notify("Cancelled", "info");
+    }
+  }
+}
+async function handleStatus(_args, ctx) {
+  if (!isGitRepo(ctx.cwd)) {
+    ctx.ui.notify("Not in a git repository", "error");
+    return;
+  }
+  const isWt = isWorktree(ctx.cwd);
+  const mainPath = getMainWorktreePath(ctx.cwd);
+  const project = getProjectName(ctx.cwd);
+  const branch = getCurrentBranch(ctx.cwd);
+  const worktrees = listWorktrees(ctx.cwd);
+  const current = worktrees.find((w) => w.isCurrent);
+  const status = [
+    `Project: ${project}`,
+    `Current path: ${ctx.cwd}`,
+    `Branch: ${branch}`,
+    `Is worktree: ${isWt ? "Yes" : "No (main repository)"}`,
+    `Main worktree: ${mainPath}`,
+    `Total worktrees: ${worktrees.length}`
+  ];
+  ctx.ui.notify(status.join(`
+`), "info");
+}
+async function handleCd(args, ctx) {
+  const worktreeName = args.trim();
+  if (!isGitRepo(ctx.cwd)) {
+    ctx.ui.notify("Not in a git repository", "error");
+    return;
+  }
+  const worktrees = listWorktrees(ctx.cwd);
+  const settings = loadSettings();
+  const parentDir = getWorktreeParentDir(ctx.cwd, settings);
+  if (!worktreeName) {
+    const main = worktrees.find((w) => w.isMain);
+    if (main) {
+      console.log(main.path);
+      ctx.ui.notify(`Main worktree: ${main.path}`, "info");
+    }
+    return;
+  }
+  const target = worktrees.find((w) => basename(w.path) === worktreeName || w.path === worktreeName || w.path === join(parentDir, worktreeName));
+  if (!target) {
+    ctx.ui.notify(`Worktree not found: ${worktreeName}`, "error");
+    return;
+  }
+  console.log(target.path);
+  ctx.ui.notify(`Worktree path: ${target.path}`, "info");
+}
+async function handlePrune(_args, ctx) {
+  if (!isGitRepo(ctx.cwd)) {
+    ctx.ui.notify("Not in a git repository", "error");
+    return;
+  }
+  let dryRun;
+  try {
+    dryRun = git(["worktree", "prune", "--dry-run"], ctx.cwd);
+  } catch (err) {
+    ctx.ui.notify(`Failed to check stale worktrees: ${err.message}`, "error");
+    return;
+  }
+  if (!dryRun.trim()) {
+    ctx.ui.notify("No stale worktree references to prune", "info");
+    return;
+  }
+  const confirmed = await ctx.ui.confirm("Prune stale worktrees?", `The following stale references will be removed:
+
+${dryRun}`);
+  if (!confirmed) {
+    ctx.ui.notify("Cancelled", "info");
+    return;
+  }
+  try {
+    git(["worktree", "prune"], ctx.cwd);
+    ctx.ui.notify("\u2713 Stale worktree references pruned", "info");
+  } catch (err) {
+    ctx.ui.notify(`Failed to prune: ${err.message}`, "error");
+  }
+}
+var commands = {
+  init: handleInit,
+  settings: handleSettings,
+  config: handleSettings,
+  create: handleCreate,
+  list: handleList,
+  ls: handleList,
+  remove: handleRemove,
+  rm: handleRemove,
+  status: handleStatus,
+  cd: handleCd,
+  prune: handlePrune
+};
+function src_default(pi) {
+  pi.registerCommand("worktree", {
+    description: "Git worktree management for isolated workspaces",
+    handler: async (args, ctx) => {
+      const [cmd, ...rest] = args.trim().split(/\s+/);
+      const handler = commands[cmd];
+      if (handler) {
+        await handler(rest.join(" "), ctx);
+      } else {
+        ctx.ui.notify(HELP_TEXT, "info");
+      }
+    }
+  });
+}
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@zenobius/pi-worktrees",
+  "version": "0.0.1",
+  "description": "Worktrees extension for Pi Coding Agent",
+  "author": {
+    "name": "Zenobius",
+    "email": "airtonix@users.noreploy.github.com"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:zenobi-us/pi-worktrees.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi-package"
+  ],
+  "files": [
+    "dist",
+    "src/version.ts"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^20.11.5",
+    "@typescript-eslint/eslint-plugin": "8.47.0",
+    "@typescript-eslint/parser": "8.47.0",
+    "bun-types": "latest",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.4",
+    "typescript-eslint": "^8.47.0",
+    "vitest": "^3.2.4"
+  }
+}