@solaqua/gji 0.10.0 → 0.12.0

package/dist/pr.js

@@ -1,16 +1,20 @@
 import { execFile } from "node:child_process";
 import { mkdir } from "node:fs/promises";
-import { basename, dirname } from "node:path";
+import { dirname } from "node:path";
 import { promisify } from "node:util";
-import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { createBootstrapReporter } from "./bootstrap-output.js";
+import { createDependencyBootstrapPreview, formatDependencyBootstrapPreview, } from "./bootstrap-preview.js";
+import { loadEffectiveConfigResult, resolveConfigString, } from "./config.js";
 import { pathExists, promptForPathConflict, } from "./conflict.js";
-import { syncFiles } from "./file-sync.js";
+import { resolveDependencyBootstrapPolicy, } from "./dependency-bootstrap-prompt.js";
+import { formatBytes } from "./format-bytes.js";
 import { isHeadless } from "./headless.js";
 import { recordWorktreeUsage } from "./history.js";
-import { extractHooks, runHook } from "./hooks.js";
-import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { createNavigationRepository, createNavigationTarget, } from "./navigation-output.js";
 import { detectRepository, resolveWorktreePath } from "./repo.js";
 import { writeShellOutput } from "./shell-handoff.js";
+import { estimateSyncDirectories } from "./sync-plan.js";
+import { bootstrapWorktree } from "./worktree-bootstrap.js";
 const execFileAsync = promisify(execFile);
 const PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
 export function parsePrInput(input) {
@@ -39,7 +43,23 @@ export function createPrCommand(dependencies = {}) {
             return 1;
         }
         const repository = await detectRepository(options.cwd);
-        const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
+        let config;
+        let dependencyBootstrapExplicit;
+        try {
+            const loaded = await loadEffectiveConfigResult(repository.repoRoot, undefined, options.json ? undefined : options.stderr);
+            config = loaded.config;
+            dependencyBootstrapExplicit = loaded.dependencyBootstrapExplicit;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+            }
+            else {
+                options.stderr(`gji pr: ${message}\n`);
+            }
+            return 1;
+        }
         const branchName = `pr/${prNumber}`;
         const remoteRef = `refs/remotes/origin/pull/${prNumber}/head`;
         const rawBasePath = resolveConfigString(config, "worktreePath");
@@ -55,25 +75,66 @@ export function createPrCommand(dependencies = {}) {
                 }
                 else {
                     options.stderr(`gji pr: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
-                    options.stderr(`Hint: Use 'gji remove pr/${prNumber}' or 'gji clean' to remove the existing worktree\n`);
+                    options.stderr(`Hint: Use 'gji done pr/${prNumber}' or 'gji clean' to remove the existing worktree\n`);
                 }
                 return 1;
             }
             const choice = await prompt(worktreePath);
             if (choice === "reuse") {
                 await recordWorktreeUsage(worktreePath, branchName);
-                await writeOutput(worktreePath, options.stdout);
+                await writeOutput(worktreePath, options.stdout, options.outputEnv);
                 return 0;
             }
             options.stderr(`Aborted because target worktree path already exists: ${worktreePath}\n`);
             return 1;
         }
+        let dependencyPolicy = {
+            mode: config.dependencyBootstrap ?? "off",
+            prompted: false,
+            source: dependencyBootstrapExplicit ? "explicit" : "default",
+        };
+        if (options.dryRun) {
+            dependencyPolicy = await resolveDependencyBootstrapPolicy({
+                currentRoot: repository.currentRoot,
+                repoRoot: repository.repoRoot,
+                worktreePath,
+            }, config, dependencyBootstrapExplicit, {
+                dependencies,
+                dryRun: true,
+                legacyInstallPromptConfigured: dependencies.promptForInstallChoice !== undefined,
+                nonInteractive: !!options.json,
+                stderr: options.stderr,
+            });
+            config = {
+                ...config,
+                dependencyBootstrap: dependencyPolicy.mode,
+            };
+        }
+        const dryRunSyncDirs = options.dryRun
+            ? await estimateSyncDirectories(repository.repoRoot, worktreePath, config.syncDirs ?? [])
+            : [];
+        const dryRunDependencyBootstrap = options.dryRun
+            ? await createDependencyBootstrapPreview(config.dependencyBootstrap ?? "off", {
+                currentRoot: repository.currentRoot,
+                repoRoot: repository.repoRoot,
+                cargoBuildCommand: config.dependencyBuildCommand,
+                worktreePath,
+            })
+            : undefined;
         if (options.dryRun) {
             if (options.json) {
-                options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath, dryRun: true }, null, 2)}\n`);
+                const output = {
+                    ...createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), worktreePath, branchName),
+                    dryRun: true,
+                };
+                if (dryRunSyncDirs.length > 0)
+                    output.syncDirs = dryRunSyncDirs;
+                if (dryRunDependencyBootstrap?.targets.length)
+                    output.dependencyBootstrap = dryRunDependencyBootstrap;
+                options.stdout(`${JSON.stringify(output, null, 2)}\n`);
             }
             else {
-                options.stdout(`Would create worktree at ${worktreePath} (branch: ${branchName})\n`);
+                options.stdout(`Would create worktree at ${worktreePath} (branch: ${branchName})\n${dryRunSyncDirs.map(({ dir, bytes }) => `Would clone ${dir} (${formatBytes(bytes)})\n`).join("")}${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`);
             }
             return 0;
         }
