@solaqua/gji 0.12.2 → 0.12.3

package/dist/install-prompt.js

@@ -1,127 +0,0 @@
-import { isCancel, select } from "@clack/prompts";
-import { runCommand } from "./command-runner.js";
-import { loadConfig, loadGlobalConfig, updateGlobalRepoConfigKey, updateLocalConfigKey, } from "./config.js";
-import { isHeadless } from "./headless.js";
-import { extractHooks } from "./hooks.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 an after-create hook is already configured (accepts both kebab and legacy camelCase).
-    if (extractHooks(config)["after-create"]) {
-        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 ?? runInstallCommand;
-        try {
-            await runner(pm.installCommand, worktreePath, stderr);
-        }
-        catch (error) {
-            stderr(`gji: install command failed: ${error instanceof Error ? error.message : String(error)}\n`);
-        }
-    }
-    const saveGlobal = config.installSaveTarget === "global";
-    const writeKey = dependencies.writeConfigKey ?? defaultWriteConfigKey;
-    const writeGlobalKey = dependencies.writeGlobalRepoConfigKey ?? defaultWriteGlobalRepoConfigKey;
-    if (choice === "always") {
-        try {
-            if (saveGlobal) {
-                // Deep-merge with any existing per-repo global hooks so other keys are preserved.
-                const existingRaw = await loadExistingGlobalRepoHooks(repoRoot);
-                const existing = extractHooks({ hooks: existingRaw });
-                await writeGlobalKey(repoRoot, "hooks", {
-                    ...(existing["after-enter"] !== undefined && {
-                        "after-enter": existing["after-enter"],
-                    }),
-                    ...(existing["before-remove"] !== undefined && {
-                        "before-remove": existing["before-remove"],
-                    }),
-                    "after-create": pm.installCommand,
-                });
-            }
-            else {
-                // Read local config hooks to deep-merge so other hook keys (e.g. after-enter) are preserved.
-                const { config: localConfig } = await loadConfig(repoRoot);
-                const existing = extractHooks(localConfig);
-                await writeKey(repoRoot, "hooks", {
-                    ...(existing["after-enter"] !== undefined && {
-                        "after-enter": existing["after-enter"],
-                    }),
-                    ...(existing["before-remove"] !== undefined && {
-                        "before-remove": existing["before-remove"],
-                    }),
-                    "after-create": pm.installCommand,
-                });
-            }
-        }
-        catch (error) {
-            stderr(`gji: failed to save config: ${error instanceof Error ? error.message : String(error)}\n`);
-        }
-    }
-    if (choice === "never") {
-        try {
-            if (saveGlobal) {
-                await writeGlobalKey(repoRoot, "skipInstallPrompt", true);
-            }
-            else {
-                await writeKey(repoRoot, "skipInstallPrompt", true);
-            }
-        }
-        catch (error) {
-            stderr(`gji: failed to save config: ${error instanceof Error ? error.message : String(error)}\n`);
-        }
-    }
-}
-export const runInstallCommand = runCommand;
-async function defaultWriteConfigKey(root, key, value) {
-    await updateLocalConfigKey(root, key, value);
-}
-async function defaultWriteGlobalRepoConfigKey(repoRoot, key, value) {
-    await updateGlobalRepoConfigKey(repoRoot, key, value);
-}
-async function loadExistingGlobalRepoHooks(repoRoot) {
-    const { config: globalConfig } = await loadGlobalConfig();
-    const repos = isPlainObject(globalConfig.repos) ? globalConfig.repos : {};
-    const perRepo = isPlainObject(repos[repoRoot])
-        ? repos[repoRoot]
-        : {};
-    return isPlainObject(perRepo.hooks) ? perRepo.hooks : {};
-}
-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 after-create 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/package-manager.d.ts

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

package/dist/package-manager.js

@@ -1,159 +0,0 @@
-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/sync-directories.d.ts

