@solaqua/gji 0.10.0 → 0.12.0

package/dist/hooks.js

@@ -1,14 +1,14 @@
 import { spawn } from "node:child_process";
-export async function runHook(hookCmd, cwd, context, stderr) {
+export async function runHook(hookCmd, cwd, context, stderr, stdout = (chunk) => process.stdout.write(chunk)) {
     if (!hookCmd)
         return;
     if (Array.isArray(hookCmd)) {
-        await runArgvHook(hookCmd, cwd, context, stderr);
+        await runArgvHook(hookCmd, cwd, context, stderr, stdout);
         return;
     }
-    await runShellHook(hookCmd, cwd, context, stderr);
+    await runShellHook(hookCmd, cwd, context, stderr, stdout);
 }
-async function runArgvHook(hookCmd, cwd, context, stderr) {
+async function runArgvHook(hookCmd, cwd, context, stderr, stdout) {
     const [command, ...args] = hookCmd.map((arg) => interpolate(arg, context));
     if (!command) {
         stderr("gji: hook argv command must include a non-empty command\n");
@@ -18,9 +18,12 @@ async function runArgvHook(hookCmd, cwd, context, stderr) {
         const child = spawn(command, args, {
             cwd,
             shell: false,
-            stdio: ["ignore", "inherit", "pipe"],
+            stdio: ["ignore", "pipe", "pipe"],
             env: hookEnvironment(context),
         });
+        child.stdout.on("data", (chunk) => {
+            stdout(chunk.toString());
+        });
         child.stderr.on("data", (chunk) => {
             stderr(chunk.toString());
         });
@@ -36,15 +39,18 @@ async function runArgvHook(hookCmd, cwd, context, stderr) {
         });
     });
 }
-async function runShellHook(hookCmd, cwd, context, stderr) {
+async function runShellHook(hookCmd, cwd, context, stderr, stdout) {
     const interpolated = interpolate(hookCmd, context);
     await new Promise((resolve) => {
         const child = spawn(interpolated, {
             cwd,
             shell: true,
-            stdio: ["ignore", "inherit", "pipe"],
+            stdio: ["ignore", "pipe", "pipe"],
             env: hookEnvironment(context),
         });
+        child.stdout.on("data", (chunk) => {
+            stdout(chunk.toString());
+        });
         child.stderr.on("data", (chunk) => {
             stderr(chunk.toString());
         });
@@ -66,6 +72,9 @@ function hookEnvironment(context) {
         GJI_BRANCH: context.branch ?? "",
         GJI_PATH: context.path,
         GJI_REPO: context.repo,
+        ...(context.slot === null || context.slot === undefined
+            ? {}
+            : { GJI_SLOT: String(context.slot) }),
     };
 }
 function formatArgvHook(command, args) {
@@ -75,7 +84,10 @@ export function interpolate(template, context) {
     return template
         .replace(/\{\{branch\}\}/g, context.branch ?? "")
         .replace(/\{\{path\}\}/g, context.path)
-        .replace(/\{\{repo\}\}/g, context.repo);
+        .replace(/\{\{repo\}\}/g, context.repo)
+        .replace(/\{\{slot\}\}/g, context.slot === null || context.slot === undefined
+        ? ""
+        : String(context.slot));
 }
 export function extractHooks(config) {
     const raw = config.hooks;

package/dist/hub.d.ts

@@ -0,0 +1,31 @@
+import { type PullRequestInfo } from "./pull-requests.js";
+import { type WorktreeInfo } from "./worktree-info.js";
+export interface HubCommandOptions {
+    cwd: string;
+    columns?: number;
+    json?: boolean;
+    now?: number;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export interface HubCommandDependencies {
+    queryRepositoryPullRequests: (repoRoot: string) => Promise<PullRequestInfo[]>;
+}
+export interface HubWorktree extends WorktreeInfo {
+    lastUsedTimestamp: number | null;
+    pullRequests: PullRequestInfo[];
+}
+export interface HubRepository {
+    current: boolean;
+    name: string;
+    pullRequests: PullRequestInfo[];
+    root: string;
+    worktrees: HubWorktree[];
+}
+export interface HubData {
+    currentRepository: string | null;
+    repositories: HubRepository[];
+}
+export declare function buildHubData(cwd: string, dependencies?: Partial<HubCommandDependencies>): Promise<HubData>;
+export declare function runHubCommand(options: HubCommandOptions, dependencies?: Partial<HubCommandDependencies>): Promise<number>;
+export declare function formatHubOutput(data: HubData, columns?: number, now?: number): string;

package/dist/hub.js

@@ -0,0 +1,287 @@
+import { basename } from "node:path";
+import { loadHistory } from "./history.js";
+import { createPullRequestQuery, } from "./pull-requests.js";
+import { detectRepository } from "./repo.js";
+import { middleEllipsize, sanitizeTerminalText, terminalWidth, } from "./terminal-text.js";
+import { formatRelativeAge, formatUpstreamState, readWorktreeInfos, } from "./worktree-info.js";
+import { listDiscoverableWorktreeSources } from "./worktree-sources.js";
+const MAX_HUB_REPOSITORY_CONCURRENCY = 4;
+const defaultDependencies = {
+    queryRepositoryPullRequests: createPullRequestQuery().listOpenPullRequestsForRepository,
+};
+export async function buildHubData(cwd, dependencies = {}) {
+    const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ??
+        defaultDependencies.queryRepositoryPullRequests;
+    const currentRepository = await detectRepository(cwd).catch(() => null);
+    const history = await loadHistory();
+    const lastUsedByPath = new Map(history.map((entry) => [entry.path, entry.timestamp]));
+    const sources = await listDiscoverableWorktreeSources(cwd);
+    const groups = new Map();
+    for (const source of sources) {
+        if (!source.repoRoot)
+            continue;
+        const repoRoot = source.repoRoot;
+        const existing = groups.get(repoRoot);
+        if (existing) {
+            existing.sources.push(source);
+        }
+        else {
+            groups.set(repoRoot, {
+                name: source.repoName || basename(repoRoot),
+                sources: [source],
+            });
+        }
+    }
+    const repositories = await mapWithConcurrency([...groups.entries()], MAX_HUB_REPOSITORY_CONCURRENCY, async ([root, group]) => {
+        const infos = await readWorktreeInfos(group.sources.map((source) => source.worktree));
+        let pullRequests = [];
+        try {
+            pullRequests = await queryRepositoryPullRequests(root);
+        }
+        catch {
+            // PR metadata is optional. The hub remains useful when a provider is unavailable.
+        }
+        const worktrees = infos.map((info) => ({
+            ...info,
+            lastUsedTimestamp: lastUsedByPath.get(info.path) ?? null,
+            pullRequests: pullRequests.filter((pullRequest) => pullRequest.sourceBranch === info.branch),
+        }));
+        return {
+            current: currentRepository?.repoRoot === root,
+            name: group.name,
+            pullRequests,
+            root,
+            worktrees,
+        };
+    });
+    repositories.sort((left, right) => {
+        if (left.current !== right.current)
+            return left.current ? -1 : 1;
+        return left.name.localeCompare(right.name);
+    });
+    return {
+        currentRepository: currentRepository?.repoRoot ?? null,
+        repositories,
+    };
+}
+export async function runHubCommand(options, dependencies = {}) {
+    const data = await buildHubData(options.cwd, dependencies);
+    if (options.json) {
+        options.stdout(`${JSON.stringify(data, null, 2)}\n`);
+        return 0;
+    }
+    options.stdout(`${formatHubOutput(data, options.columns ?? process.stdout.columns ?? 80, options.now ?? Date.now())}\n`);
+    return 0;
+}
+export function formatHubOutput(data, columns = process.stdout.columns ?? 80, now = Date.now()) {
+    if (data.repositories.length === 0) {
+        return "No registered repositories. Run gji from a repository to add one.";
+    }
+    const lineWidth = Math.max(1, columns);
+    const allWorktrees = data.repositories.flatMap((repository) => repository.worktrees.map((worktree) => ({ repository, worktree })));
+    const attention = allWorktrees.filter(({ worktree }) => isActionable(worktree));
+    const current = allWorktrees.find(({ worktree }) => worktree.isCurrent) ?? null;
+    const next = chooseNextWorktree(allWorktrees);
+    const remainingAttention = attention.filter((entry) => entry !== current && entry !== next);
+    const quiet = allWorktrees.filter((entry) => entry !== current && entry !== next && !attention.includes(entry));
+    const recentOther = [...quiet]
+        .sort((left, right) => (right.worktree.lastCommitTimestamp ?? 0) -
+        (left.worktree.lastCommitTimestamp ?? 0))
+        .slice(0, 5);
+    const hiddenCount = quiet.length - recentOther.length;
+    const lines = [
+        `GJI  ${data.repositories.length} repositories · ${allWorktrees.length} worktrees${attention.length > 0 ? ` · ${attention.length} need attention` : ""}`,
+        "",
+    ];
+    if (data.repositories.length > 1) {
+        lines.push("REPOSITORIES");
+        for (const repository of data.repositories) {
+            lines.push(formatRepositorySummary(repository, lineWidth));
+        }
+        lines.push("");
+    }
+    if (current !== null) {
+        lines.push("CURRENT");
+        lines.push(...formatHubWorktree(current, lineWidth, "@", now));
+        lines.push("");
+    }
+    if (next !== null && next !== current) {
+        lines.push("NEXT");
+        lines.push(...formatHubWorktree(next, lineWidth, "›", now));
+        lines.push("");
+    }
+    if (remainingAttention.length > 0) {
+        lines.push("ATTENTION");
+        for (const entry of remainingAttention) {
+            lines.push(...formatHubWorktree(entry, lineWidth, "!", now));
+        }
+        lines.push("");
+    }
+    if (recentOther.length > 0) {
+        lines.push("OTHER");
+        for (const entry of recentOther) {
+            lines.push(...formatHubWorktree(entry, lineWidth, " ", now));
+        }
+        if (hiddenCount > 0) {
+            lines.push(`  ${hiddenCount} quiet worktree${hiddenCount === 1 ? "" : "s"} hidden`);
+        }
+        lines.push("");
+    }
+    if (next === null &&
+        remainingAttention.length === 0 &&
+        recentOther.length === 0) {
+        lines.push("No active worktrees.");
+    }
+    lines.push("Run `gji go <repo>/<branch>` to switch worktrees.");
+    return lines
+        .map((line) => terminalWidth(line) > lineWidth ? middleEllipsize(line, lineWidth) : line)
+        .join("\n")
+        .trimEnd();
+}
+function formatRepositorySummary(repository, lineWidth) {
+    const attentionCount = repository.worktrees.filter(isActionable).length;
+    const attention = attentionCount === 0 ? "healthy" : `${attentionCount} attention`;
+    const marker = repository.current ? "*" : " ";
+    return middleEllipsize(`${marker} ${repository.name} · ${repository.worktrees.length} worktree${repository.worktrees.length === 1 ? "" : "s"} · ${attention}`, lineWidth);
+}
+function chooseNextWorktree(entries) {
+    return ([...entries].sort((left, right) => {
+        const scoreDifference = nextWorktreeScore(right) - nextWorktreeScore(left);
+        if (scoreDifference !== 0)
+            return scoreDifference;
+        const lastUsedDifference = (right.worktree.lastUsedTimestamp ?? 0) -
+            (left.worktree.lastUsedTimestamp ?? 0);
+        if (lastUsedDifference !== 0)
+            return lastUsedDifference;
+        return ((right.worktree.lastCommitTimestamp ?? 0) -
+            (left.worktree.lastCommitTimestamp ?? 0));
+    })[0] ?? null);
+}
+function nextWorktreeScore(entry) {
+    const { worktree } = entry;
+    let score = worktree.isCurrent && (worktree.task !== null || isActionable(worktree))
+        ? 100
+        : 0;
+    if (worktree.task !== null)
+        score += 40;
+    if (worktree.status === "dirty")
+        score += 30;
+    if (worktree.upstream.kind === "stale")
+        score += 25;
+    if (worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0) {
+        score += 25;
+    }
+    if (worktree.pullRequests.length > 0)
+        score += 20;
+    if (worktree.lastUsedTimestamp !== null && worktree.lastUsedTimestamp > 0) {
+        score += 15;
+    }
+    return score;
+}
+function isActionable(worktree) {
+    return (worktree.status === "dirty" ||
+        worktree.upstream.kind === "stale" ||
+        (worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0) ||
+        worktree.pullRequests.length > 0);
+}
+function formatHubWorktree(entry, lineWidth, marker, now) {
+    const { repository, worktree } = entry;
+    const branch = worktree.branch ?? "(detached)";
+    const status = [
+        formatWorktreeHealth(worktree),
+        formatWorktreeUpstream(worktree),
+        worktree.pullRequests.length > 0
+            ? worktree.pullRequests
+                .map((pullRequest) => pullRequest.title
+                ? `#${pullRequest.number} ${formatHumanText(pullRequest.title, 60)}`
+                : `#${pullRequest.number}`)
+                .join(", ")
+            : null,
+        formatWorktreeActivity(worktree, now),
+    ]
+        .filter((value) => value !== null)
+        .join(" · ");
+    const task = worktree.task === null
+        ? null
+        : `task: ${formatHumanText(worktree.task, 80)}`;
+    const target = `${repository.name}/${branch}`;
+    const lines = [`${marker} ${middleEllipsize(target, lineWidth - 2)}`];
+    if (status.length > 0) {
+        lines.push(`  ${middleEllipsize(status, lineWidth - 2)}`);
+    }
+    if (task !== null) {
+        lines.push(`  ${middleEllipsize(task, lineWidth - 2)}`);
+    }
+    if (marker === "@" || marker === "›" || marker === "!") {
+        lines.push(`  ${middleEllipsize(nextAction(worktree), lineWidth - 2)}`);
+    }
+    return lines;
+}
+function formatWorktreeHealth(worktree) {
+    if (worktree.status === "dirty")
+        return "! dirty";
+    if (worktree.status === "unknown")
+        return "? health unknown";
+    return null;
+}
+function formatWorktreeUpstream(worktree) {
+    if (worktree.upstream.kind === "stale")
+        return "! stale upstream";
+    if (worktree.upstream.kind === "tracked" &&
+        (worktree.upstream.behind > 0 || worktree.upstream.ahead > 0)) {
+        return formatUpstreamState(worktree.upstream);
+    }
+    return null;
+}
+function formatWorktreeActivity(worktree, now) {
+    if (worktree.isCurrent)
+        return null;
+    const timestamps = [
+        worktree.lastUsedTimestamp ?? 0,
+        (worktree.lastCommitTimestamp ?? 0) * 1000,
+    ].filter((timestamp) => timestamp > 0);
+    if (timestamps.length === 0)
+        return null;
+    const latest = Math.max(...timestamps);
+    const ageSeconds = Math.floor((now - latest) / 1000);
+    if (ageSeconds < 24 * 60 * 60)
+        return null;
+    return `inactive ${formatRelativeAge(Math.floor(latest / 1000), Math.floor(now / 1000))}`;
+}
+function nextAction(worktree) {
+    if (worktree.isCurrent && worktree.task !== null) {
+        return "next: continue task";
+    }
+    if (worktree.status === "dirty") {
+        return "next: switch → inspect changes";
+    }
+    if (worktree.upstream.kind === "stale" ||
+        (worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0)) {
+        return "next: switch → sync";
+    }
+    const pullRequest = worktree.pullRequests[0];
+    if (pullRequest !== undefined) {
+        return `next: switch → open PR '#${pullRequest.number}'`;
+    }
+    return "next: switch worktree";
+}
+function formatHumanText(value, maxLength) {
+    const sanitized = sanitizeTerminalText(value);
+    return sanitized.length <= maxLength
+        ? sanitized
+        : `${sanitized.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function readNext() {
+        for (;;) {
+            const index = nextIndex++;
+            if (index >= items.length)
+                return;
+            results[index] = await mapper(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => readNext()));
+    return results;
+}

package/dist/init.js

@@ -12,49 +12,56 @@ import { SHELL_INTEGRATION_END_MARKER as END_MARKER, executableExists, hasShellI
 const ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 const SHELL_WRAPPED_COMMANDS = [
     {
-        bypassOptions: ["--help"],
+        bypassOptions: ["--help", "-h", "--json"],
         commandName: "new",
         envVar: "GJI_NEW_OUTPUT_FILE",
         names: ["new"],
         tempPrefix: "gji-new",
     },
     {
-        bypassOptions: ["--help"],
+        bypassOptions: ["--help", "-h", "--json"],
         commandName: "pr",
         envVar: "GJI_PR_OUTPUT_FILE",
         names: ["pr"],
         tempPrefix: "gji-pr",
     },
     {
-        bypassOptions: ["--print"],
+        bypassOptions: ["--print", "--help", "-h"],
         commandName: "back",
         envVar: "GJI_BACK_OUTPUT_FILE",
         names: ["back"],
         tempPrefix: "gji-back",
     },
     {
-        bypassOptions: ["--print"],
+        bypassOptions: ["--print", "--json", "--help", "-h"],
         commandName: "go",
         envVar: "GJI_GO_OUTPUT_FILE",
         names: ["go", "jump"],
         tempPrefix: "gji-go",
     },
     {
-        bypassOptions: ["--print"],
+        bypassOptions: ["--print", "--help", "-h"],
         commandName: "root",
         envVar: "GJI_ROOT_OUTPUT_FILE",
         names: ["root"],
         tempPrefix: "gji-root",
     },
     {
-        bypassOptions: ["--help"],
+        bypassOptions: ["--help", "-h", "--json"],
         commandName: "remove",
         envVar: "GJI_REMOVE_OUTPUT_FILE",
         names: ["remove", "rm"],
         tempPrefix: "gji-remove",
     },
     {
-        bypassOptions: ["--print", "--json"],
+        bypassOptions: ["--help", "-h", "--json"],
+        commandName: "done",
+        envVar: "GJI_DONE_OUTPUT_FILE",
+        names: ["done"],
+        tempPrefix: "gji-done",
+    },
+    {
+        bypassOptions: ["--print", "--json", "--help", "-h"],
         commandName: "warp",
         envVar: "GJI_WARP_OUTPUT_FILE",
         names: ["warp"],
@@ -405,16 +412,17 @@ function renderFishWrapper(command) {
     const nameCondition = nameTests.length === 1
         ? nameTests[0]
         : `begin; ${nameTests.join("; or ")}; end`;
-    const bypassTests = command.bypassOptions.map((opt) => `test $argv[1] = ${opt}`);
-    const bypassCondition = bypassTests.length === 1
-        ? bypassTests[0]
-        : `begin; ${bypassTests.join("; or ")}; end`;
+    const bypassBlock = `if test (count $argv) -gt 0
+        for arg in $argv
+            if ${command.bypassOptions.map((opt) => `test $arg = ${opt}`).join("; or ")}
+                command gji ${command.commandName} $argv
+                return $status
+            end
+        end
+    end`;
     return `if test (count $argv) -gt 0; and ${nameCondition}
     set -e argv[1]
-    if test (count $argv) -gt 0; and ${bypassCondition}
-        command gji ${command.commandName} $argv
-        return $status
-    end
+    ${bypassBlock}
 
     set -l output_file (mktemp -t ${command.tempPrefix}.XXXXXX)
     or return 1
@@ -434,15 +442,15 @@ function renderPosixWrapper(command) {
     const tests = command.names
         .map((name) => `[ "$1" = "${name}" ]`)
         .join(" || ");
-    const bypassTests = command.bypassOptions
-        .map((opt) => `[ "\${1:-}" = "${opt}" ]`)
-        .join(" || ");
+    const bypassBlock = `for arg do
+    if ${command.bypassOptions.map((opt) => `[ "$arg" = "${opt}" ]`).join(" || ")}; then
+      command gji ${command.commandName} "$@"
+      return $?
+    fi
+  done`;
     return `if ${tests}; then
   shift
-  if ${bypassTests}; then
-    command gji ${command.commandName} "$@"
-    return $?
-  fi
+  ${bypassBlock}
 
   local target
   local output_file

package/dist/install-prompt.d.ts

@@ -9,3 +9,4 @@ export interface InstallPromptDependencies {
     writeGlobalRepoConfigKey?: (repoRoot: string, key: string, value: unknown) => Promise<void>;
 }
 export declare function maybeRunInstallPrompt(worktreePath: string, repoRoot: string, config: GjiConfig, stderr: (chunk: string) => void, dependencies?: InstallPromptDependencies, nonInteractive?: boolean): Promise<void>;
+export declare const runInstallCommand: import("./command-runner.js").CommandRunner;

package/dist/install-prompt.js

@@ -1,5 +1,5 @@
-import { spawn } from "node:child_process";
 import { isCancel, select } from "@clack/prompts";
+import { runCommand } from "./command-runner.js";
 import { loadConfig, loadGlobalConfig, updateGlobalRepoConfigKey, updateLocalConfigKey, } from "./config.js";
 import { isHeadless } from "./headless.js";
 import { extractHooks } from "./hooks.js";
@@ -28,7 +28,7 @@ export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stde
         return;
     }
     if (choice === "yes" || choice === "always") {
-        const runner = dependencies.runInstallCommand ?? defaultRunInstallCommand;
+        const runner = dependencies.runInstallCommand ?? runInstallCommand;
         try {
             await runner(pm.installCommand, worktreePath, stderr);
         }
@@ -88,29 +88,7 @@ export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stde
         }
     }
 }
-async function defaultRunInstallCommand(command, cwd, stderr) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, {
-            cwd,
-            shell: true,
-            stdio: ["ignore", "inherit", "pipe"],
-        });
-        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", (err) => {
-            reject(err);
-        });
-    });
-}
+export const runInstallCommand = runCommand;
 async function defaultWriteConfigKey(root, key, value) {
     await updateLocalConfigKey(root, key, value);
 }

package/dist/ls.js

@@ -26,12 +26,15 @@ export function formatDetailedWorktreeTable(worktrees) {
         lastCommit: formatLastCommit(worktree.lastCommitTimestamp),
         path: worktree.path,
         status: worktree.status,
+        task: worktree.task,
         upstream: formatUpstreamState(worktree.upstream),
     }));
     const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
     const statusWidth = Math.max("STATUS".length, ...rows.map((row) => row.status.length));
     const upstreamWidth = Math.max("UPSTREAM".length, ...rows.map((row) => row.upstream.length));
     const lastCommitWidth = Math.max("LAST".length, ...rows.map((row) => row.lastCommit.length));
+    const hasTasks = rows.some((row) => row.task !== null);
+    const taskWidth = Math.max("TASK".length, ...rows.map((row) => row.task?.slice(0, 40).length ?? 0));
     const lines = [
         "  " +
             "BRANCH".padEnd(branchWidth, " ") +
@@ -41,6 +44,7 @@ export function formatDetailedWorktreeTable(worktrees) {
             "UPSTREAM".padEnd(upstreamWidth, " ") +
             " " +
             "LAST".padEnd(lastCommitWidth, " ") +
+            (hasTasks ? " " + "TASK".padEnd(taskWidth, " ") : "") +
             " PATH",
     ];
     for (const row of rows) {
@@ -48,7 +52,11 @@ export function formatDetailedWorktreeTable(worktrees) {
             `${row.branch.padEnd(branchWidth, " ")} ` +
             `${row.status.padEnd(statusWidth, " ")} ` +
             `${row.upstream.padEnd(upstreamWidth, " ")} ` +
-            `${row.lastCommit.padEnd(lastCommitWidth, " ")} ` +
+            `${row.lastCommit.padEnd(lastCommitWidth, " ")}` +
+            (hasTasks
+                ? ` ${(row.task?.slice(0, 40) ?? "").padEnd(taskWidth, " ")}`
+                : "") +
+            " " +
             row.path);
     }
     return lines.join("\n");

package/dist/navigation-output.d.ts

@@ -0,0 +1,11 @@
+export interface NavigationRepository {
+    name: string;
+    root: string;
+}
+export interface NavigationTarget {
+    branch: string | null;
+    path: string;
+    repository: NavigationRepository;
+}
+export declare function createNavigationTarget(repository: NavigationRepository, path: string, branch: string | null): NavigationTarget;
+export declare function createNavigationRepository(name: string, root: string): NavigationRepository;

package/dist/navigation-output.js

@@ -0,0 +1,6 @@
+export function createNavigationTarget(repository, path, branch) {
+    return { branch, path, repository };
+}
+export function createNavigationRepository(name, root) {
+    return { name, root };
+}

package/dist/new.d.ts

@@ -1,22 +1,34 @@
 import { type PathConflictChoice } from "./conflict.js";
-import { type InstallPromptDependencies } from "./install-prompt.js";
+import { type DependencyBootstrapPromptDependencies } from "./dependency-bootstrap-prompt.js";
+import { type CloneDirectory } from "./dir-clone.js";
+import type { InstallPromptDependencies } from "./install-prompt.js";
 export type { PathConflictChoice };
+export type NewWorktreeMode = "create" | "checkout" | "track";
 export interface NewCommandOptions {
     branch?: string;
+    copy?: boolean;
     cwd: string;
     detached?: boolean;
     dryRun?: boolean;
     editor?: string;
     fromCurrent?: boolean;
     force?: boolean;
+    noFetch?: boolean;
     json?: boolean;
+    mode?: NewWorktreeMode;
     open?: boolean;
+    outputEnv?: string;
+    remote?: string;
+    take?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
+    task?: string;
 }
-export interface NewCommandDependencies extends InstallPromptDependencies {
+export interface NewCommandDependencies extends InstallPromptDependencies, DependencyBootstrapPromptDependencies {
+    cloneDir: CloneDirectory;
     createBranchPlaceholder: () => string;
     promptForBranch: (placeholder: string) => Promise<string | null>;
+    promptForFetchFailure: (message: string) => Promise<boolean>;
     promptForPathConflict: (path: string) => Promise<PathConflictChoice>;
     spawnEditor: (cli: string, args: string[]) => Promise<void>;
 }