@@ -97,31 +158,75 @@ export function createPrCommand(dependencies = {}) {
             ? ["worktree", "add", worktreePath, branchName]
             : ["worktree", "add", "-b", branchName, worktreePath, remoteRef];
         await execFileAsync("git", worktreeArgs, { cwd: repository.repoRoot });
-        // Sync files from main worktree before afterCreate so synced files are available to install scripts.
-        const syncPatterns = Array.isArray(config.syncFiles)
-            ? config.syncFiles.filter((p) => typeof p === "string")
-            : [];
-        for (const pattern of syncPatterns) {
-            try {
-                await syncFiles(repository.repoRoot, worktreePath, [pattern]);
+        if (!dependencyBootstrapExplicit) {
+            dependencyPolicy = await resolveDependencyBootstrapPolicy({
+                currentRoot: repository.currentRoot,
+                detectionRoot: worktreePath,
+                repoRoot: repository.repoRoot,
+                worktreePath,
+            }, config, false, {
+                dependencies,
+                legacyInstallPromptConfigured: dependencies.promptForInstallChoice !== undefined,
+                nonInteractive: !!options.json,
+                stderr: options.stderr,
+            });
+            config = {
+                ...config,
+                dependencyBootstrap: dependencyPolicy.mode,
+            };
+        }
+        const bootstrap = await bootstrapWorktree({
+            branch: branchName,
+            cloneDirectory: dependencies.cloneDir,
+            config,
+            currentRoot: repository.currentRoot,
+            dependencyDetectionRoot: worktreePath,
+            nonInteractive: !!options.json,
+            repoRoot: repository.repoRoot,
+            reporter: createBootstrapReporter(options.stderr, !!options.json),
+            runCommand: dependencies.runInstallCommand,
+            commandStdout: options.json ? () => undefined : options.stdout,
+            commandStderr: options.json ? () => undefined : options.stderr,
+            json: options.json,
+            worktreePath,
+            installDependencies: dependencies,
+            dependencyBootstrapPolicy: dependencyPolicy,
+        });
+        if (!bootstrap.ready) {
+            const details = {
+                dependencyBootstrap: bootstrap.dependencyBootstrap,
+                path: worktreePath,
+                skipped: bootstrap.skippedDirs,
+                syncFiles: bootstrap.syncFileFailures,
+            };
+            if (options.json) {
+                options.stderr(`${JSON.stringify({ error: "worktree bootstrap failed", ...details }, null, 2)}\n`);
             }
-            catch (error) {
-                options.stderr(`Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}\n`);
+            else {
+                options.stderr(`gji pr: worktree bootstrap failed at ${worktreePath}\n`);
+                options.stderr(`Hint: inspect the worktree or remove it with 'gji done ${worktreePath}' before retrying\n`);
             }
+            return 1;
         }
-        await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
-        const hooks = extractHooks(config);
-        await runHook(hooks["after-create"], worktreePath, {
-            branch: branchName,
-            path: worktreePath,
-            repo: basename(repository.repoRoot),
-        }, options.stderr);
         if (options.json) {
-            options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}\n`);
+            const output = {
+                ...createNavigationTarget(createNavigationRepository(repository.repoName, repository.repoRoot), worktreePath, branchName),
+            };
+            if (bootstrap.clonedDirs.length > 0) {
+                output.cloned = bootstrap.clonedDirs.map(({ dir, ms }) => ({
+                    dir,
+                    ms,
+                }));
+            }
+            if (bootstrap.skippedDirs.length > 0)
+                output.skipped = bootstrap.skippedDirs;
+            if (bootstrap.dependencyBootstrap.mode !== "off")
+                output.dependencyBootstrap = bootstrap.dependencyBootstrap;
+            options.stdout(`${JSON.stringify(output, null, 2)}\n`);
         }
         else {
             await recordWorktreeUsage(worktreePath, branchName);
-            await writeOutput(worktreePath, options.stdout);
+            await writeOutput(worktreePath, options.stdout, options.outputEnv);
         }
         return 0;
     };
@@ -185,6 +290,6 @@ function sourceRefForForge(forge, prNumber) {
             return `refs/merge-requests/${prNumber}/head`;
     }
 }
-async function writeOutput(worktreePath, stdout) {
-    await writeShellOutput(PR_OUTPUT_FILE_ENV, worktreePath, stdout);
+async function writeOutput(worktreePath, stdout, outputEnv) {
+    await writeShellOutput(outputEnv ?? PR_OUTPUT_FILE_ENV, worktreePath, stdout);
 }

package/dist/pull-requests.d.ts

@@ -2,6 +2,7 @@ export type PullRequestForge = "bitbucket" | "github" | "gitlab";
 export interface PullRequestInfo {
     number: number;
     sourceBranch: string;
+    title?: string;
     url: string;
 }
 export interface PullRequestRemote {

package/dist/pull-requests.js

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const PULL_REQUEST_QUERY_TIMEOUT_MS = 2500;
+const PULL_REQUEST_CACHE_TTL_MS = 30_000;
 export function parsePullRequestRemote(remoteUrl) {
     const parsed = parseRemoteUrl(remoteUrl.trim());
     if (parsed === null)
@@ -46,10 +47,36 @@ export function parsePullRequestRemote(remoteUrl) {
 export function createPullRequestQuery(dependencies = {}) {
     const runCommand = dependencies.runCommand ?? defaultRunCommand;
     const fetcher = dependencies.fetch ?? fetch;
+    const repositoryCache = new Map();
+    const repositoryInFlight = new Map();
+    const listRepositoryPullRequests = (repoRoot) => {
+        const cached = repositoryCache.get(repoRoot);
+        if (cached !== undefined && cached.expiresAt > Date.now()) {
+            return Promise.resolve(cached.value);
+        }
+        const inFlight = repositoryInFlight.get(repoRoot);
+        if (inFlight !== undefined)
+            return inFlight;
+        const request = listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher)
+            .then((value) => {
+            repositoryCache.set(repoRoot, {
+                expiresAt: Date.now() + PULL_REQUEST_CACHE_TTL_MS,
+                value,
+            });
+            repositoryInFlight.delete(repoRoot);
+            return value;
+        })
+            .catch((error) => {
+            repositoryInFlight.delete(repoRoot);
+            throw error;
+        });
+        repositoryInFlight.set(repoRoot, request);
+        return request;
+    };
     return {
         findOpenPullRequest: (repoRoot, number) => findOpenPullRequest(repoRoot, number, runCommand, fetcher),
         listOpenPullRequests: (repoRoot, sourceBranch) => listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher),
-        listOpenPullRequestsForRepository: (repoRoot) => listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher),
+        listOpenPullRequestsForRepository: listRepositoryPullRequests,
     };
 }
 async function listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher) {
@@ -153,7 +180,7 @@ function providerCliCommand(remote, query) {
                         "view",
                         String(query.number),
                         "--json",
-                        "number,url,headRefName,state",
+                        "number,url,headRefName,title,state",
                         "--repo",
                         coordinate,
                     ],
@@ -168,7 +195,7 @@ function providerCliCommand(remote, query) {
                     "open",
                     ...(query.kind === "branch" ? ["--head", sourceBranch] : []),
                     "--json",
-                    "number,url,headRefName,state",
+                    "number,url,headRefName,title,state",
                     "--limit",
                     "100",
                     "--repo",
@@ -302,6 +329,7 @@ function normalizePullRequest(value, query) {
         (isRecord(value.links) && isRecord(value.links.html)
             ? value.links.html.href
             : undefined));
+    const title = stringValue(value.title);
     const state = stringValue(value.state)?.toLowerCase();
     if (number === null || url === null)
         return null;
@@ -314,6 +342,7 @@ function normalizePullRequest(value, query) {
     return {
         number,
         sourceBranch: sourceBranch ?? "",
+        ...(title === null ? {} : { title }),
         url,
     };
 }

package/dist/remove.js

@@ -4,6 +4,8 @@ import { loadEffectiveConfig } from "./config.js";
 import { isHeadless } from "./headless.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { writeShellOutput } from "./shell-handoff.js";
+import { releaseWorktreeSlot } from "./slots.js";
+import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
 import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
 import { buildWorktreePromptEntries, promptForSingleWorktree, } from "./worktree-picker.js";
 import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "./worktree-prompts.js";
@@ -74,6 +76,20 @@ export function createRemoveCommand(dependencies = {}) {
         }
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const hooks = extractHooks(config);
+        let journal;
+        try {
+            journal = await recordUndoOperation("remove", repository.repoRoot, [
+                worktree,
+            ]);
+        }
+        catch (error) {
+            emitError(options, `could not write undo journal; no worktree was removed: ${toMessage(error)}`);
+            return 1;
+        }
+        if (!journal) {
+            emitError(options, "could not capture undo state; no worktree was removed");
+            return 1;
+        }
         await runHook(hooks["before-remove"], worktree.path, {
             branch: worktree.branch ?? undefined,
             path: worktree.path,
@@ -84,10 +100,12 @@ export function createRemoveCommand(dependencies = {}) {
         }
         catch (error) {
             if (!isWorktreeForceRemovalError(error)) {
+                await finalizeUndoOperation(journal, []);
                 throw error;
             }
             if (!options.force &&
                 !(await confirmForceRemoveWorktree(worktree.path))) {
+                await finalizeUndoOperation(journal, []);
                 options.stderr("Aborted\n");
                 return 1;
             }
@@ -95,10 +113,13 @@ export function createRemoveCommand(dependencies = {}) {
                 await forceRemoveWorktree(repository.repoRoot, worktree.path);
             }
             catch (forceError) {
+                await finalizeUndoOperation(journal, []);
                 emitError(options, `Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}`);
                 return 1;
             }
         }
+        await finalizeUndoOperation(journal, [worktree]);
+        await releaseWorktreeSlot(worktree.path);
         if (worktree.branch) {
             try {
                 await deleteBranch(repository.repoRoot, worktree.branch);
@@ -125,6 +146,7 @@ export function createRemoveCommand(dependencies = {}) {
             options.stdout(`${JSON.stringify({ branch: worktree.branch, path: worktree.path, deleted: true }, null, 2)}\n`);
         }
         else {
+            options.stderr("undo: gji undo\n");
             await writeOutput(repository.repoRoot, options.stdout);
         }
         return 0;

package/dist/repo.d.ts

@@ -11,6 +11,10 @@ export interface WorktreeEntry {
     path: string;
 }
 export declare function detectRepository(cwd: string): Promise<RepositoryContext>;
+export declare function worktreeGitDir(worktreePath: string): Promise<string>;
 export declare function resolveWorktreePath(repoRoot: string, branch: string, basePath?: string): string;
 export declare function validateBranchName(name: string): string | null;
+export declare function hasLocalBranch(repoRoot: string, branch: string): Promise<boolean>;
+export declare function hasRemoteBranch(repoRoot: string, remote: string, branch: string): Promise<boolean>;
+export declare function getRepositoryRemoteUrl(repoRoot: string, remote: string): Promise<string | null>;
 export declare function listWorktrees(cwd: string): Promise<WorktreeEntry[]>;

package/dist/repo.js

@@ -1,3 +1,4 @@
+import { access } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { runGit } from "./git.js";
@@ -16,6 +17,10 @@ export async function detectRepository(cwd) {
         repoRoot,
     };
 }
+export async function worktreeGitDir(worktreePath) {
+    const rawGitDir = await runGit(worktreePath, ["rev-parse", "--git-dir"]);
+    return isAbsolute(rawGitDir) ? rawGitDir : resolve(worktreePath, rawGitDir);
+}
 export function resolveWorktreePath(repoRoot, branch, basePath) {
     const segments = branch.split("/").filter(Boolean);
     if (segments.length === 0) {
@@ -65,6 +70,42 @@ export function validateBranchName(name) {
     }
     return null;
 }
+export async function hasLocalBranch(repoRoot, branch) {
+    try {
+        await runGit(repoRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/heads/${branch}`,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function hasRemoteBranch(repoRoot, remote, branch) {
+    try {
+        await runGit(repoRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/remotes/${remote}/${branch}`,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getRepositoryRemoteUrl(repoRoot, remote) {
+    try {
+        return await runGit(repoRoot, ["remote", "get-url", remote]);
+    }
+    catch {
+        return null;
+    }
+}
 function expandTildeInPath(p) {
     if (p === "~")
         return homedir();
@@ -78,15 +119,29 @@ export async function listWorktrees(cwd) {
         runGit(cwd, ["rev-parse", "--show-toplevel"]),
     ]);
     const entries = output.split("\n\n").filter(Boolean);
-    return entries.map((entry) => {
+    const worktrees = entries.flatMap((entry) => {
+        if (findOptionalPorcelainValue(entry, "prunable") !== null)
+            return [];
         const path = findPorcelainValue(entry, "worktree");
         const branchRef = findOptionalPorcelainValue(entry, "branch");
-        return {
-            branch: branchRef ? branchRef.replace("refs/heads/", "") : null,
-            isCurrent: path === currentRoot,
-            path,
-        };
+        return [
+            {
+                branch: branchRef ? branchRef.replace("refs/heads/", "") : null,
+                isCurrent: path === currentRoot,
+                path,
+            },
+        ];
     });
+    const accessible = await Promise.all(worktrees.map(async (worktree) => {
+        try {
+            await access(worktree.path);
+            return worktree;
+        }
+        catch {
+            return null;
+        }
+    }));
+    return accessible.filter((worktree) => worktree !== null);
 }
 function findPorcelainValue(block, key) {
     const value = findOptionalPorcelainValue(block, key);

package/dist/run-hook.js

@@ -1,6 +1,7 @@
 import { loadEffectiveConfig } from "./config.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { detectRepository, listWorktrees } from "./repo.js";
+import { getWorktreeSlot } from "./slots.js";
 const VALID_HOOKS = [
     "after-create",
     "after-enter",
@@ -31,6 +32,7 @@ export async function runHookCommand(options) {
         branch: currentWorktree?.branch ?? undefined,
         path: repository.currentRoot,
         repo: repository.repoName,
+        slot: await getWorktreeSlot(repository.currentRoot),
     }, options.stderr);
     return 0;
 }

package/dist/safe-destination.d.ts

@@ -0,0 +1,15 @@
+export type DestinationInspection = {
+    kind: "missing";
+} | {
+    kind: "exists";
+} | {
+    kind: "unsafe";
+    reason: string;
+};
+export interface OpenDestinationDirectory {
+    path: string;
+    close(): Promise<void>;
+}
+export declare function openDestinationDirectory(root: string, path: string): Promise<OpenDestinationDirectory>;
+export declare function inspectDestination(root: string, path: string): Promise<DestinationInspection>;
+export declare function ensureDestinationDirectory(root: string, path: string): Promise<void>;