@solaqua/gji 0.9.0 → 0.11.0

package/dist/shell-completion.js

@@ -2,7 +2,15 @@ import { KNOWN_GLOBAL_CONFIG_KEYS } from "./config.js";
 const TOP_LEVEL_COMMANDS = [
     {
         name: "new",
-        description: "create a new branch or detached linked worktree",
+        description: "create a new branch or detached linked worktree and CoW-bootstrap configured directories",
+    },
+    {
+        name: "done",
+        description: "finish the current linked worktree and return safely",
+    },
+    {
+        name: "undo",
+        description: "restore the most recent destructive worktree operation",
     },
     {
         name: "init",
@@ -17,7 +25,7 @@ const TOP_LEVEL_COMMANDS = [
     { name: "back", description: "navigate to the previously visited worktree" },
     { name: "history", description: "show navigation history" },
     { name: "open", description: "open the worktree in an editor" },
-    { name: "go", description: "print or select a worktree path" },
+    { name: "go", description: "resolve and jump to a worktree path" },
     { name: "jump", description: "alias of go" },
     { name: "root", description: "print the main repository root path" },
     { name: "status", description: "summarize repository and worktree health" },
@@ -30,14 +38,17 @@ const TOP_LEVEL_COMMANDS = [
     { name: "clean", description: "interactively prune linked worktrees" },
     {
         name: "remove",
-        description: "remove a linked worktree and delete its branch when present",
+        description: "deprecated: use done for one worktree or clean for bulk cleanup",
     },
-    { name: "rm", description: "alias of remove" },
+    { name: "rm", description: "deprecated alias of remove" },
     {
         name: "run-hook",
         description: "run a named hook in the current worktree",
     },
-    { name: "warp", description: "jump to any worktree across all known repos" },
+    {
+        name: "warp",
+        description: "deprecated: use go (press Tab for all known repos)",
+    },
     { name: "config", description: "manage global config defaults" },
 ];
 const SHELL_NAMES = ["bash", "fish", "zsh"];
@@ -137,7 +148,13 @@ _gji_completion() {
 
   case "$command_name" in
     new)
-      COMPREPLY=( $(compgen -W "--detached --force --open --editor --dry-run --json --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "--detached --from-current --no-fetch --take --copy --force --open --editor --dry-run --json --help" -- "$cur") )
+      ;;
+    done)
+      COMPREPLY=( $(compgen -W "--force --keep-branch --json --help" -- "$cur") )
+      ;;
+    undo)
+      COMPREPLY=( $(compgen -W "--list --json --help" -- "$cur") )
       ;;
     init)
       COMPREPLY=( $(compgen -W "${shells} --write --json --help" -- "$cur") )
@@ -179,10 +196,10 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "--json --help" -- "$cur") )
       ;;
     open)
-      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --editor --save --workspace --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --editor --select --save --workspace --help" -- "$cur") )
       ;;
     go|jump)
-      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --print --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --root --print --json --help" -- "$cur") )
       ;;
     root)
       COMPREPLY=( $(compgen -W "--print --help" -- "$cur") )
@@ -212,7 +229,7 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
       ;;
     warp)
-      COMPREPLY=( $(compgen -W "-n --new --print --json --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "--print --json --help" -- "$cur") )
       ;;
     config)
       if [ "$COMP_CWORD" -eq 2 ]; then
@@ -361,9 +378,17 @@ function __gji_should_complete_config_key
 end
 
 complete -c gji -f
+complete -c gji -n '__fish_seen_subcommand_from done' -l force -d 'remove dirty or unmerged worktrees without prompting'
+complete -c gji -n '__fish_seen_subcommand_from done' -l keep-branch -d 'remove the worktree but preserve its branch'
+complete -c gji -n '__fish_seen_subcommand_from done' -l json -d 'emit JSON on success or error instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from undo' -l list -d 'list recoverable operations'
+complete -c gji -n '__fish_seen_subcommand_from undo' -l json -d 'emit JSON on success or error instead of human-readable output'
 ${commandLines}
 
 complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a detached worktree without a branch'
+complete -c gji -n '__fish_seen_subcommand_from new' -l from-current -d 'base the new branch on the current worktree instead of the main worktree'
+complete -c gji -n '__fish_seen_subcommand_from new' -l take -d 'move current uncommitted changes into the new worktree'
+complete -c gji -n '__fish_seen_subcommand_from new' -l copy -d 'copy current uncommitted changes instead of moving them (requires --take)'
 complete -c gji -n '__fish_seen_subcommand_from new' -l force -d 'remove and recreate the worktree if the target path already exists'
 complete -c gji -n '__fish_seen_subcommand_from new' -l open -d 'open the new worktree in an editor after creation'
 complete -c gji -n '__fish_seen_subcommand_from new' -l editor -r -d 'editor CLI to use with --open (code, cursor, zed, …)'
@@ -393,11 +418,14 @@ complete -c gji -n '__fish_seen_subcommand_from back' -l print -d 'print the res
 complete -c gji -n '__fish_seen_subcommand_from history' -l json -d 'print history as JSON'
 
 complete -c gji -n '__fish_seen_subcommand_from open' -l editor -r -d 'editor CLI to use (code, cursor, zed, windsurf, subl, …)'
+complete -c gji -n '__fish_seen_subcommand_from open' -l select -d 'choose a worktree with the interactive selector'
 complete -c gji -n '__fish_seen_subcommand_from open' -l save -d 'save the chosen editor to global config'
 complete -c gji -n '__fish_seen_subcommand_from open' -l workspace -d 'generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)'
 complete -c gji -n '__fish_seen_subcommand_from open' -a '(__gji_worktree_branches)' -d 'worktree branch'
 
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l print -d 'print the resolved worktree path explicitly'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l root -d 'navigate to the main repository root'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l json -d 'emit JSON for an existing worktree destination'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -a '(__gji_worktree_branches)' -d 'worktree branch'
 
 complete -c gji -n '__fish_seen_subcommand_from root' -l print -d 'print the resolved repository root path explicitly'
@@ -428,7 +456,6 @@ complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_b
 
 ${hookLines}
 
-complete -c gji -n '__fish_seen_subcommand_from warp' -s n -l new -d 'create a new worktree in a registered repo'
 complete -c gji -n '__fish_seen_subcommand_from warp' -l print -d 'print the resolved worktree path without changing directory'
 complete -c gji -n '__fish_seen_subcommand_from warp' -l json -d 'emit JSON on success or error instead of human-readable output'
 
@@ -516,7 +543,13 @@ fi
 
 case "\${words[2]}" in
   new)