@@ -1,29 +0,0 @@
-import type { CloneDirectory } from "./dir-clone.js";
-import type { SyncDirectoryPlan } from "./sync-plan.js";
-export interface ClonedDirectory {
-    bytes?: number;
-    dir: string;
-    ms: number;
-}
-export type SyncDirectoryOutcome = {
-    kind: "cloned";
-    directory: ClonedDirectory;
-} | {
-    kind: "skipped";
-    dir: string;
-    reason: string;
-};
-export interface SyncDirectoryReporter {
-    readonly measureCloneSize: boolean;
-    write(message: string): void;
-    cloned(directory: ClonedDirectory): void;
-    skipped?(directory: {
-        dir: string;
-        reason: string;
-    }): void;
-}
-export interface SyncDirectoryExecutionOptions {
-    cloneDirectory: CloneDirectory;
-    reporter: SyncDirectoryReporter;
-}
-export declare function executeSyncDirectoryPlan(plan: readonly SyncDirectoryPlan[], options: SyncDirectoryExecutionOptions): Promise<SyncDirectoryOutcome[]>;

package/dist/sync-directories.js

@@ -1,77 +0,0 @@
-import { isCloneDestinationExistsError, isCloneInProgressError, } from "./dir-clone.js";
-import { inspectDestination } from "./safe-destination.js";
-export async function executeSyncDirectoryPlan(plan, options) {
-    const outcomes = [];
-    for (const entry of plan) {
-        if (entry.destinationWarning) {
-            recordSkipped(outcomes, options.reporter, entry.directory, entry.destinationWarning);
-            continue;
-        }
-        const destinationState = await inspectDestination(entry.worktreePath, entry.destination);
-        if (destinationState.kind === "exists") {
-            recordSkipped(outcomes, options.reporter, entry.directory, "destination already exists");
-            continue;
-        }
-        if (destinationState.kind === "unsafe") {
-            const reason = destinationState.reason;
-            recordSkipped(outcomes, options.reporter, entry.directory, reason);
-            continue;
-        }
-        if (entry.warning) {
-            recordSkipped(outcomes, options.reporter, entry.directory, entry.warning);
-            continue;
-        }
-        if (!entry.source) {
-            recordSkipped(outcomes, options.reporter, entry.directory, "source does not exist");
-            continue;
-        }
-        const refreshedDestinationState = await inspectDestination(entry.worktreePath, entry.destination);
-        if (refreshedDestinationState.kind !== "missing") {
-            recordSkipped(outcomes, options.reporter, entry.directory, refreshedDestinationState.kind === "unsafe"
-                ? refreshedDestinationState.reason
-                : "destination already exists");
-            continue;
-        }
-        let result;
-        try {
-            const cloneOptions = {
-                destinationRoot: entry.worktreePath,
-                measureBytes: options.reporter.measureCloneSize,
-            };
-            result = await options.cloneDirectory(entry.source, entry.destination, cloneOptions);
-        }
-        catch (error) {
-            if (isCloneDestinationExistsError(error)) {
-                recordSkipped(outcomes, options.reporter, entry.directory, "destination already exists");
-                continue;
-            }
-            if (isCloneInProgressError(error)) {
-                const reason = "copy-on-write clone already in progress";
-                recordSkipped(outcomes, options.reporter, entry.directory, reason);
-                continue;
-            }
-            const reason = toErrorMessage(error);
-            recordSkipped(outcomes, options.reporter, entry.directory, reason);
-            continue;
-        }
-        const clonedDirectory = {
-            bytes: result.bytes,
-            dir: entry.directory,
-            ms: result.ms,
-        };
-        const outcome = { kind: "cloned", directory: clonedDirectory };
-        outcomes.push(outcome);
-        options.reporter.cloned(clonedDirectory);
-    }
-    return outcomes;
-}
-function recordSkipped(outcomes, reporter, dir, reason) {
-    outcomes.push({ kind: "skipped", dir, reason });
-    if (reporter.skipped)
-        reporter.skipped({ dir, reason });
-    else
-        reporter.write(`syncDirs: ${reason}, skipped ${dir}\n`);
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/sync-plan.d.ts

@@ -1,16 +0,0 @@
-export interface SyncDirectoryPlan {
-    directory: string;
-    destination: string;
-    worktreePath: string;
-    destinationWasPresent: boolean;
-    destinationWarning?: string;
-    source?: string;
-    warning?: string;
-}
-export interface SyncDirectoryEstimate {
-    bytes: number;
-    dir: string;
-}
-export declare function prepareSyncDirectoryPlan(repoRoot: string, worktreePath: string, directories: readonly string[]): Promise<SyncDirectoryPlan[]>;
-export declare function estimateSyncDirectoryPlan(plan: readonly SyncDirectoryPlan[]): Promise<SyncDirectoryEstimate[]>;
-export declare function estimateSyncDirectories(repoRoot: string, worktreePath: string, directories: readonly string[]): Promise<SyncDirectoryEstimate[]>;

package/dist/sync-plan.js

@@ -1,128 +0,0 @@
-import { lstat, realpath } from "node:fs/promises";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { validateSyncDirPattern } from "./config.js";
-import { directorySize } from "./dir-clone.js";
-import { isNotFoundError } from "./fs-utils.js";
-import { inspectDestination } from "./safe-destination.js";
-export async function prepareSyncDirectoryPlan(repoRoot, worktreePath, directories) {
-    const normalizedDirectories = directories
-        .map(validateSyncDirPattern)
-        .sort(directoryDepthAscending);
-    const plan = [];
-    for (const directory of normalizedDirectories) {
-        const destination = join(worktreePath, directory);
-        const destinationState = await inspectDestination(worktreePath, destination);
-        const destinationWasPresent = destinationState.kind === "exists";
-        const destinationWarning = destinationState.kind === "unsafe" ? destinationState.reason : undefined;
-        try {
-            const source = await resolveSyncDirectorySource(repoRoot, directory);
-            if (!source) {
-                plan.push({
-                    directory,
-                    destination,
-                    worktreePath,
-                    destinationWasPresent,
-                    destinationWarning,
-                });
-            }
-            else if ("warning" in source) {
-                plan.push({
-                    directory,
-                    destination,
-                    worktreePath,
-                    destinationWasPresent,
-                    destinationWarning,
-                    warning: source.warning,
-                });
-            }
-            else {
-                plan.push({
-                    directory,
-                    destination,
-                    worktreePath,
-                    destinationWasPresent,
-                    destinationWarning,
-                    source: source.path,
-                });
-            }
-        }
-        catch (error) {
-            plan.push({
-                directory,
-                destination,
-                worktreePath,
-                destinationWasPresent,
-                destinationWarning,
-                warning: `could not inspect ${directory}: ${toErrorMessage(error)}`,
-            });
-        }
-    }
-    return plan;
-}
-export async function estimateSyncDirectoryPlan(plan) {
-    const estimates = [];
-    for (const entry of plan) {
-        if (entry.destinationWasPresent ||
-            entry.destinationWarning ||
-            !entry.source ||
-            entry.warning ||
-            isCoveredByCloneAncestor(entry, plan)) {
-            continue;
-        }
-        try {
-            estimates.push({
-                bytes: await directorySize(entry.source),
-                dir: entry.directory,
-            });
-        }
-        catch {
-            // A dry-run is informational; an unreadable source is omitted.
-        }
-    }
-    return estimates;
-}
-export async function estimateSyncDirectories(repoRoot, worktreePath, directories) {
-    const plan = await prepareSyncDirectoryPlan(repoRoot, worktreePath, directories);
-    return estimateSyncDirectoryPlan(plan);
-}
-async function resolveSyncDirectorySource(repoRoot, directory) {
-    const source = join(repoRoot, directory);
-    let resolvedSource;
-    try {
-        resolvedSource = await realpath(source);
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return null;
-        throw error;
-    }
-    if (!isPathInside(repoRoot, resolvedSource)) {
-        return {
-            warning: `source symlink resolves outside the repository (${resolvedSource})`,
-        };
-    }
-    const stats = await lstat(resolvedSource);
-    if (!stats.isDirectory())
-        return { warning: "source is not a directory" };
-    return { path: resolvedSource };
-}
-function isCoveredByCloneAncestor(entry, plan) {
-    return plan.some((candidate) => candidate !== entry &&
-        !candidate.destinationWasPresent &&
-        !candidate.destinationWarning &&
-        !!candidate.source &&
-        isPathInside(candidate.directory, entry.directory));
-}
-function directoryDepthAscending(left, right) {
-    return left.split(/[\\/]+/u).length - right.split(/[\\/]+/u).length;
-}
-function isPathInside(parent, child) {
-    const relativePath = relative(resolve(parent), resolve(child));
-    return (relativePath !== "" &&
-        !isAbsolute(relativePath) &&
-        relativePath !== ".." &&
-        !relativePath.startsWith(`..${sep}`));
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}