@solaqua/gji 0.10.0 → 0.12.0

package/dist/sync-plan.js

@@ -0,0 +1,128 @@
+import { lstat, realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { validateSyncDirPattern } from "./config.js";
+import { directorySize } from "./dir-clone.js";
+import { isNotFoundError } from "./fs-utils.js";
+import { inspectDestination } from "./safe-destination.js";
+export async function prepareSyncDirectoryPlan(repoRoot, worktreePath, directories) {
+    const normalizedDirectories = directories
+        .map(validateSyncDirPattern)
+        .sort(directoryDepthAscending);
+    const plan = [];
+    for (const directory of normalizedDirectories) {
+        const destination = join(worktreePath, directory);
+        const destinationState = await inspectDestination(worktreePath, destination);
+        const destinationWasPresent = destinationState.kind === "exists";
+        const destinationWarning = destinationState.kind === "unsafe" ? destinationState.reason : undefined;
+        try {
+            const source = await resolveSyncDirectorySource(repoRoot, directory);
+            if (!source) {
+                plan.push({
+                    directory,
+                    destination,
+                    worktreePath,
+                    destinationWasPresent,
+                    destinationWarning,
+                });
+            }
+            else if ("warning" in source) {
+                plan.push({
+                    directory,
+                    destination,
+                    worktreePath,
+                    destinationWasPresent,
+                    destinationWarning,
+                    warning: source.warning,
+                });
+            }
+            else {
+                plan.push({
+                    directory,
+                    destination,
+                    worktreePath,
+                    destinationWasPresent,
+                    destinationWarning,
+                    source: source.path,
+                });
+            }
+        }
+        catch (error) {
+            plan.push({
+                directory,
+                destination,
+                worktreePath,
+                destinationWasPresent,
+                destinationWarning,
+                warning: `could not inspect ${directory}: ${toErrorMessage(error)}`,
+            });
+        }
+    }
+    return plan;
+}
+export async function estimateSyncDirectoryPlan(plan) {
+    const estimates = [];
+    for (const entry of plan) {
+        if (entry.destinationWasPresent ||
+            entry.destinationWarning ||
+            !entry.source ||
+            entry.warning ||
+            isCoveredByCloneAncestor(entry, plan)) {
+            continue;
+        }
+        try {
+            estimates.push({
+                bytes: await directorySize(entry.source),
+                dir: entry.directory,
+            });
+        }
+        catch {
+            // A dry-run is informational; an unreadable source is omitted.
+        }
+    }
+    return estimates;
+}
+export async function estimateSyncDirectories(repoRoot, worktreePath, directories) {
+    const plan = await prepareSyncDirectoryPlan(repoRoot, worktreePath, directories);
+    return estimateSyncDirectoryPlan(plan);
+}
+async function resolveSyncDirectorySource(repoRoot, directory) {
+    const source = join(repoRoot, directory);
+    let resolvedSource;
+    try {
+        resolvedSource = await realpath(source);
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+    if (!isPathInside(repoRoot, resolvedSource)) {
+        return {
+            warning: `source symlink resolves outside the repository (${resolvedSource})`,
+        };
+    }
+    const stats = await lstat(resolvedSource);
+    if (!stats.isDirectory())
+        return { warning: "source is not a directory" };
+    return { path: resolvedSource };
+}
+function isCoveredByCloneAncestor(entry, plan) {
+    return plan.some((candidate) => candidate !== entry &&
+        !candidate.destinationWasPresent &&
+        !candidate.destinationWarning &&
+        !!candidate.source &&
+        isPathInside(candidate.directory, entry.directory));
+}
+function directoryDepthAscending(left, right) {
+    return left.split(/[\\/]+/u).length - right.split(/[\\/]+/u).length;
+}
+function isPathInside(parent, child) {
+    const relativePath = relative(resolve(parent), resolve(child));
+    return (relativePath !== "" &&
+        !isAbsolute(relativePath) &&
+        relativePath !== ".." &&
+        !relativePath.startsWith(`..${sep}`));
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/sync.js

@@ -1,5 +1,5 @@
 import { loadEffectiveConfig } from "./config.js";
-import { isDirtyWorktree, resolveRemoteDefaultBranch, runGit } from "./git.js";
+import { isDirtyWorktree, resolveRemoteBase, runGit, } from "./git.js";
 import { comparePaths } from "./paths.js";
 import { detectRepository, listWorktrees } from "./repo.js";
 export async function runSyncCommand(options) {
@@ -7,11 +7,9 @@ export async function runSyncCommand(options) {
     const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
     const worktrees = await listWorktrees(options.cwd);
     const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
-    let defaultBranch;
+    let remoteBase;
     try {
-        defaultBranch =
-            resolveConfiguredString(config.syncDefaultBranch) ??
-                (await resolveRemoteDefaultBranch(repository.repoRoot, remote));
+        remoteBase = await resolveRemoteBase(repository.repoRoot, remote, resolveConfiguredString(config.syncDefaultBranch) ?? undefined);
     }
     catch {
         emitError(options, `Unable to reach remote '${remote}'`);
@@ -20,7 +18,7 @@ export async function runSyncCommand(options) {
         }
         return 1;
     }
-    if (!defaultBranch) {
+    if (!remoteBase) {
         emitError(options, "Unable to determine the default branch for sync.");
         if (!options.json) {
             options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>\n`);
@@ -50,15 +48,11 @@ export async function runSyncCommand(options) {
     }
     const updatedWorktrees = [];
     for (const worktree of targetWorktrees) {
-        if (worktree.branch === defaultBranch) {
-            await runGit(worktree.path, [
-                "merge",
-                "--ff-only",
-                `${remote}/${defaultBranch}`,
-            ]);
+        if (worktree.branch === remoteBase.branch) {
+            await runGit(worktree.path, ["merge", "--ff-only", remoteBase.ref]);
         }
         else {
-            await runGit(worktree.path, ["rebase", `${remote}/${defaultBranch}`]);
+            await runGit(worktree.path, ["rebase", remoteBase.ref]);
         }
         updatedWorktrees.push(worktree);
         if (!options.json) {

package/dist/task-command.d.ts

@@ -0,0 +1,9 @@
+export interface TaskCommandOptions {
+    clear?: boolean;
+    cwd: string;
+    json?: boolean;
+    task?: string;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function runTaskCommand(options: TaskCommandOptions): Promise<number>;

package/dist/task-command.js

@@ -0,0 +1,29 @@
+import { detectRepository } from "./repo.js";
+import { clearTask, readTask, writeTask } from "./task.js";
+export async function runTaskCommand(options) {
+    const repository = await detectRepository(options.cwd);
+    if (options.clear && options.task !== undefined)
+        return emitTaskError(options, "--clear cannot be combined with a task");
+    if (options.clear)
+        await clearTask(repository.currentRoot);
+    else if (options.task !== undefined)
+        await writeTask(repository.currentRoot, options.task);
+    const task = await readTask(repository.currentRoot);
+    if (options.json) {
+        options.stdout(`${JSON.stringify({ task: task?.task ?? null }, null, 2)}\n`);
+    }
+    else if (task) {
+        options.stdout(`${task.task}\n`);
+    }
+    else {
+        options.stdout('no task set — set one: gji task "..."\n');
+    }
+    return 0;
+}
+function emitTaskError(options, message) {
+    if (options.json)
+        options.stderr(`${JSON.stringify({ error: message })}\n`);
+    else
+        options.stderr(`gji task: ${message}\n`);
+    return 1;
+}

package/dist/task.d.ts

@@ -0,0 +1,9 @@
+export type TaskSource = "manual" | "pr";
+export interface TaskMetadata {
+    source: TaskSource;
+    task: string;
+    updatedAt: number;
+}
+export declare function readTask(worktreePath: string): Promise<TaskMetadata | null>;
+export declare function writeTask(worktreePath: string, task: string, source?: TaskSource): Promise<TaskMetadata>;
+export declare function clearTask(worktreePath: string): Promise<void>;

package/dist/task.js

@@ -0,0 +1,37 @@
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { worktreeGitDir } from "./repo.js";
+export async function readTask(worktreePath) {
+    try {
+        const parsed = JSON.parse(await readFile(await taskPath(worktreePath), "utf8"));
+        return isTaskMetadata(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeTask(worktreePath, task, source = "manual") {
+    const metadata = { source, task, updatedAt: Date.now() };
+    const path = await taskPath(worktreePath);
+    await writeFile(path, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+    return metadata;
+}
+export async function clearTask(worktreePath) {
+    try {
+        await unlink(await taskPath(worktreePath));
+    }
+    catch {
+        // Missing task metadata is already the desired state.
+    }
+}
+async function taskPath(worktreePath) {
+    return join(await worktreeGitDir(worktreePath), "gji-task.json");
+}
+function isTaskMetadata(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const candidate = value;
+    return (typeof candidate.task === "string" &&
+        (candidate.source === "manual" || candidate.source === "pr") &&
+        typeof candidate.updatedAt === "number");
+}

package/dist/terminal-text.d.ts

@@ -0,0 +1,4 @@
+export declare function sanitizeTerminalText(value: string): string;
+export declare function middleEllipsize(value: string, maxLength: number): string;
+export declare function startEllipsize(value: string, maxLength: number): string;
+export declare function terminalWidth(value: string): number;

package/dist/terminal-text.js

@@ -0,0 +1,72 @@
+export function sanitizeTerminalText(value) {
+    return Array.from(value, (character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)
+            ? " "
+            : character;
+    }).join("");
+}
+export function middleEllipsize(value, maxLength) {
+    if (terminalWidth(value) <= maxLength)
+        return value;
+    if (maxLength <= 1)
+        return "…";
+    const keep = maxLength - 1;
+    const start = takeTerminalColumns(value, Math.ceil(keep / 2), "start");
+    const end = takeTerminalColumns(value, Math.floor(keep / 2), "end");
+    return `${start}…${end}`;
+}
+export function startEllipsize(value, maxLength) {
+    if (terminalWidth(value) <= maxLength)
+        return value;
+    if (maxLength <= 1)
+        return "…";
+    return `…${takeTerminalColumns(value, maxLength - 1, "end")}`;
+}
+export function terminalWidth(value) {
+    let width = 0;
+    for (const character of Array.from(value)) {
+        width += characterTerminalWidth(character);
+    }
+    return width;
+}
+function takeTerminalColumns(value, maxWidth, direction) {
+    const characters = direction === "start" ? Array.from(value) : Array.from(value).reverse();
+    const kept = [];
+    let width = 0;
+    for (const character of characters) {
+        const characterWidth = characterTerminalWidth(character);
+        if (width + characterWidth > maxWidth)
+            break;
+        kept.push(character);
+        width += characterWidth;
+    }
+    return direction === "start" ? kept.join("") : kept.reverse().join("");
+}
+function characterTerminalWidth(character) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === undefined)
+        return 0;
+    if (isZeroWidthCodePoint(codePoint) || /\p{Mark}/u.test(character))
+        return 0;
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0 ||
+        codePoint === 0x200d ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}

package/dist/undo.d.ts

@@ -0,0 +1,36 @@
+import { type WorktreeEntry } from "./repo.js";
+export type UndoOperation = "remove" | "clean" | "done";
+export interface UndoEntry {
+    branch: string | null;
+    headSha: string;
+    path: string;
+    upstream: string | null;
+    wasDirty: boolean;
+}
+export interface UndoRecord {
+    id: string;
+    op: UndoOperation;
+    repoRoot: string;
+    timestamp: number;
+    entries: UndoEntry[];
+}
+export interface UndoRestoreResult {
+    restored: UndoEntry[];
+    failed: Array<UndoEntry & {
+        message: string;
+    }>;
+}
+export interface UndoCommandOptions {
+    cwd: string;
+    id?: string;
+    list?: boolean;
+    json?: boolean;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function undoLogPath(home?: string): string;
+export declare function loadUndoRecords(home?: string): Promise<UndoRecord[]>;
+export declare function recordUndoOperation(op: UndoOperation, repoRoot: string, worktrees: WorktreeEntry[], home?: string): Promise<UndoRecord | null>;
+export declare function finalizeUndoOperation(record: UndoRecord, removedWorktrees: WorktreeEntry[], home?: string): Promise<void>;
+export declare function restoreUndoRecord(record: UndoRecord, home?: string): Promise<UndoRestoreResult>;
+export declare function runUndoCommand(options: UndoCommandOptions): Promise<number>;