@lsst/pik-plugin-worktree 0.4.2

package/README.md

@@ -0,0 +1,78 @@
+# @lsst/pik-plugin-worktree
+
+Git worktree management plugin for pik - easily create, list, and remove git worktrees.
+
+## Installation
+
+This plugin is included with `@lsst/pik` by default.
+
+```bash
+npm install -g @lsst/pik
+```
+
+## Usage
+
+```bash
+# Interactive create (default)
+pik worktree
+
+# Create with specific name
+pik worktree create my-feature
+
+# Create new branch
+pik worktree create my-feature -n -b feature/new-thing
+
+# List all worktrees
+pik worktree list
+
+# Remove a worktree
+pik worktree remove
+```
+
+## Configuration
+
+Add to your `pik.config.ts`:
+
+```typescript
+import { defineConfig } from '@lsst/pik';
+
+export default defineConfig({
+  worktree: {
+    // Directory where worktrees are created (relative to repo root)
+    baseDir: '../',
+
+    // Files to copy to new worktrees
+    copyFiles: ['.env.local', '.env.development'],
+
+    // Command to run after creating worktree
+    postCreate: 'npm install',
+  },
+});
+```
+
+## Commands
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `pik worktree` | `wt` | Interactive worktree creation |
+| `pik worktree create [name]` | `add` | Create a new worktree |
+| `pik worktree list` | `ls` | List all worktrees |
+| `pik worktree remove [path]` | `rm` | Remove a worktree |
+
+### Create Options
+
+| Option | Description |
+|--------|-------------|
+| `-b, --branch <branch>` | Branch to checkout or create |
+| `-n, --new` | Create a new branch |
+
+### Remove Options
+
+| Option | Description |
+|--------|-------------|
+| `-f, --force` | Force removal even if dirty |
+| `-D, --delete-branch` | Also delete the branch |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { worktreePlugin } from './lib/plugin.js';
+export type { WorktreeConfig } from './lib/types.js';
+export { git, getRepoRoot, getCurrentBranch, isClean, listWorktrees, createWorktree, removeWorktree, listBranches, branchExists, type Worktree, } from './lib/git.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,OAAO,EACL,GAAG,EACH,WAAW,EACX,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,cAAc,EACd,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,KAAK,QAAQ,GACd,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,352 @@
+import { Command } from "commander";
+import { select, input, confirm } from "@inquirer/prompts";
+import pc from "picocolors";
+import { basename, resolve, relative } from "path";
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, copyFileSync } from "fs";
+import { glob } from "glob";
+import { loadConfig } from "@lsst/pik-core";
+function git(args, cwd) {
+  try {
+    return execSync(`git ${args.join(" ")}`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch (error) {
+    const err = error;
+    const gitError = new Error(
+      err.stderr?.toString().trim() || err.message
+    );
+    gitError.stderr = err.stderr?.toString();
+    throw gitError;
+  }
+}
+function getRepoRoot(cwd) {
+  return git(["rev-parse", "--show-toplevel"], cwd);
+}
+function getCurrentBranch(cwd) {
+  return git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+}
+function isClean(cwd) {
+  const status = git(["status", "--porcelain"], cwd);
+  return status === "";
+}
+function listWorktrees(cwd) {
+  const output = git(["worktree", "list", "--porcelain"], cwd);
+  if (!output) return [];
+  const worktrees = [];
+  let current = {};
+  for (const line of output.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) {
+        worktrees.push(current);
+      }
+      current = { path: line.slice(9), isBare: false, isMain: false };
+    } else if (line.startsWith("HEAD ")) {
+      current.commit = line.slice(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.slice(7).replace("refs/heads/", "");
+    } else if (line === "bare") {
+      current.isBare = true;
+    } else if (line === "") {
+      if (worktrees.length === 0 && current.path) {
+        current.isMain = true;
+      }
+    }
+  }
+  if (current.path) {
+    if (worktrees.length === 0) {
+      current.isMain = true;
+    }
+    worktrees.push(current);
+  }
+  return worktrees;
+}
+function createWorktree(path, branch, options, cwd) {
+  const args = ["worktree", "add"];
+  if (options?.newBranch) {
+    args.push("-b", branch);
+    args.push(path);
+    if (options.baseBranch) {
+      args.push(options.baseBranch);
+    }
+  } else {
+    args.push(path, branch);
+  }
+  git(args, cwd);
+}
+function removeWorktree(path, force, cwd) {
+  const args = ["worktree", "remove"];
+  if (force) {
+    args.push("--force");
+  }
+  args.push(path);
+  git(args, cwd);
+}
+function listBranches(cwd) {
+  const output = git(["branch", "--format=%(refname:short)"], cwd);
+  return output.split("\n").filter(Boolean);
+}
+function branchExists(branch, cwd) {
+  try {
+    git(["rev-parse", "--verify", branch], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const createCommand = new Command("create").alias("add").description("Create a new worktree").argument("[name]", "Name for the worktree directory").option("-b, --branch <branch>", "Branch to checkout (or create with -n)").option("-n, --new", "Create a new branch").action(async (name, options) => {
+  try {
+    const repoRoot = getRepoRoot();
+    const config = await loadConfig(repoRoot);
+    const worktreeConfig = config?.worktree ?? {};
+    const currentBranch = getCurrentBranch(repoRoot);
+    const branches = listBranches(repoRoot);
+    const existingWorktrees = listWorktrees(repoRoot);
+    const existingPaths = new Set(existingWorktrees.map((w) => w.path));
+    let branch = options.branch;
+    let isNewBranch = options.new ?? false;
+    if (!branch) {
+      const branchAction = await select({
+        message: "What do you want to do?",
+        choices: [
+          { name: "Create a new branch", value: "new" },
+          { name: "Checkout existing branch", value: "existing" }
+        ]
+      });
+      if (branchAction === "new") {
+        isNewBranch = true;
+        branch = await input({
+          message: "New branch name:",
+          validate: (value) => {
+            if (!value.trim()) return "Branch name is required";
+            if (branchExists(value, repoRoot)) return "Branch already exists";
+            return true;
+          }
+        });
+      } else {
+        const worktreeBranches = new Set(
+          existingWorktrees.map((w) => w.branch).filter(Boolean)
+        );
+        const availableBranches = branches.filter(
+          (b) => !worktreeBranches.has(b)
+        );
+        if (availableBranches.length === 0) {
+          console.log(pc.yellow("All branches already have worktrees"));
+          return;
+        }
+        branch = await select({
+          message: "Select branch:",
+          choices: availableBranches.map((b) => ({
+            name: b === currentBranch ? `${b} (current)` : b,
+            value: b
+          }))
+        });
+      }
+    }
+    let worktreeName = name;
+    if (!worktreeName) {
+      const defaultName = branch.replace(/\//g, "-");
+      worktreeName = await input({
+        message: "Worktree directory name:",
+        default: defaultName,
+        validate: (value) => {
+          if (!value.trim()) return "Name is required";
+          return true;
+        }
+      });
+    }
+    const baseDir = worktreeConfig.baseDir ?? "../";
+    const repoName = basename(repoRoot);
+    const worktreePath = resolve(repoRoot, baseDir, `${repoName}-${worktreeName}`);
+    if (existingPaths.has(worktreePath) || existsSync(worktreePath)) {
+      console.error(pc.red(`Path already exists: ${worktreePath}`));
+      process.exit(1);
+    }
+    console.log(pc.dim(`Creating worktree at ${worktreePath}...`));
+    createWorktree(
+      worktreePath,
+      branch,
+      { newBranch: isNewBranch, baseBranch: currentBranch },
+      repoRoot
+    );
+    console.log(pc.green(`✓ Created worktree for branch ${pc.bold(branch)}`));
+    if (worktreeConfig.copyFiles?.length) {
+      console.log(pc.dim("Copying files..."));
+      for (const pattern of worktreeConfig.copyFiles) {
+        const files = await glob(pattern, { cwd: repoRoot, nodir: true });
+        for (const file of files) {
+          const src = resolve(repoRoot, file);
+          const dest = resolve(worktreePath, file);
+          const destDir = resolve(dest, "..");
+          if (!existsSync(destDir)) {
+            mkdirSync(destDir, { recursive: true });
+          }
+          if (existsSync(src)) {
+            copyFileSync(src, dest);
+            console.log(pc.dim(`  Copied ${file}`));
+          }
+        }
+      }
+    }
+    if (worktreeConfig.postCreate) {
+      const shouldRun = await confirm({
+        message: `Run "${worktreeConfig.postCreate}"?`,
+        default: true
+      });
+      if (shouldRun) {
+        console.log(pc.dim(`Running: ${worktreeConfig.postCreate}`));
+        try {
+          execSync(worktreeConfig.postCreate, {
+            cwd: worktreePath,
+            stdio: "inherit"
+          });
+          console.log(pc.green("✓ Post-create command completed"));
+        } catch {
+          console.log(pc.yellow("⚠ Post-create command failed"));
+        }
+      }
+    }
+    console.log();
+    console.log(pc.green("✓ Worktree ready!"));
+    console.log(pc.dim(`  cd ${worktreePath}`));
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "ExitPromptError") {
+        return;
+      }
+      console.error(pc.red(error.message));
+    }
+    process.exit(1);
+  }
+});
+const listCommand = new Command("list").alias("ls").description("List all worktrees").option("--json", "Output in JSON format").action(async (options) => {
+  try {
+    const repoRoot = getRepoRoot();
+    const worktrees = listWorktrees(repoRoot);
+    if (options.json) {
+      console.log(JSON.stringify(worktrees, null, 2));
+      return;
+    }
+    if (worktrees.length === 0) {
+      console.log(pc.yellow("No worktrees found"));
+      return;
+    }
+    console.log(pc.bold("Worktrees:\n"));
+    for (const wt of worktrees) {
+      const relativePath = relative(process.cwd(), wt.path) || ".";
+      const branchDisplay = wt.branch || pc.dim("(detached)");
+      const mainLabel = wt.isMain ? pc.cyan(" [main]") : "";
+      console.log(`  ${pc.green(relativePath)}${mainLabel}`);
+      console.log(`    Branch: ${branchDisplay}`);
+      console.log(`    Commit: ${pc.dim(wt.commit?.slice(0, 7) || "unknown")}`);
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(pc.red(error.message));
+    }
+    process.exit(1);
+  }
+});
+const removeCommand = new Command("remove").alias("rm").description("Remove a worktree").argument("[path]", "Path to the worktree to remove").option("-f, --force", "Force removal even if worktree is dirty").option("-D, --delete-branch", "Also delete the branch").action(async (pathArg, options) => {
+  try {
+    const repoRoot = getRepoRoot();
+    const worktrees = listWorktrees(repoRoot);
+    const removableWorktrees = worktrees.filter((w) => !w.isMain);
+    if (removableWorktrees.length === 0) {
+      console.log(pc.yellow("No removable worktrees found"));
+      return;
+    }
+    let targetPath = pathArg;
+    let targetWorktree = removableWorktrees.find((w) => w.path === targetPath);
+    if (!targetPath) {
+      const selected = await select({
+        message: "Select worktree to remove:",
+        choices: removableWorktrees.map((wt) => {
+          const relativePath2 = relative(process.cwd(), wt.path) || wt.path;
+          return {
+            name: `${relativePath2} (${wt.branch || "detached"})`,
+            value: wt
+          };
+        })
+      });
+      targetWorktree = selected;
+      targetPath = selected.path;
+    }
+    if (!targetWorktree) {
+      targetWorktree = removableWorktrees.find((w) => {
+        const rel = relative(process.cwd(), w.path);
+        return rel === targetPath || w.path.endsWith(targetPath);
+      });
+      if (!targetWorktree) {
+        console.error(pc.red(`Worktree not found: ${targetPath}`));
+        process.exit(1);
+      }
+    }
+    const relativePath = relative(process.cwd(), targetWorktree.path);
+    const shouldRemove = await confirm({
+      message: `Remove worktree ${pc.bold(relativePath)}?`,
+      default: false
+    });
+    if (!shouldRemove) {
+      console.log(pc.dim("Cancelled"));
+      return;
+    }
+    console.log(pc.dim("Removing worktree..."));
+    removeWorktree(targetWorktree.path, options.force, repoRoot);
+    console.log(pc.green(`✓ Removed worktree ${relativePath}`));
+    if (options.deleteBranch && targetWorktree.branch) {
+      const shouldDeleteBranch = await confirm({
+        message: `Also delete branch ${pc.bold(targetWorktree.branch)}?`,
+        default: false
+      });
+      if (shouldDeleteBranch) {
+        try {
+          git(["branch", "-D", targetWorktree.branch], repoRoot);
+          console.log(pc.green(`✓ Deleted branch ${targetWorktree.branch}`));
+        } catch (error) {
+          if (error instanceof Error) {
+            console.log(pc.yellow(`⚠ Could not delete branch: ${error.message}`));
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "ExitPromptError") {
+        return;
+      }
+      console.error(pc.red(error.message));
+    }
+    process.exit(1);
+  }
+});
+const worktreePlugin = {
+  name: "Worktree",
+  description: "Manage git worktrees",
+  command: "worktree",
+  aliases: ["wt"],
+  register(program) {
+    const worktreeCmd = program.command("worktree").alias("wt").description("Manage git worktrees");
+    worktreeCmd.addCommand(createCommand);
+    worktreeCmd.addCommand(listCommand);
+    worktreeCmd.addCommand(removeCommand);
+    worktreeCmd.action(async () => {
+      await createCommand.parseAsync([], { from: "user" });
+    });
+  }
+};
+export {
+  branchExists,
+  createWorktree,
+  getCurrentBranch,
+  getRepoRoot,
+  git,
+  isClean,
+  listBranches,
+  listWorktrees,
+  removeWorktree,
+  worktreePlugin
+};

package/dist/lib/commands/create.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import '../types.js';
+export declare const createCommand: Command;
+//# sourceMappingURL=create.d.ts.map

package/dist/lib/commands/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC,OAAO,aAAa,CAAC;AAOrB,eAAO,MAAM,aAAa,SAyJtB,CAAC"}

package/dist/lib/commands/list.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const listCommand: Command;
+//# sourceMappingURL=list.d.ts.map

package/dist/lib/commands/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,eAAO,MAAM,WAAW,SAqCpB,CAAC"}

package/dist/lib/commands/remove.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const removeCommand: Command;
+//# sourceMappingURL=remove.d.ts.map

package/dist/lib/commands/remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/remove.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,eAAO,MAAM,aAAa,SA+FtB,CAAC"}

package/dist/lib/git.d.ts

@@ -0,0 +1,62 @@
+export interface Worktree {
+    path: string;
+    branch: string;
+    commit: string;
+    isBare: boolean;
+    isMain: boolean;
+}
+export interface GitError extends Error {
+    stderr?: string;
+}
+/**
+ * Execute a git command and return stdout
+ */
+export declare function git(args: string[], cwd?: string): string;
+/**
+ * Execute a git command asynchronously with live output
+ */
+export declare function gitAsync(args: string[], cwd?: string): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Get the root directory of the git repository
+ */
+export declare function getRepoRoot(cwd?: string): string;
+/**
+ * Get the current branch name
+ */
+export declare function getCurrentBranch(cwd?: string): string;
+/**
+ * Check if working directory is clean
+ */
+export declare function isClean(cwd?: string): boolean;
+/**
+ * List all worktrees
+ */
+export declare function listWorktrees(cwd?: string): Worktree[];
+/**
+ * Create a new worktree
+ */
+export declare function createWorktree(path: string, branch: string, options?: {
+    newBranch?: boolean;
+    baseBranch?: string;
+}, cwd?: string): void;
+/**
+ * Remove a worktree
+ */
+export declare function removeWorktree(path: string, force?: boolean, cwd?: string): void;
+/**
+ * Get list of local branches
+ */
+export declare function listBranches(cwd?: string): string[];
+/**
+ * Check if a branch exists
+ */
+export declare function branchExists(branch: string, cwd?: string): boolean;
+/**
+ * Check if path is inside a git worktree
+ */
+export declare function isWorktree(path: string): boolean;
+//# sourceMappingURL=git.d.ts.map

package/dist/lib/git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/lib/git.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,QAAS,SAAQ,KAAK;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAexD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAwB3D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAmCtD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EACtD,GAAG,CAAC,EAAE,MAAM,GACX,IAAI,CAcN;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAOhF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAGnD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAOlE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQhD"}

package/dist/lib/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { PikPlugin } from '@lsst/pik-core';
+export declare const worktreePlugin: PikPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/lib/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/lib/plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKhD,eAAO,MAAM,cAAc,EAAE,SAsB5B,CAAC"}

package/dist/lib/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Configuration for the worktree plugin
+ */
+export interface WorktreeConfig {
+    /** Directory where worktrees will be created (relative to repo root, default: '../') */
+    baseDir?: string;
+    /** Files to copy to new worktrees (supports globs) */
+    copyFiles?: string[];
+    /** Command to run after creating worktree (e.g., 'npm install') */
+    postCreate?: string;
+}
+/**
+ * Extend PikConfig to include worktree plugin config
+ */
+declare module '@lsst/pik-core' {
+    interface PikConfig {
+        worktree?: WorktreeConfig;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,wFAAwF;IACxF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,mEAAmE;IACnE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,OAAO,QAAQ,gBAAgB,CAAC;IAC9B,UAAU,SAAS;QACjB,QAAQ,CAAC,EAAE,cAAc,CAAC;KAC3B;CACF"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@lsst/pik-plugin-worktree",
+  "version": "0.4.2",
+  "description": "Git worktree management plugin for pik CLI",
+  "type": "module",
+  "license": "MIT",
+  "author": "Yurii Tatar <lsst25@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lsst25/pik.git",
+    "directory": "packages/plugin-worktree"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@pik/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@lsst/pik-core": "*",
+    "@inquirer/prompts": "^8.1.0",
+    "commander": "^14.0.2",
+    "glob": "^10.5.0",
+    "picocolors": "^1.1.1"
+  }
+}