@solaqua/gji 0.6.2 → 0.7.0

package/dist/new.js

@@ -1,20 +1,20 @@
-import { mkdir } from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { isCancel, text } from '@clack/prompts';
-import { loadEffectiveConfig, resolveConfigString } from './config.js';
-import { defaultSpawnEditor, EDITORS } from './editor.js';
-import { syncFiles } from './file-sync.js';
-import { extractHooks, runHook } from './hooks.js';
-import { appendHistory } from './history.js';
-import { isHeadless } from './headless.js';
-import { maybeRunInstallPrompt } from './install-prompt.js';
-import { pathExists, promptForPathConflict } from './conflict.js';
-import { detectRepository, resolveWorktreePath, validateBranchName } from './repo.js';
-import { writeShellOutput } from './shell-handoff.js';
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { promisify } from "node:util";
+import { isCancel, text } from "@clack/prompts";
+import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { pathExists, promptForPathConflict, } from "./conflict.js";
+import { defaultSpawnEditor, EDITORS } from "./editor.js";
+import { syncFiles } from "./file-sync.js";
+import { isHeadless } from "./headless.js";
+import { appendHistory } from "./history.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { detectRepository, resolveWorktreePath, validateBranchName, } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
 const execFileAsync = promisify(execFile);
