@solaqua/gji 0.1.0-beta.7 → 0.1.0-beta.9

package/README.md

@@ -110,6 +110,8 @@ Pull a PR into its own worktree:
 
 ```sh
 gji pr 123
+gji pr #123
+gji pr https://github.com/owner/repo/pull/123
 ```
 
 Sync the current worktree with the latest default branch:
@@ -145,7 +147,7 @@ After removal, the shell-integrated command returns you to the repository root.
 - `gji --version` prints the installed CLI version
 - `gji init [shell]` prints shell integration for `zsh`, `bash`, or `fish`
 - `gji new [branch] [--detached]` creates a branch and linked worktree; with shell integration it moves into the new worktree, and `--detached` creates a detached worktree instead
-- `gji pr <number>` fetches `origin/pull/<number>/head` and creates a linked `pr/<number>` worktree
+- `gji pr <ref>` accepts `123`, `#123`, or a full PR/MR URL, extracts the numeric ID, then fetches `origin/pull/<number>/head` and creates a linked `pr/<number>` worktree
 - `gji go [branch] [--print]` jumps to an existing worktree when shell integration is installed, or prints the matching worktree path otherwise
 - `gji root [--print]` jumps to the main repository root when shell integration is installed, or prints it otherwise
 - `gji status [--json]` prints repository metadata, worktree health, and upstream divergence
@@ -214,7 +216,7 @@ Each worktree entry contains:
 
 - `gji` works from either the main repository root or any linked worktree
 - the current worktree is never offered as a `gji clean` removal candidate
-- `gji` currently uses GitHub-style PR refs for `gji pr`
+- `gji pr` accepts GitHub, GitLab, and Bitbucket-style PR/MR links, but still fetches from `origin` using GitHub-style `refs/pull/<number>/head`
 
 ## License
 

package/dist/cli.js

