@solaqua/gji 0.9.0 → 0.11.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/remove.js

@@ -4,6 +4,7 @@ import { loadEffectiveConfig } from "./config.js";
 import { isHeadless } from "./headless.js";
 import { extractHooks, runHook } from "./hooks.js";
 import { writeShellOutput } from "./shell-handoff.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 +75,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 +99,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 +112,12 @@ 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]);
         if (worktree.branch) {
             try {
                 await deleteBranch(repository.repoRoot, worktree.branch);
@@ -125,6 +144,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

@@ -13,4 +13,7 @@ export interface WorktreeEntry {
 export declare function detectRepository(cwd: string): Promise<RepositoryContext>;
 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";
@@ -65,6 +66,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 +115,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/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>;

package/dist/safe-destination.js

@@ -0,0 +1,166 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isAlreadyExistsError, isNotDirectoryError, isNotFoundError, } from "./fs-utils.js";
+export async function openDestinationDirectory(root, path) {
+    const segments = destinationSegments(root, path);
+    if (process.platform !== "linux") {
+        await ensureDestinationDirectory(root, path);
+        return { path: resolve(path), close: async () => undefined };
+    }
+    let handle = await open(root, destinationDirectoryFlags());
+    try {
+        for (const segment of segments) {
+            const childPath = join(fileDescriptorPath(handle.fd), segment);
+            try {
+                await mkdir(childPath);
+            }
+            catch (error) {
+                if (!isAlreadyExistsError(error))
+                    throw error;
+            }
+            const childHandle = await open(childPath, destinationDirectoryFlags());
+            await handle.close();
+            handle = childHandle;
+        }
+        return {
+            path: fileDescriptorPath(handle.fd),
+            close: async () => handle.close(),
+        };
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        throw error;
+    }
+}
+export async function inspectDestination(root, path) {
+    const resolvedPath = resolve(path);
+    const resolvedRoot = resolve(root);
+    const distance = relative(resolvedRoot, resolvedPath);
+    if (isAbsolute(distance) ||
+        distance === ".." ||
+        distance.startsWith(`..${sep}`)) {
+        return { kind: "unsafe", reason: "destination escapes the worktree" };
+    }
+    let current = resolvedRoot;
+    try {
+        const rootStats = await lstat(current);
+        if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+            return { kind: "unsafe", reason: "worktree root is not a directory" };
+        }
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return { kind: "missing" };
+        throw error;
+    }
+    const segments = distance.split(sep).filter(Boolean);
+    for (const [index, segment] of segments.entries()) {
+        current = resolve(current, segment);
+        try {
+            const stats = await lstat(current);
+            if (stats.isSymbolicLink()) {
+                return {
+                    kind: "unsafe",
+                    reason: `destination has a symbolic-link component: ${current}`,
+                };
+            }
+            if (index < segments.length - 1 && !stats.isDirectory()) {
+                return {
+                    kind: "unsafe",
+                    reason: `destination has a non-directory ancestor: ${current}`,
+                };
+            }
+            if (index === segments.length - 1) {
+                return stats.isDirectory()
+                    ? { kind: "exists" }
+                    : {
+                        kind: "unsafe",
+                        reason: `destination is not a directory: ${current}`,
+                    };
+            }
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return { kind: "missing" };
+            if (isNotDirectoryError(error)) {
+                return {
+                    kind: "unsafe",
+                    reason: `destination has a non-directory ancestor: ${current}`,
+                };
+            }
+            throw error;
+        }
+    }
+    try {
+        const stats = await lstat(current);
+        return stats.isDirectory()
+            ? { kind: "exists" }
+            : { kind: "unsafe", reason: "destination is not a directory" };
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return { kind: "missing" };
+        throw error;
+    }
+}
+function destinationSegments(root, path) {
+    const resolvedRoot = resolve(root);
+    const resolvedPath = resolve(path);
+    const distance = relative(resolvedRoot, resolvedPath);
+    if (isAbsolute(distance) ||
+        distance === ".." ||
+        distance.startsWith(`..${sep}`)) {
+        throw new Error("destination escapes the worktree");
+    }
+    return distance.split(sep).filter(Boolean);
+}
+function destinationDirectoryFlags() {
+    return constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
+}
+function fileDescriptorPath(fd) {
+    if (process.platform === "linux")
+        return `/proc/self/fd/${fd}`;
+    if (process.platform === "darwin")
+        return `/dev/fd/${fd}`;
+    throw new Error(`safe destination handles are unsupported on ${process.platform}`);
+}
+export async function ensureDestinationDirectory(root, path) {
+    const resolvedRoot = resolve(root);
+    const resolvedPath = resolve(path);
+    const distance = relative(resolvedRoot, resolvedPath);
+    if (isAbsolute(distance) ||
+        distance === ".." ||
+        distance.startsWith(`..${sep}`)) {
+        throw new Error("destination escapes the worktree");
+    }
+    let current = resolvedRoot;
+    const rootStats = await lstat(current);
+    if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
+        throw new Error("worktree root is not a directory");
+    }
+    for (const segment of distance.split(sep).filter(Boolean)) {
+        current = resolve(current, segment);
+        try {
+            const stats = await lstat(current);
+            if (stats.isSymbolicLink() || !stats.isDirectory()) {
+                throw new Error(`destination has an unsafe component: ${current}`);
+            }
+        }
+        catch (error) {
+            if (!isNotFoundError(error))
+                throw error;
+            try {
+                await mkdir(current);
+            }
+            catch (mkdirError) {
+                if (!isAlreadyExistsError(mkdirError))
+                    throw mkdirError;
+            }
+            const stats = await lstat(current);
+            if (stats.isSymbolicLink() || !stats.isDirectory()) {
+                throw new Error(`destination has an unsafe component: ${current}`);
+            }
+        }
+    }
+}