-    _arguments '--detached[create a detached worktree without a branch]' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    _arguments '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--no-fetch[skip refreshing the remote default branch before creating the new branch]' '--take[move current uncommitted changes into the new worktree]' '--copy[copy current uncommitted changes instead of moving them (requires --take)]' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    ;;
+  done)
+    _arguments '--force[remove dirty or unmerged worktrees without prompting]' '--keep-branch[remove the worktree but preserve its branch]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    ;;
+  undo)
+    _arguments '--list[list recoverable operations]' '--json[emit JSON on success or error instead of human-readable output]' '2:id: '
     ;;
   init)
     _arguments '--write[write the integration to the shell config file]' '--json[emit a JSON error in non-interactive mode]' '2:shell:(${shells})'
@@ -547,10 +580,10 @@ case "\${words[2]}" in
     _arguments '--json[print history as JSON]'
     ;;
   open)
-    _arguments '--editor[editor CLI to use (code, cursor, zed, windsurf, subl, …)]:editor:' '--save[save the chosen editor to global config]' '--workspace[generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)]' '2:branch:->worktrees'
+    _arguments '--editor[editor CLI to use (code, cursor, zed, windsurf, subl, …)]:editor:' '--select[choose a worktree with the interactive selector]' '--save[save the chosen editor to global config]' '--workspace[generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)]' '2:branch:->worktrees'
     ;;
   go|jump)
-    _arguments '--print[print the resolved worktree path explicitly]' '2:branch:->worktrees'
+    _arguments '--root[navigate to the main repository root]' '--print[print the resolved worktree path explicitly]' '--json[emit JSON for an existing worktree destination]' '2:branch:->worktrees'
     ;;
   root)
     _arguments '--print[print the resolved repository root path explicitly]'
@@ -577,7 +610,7 @@ case "\${words[2]}" in
     _arguments "2:hook:(${hooks})"
     ;;
   warp)
-    _arguments '(-n --new)'{-n,--new}'[create a new worktree in a registered repo]:branch:' '--print[print the resolved worktree path without changing directory]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    _arguments '--print[print the resolved worktree path without changing directory]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
     ;;
   config)
     if (( CURRENT == 3 )); then

package/dist/sync-directories.d.ts

@@ -0,0 +1,33 @@
+import { type CloneFailureStore } from "./clone-failure-store.js";
+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 emitCachedFailureWarnings: boolean;
+    readonly measureCloneSize: boolean;
+    write(message: string): void;
+    cloned(directory: ClonedDirectory): void;
+    skipped?(directory: {
+        dir: string;
+        reason: string;
+    }): void;
+}
+export interface SyncDirectoryExecutionOptions {
+    cloneDirectory: CloneDirectory;
+    failureStore?: CloneFailureStore;
+    repoRoot: string;
+    reporter: SyncDirectoryReporter;
+}
+export declare function executeSyncDirectoryPlan(plan: readonly SyncDirectoryPlan[], options: SyncDirectoryExecutionOptions): Promise<SyncDirectoryOutcome[]>;

package/dist/sync-directories.js