@@ -145,7 +145,7 @@ function attachCommandActions(program, options) {
     program.commands
         .find((command) => command.name() === 'pr')
         ?.action(async (number) => {
-        const exitCode = await runPrCommand({ cwd: options.cwd, number, stdout: options.stdout });
+        const exitCode = await runPrCommand({ cwd: options.cwd, number, stderr: options.stderr, stdout: options.stdout });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }

package/dist/conflict.d.ts

@@ -0,0 +1,3 @@
+export type PathConflictChoice = 'abort' | 'reuse';
+export declare function pathExists(path: string): Promise<boolean>;
+export declare function promptForPathConflict(path: string): Promise<PathConflictChoice>;

package/dist/conflict.js

@@ -0,0 +1,25 @@
+import { access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { isCancel, select } from '@clack/prompts';
+export async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function promptForPathConflict(path) {
+    const choice = await select({
+        message: `Target path already exists: ${path}`,
+        options: [
+            { value: 'abort', label: 'Abort', hint: 'Keep the existing directory untouched' },
+            { value: 'reuse', label: 'Reuse path', hint: 'Print the existing path and stop' },
+        ],
+    });
+    if (isCancel(choice)) {
+        return 'abort';
+    }
+    return choice;
+}

package/dist/init.js

@@ -11,6 +11,13 @@ const SHELL_WRAPPED_COMMANDS = [
         names: ['new'],
         tempPrefix: 'gji-new',
     },
+    {
+        bypassOption: '--help',
+        commandName: 'pr',
+        envVar: 'GJI_PR_OUTPUT_FILE',
+        names: ['pr'],
+        tempPrefix: 'gji-pr',
+    },
     {
         bypassOption: '--print',
         commandName: 'go',

package/dist/new.d.ts

@@ -1,4 +1,5 @@
-export type PathConflictChoice = 'abort' | 'reuse';
+import { type PathConflictChoice } from './conflict.js';
+export type { PathConflictChoice };
 export interface NewCommandOptions {
     branch?: string;
     cwd: string;

package/dist/new.js

@@ -1,10 +1,10 @@
-import { access, mkdir } from 'node:fs/promises';
-import { constants } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { isCancel, select, text } from '@clack/prompts';
+import { isCancel, text } from '@clack/prompts';
 import { loadEffectiveConfig } from './config.js';
+import { pathExists, promptForPathConflict } from './conflict.js';
 import { detectRepository, resolveWorktreePath } from './repo.js';
 import { writeShellOutput } from './shell-handoff.js';
 const execFileAsync = promisify(execFile);
@@ -42,21 +42,14 @@ export function createNewCommand(dependencies = {}) {
         await mkdir(dirname(worktreePath), { recursive: true });
         const gitArgs = options.detached
             ? ['worktree', 'add', '--detach', worktreePath]
-            : ['worktree', 'add', '-b', worktreeName, worktreePath];
+            : await localBranchExists(repository.repoRoot, worktreeName)
+                ? ['worktree', 'add', worktreePath, worktreeName]
+                : ['worktree', 'add', '-b', worktreeName, worktreePath];
         await execFileAsync('git', gitArgs, { cwd: repository.repoRoot });
         await writeOutput(worktreePath, options.stdout);
         return 0;
     };
 }
-async function pathExists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 export const runNewCommand = createNewCommand();
 export function generateBranchPlaceholder(random = Math.random) {
     const roots = [
@@ -120,19 +113,6 @@ async function resolveUniqueDetachedWorktreePath(repoRoot, baseName) {
         attempt += 1;
     }
 }
-async function promptForPathConflict(path) {
-    const choice = await select({
-        message: `Target path already exists: ${path}`,
-        options: [
-            { value: 'abort', label: 'Abort', hint: 'Keep the existing directory untouched' },
-            { value: 'reuse', label: 'Reuse path', hint: 'Print the existing path and stop' },
-        ],
-    });
-    if (isCancel(choice)) {
-        return 'abort';
-    }
-    return choice;
-}
 async function defaultPromptForBranch(placeholder) {
     const choice = await text({
         defaultValue: placeholder,
@@ -149,6 +129,15 @@ function pickRandom(values, random) {
     const index = Math.floor(random() * values.length);
     return values[Math.min(index, values.length - 1)];
 }
+async function localBranchExists(repoRoot, branchName) {
+    try {
+        await execFileAsync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], { cwd: repoRoot });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function writeOutput(worktreePath, stdout) {
     await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
 }

package/dist/pr.d.ts

@@ -1,6 +1,14 @@
+import { type PathConflictChoice } from './conflict.js';
+export type { PathConflictChoice };
 export interface PrCommandOptions {
     cwd: string;
     number: string;
+    stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }
-export declare function runPrCommand(options: PrCommandOptions): Promise<number>;
+export interface PrCommandDependencies {
+    promptForPathConflict: (path: string) => Promise<PathConflictChoice>;
+}
+export declare function parsePrInput(input: string): string | null;
+export declare function createPrCommand(dependencies?: Partial<PrCommandDependencies>): (options: PrCommandOptions) => Promise<number>;
+export declare const runPrCommand: (options: PrCommandOptions) => Promise<number>;

package/dist/pr.js

@@ -2,16 +2,70 @@ import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { pathExists, promptForPathConflict } from './conflict.js';
 import { detectRepository, resolveWorktreePath } from './repo.js';
+import { writeShellOutput } from './shell-handoff.js';
 const execFileAsync = promisify(execFile);
-export async function runPrCommand(options) {
-    const repository = await detectRepository(options.cwd);
-    const branchName = `pr/${options.number}`;
-    const remoteRef = `refs/remotes/origin/pull/${options.number}/head`;
-    const worktreePath = resolveWorktreePath(repository.repoRoot, branchName);
-    await execFileAsync('git', ['fetch', 'origin', `refs/pull/${options.number}/head:${remoteRef}`], { cwd: repository.repoRoot });
-    await mkdir(dirname(worktreePath), { recursive: true });
-    await execFileAsync('git', ['worktree', 'add', '-b', branchName, worktreePath, remoteRef], { cwd: repository.repoRoot });
-    options.stdout(`${worktreePath}\n`);
-    return 0;
+const PR_OUTPUT_FILE_ENV = 'GJI_PR_OUTPUT_FILE';
+export function parsePrInput(input) {
+    if (/^\d+$/.test(input))
+        return input;
+    const hashMatch = input.match(/^#(\d+)$/);
+    if (hashMatch)
+        return hashMatch[1];
+    const urlMatch = input.match(/\/(?:pull|pull-requests|merge_requests)\/(\d+)/);
+    if (urlMatch)
+        return urlMatch[1];
+    return null;
+}
+export function createPrCommand(dependencies = {}) {
+    const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
+    return async function runPrCommand(options) {
+        const prNumber = parsePrInput(options.number);
+        if (!prNumber) {
+            options.stderr(`Invalid PR reference: ${options.number}\n`);
+            return 1;
+        }
+        const repository = await detectRepository(options.cwd);
+        const branchName = `pr/${prNumber}`;
+        const remoteRef = `refs/remotes/origin/pull/${prNumber}/head`;
+        const worktreePath = resolveWorktreePath(repository.repoRoot, branchName);
+        if (await pathExists(worktreePath)) {
+            const choice = await prompt(worktreePath);
+            if (choice === 'reuse') {
+                await writeOutput(worktreePath, options.stdout);
+                return 0;
+            }
+            options.stderr(`Aborted because target worktree path already exists: ${worktreePath}\n`);
+            return 1;
+        }
+        try {
+            await execFileAsync('git', ['fetch', 'origin', `refs/pull/${prNumber}/head:${remoteRef}`], { cwd: repository.repoRoot });
+        }
+        catch {
+            options.stderr(`Failed to fetch PR #${prNumber} from origin\n`);
+            return 1;
+        }
+        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 });
+        await writeOutput(worktreePath, options.stdout);
+        return 0;
+    };
+}
+async function localBranchExists(repoRoot, branchName) {
+    try {
+        await execFileAsync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], { cwd: repoRoot });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const runPrCommand = createPrCommand();
+async function writeOutput(worktreePath, stdout) {
+    await writeShellOutput(PR_OUTPUT_FILE_ENV, worktreePath, stdout);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solaqua/gji",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.9",
   "description": "Git worktree CLI for fast context switching.",
   "license": "MIT",
   "author": "sjquant",