@solaqua/gji 0.6.1 → 0.7.0

package/dist/pr.js

@@ -1,18 +1,18 @@
-import { mkdir } from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { loadEffectiveConfig, resolveConfigString } from './config.js';
-import { syncFiles } from './file-sync.js';
-import { pathExists, promptForPathConflict } from './conflict.js';
-import { extractHooks, runHook } from './hooks.js';
-import { appendHistory } from './history.js';
-import { isHeadless } from './headless.js';
-import { maybeRunInstallPrompt } from './install-prompt.js';
-import { detectRepository, resolveWorktreePath } from './repo.js';
-import { writeShellOutput } from './shell-handoff.js';
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { promisify } from "node:util";
+import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { pathExists, promptForPathConflict, } from "./conflict.js";
+import { syncFiles } from "./file-sync.js";
+import { isHeadless } from "./headless.js";
+import { appendHistory } from "./history.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { detectRepository, resolveWorktreePath } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
 const execFileAsync = promisify(execFile);
-const PR_OUTPUT_FILE_ENV = 'GJI_PR_OUTPUT_FILE';
+const PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
 export function parsePrInput(input) {
     if (/^\d+$/.test(input))
         return input;
@@ -42,8 +42,10 @@ export function createPrCommand(dependencies = {}) {
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const branchName = `pr/${prNumber}`;
         const remoteRef = `refs/remotes/origin/pull/${prNumber}/head`;
-        const rawBasePath = resolveConfigString(config, 'worktreePath');
-        const configuredBasePath = rawBasePath?.startsWith('/') || rawBasePath?.startsWith('~') ? rawBasePath : undefined;
+        const rawBasePath = resolveConfigString(config, "worktreePath");
+        const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~")
+            ? rawBasePath
+            : undefined;
         const worktreePath = resolveWorktreePath(repository.repoRoot, branchName, configuredBasePath);
         if (await pathExists(worktreePath)) {
             if (options.json || isHeadless()) {
@@ -58,7 +60,7 @@ export function createPrCommand(dependencies = {}) {
                 return 1;
             }
             const choice = await prompt(worktreePath);
-            if (choice === 'reuse') {
+            if (choice === "reuse") {
                 appendHistory(worktreePath, branchName).catch(() => undefined);
                 await writeOutput(worktreePath, options.stdout);
                 return 0;
@@ -92,12 +94,12 @@ export function createPrCommand(dependencies = {}) {
         await mkdir(dirname(worktreePath), { recursive: true });
         const branchAlreadyExists = await localBranchExists(repository.repoRoot, branchName);
         const worktreeArgs = branchAlreadyExists
-            ? ['worktree', 'add', worktreePath, branchName]
-            : ['worktree', 'add', '-b', branchName, worktreePath, remoteRef];
-        await execFileAsync('git', worktreeArgs, { cwd: repository.repoRoot });
+            ? ["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')
+            ? config.syncFiles.filter((p) => typeof p === "string")
             : [];
         for (const pattern of syncPatterns) {
             try {
@@ -109,7 +111,11 @@ export function createPrCommand(dependencies = {}) {
         }
         await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterCreate, worktreePath, { branch: branchName, path: worktreePath, repo: basename(repository.repoRoot) }, options.stderr);
+        await runHook(hooks.afterCreate, 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`);
         }
@@ -122,7 +128,7 @@ export function createPrCommand(dependencies = {}) {
 }
 async function localBranchExists(repoRoot, branchName) {
     try {
-        await execFileAsync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], { cwd: repoRoot });
+        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
         return true;
     }
     catch {
@@ -133,7 +139,7 @@ export const runPrCommand = createPrCommand();
 async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
     for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
         try {
-            await execFileAsync('git', ['fetch', 'origin', `${sourceRef}:${remoteRef}`], { cwd: repoRoot });
+            await execFileAsync("git", ["fetch", "origin", `${sourceRef}:${remoteRef}`], { cwd: repoRoot });
             return;
         }
         catch {
@@ -143,32 +149,39 @@ async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
     throw new Error(`No pull request ref found for #${prNumber}`);
 }
 function listPullRequestSourceRefs(input, prNumber) {
-    const allForges = ['github', 'gitlab', 'bitbucket'];
+    const allForges = [
+        "github",
+        "gitlab",
+        "bitbucket",
+    ];
     const preferredForge = detectPullRequestForge(input);
-    const orderedForges = preferredForge === 'unknown'
+    const orderedForges = preferredForge === "unknown"
         ? allForges
-        : [preferredForge, ...allForges.filter((forge) => forge !== preferredForge)];
+        : [
+            preferredForge,
+            ...allForges.filter((forge) => forge !== preferredForge),
+        ];
     return orderedForges.map((forge) => sourceRefForForge(forge, prNumber));
 }
 function detectPullRequestForge(input) {
     if (/\/pull-requests\/\d+/.test(input)) {
-        return 'bitbucket';
+        return "bitbucket";
     }
     if (/\/merge_requests\/\d+/.test(input)) {
-        return 'gitlab';
+        return "gitlab";
     }
     if (/\/pull\/\d+/.test(input)) {
-        return 'github';
+        return "github";
     }
-    return 'unknown';
+    return "unknown";
 }
 function sourceRefForForge(forge, prNumber) {
     switch (forge) {
-        case 'bitbucket':
+        case "bitbucket":
             return `refs/pull-requests/${prNumber}/from`;
-        case 'github':
+        case "github":
             return `refs/pull/${prNumber}/head`;
-        case 'gitlab':
+        case "gitlab":
             return `refs/merge-requests/${prNumber}/head`;
     }
 }

package/dist/remove.d.ts

@@ -1,4 +1,4 @@
-import { type WorktreeEntry } from './repo.js';
+import { type WorktreeEntry } from "./repo.js";
 export interface RemoveCommandOptions {
     branch?: string;
     cwd: string;

package/dist/remove.js

@@ -1,26 +1,27 @@
-import { basename } from 'node:path';
-import { confirm, isCancel, select } from '@clack/prompts';
-import { loadEffectiveConfig } from './config.js';
-import { extractHooks, runHook } from './hooks.js';
-import { isHeadless } from './headless.js';
-import { sortByCurrentFirst } from './repo.js';
-import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from './worktree-management.js';
-import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree } from './worktree-prompts.js';
-import { writeShellOutput } from './shell-handoff.js';
-const REMOVE_OUTPUT_FILE_ENV = 'GJI_REMOVE_OUTPUT_FILE';
+import { basename } from "node:path";
+import { confirm, isCancel, select } from "@clack/prompts";
+import { loadEffectiveConfig } from "./config.js";
+import { isHeadless } from "./headless.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { sortByCurrentFirst } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
+import { deleteBranch, forceDeleteBranch, forceRemoveWorktree, isBranchUnmergedError, isWorktreeDirtyError, loadLinkedWorktrees, removeWorktree, } from "./worktree-management.js";
+import { defaultConfirmForceDeleteBranch, defaultConfirmForceRemoveWorktree, } from "./worktree-prompts.js";
+const REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 export function createRemoveCommand(dependencies = {}) {
     const promptForWorktree = dependencies.promptForWorktree ?? defaultPromptForWorktree;
     const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval;
-    const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
+    const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ??
+        defaultConfirmForceRemoveWorktree;
     const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
     return async function runRemoveCommand(options) {
         const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
         if (linkedWorktrees.length === 0) {
-            emitError(options, 'No linked worktrees to finish');
+            emitError(options, "No linked worktrees to finish");
             return 1;
         }
         if (!options.branch && (options.json || isHeadless())) {
-            const message = 'branch argument is required';
+            const message = "branch argument is required";
             if (options.json) {
                 emitError(options, message);
             }
@@ -29,9 +30,10 @@ export function createRemoveCommand(dependencies = {}) {
             }
             return 1;
         }
-        const selection = options.branch ?? (await promptForWorktree(sortByCurrentFirst(linkedWorktrees)));
+        const selection = options.branch ??
+            (await promptForWorktree(sortByCurrentFirst(linkedWorktrees)));
         if (!selection) {
-            options.stderr('Aborted\n');
+            options.stderr("Aborted\n");
             return 1;
         }
         const worktree = linkedWorktrees.find((entry) => entry.branch === selection || entry.path === selection);
@@ -40,7 +42,7 @@ export function createRemoveCommand(dependencies = {}) {
             return 1;
         }
         if (!options.dryRun && !options.force && (options.json || isHeadless())) {
-            const message = '--force is required';
+            const message = "--force is required";
             if (options.json) {
                 emitError(options, message);
             }
@@ -49,8 +51,10 @@ export function createRemoveCommand(dependencies = {}) {
             }
             return 1;
         }
-        if (!options.dryRun && !options.force && !(await confirmRemoval(worktree))) {
-            options.stderr('Aborted\n');
+        if (!options.dryRun &&
+            !options.force &&
+            !(await confirmRemoval(worktree))) {
+            options.stderr("Aborted\n");
             return 1;
         }
         if (options.dryRun) {
@@ -58,14 +62,20 @@ export function createRemoveCommand(dependencies = {}) {
                 options.stdout(`${JSON.stringify({ branch: worktree.branch, path: worktree.path, dryRun: true }, null, 2)}\n`);
             }
             else {
-                const desc = worktree.branch ? `branch: ${worktree.branch}` : 'detached';
+                const desc = worktree.branch
+                    ? `branch: ${worktree.branch}`
+                    : "detached";
                 options.stdout(`Would remove worktree at ${worktree.path} (${desc})\n`);
             }
             return 0;
         }
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const hooks = extractHooks(config);
-        await runHook(hooks.beforeRemove, worktree.path, { branch: worktree.branch ?? undefined, path: worktree.path, repo: basename(repository.repoRoot) }, options.stderr);
+        await runHook(hooks.beforeRemove, worktree.path, {
+            branch: worktree.branch ?? undefined,
+            path: worktree.path,
+            repo: basename(repository.repoRoot),
+        }, options.stderr);
         try {
             await removeWorktree(repository.repoRoot, worktree.path);
         }
@@ -73,8 +83,9 @@ export function createRemoveCommand(dependencies = {}) {
             if (!isWorktreeDirtyError(error)) {
                 throw error;
             }
-            if (!options.force && !(await confirmForceRemoveWorktree(worktree.path))) {
-                options.stderr('Aborted\n');
+            if (!options.force &&
+                !(await confirmForceRemoveWorktree(worktree.path))) {
+                options.stderr("Aborted\n");
                 return 1;
             }
             try {
@@ -93,7 +104,8 @@ export function createRemoveCommand(dependencies = {}) {
                 if (!isBranchUnmergedError(error)) {
                     throw error;
                 }
-                if (options.force || (await confirmForceDeleteBranch(worktree.branch))) {
+                if (options.force ||
+                    (await confirmForceDeleteBranch(worktree.branch))) {
                     try {
                         await forceDeleteBranch(repository.repoRoot, worktree.branch);
                     }
@@ -118,10 +130,10 @@ export function createRemoveCommand(dependencies = {}) {
 export const runRemoveCommand = createRemoveCommand();
 async function defaultPromptForWorktree(worktrees) {
     const choice = await select({
-        message: 'Choose a worktree to finish',
+        message: "Choose a worktree to finish",
         options: worktrees.map((worktree) => ({
             hint: worktree.isCurrent ? `${worktree.path} (current)` : worktree.path,
-            label: worktree.branch ?? '(detached)',
+            label: worktree.branch ?? "(detached)",
             value: worktree.path,
         })),
     });
@@ -132,8 +144,8 @@ async function defaultConfirmRemoval(worktree) {
         message: worktree.branch
             ? `Remove worktree and delete branch ${worktree.branch}?`
             : `Remove detached worktree ${worktree.path}?`,
-        active: 'Yes',
-        inactive: 'No',
+        active: "Yes",
+        inactive: "No",
         initialValue: true,
     });
     return !isCancel(choice) && choice;

package/dist/repo-registry.js

@@ -1,8 +1,8 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
-import { GLOBAL_CONFIG_DIRECTORY } from './config.js';
-const REGISTRY_FILE_NAME = 'repos.json';
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
+const REGISTRY_FILE_NAME = "repos.json";
 const MAX_REGISTRY_ENTRIES = 100;
 export function REGISTRY_FILE_PATH(home = homedir()) {
     const configDir = process.env.GJI_CONFIG_DIR;
@@ -14,7 +14,7 @@ export function REGISTRY_FILE_PATH(home = homedir()) {
 export async function loadRegistry(home = homedir()) {
     const path = REGISTRY_FILE_PATH(home);
     try {
-        const raw = await readFile(path, 'utf8');
+        const raw = await readFile(path, "utf8");
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed))
             return [];
@@ -24,29 +24,55 @@ export async function loadRegistry(home = homedir()) {
         return [];
     }
 }
+async function canonicalizeRepoPath(repoPath) {
+    try {
+        return await realpath(repoPath);
+    }
+    catch {
+        return resolve(repoPath);
+    }
+}
 export async function registerRepo(repoPath, home = homedir()) {
     const registryPath = REGISTRY_FILE_PATH(home);
-    const existing = await loadRegistry(home);
+    const existing = await normalizeRegistryForWrite(await loadRegistry(home));
+    const canonicalRepoPath = await canonicalizeRepoPath(repoPath);
     // Skip write if this repo is already the most-recently-used entry (common case).
-    if (existing.length > 0 && existing[0].path === repoPath)
+    if (existing.length > 0 && existing[0].path === canonicalRepoPath)
         return;
     const entry = {
         lastUsed: Date.now(),
-        name: basename(repoPath),
-        path: repoPath,
+        name: basename(canonicalRepoPath),
+        path: canonicalRepoPath,
     };
-    const filtered = existing.filter((e) => e.path !== repoPath);
+    const filtered = existing.filter((e) => e.path !== canonicalRepoPath);
     const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
     await mkdir(dirname(registryPath), { recursive: true });
-    await writeFile(registryPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+    await writeFile(registryPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}
+async function normalizeRegistryForWrite(entries) {
+    const normalized = [];
+    const seenPaths = new Set();
+    for (const entry of entries) {
+        const canonicalPath = await canonicalizeRepoPath(entry.path);
+        if (seenPaths.has(canonicalPath)) {
+            continue;
+        }
+        seenPaths.add(canonicalPath);
+        normalized.push({
+            ...entry,
+            name: basename(canonicalPath),
+            path: canonicalPath,
+        });
+    }
+    return normalized;
 }
 function isRegistryEntry(value) {
-    return (typeof value === 'object' &&
+    return (typeof value === "object" &&
         value !== null &&
-        'path' in value &&
-        typeof value.path === 'string' &&
-        'name' in value &&
-        typeof value.name === 'string' &&
-        'lastUsed' in value &&
-        typeof value.lastUsed === 'number');
+        "path" in value &&
+        typeof value.path === "string" &&
+        "name" in value &&
+        typeof value.name === "string" &&
+        "lastUsed" in value &&
+        typeof value.lastUsed === "number");
 }

package/dist/repo.js

@@ -1,9 +1,9 @@
-import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
-import { homedir } from 'node:os';
-import { runGit } from './git.js';
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { runGit } from "./git.js";
 export async function detectRepository(cwd) {
-    const currentRoot = await runGit(cwd, ['rev-parse', '--show-toplevel']);
-    const rawCommonDir = await runGit(cwd, ['rev-parse', '--git-common-dir']);
+    const currentRoot = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    const rawCommonDir = await runGit(cwd, ["rev-parse", "--git-common-dir"]);
     const gitCommonDir = isAbsolute(rawCommonDir)
         ? rawCommonDir
         : resolve(currentRoot, rawCommonDir);
@@ -17,71 +17,72 @@ export async function detectRepository(cwd) {
     };
 }
 export function resolveWorktreePath(repoRoot, branch, basePath) {
-    const segments = branch.split('/').filter(Boolean);
+    const segments = branch.split("/").filter(Boolean);
     if (segments.length === 0) {
-        throw new Error('Branch name must not be empty.');
+        throw new Error("Branch name must not be empty.");
     }
-    if (segments.some((segment) => segment === '.' || segment === '..')) {
+    if (segments.some((segment) => segment === "." || segment === "..")) {
         throw new Error(`Branch name '${branch}' contains an invalid path segment.`);
     }
     const base = basePath
         ? expandTildeInPath(basePath)
-        : join(dirname(repoRoot), 'worktrees', basename(repoRoot));
+        : join(dirname(repoRoot), "worktrees", basename(repoRoot));
     return join(base, ...segments);
 }
 export function validateBranchName(name) {
     if (name.length === 0) {
-        return 'Branch name must not be empty.';
+        return "Branch name must not be empty.";
     }
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional control chars to reject in git branch names
     if (/[\x00-\x1f\x7f ~^:?*[\\\s]/.test(name)) {
         return `Branch name '${name}' contains an invalid character.`;
     }
-    if (name.startsWith('-')) {
+    if (name.startsWith("-")) {
         return `Branch name '${name}' must not start with a dash.`;
     }
-    if (name.startsWith('/') || name.endsWith('/') || name.includes('//')) {
+    if (name.startsWith("/") || name.endsWith("/") || name.includes("//")) {
         return `Branch name '${name}' has invalid slash placement.`;
     }
-    if (name.includes('..')) {
+    if (name.includes("..")) {
         return `Branch name '${name}' must not contain '..'.`;
     }
-    if (name.endsWith('.')) {
+    if (name.endsWith(".")) {
         return `Branch name '${name}' must not end with '.'.`;
     }
-    if (name.includes('@{')) {
+    if (name.includes("@{")) {
         return `Branch name '${name}' must not contain '@{'.`;
     }
-    if (name === '@') {
+    if (name === "@") {
         return "Branch name cannot be '@'.";
     }
-    for (const segment of name.split('/')) {
-        if (segment.startsWith('.')) {
+    for (const segment of name.split("/")) {
+        if (segment.startsWith(".")) {
             return `Branch name '${name}' contains a path component starting with '.'.`;
         }
-        if (segment.endsWith('.lock')) {
+        if (segment.endsWith(".lock")) {
             return `Branch name '${name}' contains a path component ending with '.lock'.`;
         }
     }
     return null;
 }
 function expandTildeInPath(p) {
-    if (p === '~')
+    if (p === "~")
         return homedir();
-    if (p.startsWith('~/'))
+    if (p.startsWith("~/"))
         return join(homedir(), p.slice(2));
     return p;
 }
 export async function listWorktrees(cwd) {
     const [output, currentRoot] = await Promise.all([
-        runGit(cwd, ['worktree', 'list', '--porcelain']),
-        runGit(cwd, ['rev-parse', '--show-toplevel']),
+        runGit(cwd, ["worktree", "list", "--porcelain"]),
+        runGit(cwd, ["rev-parse", "--show-toplevel"]),
     ]);
-    const entries = output.split('\n\n').filter(Boolean);
+    const entries = output.split("\n\n").filter(Boolean);
     return entries.map((entry) => {
-        const path = findPorcelainValue(entry, 'worktree');
-        const branchRef = findOptionalPorcelainValue(entry, 'branch');
+        const path = findPorcelainValue(entry, "worktree");
+        const branchRef = findOptionalPorcelainValue(entry, "branch");
         return {
-            branch: branchRef ? branchRef.replace('refs/heads/', '') : null,
+            branch: branchRef ? branchRef.replace("refs/heads/", "") : null,
             isCurrent: path === currentRoot,
             path,
         };
@@ -105,7 +106,7 @@ function findPorcelainValue(block, key) {
 }
 function findOptionalPorcelainValue(block, key) {
     const line = block
-        .split('\n')
+        .split("\n")
         .find((candidate) => candidate.startsWith(`${key} `));
     if (!line) {
         return null;

package/dist/root.js

@@ -1,6 +1,6 @@
-import { detectRepository } from './repo.js';
-import { writeShellOutput } from './shell-handoff.js';
-const ROOT_OUTPUT_FILE_ENV = 'GJI_ROOT_OUTPUT_FILE';
+import { detectRepository } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
+const ROOT_OUTPUT_FILE_ENV = "GJI_ROOT_OUTPUT_FILE";
 export async function runRootCommand(options) {
     const repository = await detectRepository(options.cwd);
     if (!options.print && process.env[ROOT_OUTPUT_FILE_ENV]) {

package/dist/shell-completion.d.ts

@@ -1 +1 @@
-export declare function renderShellCompletion(shell: 'bash' | 'fish' | 'zsh'): string;
+export declare function renderShellCompletion(shell: "bash" | "fish" | "zsh"): string;