@solaqua/gji 0.9.0 → 0.11.0

package/dist/cli.js

@@ -6,6 +6,7 @@ import { runCleanCommand } from "./clean.js";
 import { runCompletionCommand } from "./completion.js";
 import { runConfigCommand } from "./config-command.js";
 import { runDoctorCommand } from "./doctor.js";
+import { runDoneCommand } from "./done.js";
 import { runGoCommand } from "./go.js";
 import { isHeadless } from "./headless.js";
 import { runHistoryCommand } from "./history-command.js";
@@ -23,6 +24,7 @@ import { runHookCommand } from "./run-hook.js";
 import { runStatusCommand } from "./status.js";
 import { runSyncCommand } from "./sync.js";
 import { runSyncFilesCommand } from "./sync-files-command.js";
+import { runUndoCommand } from "./undo.js";
 import { runWarpCommand } from "./warp.js";
 export function createProgram() {
     const program = new Command();
@@ -34,6 +36,11 @@ export function createProgram() {
         .showHelpAfterError()
         .showSuggestionAfterError();
     registerCommands(program);
+    program.addHelpText("after", "\nCommon workflows:\n" +
+        "  gji new <branch>       create a worktree\n" +
+        "  gji go <branch>        navigate to a worktree\n" +
+        "  gji go                 choose; press Tab for all repositories\n" +
+        "  gji go -               return to the previous worktree\n");
     return program;
 }
 function readPackageMetadata() {
@@ -46,13 +53,13 @@ function readPackageMetadata() {
 }
 export async function runCli(argv, options = {}) {
     await maybeNotifyForUpdates(argv);
-    if (argv[0] !== "doctor") {
-        maybeRegisterCurrentRepo(options.cwd ?? process.cwd());
-    }
-    const program = createProgram();
     const cwd = options.cwd ?? process.cwd();
     const stdout = options.stdout ?? (() => undefined);
     const stderr = options.stderr ?? (() => undefined);
+    if (shouldRegisterCurrentRepo(argv)) {
+        await maybeRegisterCurrentRepo(cwd);
+    }
+    const program = createProgram();
     program.configureOutput({
         writeErr: stderr,
         writeOut: stdout,
@@ -109,22 +116,58 @@ function defaultNotifyForUpdates(pkg) {
     const notifier = updateNotifier({ pkg });
     notifier.notify();
 }
-function maybeRegisterCurrentRepo(cwd) {
-    detectRepository(cwd)
-        .then(({ repoRoot }) => registerRepo(repoRoot))
-        .catch(() => undefined);
+function shouldRegisterCurrentRepo(argv) {
+    const command = argv[0];
+    return (argv.length > 0 &&
+        ![
+            "--help",
+            "-h",
+            "--version",
+            "-V",
+            "completion",
+            "config",
+            "doctor",
+            "help",
+            "init",
+        ].includes(command ?? ""));
+}
+async function maybeRegisterCurrentRepo(cwd) {
+    try {
+        const { repoRoot } = await detectRepository(cwd);
+        await registerRepo(repoRoot);
+    }
+    catch {
+        // Registration is best effort; command behaviour should not depend on it.
+    }
 }
 function registerCommands(program) {
     program
         .command("new [branch]")
-        .description("create a new branch or detached linked worktree")
+        .description("create a new branch or detached linked worktree and CoW-bootstrap configured directories")
         .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)")
+        .option("--no-fetch", "skip refreshing the remote default branch before creating the new branch")
+        .option("--take", "move current uncommitted changes into the new worktree")
+        .option("--copy", "copy current uncommitted changes instead of moving them (requires --take)")
         .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("--json", "emit JSON on success or error instead of human-readable output")
         .action(notImplemented("new"));
+    program
+        .command("done [branch]")
+        .description("finish the current linked worktree and return safely")
+        .option("--force", "remove dirty or unmerged worktrees without prompting")
+        .option("--keep-branch", "remove the worktree but preserve its branch")
+        .option("--json", "emit JSON on success or error instead of human-readable output")
+        .action(notImplemented("done"));
+    program
+        .command("undo [id]")
+        .description("restore the most recent destructive worktree operation")
+        .option("--list", "list recoverable operations")
+        .option("--json", "emit JSON on success or error instead of human-readable output")
+        .action(notImplemented("undo"));
     program
         .command("init [shell]")
         .description("set up shell integration interactively or print a shell wrapper")
@@ -167,6 +210,7 @@ function registerCommands(program) {
     program
         .command("open [branch]")
         .description("open the worktree in an editor")
+        .option("--select", "choose a worktree with the interactive selector")
         .option("--editor <cli>", "editor CLI to use (code, cursor, zed, windsurf, subl, …)")
         .option("--save", "save the chosen editor to global config")
         .option("--workspace", "generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)")
@@ -174,8 +218,10 @@ function registerCommands(program) {
     program
         .command("go [branch]")
         .alias("jump")
-        .description("print or select a worktree path")
+        .description("resolve and jump to a worktree path")
+        .option("--root", "navigate to the main repository root")
         .option("--print", "print the resolved worktree path explicitly")
+        .option("--json", "emit JSON for an existing worktree destination")
         .action(notImplemented("go"));
     program
         .command("root")
@@ -231,7 +277,7 @@ function registerCommands(program) {
     program
         .command("remove [branch]")
         .alias("rm")
-        .description("remove a linked worktree and delete its branch when present")
+        .description("deprecated: use gji done for one worktree or gji clean for bulk cleanup")
         .option("-f, --force", "bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch")
         .option("--dry-run", "show what would be deleted without removing anything")
         .option("--json", "emit JSON on success or error instead of human-readable output")
@@ -243,8 +289,7 @@ function registerCommands(program) {
         .action(notImplemented("run-hook"));
     program
         .command("warp [branch]")
-        .description("jump to any worktree across all known repos")
-        .option("-n, --new [branch]", "create a new worktree in a registered repo")
+        .description("deprecated: use gji go (press Tab for all known repos)")
         // --print is the shell-wrapper bypass signal (see SHELL_WRAPPED_COMMANDS in init.ts).
         // The shell omits GJI_WARP_OUTPUT_FILE, so writeShellOutput falls through to stdout.
         .option("--print", "print the resolved worktree path without changing directory")
@@ -274,17 +319,50 @@ function attachCommandActions(program, options) {
         const exitCode = await runNewCommand({
             ...options,
             branch,
+            copy: commandOptions.copy,
             detached: commandOptions.detached,
             dryRun: commandOptions.dryRun,
             editor: commandOptions.editor,
+            fromCurrent: commandOptions.fromCurrent,
             force: commandOptions.force,
+            noFetch: commandOptions.fetch === false,
             json: commandOptions.json,
             open: commandOptions.open,
+            take: commandOptions.take,
         });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
     });
+    program.commands
+        .find((command) => command.name() === "done")
+        ?.action(async (branch, commandOptions) => {
+        const exitCode = await runDoneCommand({
+            branch,
+            cwd: options.cwd,
+            force: commandOptions.force,
+            json: commandOptions.json,
+            keepBranch: commandOptions.keepBranch,
+            stderr: options.stderr,
+            stdout: options.stdout,
+        });
+        if (exitCode !== 0)
+            throw commanderExit(exitCode);
+    });
+    program.commands
+        .find((command) => command.name() === "undo")
+        ?.action(async (id, commandOptions) => {
+        const exitCode = await runUndoCommand({
+            cwd: options.cwd,
+            id,
+            json: commandOptions.json,
+            list: commandOptions.list,
+            stderr: options.stderr,
+            stdout: options.stdout,
+        });
+        if (exitCode !== 0)
+            throw commanderExit(exitCode);
+    });
     program.commands
         .find((command) => command.name() === "init")
         ?.action(async (shell, commandOptions) => {
@@ -397,6 +475,7 @@ function attachCommandActions(program, options) {
             cwd: options.cwd,
             editor: commandOptions.editor,
             save: commandOptions.save,
+            select: commandOptions.select,
             stderr: options.stderr,
             stdout: options.stdout,
             workspace: commandOptions.workspace,
@@ -411,7 +490,9 @@ function attachCommandActions(program, options) {
         const exitCode = await runGoCommand({
             branch,
             cwd: options.cwd,
+            json: commandOptions.json,
             print: commandOptions.print,
+            root: commandOptions.root,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -560,7 +641,12 @@ function attachCommandActions(program, options) {
     };
     program.commands
         .find((command) => command.name() === "remove")
-        ?.action(runRemovalCommand);
+        ?.action(async (branch, commandOptions) => {
+        if (!commandOptions.json) {
+            options.stderr("gji remove is deprecated; use 'gji done' for one worktree or 'gji clean' for bulk cleanup.\n");
+        }
+        return runRemovalCommand(branch, commandOptions);
+    });
     program.commands
         .find((command) => command.name() === "run-hook")
         ?.action(async (hook) => {
@@ -576,14 +662,13 @@ function attachCommandActions(program, options) {
     program.commands
         .find((command) => command.name() === "warp")
         ?.action(async (branch, commandOptions) => {
-        const newFlag = commandOptions.new;
-        const newWorktree = newFlag !== undefined && newFlag !== false;
-        const newBranch = typeof newFlag === "string" ? newFlag : undefined;
+        if (!commandOptions.json) {
+            options.stderr("gji warp is deprecated; use 'gji go' (press Tab for all repositories).\n");
+        }
         const exitCode = await runWarpCommand({
-            branch: newWorktree ? (newBranch ?? branch) : branch,
+            branch,
             cwd: options.cwd,
             json: commandOptions.json,
-            newWorktree,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -621,6 +706,7 @@ function attachCommandActions(program, options) {
             action: "set",
             cwd: options.cwd,
             key,
+            stderr: options.stderr,
             stdout: options.stdout,
             value,
         });

package/dist/clone-failure-store.d.ts

@@ -0,0 +1,18 @@
+export interface CloneFailureStore {
+    isCached(repoRoot: string, directory: string, scope?: string): Promise<boolean>;
+    cache(repoRoot: string, directory: string, reason: string, scope?: string): Promise<void>;
+    clear(repoRoot: string, directory: string, scope?: string): Promise<void>;
+}
+export declare class FileCloneFailureStore implements CloneFailureStore {
+    private updateQueue;
+    isCached(repoRoot: string, directory: string, scope?: string): Promise<boolean>;
+    cache(repoRoot: string, directory: string, reason: string, scope?: string): Promise<void>;
+    clear(repoRoot: string, directory: string, scope?: string): Promise<void>;
+    private update;
+    private withStateLock;
+    private readState;
+    private writeState;
+    private stateFilePath;
+}
+export declare const defaultCloneFailureStore: CloneFailureStore;
+export declare function cloneFailureScope(source: string, destination: string): Promise<string>;

package/dist/clone-failure-store.js

@@ -0,0 +1,230 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, mkdtemp, readdir, readFile, rename, rm, rmdir, stat, unlink, utimes, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
+const STATE_FILE_NAME = "state.json";
+const STATE_LOCK_SUFFIX = ".lock";
+const CLONE_FAILURE_TTL_MS = 24 * 60 * 60 * 1000;
+const STATE_LOCK_TTL_MS = 30 * 1000;
+export class FileCloneFailureStore {
+    updateQueue = Promise.resolve();
+    async isCached(repoRoot, directory, scope) {
+        const state = await this.readState();
+        const repoState = state.syncDirs?.[repoRoot];
+        const key = failureKey(directory, scope);
+        if (!repoState || !Object.hasOwn(repoState, key))
+            return false;
+        const failure = repoState[key];
+        return (isPlainObject(failure) &&
+            typeof failure.failedAt === "number" &&
+            Date.now() - failure.failedAt < CLONE_FAILURE_TTL_MS);
+    }
+    async cache(repoRoot, directory, reason, scope) {
+        await this.update(async () => {
+            const state = await this.readState();
+            const syncDirs = state.syncDirs ?? {};
+            const repoState = syncDirs[repoRoot] ?? {};
+            const key = failureKey(directory, scope);
+            syncDirs[repoRoot] = {
+                ...repoState,
+                [key]: { failedAt: Date.now(), reason },
+            };
+            await this.writeState({ ...state, syncDirs });
+        });
+    }
+    async clear(repoRoot, directory, scope) {
+        await this.update(async () => {
+            const state = await this.readState();
+            const repoState = state.syncDirs?.[repoRoot];
+            const key = failureKey(directory, scope);
+            if (!repoState || !Object.hasOwn(repoState, key))
+                return;
+            const nextRepoState = { ...repoState };
+            delete nextRepoState[key];
+            const syncDirs = { ...state.syncDirs };
+            if (Object.keys(nextRepoState).length === 0)
+                delete syncDirs[repoRoot];
+            else
+                syncDirs[repoRoot] = nextRepoState;
+            await this.writeState({ ...state, syncDirs });
+        });
+    }
+    async update(operation) {
+        const next = this.updateQueue.then(() => this.withStateLock(operation), () => this.withStateLock(operation));
+        this.updateQueue = next.then(() => undefined, () => undefined);
+        await next;
+    }
+    async withStateLock(operation) {
+        const lockPath = `${this.stateFilePath()}${STATE_LOCK_SUFFIX}`;
+        const lockToken = await acquireStateLock(lockPath);
+        if (lockToken === undefined)
+            return;
+        const stopHeartbeat = startStateLockHeartbeat(lockPath, lockToken);
+        try {
+            await operation();
+        }
+        finally {
+            stopHeartbeat();
+            await releaseStateLock(lockPath, lockToken);
+        }
+    }
+    async readState() {
+        try {
+            const raw = await readFile(this.stateFilePath(), "utf8");
+            const parsed = JSON.parse(raw);
+            if (!isPlainObject(parsed))
+                return {};
+            return isPlainObject(parsed.syncDirs)
+                ? parsed
+                : { ...parsed, syncDirs: {} };
+        }
+        catch {
+            return {};
+        }
+    }
+    async writeState(state) {
+        try {
+            const path = this.stateFilePath();
+            const directory = dirname(path);
+            await mkdir(directory, { recursive: true });
+            const temporaryDirectory = await mkdtemp(join(directory, `.gji-state-${randomUUID()}-`));
+            const temporaryPath = join(temporaryDirectory, STATE_FILE_NAME);
+            try {
+                await writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+                await rename(temporaryPath, path);
+            }
+            finally {
+                await rm(temporaryDirectory, { force: true, recursive: true });
+            }
+        }
+        catch {
+            // The cache is advisory and must never block worktree creation.
+        }
+    }
+    stateFilePath(home = homedir()) {
+        const configuredDirectory = process.env.GJI_CONFIG_DIR;
+        const directory = configuredDirectory
+            ? resolve(configuredDirectory)
+            : join(home, GLOBAL_CONFIG_DIRECTORY);
+        return join(directory, STATE_FILE_NAME);
+    }
+}
+async function acquireStateLock(lockPath) {
+    const lockToken = randomUUID();
+    await mkdir(dirname(lockPath), { recursive: true }).catch(() => undefined);
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+        try {
+            await mkdir(lockPath);
+        }
+        catch (error) {
+            if (!isErrorCode(error, "EEXIST"))
+                return undefined;
+            try {
+                const freshnessPath = await lockFreshnessPath(lockPath);
+                const lockStats = await stat(freshnessPath);
+                if (Date.now() - lockStats.mtimeMs >= STATE_LOCK_TTL_MS) {
+                    const stalePath = `${lockPath}.stale-${randomUUID()}`;
+                    try {
+                        await rename(lockPath, stalePath);
+                    }
+                    catch (renameError) {
+                        if (isErrorCode(renameError, "ENOENT"))
+                            continue;
+                        return undefined;
+                    }
+                    await rm(stalePath, { force: true, recursive: true });
+                    continue;
+                }
+            }
+            catch (lockError) {
+                if (!isErrorCode(lockError, "ENOENT"))
+                    return undefined;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+            continue;
+        }
+        try {
+            await writeFile(join(lockPath, ownerFileName(lockToken)), `${lockToken}\n`, {
+                flag: "wx",
+            });
+            return lockToken;
+        }
+        catch {
+            await rm(lockPath, { force: true, recursive: true }).catch(() => undefined);
+            return undefined;
+        }
+    }
+    return undefined;
+}
+async function lockFreshnessPath(lockPath) {
+    try {
+        const owner = (await readdir(lockPath)).find((entry) => entry.startsWith("owner-"));
+        return owner ? join(lockPath, owner) : lockPath;
+    }
+    catch (error) {
+        if (isErrorCode(error, "ENOENT"))
+            throw error;
+        return lockPath;
+    }
+}
+function startStateLockHeartbeat(lockPath, lockToken) {
+    const timer = setInterval(() => {
+        void refreshStateLock(lockPath, lockToken);
+    }, STATE_LOCK_TTL_MS / 3);
+    timer.unref?.();
+    return () => clearInterval(timer);
+}
+async function refreshStateLock(lockPath, lockToken) {
+    try {
+        const ownerPath = join(lockPath, ownerFileName(lockToken));
+        await readFile(ownerPath, "utf8");
+        const now = new Date();
+        await utimes(ownerPath, now, now);
+    }
+    catch {
+        // The cache is advisory; a failed heartbeat must not block worktree creation.
+    }
+}
+async function releaseStateLock(lockPath, lockToken) {
+    try {
+        const ownerPath = join(lockPath, ownerFileName(lockToken));
+        await unlink(ownerPath);
+        await rmdir(lockPath);
+    }
+    catch (error) {
+        if (!isErrorCode(error, "ENOENT") && !isErrorCode(error, "ENOTEMPTY")) {
+            return;
+        }
+    }
+}
+function ownerFileName(lockToken) {
+    return `owner-${lockToken}`;
+}
+export const defaultCloneFailureStore = new FileCloneFailureStore();
+export async function cloneFailureScope(source, destination) {
+    const sourcePath = resolve(source);
+    const destinationParent = resolve(dirname(destination));
+    const [sourceDevice, destinationDevice] = await Promise.all([
+        readDevice(sourcePath),
+        readDevice(destinationParent),
+    ]);
+    return JSON.stringify([sourcePath, sourceDevice, destinationDevice]);
+}
+async function readDevice(path) {
+    try {
+        return (await stat(path)).dev;
+    }
+    catch {
+        return undefined;
+    }
+}
+function failureKey(directory, scope) {
+    return scope === undefined ? directory : JSON.stringify([scope, directory]);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isErrorCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}

package/dist/command-runner.d.ts

@@ -0,0 +1,6 @@
+export type CommandRunner = (command: string, cwd: string, stderr: (chunk: string) => void, stdout?: (chunk: string) => void, options?: CommandRunnerOptions) => Promise<void>;
+export interface CommandRunnerOptions {
+    env?: NodeJS.ProcessEnv;
+    shell?: boolean;
+}
+export declare const runCommand: CommandRunner;

package/dist/command-runner.js

@@ -0,0 +1,38 @@
+import { spawn } from "node:child_process";
+export const runCommand = async (command, cwd, stderr, stdout = (chunk) => process.stdout.write(chunk), options) => {
+    await new Promise((resolve, reject) => {
+        const shell = options?.shell ?? true;
+        const [executable, args] = shell ? [command, []] : splitCommand(command);
+        const child = spawn(executable, args, {
+            cwd,
+            env: options?.env ? { ...process.env, ...options.env } : undefined,
+            shell,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.stdout.on("data", (chunk) => {
+            stdout(chunk.toString());
+        });
+        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", reject);
+    });
+};
+function splitCommand(command) {
+    const tokens = command.match(/[^\s"']+|"[^"]*"|'[^']*'/gu) ?? [];
+    const [first, ...rest] = tokens;
+    if (!first)
+        throw new Error("command must not be empty");
+    return [
+        first.replace(/^(["'])(.*)\1$/u, "$2"),
+        rest.map((token) => token.replace(/^(["'])(.*)\1$/u, "$2")),
+    ];
+}

package/dist/completion.js

@@ -1,9 +1,14 @@
 import { resolveSupportedShell } from "./shell.js";
 import { renderShellCompletion } from "./shell-completion.js";
 export async function runCompletionCommand(options) {
-    const shell = resolveSupportedShell(options.shell, process.env.SHELL);
+    const shell = options.shell
+        ? resolveSupportedShell(options.shell, undefined)
+        : resolveSupportedShell(undefined, process.env.SHELL);
     if (!shell) {
-        options.stderr?.("Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n");
+        const message = options.shell
+            ? `Unsupported shell "${options.shell}". Supported shells: bash, fish, or zsh.`
+            : "Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.";
+        options.stderr?.(`${message}\n`);
         return 1;
     }
     options.stdout(renderShellCompletion(shell));

package/dist/config-command.d.ts

@@ -2,6 +2,7 @@ export interface ConfigCommandOptions {
     action?: string;
     cwd: string;
     key?: string;
+    stderr?: (chunk: string) => void;
     stdout: (chunk: string) => void;
     value?: string;
 }

package/dist/config-command.js

@@ -13,7 +13,13 @@ export async function runConfigCommand(options) {
         }
         case "set":
             if (options.key && options.value !== undefined) {
-                await updateGlobalConfigKey(options.key, parseConfigValue(options.value));
+                try {
+                    await updateGlobalConfigKey(options.key, parseConfigValue(options.value));
+                }
+                catch (error) {
+                    options.stderr?.(`gji config: ${error instanceof Error ? error.message : String(error)}\n`);
+                    return 1;
+                }
                 return 0;
             }
             break;

package/dist/config.d.ts

@@ -4,14 +4,35 @@ 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 interface EffectiveGjiConfig extends GjiConfig {
+    branchPrefix?: string;
+    dependencyBuildCommand?: string;
+    dependencyBootstrap?: DependencyBootstrapMode;
+    editor?: string;
+    hooks?: Record<string, unknown>;
+    installSaveTarget?: string;
+    shellIntegration?: string;
+    skipInstallPrompt?: boolean;
+    syncDirs?: readonly string[];
+    syncFiles?: readonly string[];
+    syncDefaultBranch?: string;
+    syncRemote?: string;
+    worktreePath?: string;
+}
 export interface LoadedConfig {
     config: GjiConfig;
     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<GjiConfig>;
+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>;
@@ -22,3 +43,7 @@ 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;