-const NEW_OUTPUT_FILE_ENV = 'GJI_NEW_OUTPUT_FILE';
+const NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
 export function createNewCommand(dependencies = {}) {
     const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
     const promptForBranch = dependencies.promptForBranch ?? defaultPromptForBranch;
@@ -25,10 +25,12 @@ export function createNewCommand(dependencies = {}) {
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const usesGeneratedDetachedName = options.detached && options.branch === undefined;
         if (options.editor && !options.open) {
-            options.stderr('gji new: --editor has no effect without --open\n');
+            options.stderr("gji new: --editor has no effect without --open\n");
         }
-        if (!options.detached && !options.branch && (options.json || isHeadless())) {
-            const message = 'branch argument is required';
+        if (!options.detached &&
+            !options.branch &&
+            (options.json || isHeadless())) {
+            const message = "branch argument is required";
             if (options.json) {
                 options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
             }
@@ -38,14 +40,14 @@ export function createNewCommand(dependencies = {}) {
             return 1;
         }
         const rawBranch = options.detached
-            ? options.branch ?? createBranchPlaceholder()
-            : options.branch ?? await promptForBranch(createBranchPlaceholder());
+            ? (options.branch ?? createBranchPlaceholder())
+            : (options.branch ?? (await promptForBranch(createBranchPlaceholder())));
         if (!rawBranch) {
             if (options.json) {
-                options.stderr(`${JSON.stringify({ error: 'Aborted' }, null, 2)}\n`);
+                options.stderr(`${JSON.stringify({ error: "Aborted" }, null, 2)}\n`);
             }
             else {
-                options.stderr('Aborted\n');
+                options.stderr("Aborted\n");
             }
             return 1;
         }
@@ -61,19 +63,21 @@ export function createNewCommand(dependencies = {}) {
                 return 1;
             }
         }
-        const rawBasePath = resolveConfigString(config, 'worktreePath');
-        const configuredBasePath = rawBasePath?.startsWith('/') || rawBasePath?.startsWith('~') ? rawBasePath : undefined;
+        const rawBasePath = resolveConfigString(config, "worktreePath");
+        const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~")
+            ? rawBasePath
+            : undefined;
         const worktreeName = options.detached
             ? rawBranch
             : applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
         const worktreePath = usesGeneratedDetachedName
             ? await resolveUniqueDetachedWorktreePath(repository.repoRoot, worktreeName, configuredBasePath)
             : resolveWorktreePath(repository.repoRoot, worktreeName, configuredBasePath);
-        if (!usesGeneratedDetachedName && await pathExists(worktreePath)) {
+        if (!usesGeneratedDetachedName && (await pathExists(worktreePath))) {
             if (options.force) {
                 if (!options.dryRun) {
                     try {
-                        await execFileAsync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: repository.repoRoot });
+                        await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], { cwd: repository.repoRoot });
                     }
                     catch (err) {
                         if (!isNotRegisteredWorktreeError(err)) {
@@ -88,7 +92,9 @@ export function createNewCommand(dependencies = {}) {
                     }
                     if (!options.detached) {
                         try {
-                            await execFileAsync('git', ['branch', '-D', worktreeName], { cwd: repository.repoRoot });
+                            await execFileAsync("git", ["branch", "-D", worktreeName], {
+                                cwd: repository.repoRoot,
+                            });
                         }
                         catch {
                             // Branch may not exist; proceed anyway.
@@ -110,7 +116,7 @@ export function createNewCommand(dependencies = {}) {
             }
             else {
                 const choice = await prompt(worktreePath);
-                if (choice === 'reuse') {
+                if (choice === "reuse") {
                     appendHistory(worktreePath, worktreeName).catch(() => undefined);
                     await writeOutput(worktreePath, options.stdout);
                     return 0;
@@ -125,23 +131,25 @@ export function createNewCommand(dependencies = {}) {
             }
             else {
                 const resolvedEditor = options.open
-                    ? (options.editor ?? resolveConfigString(config, 'editor'))
+                    ? (options.editor ?? resolveConfigString(config, "editor"))
                     : undefined;
-                const openNote = resolvedEditor ? `, then open in ${resolvedEditor}` : '';
+                const openNote = resolvedEditor
+                    ? `, then open in ${resolvedEditor}`
+                    : "";
                 options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName}${openNote})\n`);
             }
             return 0;
         }
         await mkdir(dirname(worktreePath), { recursive: true });
         const gitArgs = options.detached
-            ? ['worktree', 'add', '--detach', worktreePath]
-            : await localBranchExists(repository.repoRoot, worktreeName)
-                ? ['worktree', 'add', worktreePath, worktreeName]
-                : ['worktree', 'add', '-b', worktreeName, worktreePath];
-        await execFileAsync('git', gitArgs, { cwd: repository.repoRoot });
+            ? ["worktree", "add", "--detach", worktreePath]
+            : (await localBranchExists(repository.repoRoot, worktreeName))
+                ? ["worktree", "add", worktreePath, worktreeName]
+                : ["worktree", "add", "-b", worktreeName, worktreePath];
+        await execFileAsync("git", gitArgs, { cwd: repository.repoRoot });
         // Sync files from main worktree before afterCreate so synced files are available to install scripts.
         const syncPatterns = Array.isArray(config.syncFiles)
-            ? config.syncFiles.filter((p) => typeof p === 'string')
+            ? config.syncFiles.filter((p) => typeof p === "string")
             : [];
         for (const pattern of syncPatterns) {
             try {
@@ -153,7 +161,11 @@ export function createNewCommand(dependencies = {}) {
         }
         await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterCreate, worktreePath, { branch: worktreeName, path: worktreePath, repo: basename(repository.repoRoot) }, options.stderr);
+        await runHook(hooks.afterCreate, worktreePath, {
+            branch: worktreeName,
+            path: worktreePath,
+            repo: basename(repository.repoRoot),
+        }, options.stderr);
         if (options.json) {
             options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}\n`);
         }
@@ -162,7 +174,7 @@ export function createNewCommand(dependencies = {}) {
             await writeOutput(worktreePath, options.stdout);
         }
         if (options.open) {
-            const resolvedEditor = options.editor ?? resolveConfigString(config, 'editor');
+            const resolvedEditor = options.editor ?? resolveConfigString(config, "editor");
             await openWorktree(worktreePath, resolvedEditor, spawnEditor, options.stderr);
         }
         return 0;
@@ -171,48 +183,48 @@ export function createNewCommand(dependencies = {}) {
 export const runNewCommand = createNewCommand();
 export function generateBranchPlaceholder(random = Math.random) {
     const roots = [
-        'socrates',
-        'prometheus',
-        'beethoven',
-        'ada',
-        'turing',
-        'hypatia',
-        'tesla',
-        'curie',
-        'diogenes',
-        'plato',
-        'hephaestus',
-        'athena',
-        'archimedes',
-        'euclid',
-        'heraclitus',
-        'galileo',
-        'newton',
-        'lovelace',
-        'nietzsche',
-        'kafka',
+        "socrates",
+        "prometheus",
+        "beethoven",
+        "ada",
+        "turing",
+        "hypatia",
+        "tesla",
+        "curie",
+        "diogenes",
+        "plato",
+        "hephaestus",
+        "athena",
+        "archimedes",
+        "euclid",
+        "heraclitus",
+        "galileo",
+        "newton",
+        "lovelace",
+        "nietzsche",
+        "kafka",
     ];
     const antics = [
-        'borrowed-a-bike',
-        'brought-snacks',
-        'missed-the-bus',
-        'lost-the-keys',
-        'spilled-the-coffee',
-        'forgot-the-umbrella',
-        'walked-the-dog',
-        'missed-the-train',
-        'wrote-a-poem',
-        'burned-the-toast',
-        'fed-the-pigeons',
-        'watered-the-plants',
-        'washed-the-dishes',
-        'folded-the-laundry',
-        'took-a-nap',
+        "borrowed-a-bike",
+        "brought-snacks",
+        "missed-the-bus",
+        "lost-the-keys",
+        "spilled-the-coffee",
+        "forgot-the-umbrella",
+        "walked-the-dog",
+        "missed-the-train",
+        "wrote-a-poem",
+        "burned-the-toast",
+        "fed-the-pigeons",
+        "watered-the-plants",
+        "washed-the-dishes",
+        "folded-the-laundry",
+        "took-a-nap",
     ];
     return `${pickRandom(roots, random)}-${pickRandom(antics, random)}`;
 }
 function applyConfiguredBranchPrefix(branch, branchPrefix) {
-    if (typeof branchPrefix !== 'string' || branchPrefix.length === 0) {
+    if (typeof branchPrefix !== "string" || branchPrefix.length === 0) {
         return branch;
     }
     if (branch.startsWith(branchPrefix)) {
@@ -225,7 +237,7 @@ async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
     while (true) {
         const candidateName = attempt === 1 ? baseName : `${baseName}-${attempt}`;
         const candidatePath = resolveWorktreePath(repoRoot, candidateName, basePath);
-        if (!await pathExists(candidatePath)) {
+        if (!(await pathExists(candidatePath))) {
             return candidatePath;
         }
         attempt += 1;
@@ -234,7 +246,7 @@ async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
 async function defaultPromptForBranch(placeholder) {
     const choice = await text({
         defaultValue: placeholder,
-        message: 'Name the new branch',
+        message: "Name the new branch",
         placeholder,
         validate: (value) => {
             const trimmed = value.trim();
@@ -252,7 +264,7 @@ function pickRandom(values, random) {
 }
 async function localBranchExists(repoRoot, branchName) {
     try {
-        await execFileAsync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], { cwd: repoRoot });
+        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
         return true;
     }
     catch {
@@ -264,17 +276,20 @@ async function writeOutput(worktreePath, stdout) {
 }
 function isNotRegisteredWorktreeError(error) {
     const stderr = hasExecStderr(error) ? error.stderr : String(error);
-    return stderr.includes('is not a working tree') || stderr.includes('not a linked working tree');
+    return (stderr.includes("is not a working tree") ||
+        stderr.includes("not a linked working tree"));
 }
 function hasExecStderr(error) {
-    return error instanceof Error && 'stderr' in error && typeof error.stderr === 'string';
+    return (error instanceof Error &&
+        "stderr" in error &&
+        typeof error.stderr === "string");
 }
 function toExecMessage(error) {
     return hasExecStderr(error) ? error.stderr.trim() : String(error);
 }
 async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
     if (!editorCli) {
-        stderr('gji new: --open requires --editor <cli> or a saved editor in config\n');
+        stderr("gji new: --open requires --editor <cli> or a saved editor in config\n");
         return;
     }
     const editorDef = EDITORS.find((e) => e.cli === editorCli);

package/dist/open.d.ts

@@ -1,5 +1,5 @@
-import { type EditorDefinition } from './editor.js';
-import { type WorktreeEntry } from './repo.js';
+import { type EditorDefinition } from "./editor.js";
+import { type WorktreeEntry } from "./repo.js";
 export type { EditorDefinition };
 export interface OpenCommandOptions {
     branch?: string;

package/dist/open.js

@@ -1,12 +1,12 @@
-import { execFile } from 'node:child_process';
-import { access, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-import { isCancel, select } from '@clack/prompts';
-import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey } from './config.js';
-import { defaultSpawnEditor, EDITORS } from './editor.js';
-import { isHeadless } from './headless.js';
-import { detectRepository, listWorktrees, sortByCurrentFirst } from './repo.js';
+import { execFile } from "node:child_process";
+import { access, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { isCancel, select } from "@clack/prompts";
+import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey, } from "./config.js";
+import { defaultSpawnEditor, EDITORS, } from "./editor.js";
+import { isHeadless } from "./headless.js";
+import { detectRepository, listWorktrees, sortByCurrentFirst, } from "./repo.js";
 const execFileAsync = promisify(execFile);
 export function createOpenCommand(dependencies = {}) {
     const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
@@ -35,14 +35,14 @@ export function createOpenCommand(dependencies = {}) {
         else {
             const chosen = await promptForWorktree(sortByCurrentFirst(worktrees));
             if (!chosen) {
-                options.stderr('Aborted\n');
+                options.stderr("Aborted\n");
                 return 1;
             }
             targetPath = chosen;
         }
         // Resolve which editor to use.
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
-        const savedEditor = resolveConfigString(config, 'editor');
+        const savedEditor = resolveConfigString(config, "editor");
         let editorCli;
         if (options.editor) {
             editorCli = options.editor;
@@ -53,7 +53,7 @@ export function createOpenCommand(dependencies = {}) {
         else {
             const installed = await detectEditors();
             if (installed.length === 0) {
-                options.stderr('gji open: no supported editor detected. Use --editor <code|cursor|zed|...> to specify one.\n');
+                options.stderr("gji open: no supported editor detected. Use --editor <code|cursor|zed|...> to specify one.\n");
                 return 1;
             }
             if (installed.length === 1 || isHeadless()) {
@@ -62,7 +62,7 @@ export function createOpenCommand(dependencies = {}) {
             else {
                 const chosen = await promptForEditor(installed);
                 if (!chosen) {
-                    options.stderr('Aborted\n');
+                    options.stderr("Aborted\n");
                     return 1;
                 }
                 editorCli = chosen;
@@ -70,7 +70,7 @@ export function createOpenCommand(dependencies = {}) {
         }
         // Persist editor choice when requested.
         if (options.save && editorCli !== savedEditor) {
-            await updateGlobalConfigKey('editor', editorCli);
+            await updateGlobalConfigKey("editor", editorCli);
             const displayName = EDITORS.find((e) => e.cli === editorCli)?.name ?? editorCli;
             options.stdout(`Saved editor "${displayName}" to global config\n`);
         }
@@ -106,12 +106,15 @@ export function createOpenCommand(dependencies = {}) {
 }
 export const runOpenCommand = createOpenCommand();
 async function detectInstalledEditors() {
-    const results = await Promise.all(EDITORS.map(async (editor) => ({ editor, available: await isCommandAvailable(editor.cli) })));
+    const results = await Promise.all(EDITORS.map(async (editor) => ({
+        editor,
+        available: await isCommandAvailable(editor.cli),
+    })));
     return results.filter((r) => r.available).map((r) => r.editor);
 }
 async function isCommandAvailable(command) {
     try {
-        await execFileAsync('which', [command]);
+        await execFileAsync("which", [command]);
         return true;
     }
     catch {
@@ -120,10 +123,10 @@ async function isCommandAvailable(command) {
 }
 async function defaultPromptForWorktree(worktrees) {
     const choice = await select({
-        message: 'Choose a worktree to open',
+        message: "Choose a worktree to open",
         options: worktrees.map((w) => ({
             value: w.path,
-            label: w.branch ?? '(detached)',
+            label: w.branch ?? "(detached)",
             hint: w.isCurrent ? `${w.path} (current)` : w.path,
         })),
     });
@@ -133,7 +136,7 @@ async function defaultPromptForWorktree(worktrees) {
 }
 async function defaultPromptForEditor(editors) {
     const choice = await select({
-        message: 'Choose an editor',
+        message: "Choose an editor",
         options: editors.map((e) => ({ value: e.cli, label: e.name })),
     });
     if (isCancel(choice))
@@ -149,7 +152,7 @@ async function ensureWorkspaceFile(worktreePath, repoName) {
     catch {
         // File doesn't exist yet — create it.
     }
-    const workspace = { folders: [{ path: '.' }], settings: {} };
-    await writeFile(workspacePath, `${JSON.stringify(workspace, null, 2)}\n`, 'utf8');
+    const workspace = { folders: [{ path: "." }], settings: {} };
+    await writeFile(workspacePath, `${JSON.stringify(workspace, null, 2)}\n`, "utf8");
     return workspacePath;
 }

package/dist/package-manager.js

@@ -1,70 +1,121 @@
-import { access, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { access, readdir } from "node:fs/promises";
+import { join } from "node:path";
 const ENTRIES = [
     // JavaScript / TypeScript
-    { name: 'pnpm', signals: ['pnpm-lock.yaml'], command: 'pnpm install' },
-    { name: 'yarn', signals: ['yarn.lock'], command: 'yarn install' },
-    { name: 'bun', signals: ['bun.lockb'], command: 'bun install' },
-    { name: 'npm', signals: ['package-lock.json'], command: 'npm install' },
-    { name: 'deno', signals: ['deno.json', 'deno.jsonc'], command: 'deno cache' },
+    { name: "pnpm", signals: ["pnpm-lock.yaml"], command: "pnpm install" },
+    { name: "yarn", signals: ["yarn.lock"], command: "yarn install" },
+    { name: "bun", signals: ["bun.lockb"], command: "bun install" },
+    { name: "npm", signals: ["package-lock.json"], command: "npm install" },
+    { name: "deno", signals: ["deno.json", "deno.jsonc"], command: "deno cache" },
     // Python
-    { name: 'poetry', signals: ['poetry.lock'], command: 'poetry install' },
-    { name: 'uv', signals: ['uv.lock'], command: 'uv sync' },
-    { name: 'pipenv', signals: ['Pipfile.lock'], command: 'pipenv install' },
-    { name: 'pdm', signals: ['pdm.lock'], command: 'pdm install' },
-    { name: 'conda-lock', signals: ['conda-lock.yml'], command: 'conda-lock install' },
-    { name: 'conda', signals: ['environment.yml'], command: 'conda env update --file environment.yml' },
+    { name: "poetry", signals: ["poetry.lock"], command: "poetry install" },
+    { name: "uv", signals: ["uv.lock"], command: "uv sync" },
+    { name: "pipenv", signals: ["Pipfile.lock"], command: "pipenv install" },
+    { name: "pdm", signals: ["pdm.lock"], command: "pdm install" },
+    {
+        name: "conda-lock",
+        signals: ["conda-lock.yml"],
+        command: "conda-lock install",
+    },
+    {
+        name: "conda",
+        signals: ["environment.yml"],
+        command: "conda env update --file environment.yml",
+    },
     // R
-    { name: 'renv', signals: ['renv.lock'], command: "Rscript -e 'renv::restore()'" },
+    {
+        name: "renv",
+        signals: ["renv.lock"],
+        command: "Rscript -e 'renv::restore()'",
+    },
     // Rust
-    { name: 'cargo', signals: ['Cargo.lock'], command: 'cargo build' },
+    { name: "cargo", signals: ["Cargo.lock"], command: "cargo build" },
     // Go
-    { name: 'go', signals: ['go.sum'], command: 'go mod download' },
+    { name: "go", signals: ["go.sum"], command: "go mod download" },
     // Ruby
-    { name: 'bundler', signals: ['Gemfile.lock'], command: 'bundle install' },
+    { name: "bundler", signals: ["Gemfile.lock"], command: "bundle install" },
     // PHP
-    { name: 'composer', signals: ['composer.lock'], command: 'composer install' },
+    { name: "composer", signals: ["composer.lock"], command: "composer install" },
     // Elixir / Erlang
-    { name: 'mix', signals: ['mix.lock'], command: 'mix deps.get' },
-    { name: 'rebar3', signals: ['rebar.lock'], command: 'rebar3 deps' },
+    { name: "mix", signals: ["mix.lock"], command: "mix deps.get" },
+    { name: "rebar3", signals: ["rebar.lock"], command: "rebar3 deps" },
     // Dart / Flutter
-    { name: 'dart', signals: ['pubspec.lock'], command: 'dart pub get' },
+    { name: "dart", signals: ["pubspec.lock"], command: "dart pub get" },
     // Java / Kotlin / Scala
-    { name: 'maven', signals: ['pom.xml'], command: 'mvn install' },
-    { name: 'gradle', signals: ['gradlew'], command: './gradlew build' },
-    { name: 'gradle', signals: ['build.gradle', 'build.gradle.kts'], command: 'gradle build' },
-    { name: 'sbt', signals: ['build.sbt'], command: 'sbt compile' },
+    { name: "maven", signals: ["pom.xml"], command: "mvn install" },
+    { name: "gradle", signals: ["gradlew"], command: "./gradlew build" },
+    {
+        name: "gradle",
+        signals: ["build.gradle", "build.gradle.kts"],
+        command: "gradle build",
+    },
+    { name: "sbt", signals: ["build.sbt"], command: "sbt compile" },
     // .NET (C# / F# / VB)
-    { name: 'dotnet', signals: ['*.sln', '*.csproj', '*.fsproj', '*.vbproj'], command: 'dotnet restore', glob: true },
+    {
+        name: "dotnet",
+        signals: ["*.sln", "*.csproj", "*.fsproj", "*.vbproj"],
+        command: "dotnet restore",
+        glob: true,
+    },
     // Swift
-    { name: 'swift', signals: ['Package.swift'], command: 'swift package resolve' },
+    {
+        name: "swift",
+        signals: ["Package.swift"],
+        command: "swift package resolve",
+    },
     // Haskell
-    { name: 'stack', signals: ['stack.yaml'], command: 'stack build' },
-    { name: 'cabal', signals: ['cabal.project'], command: 'cabal install --only-dependencies' },
-    { name: 'cabal', signals: ['*.cabal'], command: 'cabal install --only-dependencies', glob: true },
+    { name: "stack", signals: ["stack.yaml"], command: "stack build" },
+    {
+        name: "cabal",
+        signals: ["cabal.project"],
+        command: "cabal install --only-dependencies",
+    },
+    {
+        name: "cabal",
+        signals: ["*.cabal"],
+        command: "cabal install --only-dependencies",
+        glob: true,
+    },
     // Clojure
-    { name: 'clojure', signals: ['deps.edn'], command: 'clojure -P' },
-    { name: 'leiningen', signals: ['project.clj'], command: 'lein deps' },
+    { name: "clojure", signals: ["deps.edn"], command: "clojure -P" },
+    { name: "leiningen", signals: ["project.clj"], command: "lein deps" },
     // OCaml
-    { name: 'dune', signals: ['dune-project'], command: 'dune build' },
+    { name: "dune", signals: ["dune-project"], command: "dune build" },
     // Julia
-    { name: 'julia', signals: ['Manifest.toml'], command: "julia --project -e 'using Pkg; Pkg.instantiate()'" },
+    {
+        name: "julia",
+        signals: ["Manifest.toml"],
+        command: "julia --project -e 'using Pkg; Pkg.instantiate()'",
+    },
     // Nim
-    { name: 'nimble', signals: ['*.nimble'], command: 'nimble install', glob: true },
+    {
+        name: "nimble",
+        signals: ["*.nimble"],
+        command: "nimble install",
+        glob: true,
+    },
     // Crystal
-    { name: 'shards', signals: ['shard.yml'], command: 'shards install' },
+    { name: "shards", signals: ["shard.yml"], command: "shards install" },
     // Perl
-    { name: 'cpanm', signals: ['cpanfile'], command: 'cpanm --installdeps .' },
+    { name: "cpanm", signals: ["cpanfile"], command: "cpanm --installdeps ." },
     // Zig
-    { name: 'zig', signals: ['build.zig.zon'], command: 'zig build' },
+    { name: "zig", signals: ["build.zig.zon"], command: "zig build" },
     // C / C++
-    { name: 'vcpkg', signals: ['vcpkg.json'], command: 'vcpkg install' },
-    { name: 'conan', signals: ['conanfile.py', 'conanfile.txt'], command: 'conan install .' },
+    { name: "vcpkg", signals: ["vcpkg.json"], command: "vcpkg install" },
+    {
+        name: "conan",
+        signals: ["conanfile.py", "conanfile.txt"],
+        command: "conan install .",
+    },
     // Nix
-    { name: 'nix', signals: ['flake.nix'], command: 'nix develop' },
-    { name: 'nix-shell', signals: ['shell.nix'], command: 'nix-shell' },
+    { name: "nix", signals: ["flake.nix"], command: "nix develop" },
+    { name: "nix-shell", signals: ["shell.nix"], command: "nix-shell" },
     // Terraform / OpenTofu
-    { name: 'terraform', signals: ['terraform.lock.hcl'], command: 'terraform init' },
+    {
+        name: "terraform",
+        signals: ["terraform.lock.hcl"],
+        command: "terraform init",
+    },
 ];
 export async function detectPackageManager(repoRoot) {
     for (const entry of ENTRIES) {
@@ -102,7 +153,7 @@ async function matchesGlob(repoRoot, patterns) {
 }
 function patternToRegex(pattern) {
     const escaped = pattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '[^/]*');
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, "[^/]*");
     return new RegExp(`^${escaped}$`);
 }

package/dist/pr.d.ts

@@ -1,5 +1,5 @@
-import { type PathConflictChoice } from './conflict.js';
-import { type InstallPromptDependencies } from './install-prompt.js';
+import { type PathConflictChoice } from "./conflict.js";
+import { type InstallPromptDependencies } from "./install-prompt.js";
 export type { PathConflictChoice };
 export interface PrCommandOptions {
     cwd: string;