@solaqua/gji 0.9.0 → 0.11.0

package/dist/undo.js

@@ -0,0 +1,392 @@
+import { access, mkdir, open, readFile, rename, stat, unlink, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
+import { isDirtyWorktree, runGit } from "./git.js";
+import { isHeadless } from "./headless.js";
+import { detectRepository } from "./repo.js";
+const MAX_UNDO_RECORDS = 20;
+const UNDO_LOCK_STALE_AFTER_MS = 60_000;
+const UNDO_LOCK_RETRY_DELAY_MS = 5;
+const UNDO_LOCK_WAIT_TIMEOUT_MS = UNDO_LOCK_STALE_AFTER_MS + UNDO_LOCK_RETRY_DELAY_MS;
+const undoLogQueues = new Map();
+export function undoLogPath(home = homedir()) {
+    const configured = process.env.GJI_CONFIG_DIR;
+    return join(configured ? resolve(configured) : join(home, GLOBAL_CONFIG_DIRECTORY), "undo-log.json");
+}
+export async function loadUndoRecords(home = homedir()) {
+    try {
+        const parsed = JSON.parse(await readFile(undoLogPath(home), "utf8"));
+        return Array.isArray(parsed) ? parsed.filter(isUndoRecord) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function recordUndoOperation(op, repoRoot, worktrees, home = homedir()) {
+    const entries = [];
+    for (const worktree of worktrees) {
+        try {
+            const headSha = await runGit(worktree.path, ["rev-parse", "HEAD"]);
+            let upstream = null;
+            try {
+                upstream = await runGit(worktree.path, [
+                    "rev-parse",
+                    "--abbrev-ref",
+                    "--symbolic-full-name",
+                    "@{u}",
+                ]);
+            }
+            catch {
+                /* no upstream */
+            }
+            entries.push({
+                branch: worktree.branch,
+                headSha,
+                path: worktree.path,
+                upstream,
+                wasDirty: await isDirtyWorktree(worktree.path).catch(() => false),
+            });
+        }
+        catch {
+            /* candidate disappeared before the destructive operation */
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    const timestamp = Date.now();
+    const record = {
+        id: `u-${formatTimestamp(timestamp)}-${Math.random().toString(36).slice(2, 6)}`,
+        op,
+        repoRoot,
+        timestamp,
+        entries,
+    };
+    return enqueueUndoLogWrite(home, async () => {
+        const existing = await loadUndoRecords(home);
+        await writeUndoRecords(home, [record, ...existing].slice(0, MAX_UNDO_RECORDS));
+        return record;
+    });
+}
+export async function finalizeUndoOperation(record, removedWorktrees, home = homedir()) {
+    const removedPaths = new Set(removedWorktrees.map((worktree) => worktree.path));
+    await enqueueUndoLogWrite(home, async () => {
+        const records = await loadUndoRecords(home);
+        const remaining = records.flatMap((candidate) => {
+            if (candidate.id !== record.id)
+                return [candidate];
+            const entries = candidate.entries.filter((entry) => removedPaths.has(entry.path));
+            return entries.length === 0 ? [] : [{ ...candidate, entries }];
+        });
+        await writeUndoRecords(home, remaining);
+    });
+}
+export async function restoreUndoRecord(record, home = homedir()) {
+    const restored = [];
+    const failed = [];
+    const unresolved = [];
+    for (const entry of record.entries) {
+        try {
+            const upstreamFailure = await restoreUndoEntry(record.repoRoot, entry);
+            restored.push(entry);
+            if (upstreamFailure) {
+                failed.push({ ...entry, message: upstreamFailure });
+                unresolved.push(entry);
+            }
+        }
+        catch (error) {
+            failed.push({ ...entry, message: toMessage(error) });
+            unresolved.push(entry);
+        }
+    }
+    await enqueueUndoLogWrite(home, async () => {
+        const records = await loadUndoRecords(home);
+        const remaining = records.flatMap((candidate) => {
+            if (candidate.id !== record.id)
+                return [candidate];
+            if (unresolved.length === 0)
+                return [];
+            return [{ ...candidate, entries: unresolved }];
+        });
+        await writeUndoRecords(home, remaining);
+    });
+    return { restored, failed };
+}
+export async function runUndoCommand(options) {
+    if (await hasMalformedUndoLog())
+        options.stderr("Warning: undo journal is invalid; starting with an empty journal\n");
+    const records = await loadUndoRecords();
+    if (options.list) {
+        if (options.json)
+            options.stdout(`${JSON.stringify(records, null, 2)}\n`);
+        else if (records.length === 0)
+            options.stdout("nothing to undo\n");
+        else
+            for (const record of records)
+                options.stdout(`${record.id} ${record.op} ${record.entries.length} worktree${record.entries.length === 1 ? "" : "s"} ${new Date(record.timestamp).toISOString()}\n`);
+        return 0;
+    }
+    if (records.length === 0) {
+        if (options.json)
+            options.stdout(`${JSON.stringify({ restored: [], failed: [] }, null, 2)}\n`);
+        else
+            options.stdout("nothing to undo\n");
+        return 0;
+    }
+    let repoRoot = null;
+    try {
+        repoRoot = (await detectRepository(options.cwd)).repoRoot;
+    }
+    catch {
+        /* use latest globally */
+    }
+    let record;
+    if (options.id) {
+        record = records.find((candidate) => candidate.id === options.id);
+    }
+    else if (repoRoot !== null && records[0]?.repoRoot !== repoRoot) {
+        const latest = records[0];
+        const message = `latest undo record belongs to ${latest.repoRoot}; use --id to select it`;
+        if (options.json || isHeadless())
+            return emitUndoError(options, message);
+        const choice = await confirm({
+            message: `${message}. Restore it anyway?`,
+            active: "Yes",
+            inactive: "No",
+            initialValue: false,
+        });
+        if (isCancel(choice) || !choice)
+            return emitUndoError(options, "Aborted");
+        record = latest;
+    }
+    else {
+        record = repoRoot
+            ? records.find((candidate) => candidate.repoRoot === repoRoot)
+            : records[0];
+    }
+    if (!record)
+        return emitUndoError(options, `undo record not found: ${options.id}`);
+    const result = await restoreUndoRecord(record);
+    if (options.json)
+        options.stdout(`${JSON.stringify({ restored: result.restored.map((entry) => ({ branch: entry.branch, path: entry.path })), failed: result.failed.map((entry) => ({ branch: entry.branch, path: entry.path, error: entry.message })) }, null, 2)}\n`);
+    else {
+        for (const entry of result.restored) {
+            options.stdout(`✓ restored ${entry.branch ?? "detached worktree"} at ${entry.path}\n`);
+            if (entry.wasDirty)
+                options.stderr("note: uncommitted changes at deletion time were not preserved\n");
+        }
+        for (const entry of result.failed)
+            options.stderr(`Failed to restore ${entry.branch ?? entry.path}: ${entry.message}\n`);
+    }
+    return result.failed.length === 0 ? 0 : 1;
+}
+async function hasMalformedUndoLog() {
+    try {
+        const parsed = JSON.parse(await readFile(undoLogPath(), "utf8"));
+        return (!Array.isArray(parsed) || parsed.some((entry) => !isUndoRecord(entry)));
+    }
+    catch (error) {
+        return (error instanceof Error &&
+            "code" in error &&
+            error.code !== "ENOENT");
+    }
+}
+async function restoreUndoEntry(repoRoot, entry) {
+    try {
+        await access(entry.path);
+        throw new Error(`path already exists: ${entry.path}`);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.startsWith("path already exists:"))
+            throw error;
+    }
+    if (entry.branch === null) {
+        await assertCommitExists(repoRoot, entry.headSha);
+        await runGit(repoRoot, [
+            "worktree",
+            "add",
+            "--detach",
+            entry.path,
+            entry.headSha,
+        ]);
+        return null;
+    }
+    let branchExists = false;
+    let existingUpstream = null;
+    try {
+        await runGit(repoRoot, [
+            "show-ref",
+            "--verify",
+            `refs/heads/${entry.branch}`,
+        ]);
+        branchExists = true;
+    }
+    catch {
+        /* branch was deleted */
+    }
+    if (branchExists) {
+        const currentSha = await runGit(repoRoot, ["rev-parse", entry.branch]);
+        if (currentSha !== entry.headSha)
+            throw new Error(`branch ${entry.branch} already exists at a different commit`);
+        existingUpstream = await runGit(repoRoot, [
+            "rev-parse",
+            "--abbrev-ref",
+            "--symbolic-full-name",
+            `${entry.branch}@{u}`,
+        ]).catch(() => null);
+        if (entry.upstream &&
+            existingUpstream &&
+            existingUpstream !== entry.upstream)
+            throw new Error(`branch ${entry.branch} already tracks ${existingUpstream}; refusing to overwrite it`);
+    }
+    else {
+        await assertCommitExists(repoRoot, entry.headSha);
+        await runGit(repoRoot, ["branch", entry.branch, entry.headSha]);
+    }
+    try {
+        await runGit(repoRoot, ["worktree", "add", entry.path, entry.branch]);
+    }
+    catch (error) {
+        if (!branchExists) {
+            try {
+                await runGit(repoRoot, ["branch", "-D", entry.branch]);
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        throw error;
+    }
+    if (entry.upstream) {
+        if (existingUpstream === entry.upstream)
+            return null;
+        try {
+            await runGit(repoRoot, [
+                "branch",
+                "--set-upstream-to",
+                entry.upstream,
+                entry.branch,
+            ]);
+        }
+        catch (error) {
+            return `could not restore upstream ${entry.upstream}: ${toRestoreMessage(error)}`;
+        }
+    }
+    return null;
+}
+async function assertCommitExists(repoRoot, headSha) {
+    try {
+        await runGit(repoRoot, ["cat-file", "-e", `${headSha}^{commit}`]);
+    }
+    catch {
+        throw new Error("commit no longer exists (gc'd) — cannot restore");
+    }
+}
+async function enqueueUndoLogWrite(home, operation) {
+    const path = undoLogPath(home);
+    await mkdir(dirname(path), { recursive: true });
+    const previous = undoLogQueues.get(path) ?? Promise.resolve();
+    const runLocked = async () => {
+        const release = await acquireUndoLogLock(path);
+        try {
+            return await operation();
+        }
+        finally {
+            await release();
+        }
+    };
+    const current = previous.then(runLocked, runLocked);
+    const settled = current.then(() => undefined, () => undefined);
+    undoLogQueues.set(path, settled);
+    try {
+        return await current;
+    }
+    finally {
+        if (undoLogQueues.get(path) === settled)
+            undoLogQueues.delete(path);
+    }
+}
+async function acquireUndoLogLock(path) {
+    const lockPath = `${path}.lock`;
+    const deadline = Date.now() + UNDO_LOCK_WAIT_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        try {
+            const handle = await open(lockPath, "wx");
+            return async () => {
+                await handle.close();
+                await unlink(lockPath).catch(() => undefined);
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+                throw error;
+            const lockStat = await stat(lockPath).catch(() => null);
+            if (lockStat && Date.now() - lockStat.mtimeMs > UNDO_LOCK_STALE_AFTER_MS)
+                await unlink(lockPath).catch(() => undefined);
+            const remainingMs = deadline - Date.now();
+            if (remainingMs > 0)
+                await new Promise((resolve) => setTimeout(resolve, Math.min(UNDO_LOCK_RETRY_DELAY_MS, remainingMs)));
+        }
+    }
+    throw new Error("timed out waiting for the undo journal lock");
+}
+async function writeUndoRecords(home, records) {
+    const path = undoLogPath(home);
+    await mkdir(dirname(path), { recursive: true });
+    const temporaryPath = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+        await writeFile(temporaryPath, `${JSON.stringify(records, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx",
+        });
+        await rename(temporaryPath, path);
+    }
+    finally {
+        await unlink(temporaryPath).catch(() => undefined);
+    }
+}
+function isUndoRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const c = value;
+    return (typeof c.id === "string" &&
+        (c.op === "remove" || c.op === "clean" || c.op === "done") &&
+        typeof c.repoRoot === "string" &&
+        typeof c.timestamp === "number" &&
+        Array.isArray(c.entries) &&
+        c.entries.every(isUndoEntry));
+}
+function isUndoEntry(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const c = value;
+    return ((c.branch === null || typeof c.branch === "string") &&
+        typeof c.headSha === "string" &&
+        typeof c.path === "string" &&
+        (c.upstream === null || typeof c.upstream === "string") &&
+        typeof c.wasDirty === "boolean");
+}
+function formatTimestamp(timestamp) {
+    return new Date(timestamp)
+        .toISOString()
+        .replace(/[-:TZ.]/g, "")
+        .slice(0, 12);
+}
+function toMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toRestoreMessage(error) {
+    const message = toMessage(error);
+    return /bad object|unknown revision|not a valid object name/i.test(message)
+        ? "commit no longer exists (gc'd) — cannot restore"
+        : message;
+}
+function emitUndoError(options, message) {
+    if (options.json)
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+    else
+        options.stderr(`${message}\n`);
+    return 1;
+}

package/dist/warp.d.ts

@@ -1,9 +1,9 @@
+import { type NavigationRepository } from "./navigation-output.js";
 import { type QueryWorktreePullRequests } from "./worktree-picker.js";
 export interface WarpCommandOptions {
     branch?: string;
     cwd: string;
     json?: boolean;
-    newWorktree?: boolean;
     queryPullRequests?: QueryWorktreePullRequests;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
@@ -12,11 +12,13 @@ export declare function runWarpCommand(options: WarpCommandOptions): Promise<num
 export interface WarpTarget {
     branch: string | null;
     path: string;
+    repository: NavigationRepository;
 }
 export declare function resolveWarpTarget(options: {
     branch?: string;
     commandName?: string;
     cwd: string;
+    excludeRepoRoot?: string;
     json?: boolean;
     queryPullRequests?: QueryWorktreePullRequests;
     stderr: (chunk: string) => void;

package/dist/warp.js

@@ -1,24 +1,13 @@
-import { realpath } from "node:fs/promises";
-import { basename, resolve } from "node:path";
-import { isCancel, select } from "@clack/prompts";
 import { isHeadless } from "./headless.js";
 import { recordWorktreeUsage } from "./history.js";
-import { runNewCommand } from "./new.js";
-import { detectRepository, listWorktrees } from "./repo.js";
+import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
+import { detectRepository } from "./repo.js";
 import { loadRegistry } from "./repo-registry.js";
 import { writeShellOutput } from "./shell-handoff.js";
 import { buildWorktreePromptEntries, promptForSingleWorktree, resolveWorktreeQuery, } from "./worktree-picker.js";
+import { listRegisteredWorktreeSources } from "./worktree-sources.js";
 const WARP_OUTPUT_FILE_ENV = "GJI_WARP_OUTPUT_FILE";
 export async function runWarpCommand(options) {
-    if (options.newWorktree) {
-        const registry = await loadRegistry();
-        if (registry.length === 0) {
-            options.stderr("gji warp: no repos registered yet.\n" +
-                "Use any gji command in a repository to register it automatically.\n");
-            return 1;
-        }
-        return runWarpNew(options, registry);
-    }
     return runWarpNavigate(options);
 }
 async function runWarpNavigate(options) {
@@ -42,95 +31,13 @@ async function runWarpNavigate(options) {
         return 1;
     if (options.json) {
         // json callers use the output programmatically; skip history and shell handoff.
-        options.stdout(`${JSON.stringify({ branch: target.branch, path: target.path }, null, 2)}\n`);
+        options.stdout(`${JSON.stringify(createNavigationTarget(target.repository, target.path, target.branch), null, 2)}\n`);
         return 0;
     }
     await recordWorktreeUsage(target.path, target.branch);
     await writeShellOutput(WARP_OUTPUT_FILE_ENV, target.path, options.stdout);
     return 0;
 }
-async function runWarpNew(options, registry) {
-    const deduplicatedRegistry = await deduplicateRegistryForNew(registry);
-    let targetRepoRoot;
-    if (deduplicatedRegistry.length === 1) {
-        targetRepoRoot = deduplicatedRegistry[0].path;
-    }
-    else {
-        if (isHeadless()) {
-            options.stderr("gji warp: repo argument is required in non-interactive mode (GJI_NO_TUI=1)\n");
-            return 1;
-        }
-        const choice = await select({
-            message: "Create worktree in which repo?",
-            options: deduplicatedRegistry.map((entry) => ({
-                value: entry.path,
-                label: entry.name,
-                hint: entry.path,
-            })),
-        });
-        if (isCancel(choice)) {
-            options.stderr("Aborted\n");
-            return 1;
-        }
-        targetRepoRoot = choice;
-    }
-    if (options.json) {
-        return runNewCommand({
-            branch: options.branch,
-            cwd: targetRepoRoot,
-            json: true,
-            stderr: options.stderr,
-            stdout: options.stdout,
-        });
-    }
-    // runNewCommand writes the created path to options.stdout via writeShellOutput.
-    // Since GJI_NEW_OUTPUT_FILE is not set in the warp shell context, it falls
-    // through to our captured stdout, giving us the path to hand off.
-    let capturedPath = "";
-    const captureStdout = (chunk) => {
-        capturedPath = chunk.trim();
-    };
-    const exitCode = await runNewCommand({
-        branch: options.branch,
-        cwd: targetRepoRoot,
-        stderr: options.stderr,
-        stdout: captureStdout,
-    });
-    if (exitCode !== 0) {
-        return exitCode;
-    }
-    if (!capturedPath) {
-        options.stderr("gji warp: could not determine new worktree path\n");
-        return 1;
-    }
-    await writeShellOutput(WARP_OUTPUT_FILE_ENV, capturedPath, options.stdout);
-    return 0;
-}
-async function deduplicateRegistryForNew(registry) {
-    const deduplicated = [];
-    const seenPaths = new Set();
-    for (const entry of registry) {
-        const canonicalPath = await canonicalizeRepoPath(entry.path);
-        if (seenPaths.has(canonicalPath)) {
-            continue;
-        }
-        seenPaths.add(canonicalPath);
-        deduplicated.push({
-            ...entry,
-            name: basename(canonicalPath),
-            path: canonicalPath,
-        });
-    }
-    return deduplicated;
-}
-async function canonicalizeRepoPath(repoPath) {
-    try {
-        return await realpath(repoPath);
-    }
-    catch {
-        return resolve(repoPath);
-    }
-}
 export async function resolveWarpTarget(options) {
     const cmd = options.commandName ?? "gji";
     const emitError = (message, hint) => {
@@ -144,35 +51,18 @@ export async function resolveWarpTarget(options) {
         }
     };
     const registry = await loadRegistry();
-    const currentRoot = await detectRepository(options.cwd)
-        .then((repository) => repository.currentRoot)
-        .catch(() => null);
     if (registry.length === 0) {
         emitError("not in a git repository and no repos registered yet.", "Use any gji command inside a repository to register it.\n");
         return null;
     }
-    const results = await Promise.allSettled(registry.map(async (entry) => {
-        const worktrees = await listWorktrees(entry.path);
-        return { repoName: entry.name, repoRoot: entry.path, worktrees };
-    }));
-    const allItems = [];
-    for (const result of results) {
-        if (result.status === "rejected")
-            continue;
-        const { repoName, repoRoot, worktrees } = result.value;
-        for (const worktree of worktrees) {
-            allItems.push({
-                repoRoot,
-                repoName,
-                worktree: {
-                    ...worktree,
-                    isCurrent: currentRoot !== null && worktree.path === currentRoot,
-                },
-            });
-        }
-    }
+    let skippedRegisteredRepos = 0;
+    const allItems = (await listRegisteredWorktreeSources(options.cwd, () => {
+        skippedRegisteredRepos++;
+    })).filter((item) => item.repoRoot !== options.excludeRepoRoot);
     if (allItems.length === 0) {
-        emitError("no accessible worktrees found in any registered repo.");
+        emitError("no accessible worktrees found in any registered repo.", skippedRegisteredRepos > 0
+            ? "Hint: Run 'gji doctor' to inspect stale repository entries.\n"
+            : undefined);
         return null;
     }
     const promptSources = allItems.map((item) => ({
@@ -183,12 +73,20 @@ export async function resolveWarpTarget(options) {
     if (options.branch) {
         const match = resolveWorktreeQuery(promptSources, options.branch);
         if (!match) {
-            emitError(`no worktree found matching: ${options.branch}`);
+            emitError(`no worktree found matching: ${options.branch}`, skippedRegisteredRepos > 0
+                ? "Hint: Run 'gji doctor' to inspect stale repository entries.\n"
+                : undefined);
             return null;
         }
-        return { branch: match.worktree.branch, path: match.worktree.path };
+        return {
+            branch: match.worktree.branch,
+            path: match.worktree.path,
+            repository: createNavigationRepository(match.repoName, match.repoRoot ??
+                (await detectRepository(match.worktree.path)).repoRoot),
+        };
     }
     const promptEntries = await buildWorktreePromptEntries(promptSources, {
+        metadata: "fast",
         queryPullRequests: options.queryPullRequests,
     });
     const path = await promptForWarpTarget(promptEntries);
@@ -196,8 +94,17 @@ export async function resolveWarpTarget(options) {
         options.stderr("Aborted\n");
         return null;
     }
-    const chosen = promptEntries.find((item) => item.path === path);
-    return { branch: chosen?.branch ?? null, path };
+    const chosenSource = promptSources.find((item) => item.worktree.path === path);
+    if (chosenSource === undefined) {
+        emitError("selected worktree is no longer registered");
+        return null;
+    }
+    return {
+        branch: chosenSource.worktree.branch,
+        path,
+        repository: createNavigationRepository(chosenSource.repoName, chosenSource.repoRoot ??
+            (await detectRepository(chosenSource.worktree.path)).repoRoot),
+    };
 }
 async function promptForWarpTarget(items) {
     return promptForSingleWorktree("Warp to a worktree", items);

package/dist/worktree-bootstrap.d.ts

@@ -0,0 +1,35 @@
+import type { EffectiveGjiConfig } from "./config.js";
+import { type BootstrapCommandRunner, type BootstrapEvent, type DependencyBootstrapReport, type DependencyBootstrapReporter } from "./dependency-bootstrap.js";
+import type { DependencyBootstrapPolicyResolution } from "./dependency-bootstrap-prompt.js";
+import { type CloneDirectory } from "./dir-clone.js";
+import { type InstallPromptDependencies } from "./install-prompt.js";
+import { type ClonedDirectory, type SyncDirectoryReporter } from "./sync-directories.js";
+export type { ClonedDirectory as ClonedDir } from "./sync-directories.js";
+export interface WorktreeBootstrapOptions {
+    branch: string;
+    cloneDirectory?: CloneDirectory;
+    config: EffectiveGjiConfig;
+    currentRoot?: string;
+    dependencyDetectionRoot?: string;
+    installDependencies?: InstallPromptDependencies;
+    runCommand?: BootstrapCommandRunner;
+    commandStdout?: (chunk: string) => void;
+    commandStderr?: (chunk: string) => void;
+    dependencyBootstrapPolicy?: DependencyBootstrapPolicyResolution;
+    json?: boolean;
+    nonInteractive: boolean;
+    repoRoot: string;
+    reporter: SyncDirectoryReporter & DependencyBootstrapReporter;
+    worktreePath: string;
+}
+export interface WorktreeBootstrapResult {
+    clonedDirs: readonly ClonedDirectory[];
+    dependencyBootstrap: DependencyBootstrapReport;
+    ready: boolean;
+    syncFileFailures: readonly BootstrapEvent[];
+    skippedDirs: readonly {
+        dir: string;
+        reason: string;
+    }[];
+}
+export declare function bootstrapWorktree(options: WorktreeBootstrapOptions): Promise<WorktreeBootstrapResult>;