@@ -0,0 +1,97 @@
+import { cloneFailureScope, defaultCloneFailureStore, } from "./clone-failure-store.js";
+import { isCloneDestinationExistsError, isCloneInProgressError, isCloneUnsupportedError, } from "./dir-clone.js";
+import { inspectDestination } from "./safe-destination.js";
+export async function executeSyncDirectoryPlan(plan, options) {
+    const failureStore = options.failureStore ?? defaultCloneFailureStore;
+    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 failureScope = await cloneFailureScope(entry.source, entry.destination);
+        if (await failureStore.isCached(options.repoRoot, entry.directory, failureScope)) {
+            if (options.reporter.emitCachedFailureWarnings ||
+                options.reporter.skipped) {
+                recordSkipped(outcomes, options.reporter, entry.directory, "copy-on-write failure cached");
+            }
+            else {
+                options.reporter.write(`syncDirs: previous copy-on-write failure cached, skipped ${entry.directory}\n`);
+                recordSkipped(outcomes, options.reporter, entry.directory, "copy-on-write failure cached", false);
+            }
+            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);
+            if (isCloneUnsupportedError(error)) {
+                await failureStore.cache(options.repoRoot, entry.directory, reason, failureScope);
+            }
+            recordSkipped(outcomes, options.reporter, entry.directory, reason);
+            continue;
+        }
+        await failureStore.clear(options.repoRoot, entry.directory, failureScope);
+        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, notify = true) {
+    outcomes.push({ kind: "skipped", dir, reason });
+    if (notify) {
+        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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,128 @@
+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);
+}

package/dist/sync.js

@@ -1,5 +1,5 @@
 import { loadEffectiveConfig } from "./config.js";
-import { isDirtyWorktree, resolveRemoteDefaultBranch, runGit } from "./git.js";
+import { isDirtyWorktree, resolveRemoteBase, runGit, } from "./git.js";
 import { comparePaths } from "./paths.js";
 import { detectRepository, listWorktrees } from "./repo.js";
 export async function runSyncCommand(options) {
@@ -7,11 +7,9 @@ export async function runSyncCommand(options) {
     const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
     const worktrees = await listWorktrees(options.cwd);
     const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
-    let defaultBranch;
+    let remoteBase;
     try {
-        defaultBranch =
-            resolveConfiguredString(config.syncDefaultBranch) ??
-                (await resolveRemoteDefaultBranch(repository.repoRoot, remote));
+        remoteBase = await resolveRemoteBase(repository.repoRoot, remote, resolveConfiguredString(config.syncDefaultBranch) ?? undefined);
     }
     catch {
         emitError(options, `Unable to reach remote '${remote}'`);
@@ -20,7 +18,7 @@ export async function runSyncCommand(options) {
         }
         return 1;
     }
-    if (!defaultBranch) {
+    if (!remoteBase) {
         emitError(options, "Unable to determine the default branch for sync.");
         if (!options.json) {
             options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>\n`);
@@ -50,15 +48,11 @@ export async function runSyncCommand(options) {
     }
     const updatedWorktrees = [];
     for (const worktree of targetWorktrees) {
-        if (worktree.branch === defaultBranch) {
-            await runGit(worktree.path, [
-                "merge",
-                "--ff-only",
-                `${remote}/${defaultBranch}`,
-            ]);
+        if (worktree.branch === remoteBase.branch) {
+            await runGit(worktree.path, ["merge", "--ff-only", remoteBase.ref]);
         }
         else {
-            await runGit(worktree.path, ["rebase", `${remote}/${defaultBranch}`]);
+            await runGit(worktree.path, ["rebase", remoteBase.ref]);
         }
         updatedWorktrees.push(worktree);
         if (!options.json) {

package/dist/undo.d.ts

@@ -0,0 +1,36 @@
+import { type WorktreeEntry } from "./repo.js";
+export type UndoOperation = "remove" | "clean" | "done";
+export interface UndoEntry {
+    branch: string | null;
+    headSha: string;
+    path: string;
+    upstream: string | null;
+    wasDirty: boolean;
+}
+export interface UndoRecord {
+    id: string;
+    op: UndoOperation;
+    repoRoot: string;
+    timestamp: number;
+    entries: UndoEntry[];
+}
+export interface UndoRestoreResult {
+    restored: UndoEntry[];
+    failed: Array<UndoEntry & {
+        message: string;
+    }>;
+}
+export interface UndoCommandOptions {
+    cwd: string;
+    id?: string;
+    list?: boolean;
+    json?: boolean;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function undoLogPath(home?: string): string;
+export declare function loadUndoRecords(home?: string): Promise<UndoRecord[]>;
+export declare function recordUndoOperation(op: UndoOperation, repoRoot: string, worktrees: WorktreeEntry[], home?: string): Promise<UndoRecord | null>;
+export declare function finalizeUndoOperation(record: UndoRecord, removedWorktrees: WorktreeEntry[], home?: string): Promise<void>;
+export declare function restoreUndoRecord(record: UndoRecord, home?: string): Promise<UndoRestoreResult>;
+export declare function runUndoCommand(options: UndoCommandOptions): Promise<number>;