@solaqua/gji 0.12.2 → 0.12.3

package/dist/bootstrap-output.d.ts

@@ -1,3 +1,4 @@
 import type { DependencyBootstrapReporter } from "./dependency-bootstrap.js";
-import type { SyncDirectoryReporter } from "./sync-directories.js";
-export declare function createBootstrapReporter(write: (chunk: string) => void, json: boolean, measureCloneSize?: boolean): SyncDirectoryReporter & DependencyBootstrapReporter;
+export declare function createBootstrapReporter(write: (chunk: string) => void, json: boolean): DependencyBootstrapReporter & {
+    write: (chunk: string) => void;
+};

package/dist/bootstrap-output.js

@@ -1,18 +1,6 @@
-import { formatBytes } from "./format-bytes.js";
-export function createBootstrapReporter(write, json, measureCloneSize = false) {
+export function createBootstrapReporter(write, json) {
     return {
-        measureCloneSize: measureCloneSize && !json,
         write,
-        cloned: (directory) => {
-            if (json)
-                return;
-            write(`⚡ cloned ${directory.dir} (${formatBytes(directory.bytes)} → ${formatDuration(directory.ms)})\n`);
-        },
-        skipped: (directory) => {
-            if (json)
-                return;
-            write(`gji: skipped ${directory.dir} — ${directory.reason}\n`);
-        },
         dependency: (event) => {
             if (json)
                 return;
@@ -21,6 +9,3 @@ export function createBootstrapReporter(write, json, measureCloneSize = false) {
         },
     };
 }
-function formatDuration(ms) {
-    return `${(ms / 1000).toFixed(1)}s`;
-}

package/dist/bootstrap-preview.d.ts

@@ -1,10 +1,9 @@
-import type { DependencyBootstrapMode } from "./config.js";
-import { type BootstrapTarget, type DependencyBootstrapPreview } from "./dependency-bootstrap.js";
+import type { DependencyBootstrapMode } from "./dependency-bootstrap.js";
+import { type DependencyBootstrapPreview } from "./dependency-bootstrap.js";
 export declare function createDependencyBootstrapPreview(mode: DependencyBootstrapMode, context: {
     repoRoot: string;
     currentRoot?: string;
     worktreePath: string;
     cargoBuildCommand?: string;
-    checkUvRuntime?: (target: BootstrapTarget) => Promise<boolean>;
 }): Promise<DependencyBootstrapPreview>;
 export declare function formatDependencyBootstrapPreview(preview: DependencyBootstrapPreview | undefined): string;

package/dist/bootstrap-preview.js

@@ -6,16 +6,6 @@ export function formatDependencyBootstrapPreview(preview) {
     if (!preview)
         return "";
     return preview.targets
-        .map(({ adapter, target, strategy }) => `Would ${formatBootstrapStrategy(strategy)} ${target} with ${adapter}\n`)
+        .map(({ adapter, target, command }) => `Would install ${target || "dependencies"} with ${adapter}: ${command}\n`)
         .join("");
 }
-function formatBootstrapStrategy(strategy) {
-    switch (strategy) {
-        case "cow-then-repair":
-            return "seed and repair";
-        case "repair-only":
-            return "repair";
-        case "install-only":
-            return "install";
-    }
-}

package/dist/cli.js

@@ -155,7 +155,7 @@ async function maybeRegisterCurrentRepo(cwd) {
 function registerCommands(program) {
     program
         .command("new [branch]")
-        .description("create a new branch or detached linked worktree and CoW-bootstrap configured directories")
+        .description("create a new branch or detached linked worktree")
         .option("-f, --force", "remove and recreate the worktree if the target path already exists")
         .option("--detached", "create a detached worktree without a branch")
         .option("--from-current", "base the new branch on the current worktree instead of the main worktree (cannot be combined with --detached)")
@@ -166,6 +166,7 @@ function registerCommands(program) {
         .option("--open", "open the new worktree in an editor after creation")
         .option("--editor <cli>", "editor CLI to use with --open (code, cursor, zed, …)")
         .option("--dry-run", "show what would be created without executing any git commands or writing files")
+        .option("--no-install", "skip automatic dependency setup in the new worktree")
         .option("--json", "emit JSON on success or error instead of human-readable output")
         .action(notImplemented("new"));
     program
@@ -203,6 +204,7 @@ function registerCommands(program) {
         .usage("[options] <ref>")
         .description("fetch a pull request by number, #number, or URL into a linked worktree")
         .option("--dry-run", "show what would be created without executing any git commands or writing files")
+        .option("--no-install", "skip automatic dependency setup in the PR worktree")
         .option("--json", "emit JSON on success or error instead of human-readable output")
         .action(notImplemented("pr"));
     prCommand
@@ -347,6 +349,7 @@ function attachCommandActions(program, options) {
             force: commandOptions.force,
             noFetch: commandOptions.fetch === false,
             json: commandOptions.json,
+            noInstall: commandOptions.install === false,
             open: commandOptions.open,
             take: commandOptions.take,
             task: commandOptions.task,
@@ -433,6 +436,7 @@ function attachCommandActions(program, options) {
             cwd: options.cwd,
             dryRun: commandOptions.dryRun,
             json: commandOptions.json,
+            noInstall: commandOptions.install === false,
             number,
             stderr: options.stderr,
             stdout: options.stdout,

package/dist/config.d.ts

@@ -4,17 +4,15 @@ export declare const GLOBAL_CONFIG_NAME = "config.json";
 export declare const KNOWN_CONFIG_KEYS: ReadonlySet<string>;
 export declare const KNOWN_GLOBAL_CONFIG_KEYS: ReadonlySet<string>;
 export type GjiConfig = Record<string, unknown>;
-export type DependencyBootstrapMode = "off" | "cow-then-repair" | "install-only";
+export type DependencyBootstrapSetting = "off";
 export interface EffectiveGjiConfig extends GjiConfig {
     branchPrefix?: string;
     dependencyBuildCommand?: string;
-    dependencyBootstrap?: DependencyBootstrapMode;
+    dependencyBootstrap?: DependencyBootstrapSetting;
     editor?: string;
     hooks?: Record<string, unknown>;
     installSaveTarget?: string;
     shellIntegration?: string;
-    skipInstallPrompt?: boolean;
-    syncDirs?: readonly string[];
     syncFiles?: readonly string[];
     syncDefaultBranch?: string;
     syncRemote?: string;
@@ -25,14 +23,9 @@ export interface LoadedConfig {
     exists: boolean;
     path: string;
 }
-export interface EffectiveConfigResult {
-    config: EffectiveGjiConfig;
-    dependencyBootstrapExplicit: boolean;
-}
 export declare const DEFAULT_CONFIG: GjiConfig;
 export declare function loadConfig(root: string): Promise<LoadedConfig>;
 export declare function loadEffectiveConfig(root: string, home?: string, onWarning?: (message: string) => void): Promise<EffectiveGjiConfig>;
-export declare function loadEffectiveConfigResult(root: string, home?: string, onWarning?: (message: string) => void): Promise<EffectiveConfigResult>;
 export declare function loadGlobalConfig(home?: string): Promise<LoadedConfig>;
 export declare function saveLocalConfig(root: string, config: GjiConfig): Promise<string>;
 export declare function updateLocalConfigKey(root: string, key: string, value: unknown): Promise<GjiConfig>;
@@ -43,7 +36,4 @@ export declare function updateGlobalRepoConfigKey(repoRoot: string, key: string,
 export declare function GLOBAL_CONFIG_FILE_PATH(home?: string): string;
 export declare function parseConfigValue(value: string): unknown;
 export declare function resolveConfigString(config: GjiConfig, key: string): string | undefined;
-export declare function validateSyncDirsConfig(value: unknown): void;
-export declare function normalizeDependencyBootstrap(value: unknown): DependencyBootstrapMode | undefined;
-export declare function normalizeSyncDirsConfig(value: unknown): readonly string[] | undefined;
-export declare function validateSyncDirPattern(pattern: string): string;
+export declare function normalizeDependencyBootstrap(value: unknown): DependencyBootstrapSetting | undefined;

package/dist/config.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join, normalize, resolve, win32, } from "node:path";
+import { dirname, join, resolve } from "node:path";
 export const CONFIG_FILE_NAME = ".gji.json";
 export const GLOBAL_CONFIG_DIRECTORY = ".config/gji";
 export const GLOBAL_CONFIG_NAME = "config.json";
@@ -12,8 +12,6 @@ export const KNOWN_CONFIG_KEYS = new Set([
     "hooks",
     "installSaveTarget",
     "shellIntegration",
-    "skipInstallPrompt",
-    "syncDirs",
     "syncDefaultBranch",
     "syncFiles",
     "syncRemote",
@@ -23,15 +21,13 @@ export const KNOWN_GLOBAL_CONFIG_KEYS = new Set([
     ...KNOWN_CONFIG_KEYS,
     "repos",
 ]);
+const REMOVED_CONFIG_KEYS = new Set(["syncDirs"]);
 export const DEFAULT_CONFIG = Object.freeze({});
 export async function loadConfig(root) {
     const path = join(root, CONFIG_FILE_NAME);
     return loadConfigFile(path);
 }
 export async function loadEffectiveConfig(root, home = homedir(), onWarning) {
-    return (await loadEffectiveConfigResult(root, home, onWarning)).config;
-}
-export async function loadEffectiveConfigResult(root, home = homedir(), onWarning) {
     const [globalConfig, localConfig] = await Promise.all([
         loadGlobalConfig(home),
         loadConfig(root),
@@ -42,7 +38,6 @@ export async function loadEffectiveConfigResult(root, home = homedir(), onWarnin
     const perRepoConfig = isPlainObject(repos)
         ? findPerRepoConfig(repos, root, home)
         : {};
-    validateSyncDirsConfig(perRepoConfig.syncDirs);
     // Strip the internal `repos` registry from the global base before merging.
     const globalBase = { ...globalConfig.config };
     delete globalBase.repos;
@@ -83,12 +78,7 @@ export async function loadEffectiveConfigResult(root, home = homedir(), onWarnin
         Object.keys(localHooks).length > 0) {
         merged.hooks = { ...globalHooks, ...perRepoHooks, ...localHooks };
     }
-    return {
-        config: toEffectiveConfig(merged),
-        dependencyBootstrapExplicit: Object.hasOwn(globalBase, "dependencyBootstrap") ||
-            Object.hasOwn(perRepoConfig, "dependencyBootstrap") ||
-            Object.hasOwn(localConfig.config, "dependencyBootstrap"),
-    };
+    return toEffectiveConfig(merged);
 }
 export async function loadGlobalConfig(home = homedir()) {
     return loadConfigFile(GLOBAL_CONFIG_FILE_PATH(home));
@@ -100,6 +90,7 @@ export async function saveLocalConfig(root, config) {
     return path;
 }
 export async function updateLocalConfigKey(root, key, value) {
+    assertConfigKeySupported(key);
     const loaded = await loadConfig(root);
     const nextConfig = {
         ...loaded.config,
@@ -123,6 +114,7 @@ export async function unsetGlobalConfigKey(key, home = homedir()) {
     return nextConfig;
 }
 export async function updateGlobalConfigKey(key, value, home = homedir()) {
+    assertConfigKeySupported(key);
     const loaded = await loadGlobalConfig(home);
     const nextConfig = {
         ...loaded.config,
@@ -132,6 +124,7 @@ export async function updateGlobalConfigKey(key, value, home = homedir()) {
     return nextConfig;
 }
 export async function updateGlobalRepoConfigKey(repoRoot, key, value, home = homedir()) {
+    assertConfigKeySupported(key);
     const loaded = await loadGlobalConfig(home);
     const repos = isPlainObject(loaded.config.repos)
         ? { ...loaded.config.repos }
@@ -163,34 +156,20 @@ export function resolveConfigString(config, key) {
     const value = config[key];
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
-export function validateSyncDirsConfig(value) {
-    normalizeSyncDirsConfig(value);
+function assertConfigKeySupported(key) {
+    if (REMOVED_CONFIG_KEYS.has(key)) {
+        throw new Error(`configuration key "${key}" is no longer supported`);
+    }
 }
 export function normalizeDependencyBootstrap(value) {
     if (value === undefined)
         return;
-    if (value !== "off" &&
-        value !== "cow-then-repair" &&
-        value !== "install-only") {
-        throw new Error('dependencyBootstrap: expected "off", "cow-then-repair", or "install-only"');
+    if (value !== "off") {
+        throw new Error('dependencyBootstrap: expected "off"');
     }
     return value;
 }
-export function normalizeSyncDirsConfig(value) {
-    if (value === undefined)
-        return;
-    if (!Array.isArray(value)) {
-        throw new Error("syncDirs: expected an array of relative directory paths");
-    }
-    return value.map((pattern) => {
-        if (typeof pattern !== "string") {
-            throw new Error("syncDirs: every entry must be a string");
-        }
-        return validateSyncDirPattern(pattern);
-    });
-}
 function validateConfigValues(config) {
-    validateSyncDirsConfig(config.syncDirs);
     normalizeDependencyBootstrap(config.dependencyBootstrap);
     const repos = config.repos;
     if (!isPlainObject(repos))
@@ -201,25 +180,6 @@ function validateConfigValues(config) {
         }
     }
 }
-export function validateSyncDirPattern(pattern) {
-    if (pattern.length === 0 ||
-        isAbsolute(pattern) ||
-        win32.isAbsolute(pattern)) {
-        throw new Error(`syncDirs: pattern must be a relative path, got: ${pattern}`);
-    }
-    const segments = pattern.split(/[\\/]+/u);
-    if (segments.includes("..")) {
-        throw new Error(`syncDirs: pattern must not contain '..' segments, got: ${pattern}`);
-    }
-    if (segments.some((segment) => segment.toLowerCase() === ".git")) {
-        throw new Error(`syncDirs: pattern must not include .git, got: ${pattern}`);
-    }
-    const normalized = normalize(pattern);
-    if (normalized === ".") {
-        throw new Error(`syncDirs: pattern must name a directory below the repository root, got: ${pattern}`);
-    }
-    return normalized;
-}
 async function loadConfigFile(path) {
     try {
         const rawConfig = await readFile(path, "utf8");
@@ -264,13 +224,6 @@ function toEffectiveConfig(config) {
             delete effective[key];
         }
     }
-    if (effective.skipInstallPrompt !== undefined &&
-        typeof effective.skipInstallPrompt !== "boolean") {
-        delete effective.skipInstallPrompt;
-    }
-    if (config.syncDirs !== undefined) {
-        effective.syncDirs = normalizeSyncDirsConfig(config.syncDirs);
-    }
     if (Array.isArray(config.syncFiles)) {
         effective.syncFiles = config.syncFiles.filter((value) => typeof value === "string");
     }

package/dist/dependency-bootstrap.d.ts

@@ -1,10 +1,9 @@
 import { type CommandRunner } from "./command-runner.js";
-import type { DependencyBootstrapMode } from "./config.js";
-import { type CloneDirectory } from "./dir-clone.js";
 export type BootstrapKind = "dependency" | "build-cache" | "sync-file";
-export type BootstrapState = "seeded" | "repaired" | "installed" | "repair-only" | "skipped" | "failed";
-export type BootstrapStrategy = "cow-then-repair" | "repair-only" | "install-only";
+export type BootstrapState = "installed" | "failed";
+export type DependencyBootstrapMode = "off" | "install";
 export type BootstrapCommandRunner = CommandRunner;
+export declare function resolveDependencyBootstrapMode(dependencyBootstrap: "off" | undefined, noInstall?: boolean): DependencyBootstrapMode;
 export interface BootstrapPreparationContext {
     detectionRoot?: string;
     sourceRoot: string;
@@ -19,42 +18,31 @@ export interface BootstrapExecutionContext extends BootstrapCommandExecutionCont
     input: BootstrapTargetInput;
 }
 export interface BootstrapTarget {
-    adapter: string;
     kind: BootstrapKind;
     relativePath: string;
     sourceRoot: string;
+    detectionRoot?: string;
     worktreePath: string;
-    sourcePath: string;
-    targetPath: string;
-    repairCommand: string;
-    repairState: "repaired" | "installed";
+    sourcePath?: string;
+    targetPath?: string;
+    installCommand: string;
     shell: boolean;
-    initialInput: Exclude<BootstrapTargetInput, "seed">;
-}
-export type BootstrapTargetInput = "clean" | "preserve" | "seed";
-export interface BootstrapRepairFailureContext {
-    input: BootstrapTargetInput;
-    target: BootstrapTarget;
 }
+export type BootstrapTargetInput = "clean" | "preserve";
 export interface BootstrapAdapter {
     readonly kind: BootstrapKind;
-    readonly lockfile: string;
     readonly name: string;
     readonly relativePath: string;
     detect(context: BootstrapPreparationContext): Promise<BootstrapTarget | null>;
-    seedPath(target: BootstrapTarget): string;
-    repair(target: BootstrapTarget, context: BootstrapExecutionContext): Promise<void>;
-    canSeed(target: BootstrapTarget): Promise<boolean>;
-    shouldRetryAfterRepairFailure(context: BootstrapRepairFailureContext): boolean;
-    cleanupAfterRepairFailure(context: BootstrapRepairFailureContext): Promise<void>;
+    install(target: BootstrapTarget, context: BootstrapExecutionContext): Promise<void>;
 }
 export interface DependencyBootstrapPlan {
     mode: DependencyBootstrapMode;
     targets: readonly PlannedBootstrapTarget[];
 }
 export interface PlannedBootstrapTarget {
+    adapter: BootstrapAdapter;
     target: BootstrapTarget;
-    seedable: boolean;
 }
 export interface BootstrapEvent {
     adapter: string;
@@ -65,7 +53,6 @@ export interface BootstrapEvent {
     message: string;
 }
 export interface DependencyBootstrapReporter {
-    readonly measureCloneSize: boolean;
     dependency(event: BootstrapEvent): void;
 }
 export interface DependencyBootstrapReport {
@@ -74,11 +61,9 @@ export interface DependencyBootstrapReport {
     events: readonly BootstrapEvent[];
 }
 export interface DependencyBootstrapDependencies {
-    cloneDirectory?: CloneDirectory;
     runCommand?: BootstrapCommandRunner;
     stderr?: (chunk: string) => void;
     stdout?: (chunk: string) => void;
-    seededDirectories?: readonly string[];
 }
 export interface DependencyBootstrapPreview {
     mode: DependencyBootstrapMode;
@@ -86,35 +71,16 @@ export interface DependencyBootstrapPreview {
         adapter: string;
         kind: BootstrapKind;
         target: string;
-        repairCommand: string;
-        seedable: boolean;
-        strategy: BootstrapStrategy;
+        command: string;
     }[];
 }
-export interface DependencyBootstrapCandidate {
-    adapter: string;
-    kind: BootstrapKind;
-    lockfile: string;
-    target: string;
-    repairCommand: string;
-    seedable: boolean;
-}
 export declare function prepareDependencyBootstrap(mode: DependencyBootstrapMode, context: {
     repoRoot: string;
     currentRoot?: string;
     detectionRoot?: string;
     worktreePath: string;
-    checkUvRuntime?: (target: BootstrapTarget) => Promise<boolean>;
     cargoBuildCommand?: string;
 }): Promise<DependencyBootstrapPlan>;
-export declare function detectDependencyBootstrapCandidate(context: {
-    repoRoot: string;
-    currentRoot?: string;
-    detectionRoot?: string;
-    worktreePath: string;
-    checkUvRuntime?: (target: BootstrapTarget) => Promise<boolean>;
-    cargoBuildCommand?: string;
-}): Promise<DependencyBootstrapCandidate | null>;
 export declare function previewDependencyBootstrap(plan: DependencyBootstrapPlan): DependencyBootstrapPreview;
 export declare function executeDependencyBootstrap(plan: DependencyBootstrapPlan, options: DependencyBootstrapDependencies & {
     reporter: DependencyBootstrapReporter;