@solaqua/gji 0.1.0-beta.9 → 0.2.0

package/dist/config.js

@@ -14,11 +14,31 @@ export async function loadEffectiveConfig(root, home = homedir()) {
         loadGlobalConfig(home),
         loadConfig(root),
     ]);
-    return mergeConfig(globalConfig.config, localConfig.config);
+    const merged = mergeConfig(globalConfig.config, localConfig.config);
+    const globalHooks = isPlainObject(globalConfig.config.hooks) ? globalConfig.config.hooks : {};
+    const localHooks = isPlainObject(localConfig.config.hooks) ? localConfig.config.hooks : {};
+    if (Object.keys(globalHooks).length > 0 || Object.keys(localHooks).length > 0) {
+        merged.hooks = { ...globalHooks, ...localHooks };
+    }
+    return merged;
 }
 export async function loadGlobalConfig(home = homedir()) {
     return loadConfigFile(GLOBAL_CONFIG_FILE_PATH(home));
 }
+export async function saveLocalConfig(root, config) {
+    const path = join(root, CONFIG_FILE_NAME);
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    return path;
+}
+export async function updateLocalConfigKey(root, key, value) {
+    const loaded = await loadConfig(root);
+    const nextConfig = {
+        ...loaded.config,
+        [key]: value,
+    };
+    await saveLocalConfig(root, nextConfig);
+    return nextConfig;
+}
 export async function saveGlobalConfig(config, home = homedir()) {
     const path = GLOBAL_CONFIG_FILE_PATH(home);
     await mkdir(dirname(path), { recursive: true });
@@ -79,6 +99,9 @@ function mergeConfig(...values) {
         ...value,
     }), { ...DEFAULT_CONFIG });
 }
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function isMissingFileError(error) {
     return (error instanceof Error &&
         'code' in error &&

package/dist/file-sync.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copies files matching each pattern (relative to mainRoot) into the equivalent
+ * relative path under targetPath, creating parent directories as needed.
+ *
+ * - Non-destructive: silently skips if the target file already exists.
+ * - Silently skips if the source file does not exist.
+ * - Rejects patterns that are absolute paths or contain `..` segments.
+ */
+export declare function syncFiles(mainRoot: string, targetPath: string, patterns: string[]): Promise<void>;

package/dist/file-sync.js

@@ -0,0 +1,52 @@
+import { copyFile, mkdir, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, join, normalize } from 'node:path';
+/**
+ * Copies files matching each pattern (relative to mainRoot) into the equivalent
+ * relative path under targetPath, creating parent directories as needed.
+ *
+ * - Non-destructive: silently skips if the target file already exists.
+ * - Silently skips if the source file does not exist.
+ * - Rejects patterns that are absolute paths or contain `..` segments.
+ */
+export async function syncFiles(mainRoot, targetPath, patterns) {
+    for (const pattern of patterns) {
+        if (isAbsolute(pattern)) {
+            throw new Error(`syncFiles: pattern must be a relative path, got: ${pattern}`);
+        }
+        const normalized = normalize(pattern);
+        if (normalized.startsWith('..')) {
+            throw new Error(`syncFiles: pattern must not contain '..' segments, got: ${pattern}`);
+        }
+        const sourcePath = join(mainRoot, normalized);
+        const destPath = join(targetPath, normalized);
+        // Skip silently if source does not exist
+        const sourceExists = await fileExists(sourcePath);
+        if (!sourceExists) {
+            continue;
+        }
+        // Skip silently if target already exists
+        const destExists = await fileExists(destPath);
+        if (destExists) {
+            continue;
+        }
+        await mkdir(dirname(destPath), { recursive: true });
+        await copyFile(sourcePath, destPath);
+    }
+}
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function isNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/dist/go.js

@@ -1,26 +1,37 @@
+import { basename } from 'node:path';
 import { isCancel, select } from '@clack/prompts';
-import { listWorktrees } from './repo.js';
+import { loadEffectiveConfig } from './config.js';
+import { isHeadless } from './headless.js';
+import { extractHooks, runHook } from './hooks.js';
+import { detectRepository, listWorktrees } from './repo.js';
 import { writeShellOutput } from './shell-handoff.js';
 const GO_OUTPUT_FILE_ENV = 'GJI_GO_OUTPUT_FILE';
 export function createGoCommand(dependencies = {}) {
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
     return async function runGoCommand(options) {
-        const worktrees = await listWorktrees(options.cwd);
-        if (options.branch) {
-            const worktree = worktrees.find((entry) => entry.branch === options.branch);
-            if (!worktree) {
-                options.stderr(`No worktree found for branch: ${options.branch}\n`);
-                return 1;
-            }
-            options.stdout(`${worktree.path}\n`);
-            return 0;
+        const [worktrees, repository] = await Promise.all([
+            listWorktrees(options.cwd),
+            detectRepository(options.cwd),
+        ]);
+        if (!options.branch && isHeadless()) {
+            options.stderr('gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n');
+            return 1;
         }
-        const chosenPath = await prompt(worktrees);
-        if (!chosenPath) {
-            options.stderr('Aborted\n');
+        const prompted = options.branch ? null : await prompt(worktrees);
+        const resolvedPath = options.branch
+            ? worktrees.find((entry) => entry.branch === options.branch)?.path
+            : prompted ?? undefined;
+        if (!resolvedPath) {
+            options.stderr(options.branch
+                ? `No worktree found for branch: ${options.branch}\n`
+                : 'Aborted\n');
             return 1;
         }
-        await writeShellOutput(GO_OUTPUT_FILE_ENV, chosenPath, options.stdout);
+        const chosenWorktree = worktrees.find((w) => w.path === resolvedPath);
+        const config = await loadEffectiveConfig(repository.repoRoot);
+        const hooks = extractHooks(config);
+        await runHook(hooks.afterEnter, resolvedPath, { branch: chosenWorktree?.branch ?? undefined, path: resolvedPath, repo: basename(repository.repoRoot) }, options.stderr);
+        await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
         return 0;
     };
 }

package/dist/headless.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns true when running in a non-interactive (headless) environment.
+ * Set GJI_NO_TUI=1 to disable all interactive prompts.
+ * Commands that would otherwise hang waiting for input must fail fast instead.
+ */
+export declare function isHeadless(): boolean;

package/dist/headless.js

@@ -0,0 +1,8 @@
+/**
+ * Returns true when running in a non-interactive (headless) environment.
+ * Set GJI_NO_TUI=1 to disable all interactive prompts.
+ * Commands that would otherwise hang waiting for input must fail fast instead.
+ */
+export function isHeadless() {
+    return process.env.GJI_NO_TUI === '1';
+}

package/dist/hooks.d.ts

@@ -0,0 +1,13 @@
+export interface GjiHooks {
+    afterCreate?: string;
+    afterEnter?: string;
+    beforeRemove?: string;
+}
+export interface HookContext {
+    branch?: string;
+    path: string;
+    repo: string;
+}
+export declare function runHook(hookCmd: string | undefined, cwd: string, context: HookContext, stderr: (chunk: string) => void): Promise<void>;
+export declare function interpolate(template: string, context: HookContext): string;
+export declare function extractHooks(config: Record<string, unknown>): GjiHooks;

package/dist/hooks.js

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+export async function runHook(hookCmd, cwd, context, stderr) {
+    if (!hookCmd)
+        return;
+    const interpolated = interpolate(hookCmd, context);
+    await new Promise((resolve) => {
+        const child = spawn(interpolated, {
+            cwd,
+            shell: true,
+            stdio: ['ignore', 'inherit', 'pipe'],
+            env: {
+                ...process.env,
+                GJI_BRANCH: context.branch ?? '',
+                GJI_PATH: context.path,
+                GJI_REPO: context.repo,
+            },
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr(chunk.toString());
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                stderr(`gji: hook exited with code ${code}: ${interpolated}\n`);
+            }
+            resolve();
+        });
+        child.on('error', (err) => {
+            stderr(`gji: hook failed to start: ${err.message}\n`);
+            resolve();
+        });
+    });
+}
+export function interpolate(template, context) {
+    return template
+        .replace(/\{\{branch\}\}/g, context.branch ?? '')
+        .replace(/\{\{path\}\}/g, context.path)
+        .replace(/\{\{repo\}\}/g, context.repo);
+}
+export function extractHooks(config) {
+    const raw = config.hooks;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return {};
+    }
+    const hooks = raw;
+    return {
+        afterCreate: typeof hooks.afterCreate === 'string' ? hooks.afterCreate : undefined,
+        afterEnter: typeof hooks.afterEnter === 'string' ? hooks.afterEnter : undefined,
+        beforeRemove: typeof hooks.beforeRemove === 'string' ? hooks.beforeRemove : undefined,
+    };
+}

package/dist/init.js

@@ -181,7 +181,7 @@ function renderPosixWrapper(command) {
   local target
   local output_file
   output_file="$(mktemp -t ${command.tempPrefix}.XXXXXX)" || return 1
-  ${command.envVar}="$output_file" command gji ${command.commandName} "$@" || { local status=$?; rm -f "$output_file"; return $status; }
+  ${command.envVar}="$output_file" command gji ${command.commandName} "$@" || { local exit_code=$?; rm -f "$output_file"; return $exit_code; }
   target="$(cat "$output_file")"
   rm -f "$output_file"
   cd "$target" || return $?

package/dist/install-prompt.d.ts

@@ -0,0 +1,10 @@
+import { type GjiConfig } from './config.js';
+import { type PackageManager } from './package-manager.js';
+export type InstallChoice = 'yes' | 'no' | 'always' | 'never';
+export interface InstallPromptDependencies {
+    detectInstallPackageManager?: (root: string) => Promise<PackageManager | null>;
+    promptForInstallChoice?: (pm: PackageManager) => Promise<InstallChoice | null>;
+    runInstallCommand?: (command: string, cwd: string, stderr: (chunk: string) => void) => Promise<void>;
+    writeConfigKey?: (root: string, key: string, value: unknown) => Promise<void>;
+}
+export declare function maybeRunInstallPrompt(worktreePath: string, repoRoot: string, config: GjiConfig, stderr: (chunk: string) => void, dependencies?: InstallPromptDependencies, nonInteractive?: boolean): Promise<void>;

package/dist/install-prompt.js

@@ -0,0 +1,99 @@
+import { spawn } from 'node:child_process';
+import { isCancel, select } from '@clack/prompts';
+import { loadConfig, updateLocalConfigKey } from './config.js';
+import { isHeadless } from './headless.js';
+import { detectPackageManager } from './package-manager.js';
+export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dependencies = {}, nonInteractive = false) {
+    // Skip in non-interactive mode — no prompt can be shown.
+    if (isHeadless() || nonInteractive) {
+        return;
+    }
+    // Skip if afterCreate hook is already configured in effective config.
+    const hooks = isPlainObject(config.hooks) ? config.hooks : null;
+    if (typeof hooks?.afterCreate === 'string' && hooks.afterCreate.length > 0) {
+        return;
+    }
+    // Skip if user has permanently opted out of install prompts.
+    if (config.skipInstallPrompt === true) {
+        return;
+    }
+    const detect = dependencies.detectInstallPackageManager ?? detectPackageManager;
+    const pm = await detect(worktreePath);
+    if (!pm) {
+        return;
+    }
+    const prompt = dependencies.promptForInstallChoice ?? defaultPromptForInstallChoice;
+    const choice = await prompt(pm);
+    if (!choice || choice === 'no') {
+        return;
+    }
+    if (choice === 'yes' || choice === 'always') {
+        const runner = dependencies.runInstallCommand ?? defaultRunInstallCommand;
+        try {
+            await runner(pm.installCommand, worktreePath, stderr);
+        }
+        catch (error) {
+            stderr(`gji: install command failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    const writeKey = dependencies.writeConfigKey ?? defaultWriteConfigKey;
+    if (choice === 'always') {
+        try {
+            // Read local config hooks to deep-merge so other hook keys (e.g. afterEnter) are preserved.
+            const { config: localConfig } = await loadConfig(repoRoot);
+            const existingLocalHooks = isPlainObject(localConfig.hooks) ? localConfig.hooks : {};
+            await writeKey(repoRoot, 'hooks', { ...existingLocalHooks, afterCreate: pm.installCommand });
+        }
+        catch (error) {
+            stderr(`gji: failed to save config: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    if (choice === 'never') {
+        try {
+            await writeKey(repoRoot, 'skipInstallPrompt', true);
+        }
+        catch (error) {
+            stderr(`gji: failed to save config: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+}
+async function defaultRunInstallCommand(command, cwd, stderr) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, { cwd, shell: true, stdio: ['ignore', 'inherit', 'pipe'] });
+        child.stderr.on('data', (chunk) => {
+            stderr(chunk.toString());
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`exited with code ${code}`));
+            }
+            else {
+                resolve();
+            }
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+async function defaultWriteConfigKey(root, key, value) {
+    await updateLocalConfigKey(root, key, value);
+}
+async function defaultPromptForInstallChoice(pm) {
+    const choice = await select({
+        message: `Run \`${pm.installCommand}\` in the new worktree?`,
+        options: [
+            { value: 'yes', label: 'Yes', hint: 'run once' },
+            { value: 'no', label: 'No', hint: 'skip this time' },
+            { value: 'always', label: 'Always', hint: 'save as afterCreate hook' },
+            { value: 'never', label: 'Never', hint: 'disable this prompt for this repo' },
+        ],
+    });
+    if (isCancel(choice)) {
+        return null;
+    }
+    return choice;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/new.d.ts

@@ -1,13 +1,15 @@
+import { type InstallPromptDependencies } from './install-prompt.js';
 import { type PathConflictChoice } from './conflict.js';
 export type { PathConflictChoice };
 export interface NewCommandOptions {
     branch?: string;
     cwd: string;
     detached?: boolean;
+    json?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
-export interface NewCommandDependencies {
+export interface NewCommandDependencies extends InstallPromptDependencies {
     createBranchPlaceholder: () => string;
     promptForBranch: (placeholder: string) => Promise<string | null>;
     promptForPathConflict: (path: string) => Promise<PathConflictChoice>;

package/dist/new.js

@@ -1,9 +1,13 @@
 import { mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
+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 } from './config.js';
+import { syncFiles } from './file-sync.js';
+import { extractHooks, runHook } from './hooks.js';
+import { isHeadless } from './headless.js';
+import { maybeRunInstallPrompt } from './install-prompt.js';
 import { pathExists, promptForPathConflict } from './conflict.js';
 import { detectRepository, resolveWorktreePath } from './repo.js';
 import { writeShellOutput } from './shell-handoff.js';
@@ -17,11 +21,26 @@ export function createNewCommand(dependencies = {}) {
         const repository = await detectRepository(options.cwd);
         const config = await loadEffectiveConfig(repository.repoRoot);
         const usesGeneratedDetachedName = options.detached && options.branch === undefined;
+        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`);
+            }
+            else {
+                options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+            }
+            return 1;
+        }
         const rawBranch = options.detached
             ? options.branch ?? createBranchPlaceholder()
             : options.branch ?? await promptForBranch(createBranchPlaceholder());
         if (!rawBranch) {
-            options.stderr('Aborted\n');
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: 'Aborted' }, null, 2)}\n`);
+            }
+            else {
+                options.stderr('Aborted\n');
+            }
             return 1;
         }
         const worktreeName = options.detached
@@ -31,6 +50,16 @@ export function createNewCommand(dependencies = {}) {
             ? await resolveUniqueDetachedWorktreePath(repository.repoRoot, worktreeName)
             : resolveWorktreePath(repository.repoRoot, worktreeName);
         if (!usesGeneratedDetachedName && await pathExists(worktreePath)) {
+            if (options.json || isHeadless()) {
+                const message = `target worktree path already exists: ${worktreePath}`;
+                if (options.json) {
+                    options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+                }
+                else {
+                    options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+                }
+                return 1;
+            }
             const choice = await prompt(worktreePath);
             if (choice === 'reuse') {
                 await writeOutput(worktreePath, options.stdout);
@@ -46,7 +75,27 @@ export function createNewCommand(dependencies = {}) {
                 ? ['worktree', 'add', worktreePath, worktreeName]
                 : ['worktree', 'add', '-b', worktreeName, worktreePath];
         await execFileAsync('git', gitArgs, { cwd: repository.repoRoot });
-        await writeOutput(worktreePath, options.stdout);
+        // 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')
+            : [];
+        for (const pattern of syncPatterns) {
+            try {
+                await syncFiles(repository.repoRoot, worktreePath, [pattern]);
+            }
+            catch (error) {
+                options.stderr(`Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+        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);
+        if (options.json) {
+            options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}\n`);
+        }
+        else {
+            await writeOutput(worktreePath, options.stdout);
+        }
         return 0;
     };
 }

package/dist/package-manager.d.ts

@@ -0,0 +1,5 @@
+export interface PackageManager {
+    name: string;
+    installCommand: string;
+}
+export declare function detectPackageManager(repoRoot: string): Promise<PackageManager | null>;

package/dist/package-manager.js

@@ -0,0 +1,108 @@
+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' },
+    // 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' },
+    // R
+    { name: 'renv', signals: ['renv.lock'], command: "Rscript -e 'renv::restore()'" },
+    // Rust
+    { name: 'cargo', signals: ['Cargo.lock'], command: 'cargo build' },
+    // Go
+    { name: 'go', signals: ['go.sum'], command: 'go mod download' },
+    // Ruby
+    { name: 'bundler', signals: ['Gemfile.lock'], command: 'bundle install' },
+    // PHP
+    { 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' },
+    // Dart / Flutter
+    { 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' },
+    // .NET (C# / F# / VB)
+    { name: 'dotnet', signals: ['*.sln', '*.csproj', '*.fsproj', '*.vbproj'], command: 'dotnet restore', glob: true },
+    // Swift
+    { 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 },
+    // Clojure
+    { 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' },
+    // Julia
+    { name: 'julia', signals: ['Manifest.toml'], command: "julia --project -e 'using Pkg; Pkg.instantiate()'" },
+    // Nim
+    { name: 'nimble', signals: ['*.nimble'], command: 'nimble install', glob: true },
+    // Crystal
+    { name: 'shards', signals: ['shard.yml'], command: 'shards install' },
+    // Perl
+    { name: 'cpanm', signals: ['cpanfile'], command: 'cpanm --installdeps .' },
+    // Zig
+    { 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 .' },
+    // Nix
+    { 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' },
+];
+export async function detectPackageManager(repoRoot) {
+    for (const entry of ENTRIES) {
+        const matched = entry.glob
+            ? await matchesGlob(repoRoot, entry.signals)
+            : await matchesExact(repoRoot, entry.signals);
+        if (matched) {
+            return { name: entry.name, installCommand: entry.command };
+        }
+    }
+    return null;
+}
+async function matchesExact(repoRoot, signals) {
+    for (const signal of signals) {
+        try {
+            await access(join(repoRoot, signal));
+            return true;
+        }
+        catch {
+            // file not found, try next signal
+        }
+    }
+    return false;
+}
+async function matchesGlob(repoRoot, patterns) {
+    let files;
+    try {
+        files = await readdir(repoRoot);
+    }
+    catch {
+        return false;
+    }
+    const regexes = patterns.map(patternToRegex);
+    return files.some((file) => regexes.some((re) => re.test(file)));
+}
+function patternToRegex(pattern) {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '[^/]*');
+    return new RegExp(`^${escaped}$`);
+}

package/dist/pr.d.ts

@@ -1,12 +1,14 @@
 import { type PathConflictChoice } from './conflict.js';
+import { type InstallPromptDependencies } from './install-prompt.js';
 export type { PathConflictChoice };
 export interface PrCommandOptions {
     cwd: string;
+    json?: boolean;
     number: string;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
-export interface PrCommandDependencies {
+export interface PrCommandDependencies extends InstallPromptDependencies {
     promptForPathConflict: (path: string) => Promise<PathConflictChoice>;
 }
 export declare function parsePrInput(input: string): string | null;