@solaqua/gji 0.12.5 → 0.14.0

package/dist/cli/commands/clean.js

@@ -0,0 +1,555 @@
+import { confirm, isCancel } from "@clack/prompts";
+import { loadLinkedWorktrees, } from "../../application/worktree/catalog.js";
+import { deduplicateWorktreeSources, listRegisteredWorktreeSources, } from "../../application/worktree/sources.js";
+import { mapWithConcurrency } from "../../domain/shared/concurrency.js";
+import { buildWorktreePromptEntries, promptForMultipleWorktrees, } from "../../presentation/worktree/picker.js";
+import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "../../presentation/worktree/prompts.js";
+import { defaultCliDependencies, } from "../dependencies.js";
+import { isHeadless } from "../runtime/headless.js";
+import { finalizeUndoOperation, recordUndoOperation, } from "./undo.js";
+function toPromptSource(candidate) {
+    return {
+        repoName: candidate.repoName,
+        repoRoot: candidate.repoRoot,
+        worktree: candidate.worktree,
+    };
+}
+const MAX_CLEAN_REPOSITORY_CONCURRENCY = 4;
+const MAX_CLEAN_WORKTREE_CONCURRENCY = 8;
+export function createCleanCommand(dependencies = {}) {
+    const promptForWorktrees = dependencies.promptForWorktrees ?? defaultPromptForWorktrees;
+    const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
+    const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ??
+        defaultConfirmForceRemoveWorktree;
+    const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
+    return async function runCleanCommand(options) {
+        const runtime = options.runtime ?? defaultCliDependencies;
+        const { readWorktreeHealth, isBranchMergedInto, resolveRemoteBase, runGit, } = runtime.git;
+        const { loadEffectiveConfig } = runtime.config;
+        const { releaseWorktreeSlot } = runtime.slots;
+        const sourceDependencies = {
+            ...runtime.repositoryContext,
+            ...runtime.repositoryRegistry,
+            ...runtime.worktrees,
+        };
+        const { formatLastCommit, formatUpstreamState, readWorktreeInfos, serializeWorktreeInfo, } = runtime.worktreeInfo;
+        const { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isSubmoduleWorktreeRemovalError, isWorktreeDeletionError, isWorktreeForceRemovalError, removeWorktree, } = runtime.worktreeLifecycle;
+        const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd, sourceDependencies);
+        const currentSources = linkedWorktrees
+            .filter((worktree) => worktree.path !== repository.currentRoot)
+            .map((worktree) => ({
+            repoName: repository.repoName,
+            repoRoot: repository.repoRoot,
+            worktree,
+        }));
+        const cleanupDependencies = {
+            isBranchMergedInto,
+            loadEffectiveConfig,
+            readWorktreeHealth,
+            resolveRemoteBase,
+            runGit,
+        };
+        const currentCandidates = await resolveCleanupCandidates({
+            sources: currentSources,
+            stale: options.stale,
+            stderr: options.stderr,
+        }, cleanupDependencies);
+        let activeCandidates = currentCandidates;
+        let allCandidates = null;
+        let currentScope = true;
+        const interactiveSelection = !options.force && !options.json && !isHeadless();
+        const skippedRepositories = [];
+        const loadAllCandidates = async (signal) => {
+            throwIfAborted(signal);
+            if (allCandidates !== null)
+                return allCandidates;
+            const registered = await listRegisteredWorktreeSources({
+                cwd: options.cwd,
+                repositoryPort: sourceDependencies,
+                signal,
+            });
+            skippedRepositories.push(...registered.skipped);
+            if (registered.skipped.length > 0) {
+                reportSkippedRepositories(skippedRepositories, options.stderr);
+            }
+            const sources = deduplicateWorktreeSources([
+                ...currentSources,
+                ...registered.sources,
+            ]).filter((source) => source.repoRoot !== undefined &&
+                source.worktree.path !== source.repoRoot &&
+                source.worktree.path !== repository.currentRoot);
+            const otherRepositorySources = sources.filter((source) => source.repoRoot !== repository.repoRoot);
+            const otherRepositoryCandidates = await resolveCleanupCandidates({
+                sources: otherRepositorySources,
+                stale: options.stale,
+                stderr: options.stderr,
+                signal,
+            }, cleanupDependencies);
+            allCandidates = [...currentCandidates, ...otherRepositoryCandidates];
+            throwIfAborted(signal);
+            return allCandidates;
+        };
+        const scope = {
+            label: "current repository",
+            toggleLabel: "all repositories",
+            toggle: async (signal) => {
+                const nextCurrentScope = !currentScope;
+                const nextCandidates = nextCurrentScope
+                    ? currentCandidates
+                    : await loadAllCandidates(signal);
+                throwIfAborted(signal);
+                currentScope = nextCurrentScope;
+                activeCandidates = nextCandidates;
+                return {
+                    sources: nextCandidates.map(toPromptSource),
+                    metadata: nextCurrentScope ? "full" : "fast",
+                    label: nextCurrentScope ? "current repository" : "all repositories",
+                    toggleLabel: nextCurrentScope
+                        ? "all repositories"
+                        : "current repository",
+                };
+            },
+        };
+        if (currentCandidates.length === 0 && interactiveSelection) {
+            const loadedAllCandidates = await loadAllCandidates();
+            if (loadedAllCandidates.length === 0) {
+                if (options.stale) {
+                    emitNoStaleCandidates(options);
+                    return 0;
+                }
+                emitError(options, "No linked worktrees to clean");
+                return 1;
+            }
+            currentScope = false;
+            activeCandidates = loadedAllCandidates;
+            scope.label = "all repositories";
+            scope.toggleLabel = "current repository";
+        }
+        if (currentCandidates.length === 0 && !interactiveSelection) {
+            if (options.stale) {
+                emitNoStaleCandidates(options);
+                return 0;
+            }
+            emitError(options, "No linked worktrees to clean");
+            return 1;
+        }
+        if (!options.dryRun && !options.force && (options.json || isHeadless())) {
+            const message = "--force is required";
+            if (options.json) {
+                emitError(options, message);
+            }
+            else {
+                options.stderr(`gji clean: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+            }
+            return 1;
+        }
+        // With --force, or non-interactive dry-runs, skip selection prompt and target all candidates.
+        const shouldSelectAll = options.force ||
+            (options.dryRun && (options.stale || options.json || isHeadless()));
+        const selections = shouldSelectAll
+            ? activeCandidates.map(({ worktree }) => worktree.path)
+            : await promptForWorktrees(await buildWorktreePromptEntries(activeCandidates, {
+                metadata: currentScope ? "full" : "fast",
+                catalog: runtime.worktreeCatalog,
+            }), scope, runtime.worktreeCatalog);
+        if (!selections || selections.length === 0) {
+            options.stderr("Aborted\n");
+            return 1;
+        }
+        const selectedCandidates = resolveSelectedCandidates(activeCandidates, selections);
+        if (selectedCandidates.length !== selections.length) {
+            options.stderr("Selected worktree no longer exists\n");
+            return 1;
+        }
+        const selectedWorktrees = selectedCandidates.map(({ worktree }) => worktree);
+        const selectedWorktreeInfos = await readWorktreeInfos(selectedWorktrees);
+        const selectedInfoByPath = new Map(selectedWorktreeInfos.map((info) => [info.path, info]));
+        if (!options.dryRun &&
+            !options.force &&
+            !(await confirmRemoval(selectedWorktrees))) {
+            options.stderr("Aborted\n");
+            return 1;
+        }
+        if (options.dryRun) {
+            if (options.json) {
+                const removed = selectedWorktreeInfos.map((info) => serializeWorktreeInfo(info));
+                options.stdout(`${JSON.stringify({ removed, dryRun: true }, null, 2)}\n`);
+            }
+            else {
+                for (const info of selectedWorktreeInfos) {
+                    options.stdout(`Would remove worktree at ${info.path} (${formatCleanInfo(info, formatLastCommit, formatUpstreamState)})\n`);
+                }
+            }
+            return 0;
+        }
+        const candidatesByRepository = groupCandidatesByRepository(selectedCandidates);
+        const journals = new Map();
+        const failures = [];
+        try {
+            for (const [repoRoot, candidates] of candidatesByRepository) {
+                const journal = await recordUndoOperation("clean", repoRoot, candidates.map(({ worktree }) => worktree), undefined, runtime);
+                if (!journal) {
+                    await discardUndoRecords(journals.values(), runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
+                    emitError(options, "could not capture undo state; no worktrees were removed");
+                    return 1;
+                }
+                journals.set(repoRoot, journal);
+            }
+        }
+        catch (error) {
+            await discardUndoRecords(journals.values(), runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
+            emitError(options, `could not write undo journal; no worktrees were removed: ${toMessage(error)}`);
+            return 1;
+        }
+        const removedCandidates = [];
+        for (const candidate of selectedCandidates) {
+            const { repoRoot, staleBaseRef, worktree } = candidate;
+            if (options.stale &&
+                !(await isStaleCleanupCandidate({ repoRoot, worktree, baseBranch: staleBaseRef }, cleanupDependencies))) {
+                options.stderr(`Skipped ${worktree.path}: no longer a safe stale cleanup candidate\n`);
+                continue;
+            }
+            try {
+                await removeWorktree(repoRoot, worktree.path);
+            }
+            catch (error) {
+                if (!isWorktreeForceRemovalError(error)) {
+                    failures.push({
+                        branch: worktree.branch,
+                        message: toMessage(error),
+                        path: worktree.path,
+                    });
+                    continue;
+                }
+                if (options.stale &&
+                    !isWorktreeDeletionError(error) &&
+                    !isSubmoduleWorktreeRemovalError(error)) {
+                    options.stderr(`Skipped ${worktree.path}: no longer a safe stale cleanup candidate\n`);
+                    continue;
+                }
+                if (!options.force &&
+                    !(await confirmForceRemoveWorktree(worktree.path))) {
+                    failures.push({
+                        branch: worktree.branch,
+                        message: "force removal declined",
+                        path: worktree.path,
+                    });
+                    continue;
+                }
+                try {
+                    await forceRemoveWorktree(repoRoot, worktree.path);
+                }
+                catch (forceError) {
+                    failures.push({
+                        branch: worktree.branch,
+                        message: toMessage(forceError),
+                        path: worktree.path,
+                    });
+                    continue;
+                }
+            }
+            removedCandidates.push(candidate);
+            if (worktree.branch) {
+                try {
+                    await deleteBranch(repoRoot, worktree.branch);
+                }
+                catch (error) {
+                    if (!isBranchUnmergedError(error)) {
+                        failures.push({
+                            branch: worktree.branch,
+                            message: toMessage(error),
+                            path: worktree.path,
+                        });
+                        continue;
+                    }
+                    if (options.force ||
+                        (await confirmForceDeleteBranch(worktree.branch))) {
+                        try {
+                            await forceDeleteBranch(repoRoot, worktree.branch);
+                        }
+                        catch (forceError) {
+                            options.stderr(`Failed to delete branch ${worktree.branch}: ${toMessage(forceError)}\n`);
+                        }
+                    }
+                    else {
+                        options.stderr(`Branch ${worktree.branch} was not deleted (has unmerged commits)\n`);
+                    }
+                }
+            }
+        }
+        for (const [repoRoot, journal] of journals) {
+            await finalizeUndoOperation(journal, removedCandidates
+                .filter((candidate) => candidate.repoRoot === repoRoot)
+                .map(({ worktree }) => worktree), undefined, runtime.configStore.GLOBAL_CONFIG_DIRECTORY);
+        }
+        const undoRecords = remainingUndoRecords(journals.values(), removedCandidates);
+        await Promise.all(removedCandidates.map(({ worktree }) => releaseWorktreeSlot(worktree.path)));
+        if (options.json) {
+            const removed = removedCandidates.map(({ worktree }) => {
+                const info = selectedInfoByPath.get(worktree.path);
+                return info === undefined
+                    ? { branch: worktree.branch, path: worktree.path }
+                    : serializeWorktreeInfo(info);
+            });
+            const payload = {
+                removed,
+                ...(failures.length === 0 ? {} : { failed: failures }),
+                ...(needsExplicitUndoIds(undoRecords, repository.repoRoot)
+                    ? {
+                        undo: undoRecords.map(({ id, repoRoot }) => ({ id, repoRoot })),
+                    }
+                    : {}),
+            };
+            options.stdout(`${JSON.stringify(payload, null, 2)}\n`);
+        }
+        else if (failures.length > 0) {
+            reportCleanFailures(failures, options.stderr);
+            emitUndoHints(undoRecords, repository.repoRoot, options.stderr);
+        }
+        else {
+            emitUndoHints(undoRecords, repository.repoRoot, options.stderr);
+            options.stdout(`${[...new Set(selectedCandidates.map(({ repoRoot }) => repoRoot))].join("\n")}\n`);
+        }
+        return failures.length === 0 ? 0 : 1;
+    };
+}
+export const runCleanCommand = createCleanCommand();
+async function resolveCleanupCandidates(options, dependencies) {
+    const { sources, stale, stderr, signal } = options;
+    const grouped = new Map();
+    for (const source of sources) {
+        if (source.repoRoot === undefined)
+            continue;
+        const existing = grouped.get(source.repoRoot);
+        if (existing === undefined) {
+            grouped.set(source.repoRoot, {
+                repoName: source.repoName,
+                worktrees: [source.worktree],
+            });
+        }
+        else {
+            existing.worktrees.push(source.worktree);
+        }
+    }
+    const results = await mapWithConcurrency([...grouped.entries()], MAX_CLEAN_REPOSITORY_CONCURRENCY, async ([repoRoot, group]) => {
+        throwIfAborted(signal);
+        const staleBaseRef = stale
+            ? await resolveStaleBaseRef({ repoRoot, stderr }, dependencies)
+            : null;
+        const worktrees = stale
+            ? await filterStaleCleanupCandidates({
+                repoRoot,
+                worktrees: group.worktrees,
+                baseBranch: staleBaseRef,
+                signal,
+            }, dependencies)
+            : group.worktrees;
+        return worktrees.map((worktree) => ({
+            repoName: group.repoName,
+            repoRoot,
+            staleBaseRef,
+            worktree,
+        }));
+    }, signal);
+    return results.flat();
+}
+function resolveSelectedCandidates(candidates, selections) {
+    const selected = [];
+    const seenPaths = new Set();
+    for (const selection of selections) {
+        const candidate = candidates.find((entry) => entry.worktree.path === selection ||
+            entry.worktree.branch === selection);
+        if (candidate === undefined || seenPaths.has(candidate.worktree.path)) {
+            continue;
+        }
+        selected.push(candidate);
+        seenPaths.add(candidate.worktree.path);
+    }
+    return selected;
+}
+function groupCandidatesByRepository(candidates) {
+    const grouped = new Map();
+    for (const candidate of candidates) {
+        const existing = grouped.get(candidate.repoRoot);
+        if (existing === undefined)
+            grouped.set(candidate.repoRoot, [candidate]);
+        else
+            existing.push(candidate);
+    }
+    return grouped;
+}
+function remainingUndoRecords(records, removedCandidates) {
+    return [...records].filter((record) => removedCandidates.some((candidate) => candidate.repoRoot === record.repoRoot &&
+        record.entries.some((entry) => entry.path === candidate.worktree.path)));
+}
+async function discardUndoRecords(records, globalConfigDirectory) {
+    await Promise.all([...records].map((record) => finalizeUndoOperation(record, [], undefined, globalConfigDirectory)));
+}
+async function filterStaleCleanupCandidates(options, dependencies) {
+    const { repoRoot, worktrees, baseBranch, signal } = options;
+    throwIfAborted(signal);
+    if (baseBranch === null) {
+        return [];
+    }
+    const results = await mapWithConcurrency(worktrees, MAX_CLEAN_WORKTREE_CONCURRENCY, (worktree) => isStaleCleanupCandidate({ repoRoot, worktree, baseBranch }, dependencies), signal);
+    throwIfAborted(signal);
+    return worktrees.filter((_, index) => results[index]);
+}
+async function resolveStaleBaseRef(options, dependencies) {
+    const { repoRoot, stderr } = options;
+    const config = await dependencies.loadEffectiveConfig(repoRoot, undefined, stderr);
+    const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
+    const configuredDefaultBranch = resolveConfiguredString(config.syncDefaultBranch);
+    try {
+        const remoteBase = await dependencies.resolveRemoteBase(repoRoot, remote, configuredDefaultBranch ?? undefined);
+        return remoteBase === null
+            ? null
+            : resolveFetchedRemoteRef({ branch: remoteBase.branch, remote, repoRoot }, dependencies.runGit);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveFetchedRemoteRef(options, runGit) {
+    const { repoRoot, remote, branch } = options;
+    try {
+        await runGit(repoRoot, ["fetch", "--prune", remote]);
+        await runGit(repoRoot, [
+            "rev-parse",
+            "--verify",
+            "--quiet",
+            `${remote}/${branch}`,
+        ]);
+        return `${remote}/${branch}`;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfiguredString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+async function isStaleCleanupCandidate(options, dependencies) {
+    const { repoRoot, worktree, baseBranch } = options;
+    if (baseBranch === null) {
+        return false;
+    }
+    if (worktree.branch === null) {
+        return false;
+    }
+    const health = await dependencies.readWorktreeHealth(worktree.path);
+    if (health.status !== "clean" || !health.upstreamGone) {
+        return false;
+    }
+    if (await dependencies.isBranchMergedInto(repoRoot, worktree.branch, baseBranch)) {
+        return true;
+    }
+    return isBranchPatchEquivalentInto({ baseBranch, repoRoot, worktreeBranch: worktree.branch }, dependencies.runGit);
+}
+async function isBranchPatchEquivalentInto(options, runGit) {
+    const { repoRoot, worktreeBranch, baseBranch } = options;
+    try {
+        const output = await runGit(repoRoot, [
+            "cherry",
+            baseBranch,
+            worktreeBranch,
+        ]);
+        const lines = output.split("\n").filter(Boolean);
+        return lines.length > 0 && lines.every((line) => line.startsWith("-"));
+    }
+    catch {
+        return false;
+    }
+}
+function reportCleanFailures(failures, stderr) {
+    const noun = failures.length === 1 ? "worktree" : "worktrees";
+    stderr(`Failed to clean ${failures.length} ${noun}:\n`);
+    for (const failure of failures) {
+        const branch = failure.branch === null ? "detached" : failure.branch;
+        stderr(`- ${failure.path} (${branch}): ${failure.message}\n`);
+    }
+}
+function emitUndoHints(records, currentRepositoryRoot, stderr) {
+    if (records.length === 0)
+        return;
+    if (!needsExplicitUndoIds(records, currentRepositoryRoot)) {
+        stderr("undo: gji undo\n");
+        return;
+    }
+    const message = records.length === 1
+        ? "undo: restore with:"
+        : "undo: restore each repository with:";
+    stderr(`${message}\n`);
+    for (const record of records) {
+        stderr(`  gji undo --id ${record.id} (${record.repoRoot})\n`);
+    }
+}
+function needsExplicitUndoIds(records, currentRepositoryRoot) {
+    return (records.length > 1 ||
+        records.some((record) => record.repoRoot !== currentRepositoryRoot));
+}
+function reportSkippedRepositories(repositories, stderr) {
+    const noun = repositories.length === 1 ? "repository" : "repositories";
+    stderr(`Skipped ${repositories.length} registered ${noun} because worktrees could not be listed:\n`);
+    for (const repository of repositories) {
+        stderr(`- ${repository.name} (${repository.path})\n`);
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Operation cancelled");
+}
+function formatCleanInfo(info, formatLastCommit, formatUpstreamState) {
+    const branch = info.branch === null ? "detached" : `branch: ${info.branch}`;
+    const status = `status: ${info.status}`;
+    const upstream = `upstream: ${formatUpstreamState(info.upstream)}`;
+    const last = `last: ${formatLastCommit(info.lastCommitTimestamp)}`;
+    return [branch, status, upstream, last].join(", ");
+}
+function emitError(options, message) {
+    if (options.json) {
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+    }
+    else {
+        options.stderr(`${message}\n`);
+    }
+}
+function emitNoStaleCandidates(options) {
+    if (options.json) {
+        const payload = options.dryRun
+            ? { removed: [], dryRun: true }
+            : { removed: [] };
+        options.stdout(`${JSON.stringify(payload, null, 2)}\n`);
+        return;
+    }
+    options.stdout("No stale linked worktrees to clean\n");
+}
+function toMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function defaultPromptForWorktrees(worktrees, scope, catalog) {
+    return promptForMultipleWorktrees("Choose worktrees to clean", worktrees, {
+        catalog,
+        scope,
+    });
+}
+async function defaultConfirmRemoval(worktrees) {
+    const branchCount = worktrees.filter((worktree) => worktree.branch !== null).length;
+    const detachedCount = worktrees.length - branchCount;
+    const messageParts = [
+        `Remove ${worktrees.length} linked worktree${worktrees.length === 1 ? "" : "s"}`,
+    ];
+    if (branchCount > 0) {
+        messageParts.push(`delete ${branchCount} branch${branchCount === 1 ? "" : "es"}`);
+    }
+    if (detachedCount > 0) {
+        messageParts.push(`remove ${detachedCount} detached worktree${detachedCount === 1 ? "" : "s"}`);
+    }
+    const choice = await confirm({
+        active: "Yes",
+        inactive: "No",
+        initialValue: true,
+        message: `${messageParts.join(", ")}?`,
+    });
+    return !isCancel(choice) && choice;
+}

package/dist/{completion.js → cli/commands/completion.js}

@@ -1,5 +1,5 @@
-import { resolveSupportedShell } from "./shell.js";
-import { renderShellCompletion } from "./shell-completion.js";
+import { renderShellCompletion } from "../../presentation/shell/completion.js";
+import { resolveSupportedShell } from "../../presentation/shell/shell.js";
 export async function runCompletionCommand(options) {
     const shell = options.shell
         ? resolveSupportedShell(options.shell, undefined)

package/dist/{config-command.d.ts → cli/commands/config-command.d.ts}

@@ -1,3 +1,4 @@
+import { type CliRuntime } from "../dependencies.js";
 export interface ConfigCommandOptions {
     action?: string;
     cwd: string;
@@ -5,5 +6,6 @@ export interface ConfigCommandOptions {
     stderr?: (chunk: string) => void;
     stdout: (chunk: string) => void;
     value?: string;
+    runtime?: CliRuntime<"configStore">;
 }
 export declare function runConfigCommand(options: ConfigCommandOptions): Promise<number>;

package/dist/{config-command.js → cli/commands/config-command.js}

@@ -1,20 +1,22 @@
-import { loadGlobalConfig, parseConfigValue, unsetGlobalConfigKey, updateGlobalConfigKey, } from "./config.js";
+import { defaultCliDependencies } from "../dependencies.js";
 export async function runConfigCommand(options) {
+    const runtime = options.runtime ?? defaultCliDependencies;
+    const config = runtime.configStore;
     switch (options.action) {
         case undefined: {
-            const loaded = await loadGlobalConfig();
+            const loaded = await config.loadGlobalConfig();
             writeJson(options.stdout, loaded.config);
             return 0;
         }
         case "get": {
-            const loaded = await loadGlobalConfig();
+            const loaded = await config.loadGlobalConfig();
             writeJson(options.stdout, options.key ? loaded.config[options.key] : loaded.config);
             return 0;
         }
         case "set":
             if (options.key && options.value !== undefined) {
                 try {
-                    await updateGlobalConfigKey(options.key, parseConfigValue(options.value));
+                    await config.updateGlobalConfigKey(options.key, config.parseConfigValue(options.value));
                 }
                 catch (error) {
                     options.stderr?.(`gji config: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -25,7 +27,7 @@ export async function runConfigCommand(options) {
             break;
         case "unset":
             if (options.key) {
-                await unsetGlobalConfigKey(options.key);
+                await config.unsetGlobalConfigKey(options.key);
                 return 0;
             }
             break;

package/dist/{doctor.d.ts → cli/commands/doctor.d.ts}

@@ -1,3 +1,4 @@
+import { type CliRuntime } from "../dependencies.js";
 export type DoctorCheckStatus = "fail" | "ok" | "skip";
 export interface DoctorCheck {
     hint?: string;
@@ -22,6 +23,7 @@ export interface DoctorCommandOptions {
     confirmFixes?: (fixes: DoctorFix[]) => Promise<boolean>;
     shell?: string;
     yes?: boolean;
+    runtime?: CliRuntime<"integrations" | "slots" | "repositoryContext" | "configStore" | "registry">;
     stderr?: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }