@solaqua/gji 0.10.0 → 0.12.0

package/dist/done.js

@@ -0,0 +1,210 @@
+import { basename } from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { isBranchMergedInto, readWorktreeHealth, resolveRemoteDefaultBranch, runGit, } from "./git.js";
+import { isHeadless } from "./headless.js";
+import { loadHistory } from "./history.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { detectRepository, listWorktrees } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
+import { releaseWorktreeSlot } from "./slots.js";
+import { finalizeUndoOperation, recordUndoOperation } from "./undo.js";
+import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeForceRemovalError, removeWorktree, } from "./worktree-management.js";
+const DONE_OUTPUT_FILE_ENV = "GJI_DONE_OUTPUT_FILE";
+export async function runDoneCommand(options) {
+    const repository = await detectRepository(options.cwd);
+    if (!repository.isWorktree && !options.branch)
+        return doneError(options, "gji done: not inside a linked worktree");
+    const linked = (await listWorktrees(options.cwd)).filter((entry) => entry.path !== repository.repoRoot);
+    const target = options.branch
+        ? linked.find((entry) => entry.branch === options.branch || entry.path === options.branch)
+        : linked.find((entry) => entry.path === repository.currentRoot);
+    if (!target)
+        return doneError(options, options.branch
+            ? `gji done: no linked worktree found for ${options.branch}`
+            : "gji done: not inside a linked worktree");
+    const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
+    await refreshUpstream(repository.repoRoot, target.path);
+    const health = await readWorktreeHealth(target.path);
+    if (target.branch &&
+        !options.force &&
+        !options.keepBranch &&
+        !(await isSafeToComplete(repository.repoRoot, target.branch, health, config))) {
+        if (options.json || isHeadless())
+            return doneError(options, "branch is not merged and its upstream is not gone; use --force");
+        const choice = await confirm({
+            message: `branch "${target.branch}" doesn't look merged. Delete anyway?`,
+            active: "Yes",
+            inactive: "No",
+            initialValue: false,
+        });
+        if (isCancel(choice) || !choice)
+            return doneError(options, "Aborted");
+    }
+    if (health.status === "dirty" && !options.force) {
+        if (options.json || isHeadless())
+            return doneError(options, "worktree has uncommitted changes; use --force");
+        const choice = await confirm({
+            message: `worktree ${target.path} has uncommitted changes that cannot be undone. Remove anyway?`,
+            active: "Yes",
+            inactive: "No",
+            initialValue: false,
+        });
+        if (isCancel(choice) || !choice)
+            return doneError(options, "Aborted");
+    }
+    let journal;
+    try {
+        journal = await recordUndoOperation("done", repository.repoRoot, [target]);
+    }
+    catch (error) {
+        return doneError(options, `could not write undo journal; no worktree was removed: ${toMessage(error)}`);
+    }
+    if (!journal)
+        return doneError(options, "could not capture undo state; no worktree was removed");
+    await runHook(extractHooks(config)["before-remove"], target.path, {
+        branch: target.branch ?? undefined,
+        path: target.path,
+        repo: basename(repository.repoRoot),
+    }, options.stderr);
+    try {
+        await removeWorktree(repository.repoRoot, target.path);
+    }
+    catch (error) {
+        if (!isWorktreeForceRemovalError(error)) {
+            await finalizeUndoOperation(journal, []);
+            return doneError(options, `Failed to remove worktree at ${target.path}: ${toMessage(error)}`);
+        }
+        if (!options.force) {
+            if (options.json || isHeadless()) {
+                await finalizeUndoOperation(journal, []);
+                return doneError(options, "worktree requires force removal; use --force");
+            }
+            const choice = await confirm({
+                message: `worktree ${target.path} contains files or initialized submodules that cannot be undone. Force remove?`,
+                active: "Yes",
+                inactive: "No",
+                initialValue: false,
+            });
+            if (isCancel(choice) || !choice) {
+                await finalizeUndoOperation(journal, []);
+                return doneError(options, "Aborted");
+            }
+        }
+        try {
+            await forceRemoveWorktree(repository.repoRoot, target.path);
+        }
+        catch (forceError) {
+            await finalizeUndoOperation(journal, []);
+            return doneError(options, `Failed to remove worktree at ${target.path}: ${toMessage(forceError)}`);
+        }
+    }
+    let branchDeleted = false;
+    if (target.branch && !options.keepBranch) {
+        try {
+            await deleteBranch(repository.repoRoot, target.branch);
+            branchDeleted = true;
+        }
+        catch (error) {
+            if (!isBranchUnmergedError(error))
+                return doneError(options, `Failed to delete branch ${target.branch}: ${toMessage(error)}`);
+            if (options.force) {
+                try {
+                    await forceDeleteBranch(repository.repoRoot, target.branch);
+                    branchDeleted = true;
+                }
+                catch (forceError) {
+                    return doneError(options, `Failed to delete branch ${target.branch}: ${toMessage(forceError)}`);
+                }
+            }
+            else if (!options.json) {
+                options.stderr(`Branch ${target.branch} was not deleted (has unmerged commits)\n`);
+            }
+        }
+    }
+    await finalizeUndoOperation(journal, [target]);
+    await releaseWorktreeSlot(target.path);
+    await runGit(repository.repoRoot, ["worktree", "prune"]).catch(() => undefined);
+    const shouldMove = options.branch === undefined || target.path === repository.currentRoot;
+    const movedTo = shouldMove
+        ? await resolveDoneDestination(repository.repoRoot, target.path)
+        : null;
+    if (!options.json && movedTo)
+        await writeShellOutput(DONE_OUTPUT_FILE_ENV, movedTo, options.stdout);
+    else if (!options.json && options.branch && process.env[DONE_OUTPUT_FILE_ENV])
+        await writeShellOutput(DONE_OUTPUT_FILE_ENV, options.cwd, options.stdout);
+    if (options.json)
+        options.stdout(`${JSON.stringify({ branch: target.branch, path: target.path, deleted: true, branchDeleted, movedTo }, null, 2)}\n`);
+    else
+        options.stderr(`✓ removed ${target.branch ?? "detached worktree"} (worktree${branchDeleted ? " + branch" : ""})${movedTo ? ` → back at ${movedTo}` : ""} · undo: gji undo\n`);
+    return 0;
+}
+async function isSafeToComplete(repoRoot, branch, health, config) {
+    if (health.upstreamGone)
+        return true;
+    const remote = resolveConfigString(config, "syncRemote") ?? "origin";
+    const configuredDefault = resolveConfigString(config, "syncDefaultBranch");
+    const remoteDefault = configuredDefault ??
+        (await resolveRemoteDefaultBranch(repoRoot, remote).catch(() => null));
+    if (remoteDefault) {
+        for (const base of [`${remote}/${remoteDefault}`, remoteDefault]) {
+            if (await gitRefExists(repoRoot, base))
+                return isBranchMergedInto(repoRoot, branch, base).catch(() => false);
+        }
+        return false;
+    }
+    const base = await runGit(repoRoot, [
+        "symbolic-ref",
+        "--short",
+        "HEAD",
+    ]).catch(() => null);
+    return base === null
+        ? false
+        : isBranchMergedInto(repoRoot, branch, base).catch(() => false);
+}
+async function gitRefExists(repoRoot, ref) {
+    try {
+        await runGit(repoRoot, ["rev-parse", "--verify", ref]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function refreshUpstream(repoRoot, worktreePath) {
+    const upstream = await runGit(worktreePath, [
+        "rev-parse",
+        "--abbrev-ref",
+        "--symbolic-full-name",
+        "@{u}",
+    ]).catch(() => null);
+    const remote = upstream?.split("/")[0];
+    if (!remote)
+        return;
+    await runGit(repoRoot, ["fetch", "--prune", "--quiet", remote]).catch(() => undefined);
+}
+async function resolveDoneDestination(repoRoot, removedPath) {
+    const history = await loadHistory();
+    for (const entry of history) {
+        if (entry.path !== removedPath && entry.path !== repoRoot) {
+            try {
+                await runGit(entry.path, ["rev-parse", "--show-toplevel"]);
+                return entry.path;
+            }
+            catch {
+                /* stale history */
+            }
+        }
+    }
+    return repoRoot;
+}
+function doneError(options, message) {
+    if (options.json)
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+    else
+        options.stderr(`${message}\n`);
+    return 1;
+}
+function toMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/file-sync.js

@@ -1,5 +1,8 @@
-import { copyFile, mkdir, stat } from "node:fs/promises";
-import { dirname, isAbsolute, join, normalize } from "node:path";
+import { constants } from "node:fs";
+import { copyFile, lstat, realpath } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep, } from "node:path";
+import { isAlreadyExistsError, isNotFoundError } from "./fs-utils.js";
+import { inspectDestination, openDestinationDirectory, } from "./safe-destination.js";
 /**
  * Copies files matching each pattern (relative to mainRoot) into the equivalent
  * relative path under targetPath, creating parent directories as needed.
@@ -11,20 +14,43 @@ import { dirname, isAbsolute, join, normalize } from "node:path";
 export async function syncFiles(mainRoot, targetPath, patterns) {
     for (const pattern of patterns) {
         const normalized = validateSyncFilePattern(pattern);
-        const sourcePath = join(mainRoot, normalized);
-        const destPath = join(targetPath, normalized);
-        // Skip silently if source does not exist
-        const sourceExists = await fileExists(sourcePath);
-        if (!sourceExists) {
+        const sourcePath = await resolveSyncFileSource(mainRoot, normalized);
+        if (!sourcePath)
             continue;
+        const destPath = join(targetPath, normalized);
+        // Skip ordinary existing targets, but fail closed on any symlink.
+        const existingDestination = await readDestinationEntry(destPath);
+        if (existingDestination?.isSymbolicLink()) {
+            throw new Error(`destination is a symbolic link: ${destPath}`);
         }
-        // Skip silently if target already exists
-        const destExists = await fileExists(destPath);
-        if (destExists) {
+        if (existingDestination) {
             continue;
         }
-        await mkdir(dirname(destPath), { recursive: true });
-        await copyFile(sourcePath, destPath);
+        const destinationParent = dirname(destPath);
+        const beforeCreate = await inspectDestination(targetPath, destinationParent);
+        if (beforeCreate.kind === "unsafe") {
+            throw new Error(beforeCreate.reason);
+        }
+        const safeParent = await openDestinationDirectory(targetPath, destinationParent);
+        try {
+            const safeDestination = join(safeParent.path, basename(destPath));
+            const safeExistingDestination = await readDestinationEntry(safeDestination);
+            if (safeExistingDestination?.isSymbolicLink()) {
+                throw new Error(`destination is a symbolic link: ${destPath}`);
+            }
+            if (safeExistingDestination)
+                continue;
+            try {
+                await copyFile(sourcePath, safeDestination, constants.COPYFILE_EXCL);
+            }
+            catch (error) {
+                if (!isAlreadyExistsError(error))
+                    throw error;
+            }
+        }
+        finally {
+            await safeParent.close().catch(() => undefined);
+        }
     }
 }
 export function validateSyncFilePattern(pattern) {
@@ -37,20 +63,43 @@ export function validateSyncFilePattern(pattern) {
     }
     return normalized;
 }
-async function fileExists(path) {
+async function resolveSyncFileSource(mainRoot, pattern) {
+    let resolvedRoot;
+    let resolvedSource;
     try {
-        await stat(path);
-        return true;
+        [resolvedRoot, resolvedSource] = await Promise.all([
+            realpath(mainRoot),
+            realpath(join(mainRoot, pattern)),
+        ]);
     }
     catch (error) {
-        if (isNotFoundError(error)) {
-            return false;
-        }
+        if (isNotFoundError(error))
+            return undefined;
+        throw error;
+    }
+    if (!isPathInside(resolvedRoot, resolvedSource)) {
+        throw new Error(`syncFiles: source symlink resolves outside the repository: ${resolvedSource}`);
+    }
+    const sourceStats = await lstat(resolvedSource);
+    if (!sourceStats.isFile()) {
+        throw new Error(`syncFiles: source is not a file: ${join(mainRoot, pattern)}`);
+    }
+    return resolvedSource;
+}
+async function readDestinationEntry(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return undefined;
         throw error;
     }
 }
-function isNotFoundError(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOENT");
+function isPathInside(root, candidate) {
+    const distance = relative(resolve(root), resolve(candidate));
+    return (distance === "" ||
+        (!isAbsolute(distance) &&
+            distance !== ".." &&
+            !distance.startsWith(`..${sep}`)));
 }

package/dist/format-bytes.d.ts

@@ -0,0 +1 @@
+export declare function formatBytes(bytes: number | undefined): string;

package/dist/format-bytes.js

@@ -0,0 +1,14 @@
+export function formatBytes(bytes) {
+    if (bytes === undefined)
+        return "size unavailable";
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unit = -1;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unit]}`;
+}

package/dist/fs-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function pathExists(path: string): Promise<boolean>;
+export declare function isAlreadyExistsError(error: unknown): boolean;
+export declare function isNotDirectoryError(error: unknown): boolean;
+export declare function isNotFoundError(error: unknown): boolean;

package/dist/fs-utils.js

@@ -0,0 +1,26 @@
+import { lstat } from "node:fs/promises";
+export async function pathExists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return false;
+        throw error;
+    }
+}
+export function isAlreadyExistsError(error) {
+    return (hasErrorCode(error, "EEXIST") || hasErrorCode(error, "ERR_FS_CP_EEXIST"));
+}
+export function isNotDirectoryError(error) {
+    return hasErrorCode(error, "ENOTDIR");
+}
+export function isNotFoundError(error) {
+    return hasErrorCode(error, "ENOENT");
+}
+function hasErrorCode(error, code) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
+}

package/dist/git.d.ts

@@ -5,9 +5,14 @@ export interface WorktreeHealth {
     upstreamGone: boolean;
     status: "clean" | "dirty";
 }
+export interface RemoteBase {
+    branch: string;
+    ref: string;
+}
 export declare function runGit(cwd: string, args: string[]): Promise<string>;
 export declare function readWorktreeHealth(cwd: string): Promise<WorktreeHealth>;
 export declare function isDirtyWorktree(cwd: string): Promise<boolean>;
 export declare function isBranchMergedInto(cwd: string, branch: string, base?: string): Promise<boolean>;
 export declare function resolveRemoteDefaultBranch(cwd: string, remote: string): Promise<string | null>;
+export declare function resolveRemoteBase(cwd: string, remote: string, configuredBranch?: string): Promise<RemoteBase | null>;
 export declare function readBranchLastCommitTimestamp(cwd: string, branch: string): Promise<number | null>;

package/dist/git.js

@@ -44,6 +44,56 @@ export async function resolveRemoteDefaultBranch(cwd, remote) {
     const match = /^ref: refs\/heads\/(.+)\tHEAD$/.exec(refLine);
     return match?.[1] ?? null;
 }
+export async function resolveRemoteBase(cwd, remote, configuredBranch) {
+    try {
+        await runGit(cwd, ["remote", "get-url", remote]);
+    }
+    catch {
+        return null;
+    }
+    let branch = configuredBranch;
+    if (!branch) {
+        try {
+            const discoveredBranch = await resolveRemoteDefaultBranch(cwd, remote);
+            branch =
+                discoveredBranch ??
+                    (await resolveCachedRemoteDefaultBranch(cwd, remote));
+        }
+        catch {
+            branch = await resolveCachedRemoteDefaultBranch(cwd, remote);
+        }
+    }
+    if (!branch)
+        return null;
+    return {
+        branch,
+        ref: `${remote}/${branch}`,
+    };
+}
+async function resolveCachedRemoteDefaultBranch(cwd, remote) {
+    try {
+        const ref = await runGit(cwd, [
+            "symbolic-ref",
+            "--short",
+            `refs/remotes/${remote}/HEAD`,
+        ]);
+        const prefix = `${remote}/`;
+        return ref.startsWith(prefix) ? ref.slice(prefix.length) : undefined;
+    }
+    catch {
+        try {
+            const refs = await runGit(cwd, [
+                "for-each-ref",
+                "--format=%(refname:strip=3)",
+                `refs/remotes/${remote}`,
+            ]);
+            return refs.split("\n").find((ref) => ref !== "HEAD");
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
 export async function readBranchLastCommitTimestamp(cwd, branch) {
     try {
         const { stdout } = await execFileAsync("git", ["log", "-1", "--format=%ct", branch], { cwd });