@solaqua/gji 0.2.0 → 0.2.1

package/dist/clean.d.ts

@@ -1,6 +1,7 @@
 import type { WorktreeEntry } from './repo.js';
 export interface CleanCommandOptions {
     cwd: string;
+    dryRun?: boolean;
     force?: boolean;
     json?: boolean;
     stderr: (chunk: string) => void;

package/dist/clean.js

@@ -14,7 +14,7 @@ export function createCleanCommand(dependencies = {}) {
             emitError(options, 'No linked worktrees to clean');
             return 1;
         }
-        if (!options.force && (options.json || isHeadless())) {
+        if (!options.dryRun && !options.force && (options.json || isHeadless())) {
             const message = '--force is required';
             if (options.json) {
                 emitError(options, message);
@@ -24,8 +24,9 @@ export function createCleanCommand(dependencies = {}) {
             }
             return 1;
         }
-        // With --force, skip selection prompt and target all candidates.
-        const selections = options.force
+        // With --force, or dry-run in headless/json mode, skip selection prompt and target all candidates.
+        const shouldSelectAll = options.force || (options.dryRun && (options.json || isHeadless()));
+        const selections = shouldSelectAll
             ? cleanupCandidates.map((w) => w.path)
             : await promptForWorktrees(cleanupCandidates);
         if (!selections || selections.length === 0) {
@@ -37,10 +38,23 @@ export function createCleanCommand(dependencies = {}) {
             options.stderr('Selected worktree no longer exists\n');
             return 1;
         }
-        if (!options.force && !(await confirmRemoval(selectedWorktrees))) {
+        if (!options.dryRun && !options.force && !(await confirmRemoval(selectedWorktrees))) {
             options.stderr('Aborted\n');
             return 1;
         }
+        if (options.dryRun) {
+            if (options.json) {
+                const removed = selectedWorktrees.map((w) => ({ branch: w.branch, path: w.path }));
+                options.stdout(`${JSON.stringify({ removed, dryRun: true }, null, 2)}\n`);
+            }
+            else {
+                for (const w of selectedWorktrees) {
+                    const desc = w.branch ? `branch: ${w.branch}` : 'detached';
+                    options.stdout(`Would remove worktree at ${w.path} (${desc})\n`);
+                }
+            }
+            return 0;
+        }
         const removedPaths = [];
         const removedWorktrees = [];
         for (const worktree of selectedWorktrees) {

package/dist/cli.js

@@ -59,6 +59,7 @@ function registerCommands(program) {
         .command('new [branch]')
         .description('create a new branch or detached linked worktree')
         .option('--detached', 'create a detached worktree without a branch')
+        .option('--dry-run', 'show what would be created without executing any git commands or writing files')
         .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('new'));
     program
@@ -67,8 +68,9 @@ function registerCommands(program) {
         .option('--write', 'write the integration to the shell config file')
         .action(notImplemented('init'));
     program
-        .command('pr <number>')
-        .description('fetch a pull request ref and create a linked worktree')
+        .command('pr <ref>')
+        .description('fetch a pull request by number, #number, or URL into a linked worktree')
+        .option('--dry-run', 'show what would be created without executing any git commands or writing files')
         .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('pr'));
     program
@@ -90,6 +92,7 @@ function registerCommands(program) {
         .command('sync')
         .description('fetch and update one or all worktrees')
         .option('--all', 'sync every worktree in the repository')
+        .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('sync'));
     program
         .command('ls')
@@ -100,6 +103,7 @@ function registerCommands(program) {
         .command('clean')
         .description('interactively prune linked worktrees')
         .option('-f, --force', 'bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches')
+        .option('--dry-run', 'show what would be deleted without removing anything')
         .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('clean'));
     program
@@ -107,6 +111,7 @@ function registerCommands(program) {
         .alias('rm')
         .description('remove a linked worktree and delete its branch when present')
         .option('-f, --force', 'bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch')
+        .option('--dry-run', 'show what would be deleted without removing anything')
         .option('--json', 'emit JSON on success or error instead of human-readable output')
         .action(notImplemented('remove'));
     const configCommand = program
@@ -130,7 +135,7 @@ function attachCommandActions(program, options) {
     program.commands
         .find((command) => command.name() === 'new')
         ?.action(async (branch, commandOptions) => {
-        const exitCode = await runNewCommand({ ...options, branch, detached: commandOptions.detached, json: commandOptions.json });
+        const exitCode = await runNewCommand({ ...options, branch, detached: commandOptions.detached, dryRun: commandOptions.dryRun, json: commandOptions.json });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
@@ -151,7 +156,7 @@ function attachCommandActions(program, options) {
     program.commands
         .find((command) => command.name() === 'pr')
         ?.action(async (number, commandOptions) => {
-        const exitCode = await runPrCommand({ cwd: options.cwd, json: commandOptions.json, number, stderr: options.stderr, stdout: options.stdout });
+        const exitCode = await runPrCommand({ cwd: options.cwd, dryRun: commandOptions.dryRun, json: commandOptions.json, number, stderr: options.stderr, stdout: options.stdout });
         if (exitCode !== 0) {
             throw commanderExit(exitCode);
         }
@@ -200,6 +205,7 @@ function attachCommandActions(program, options) {
         const exitCode = await runSyncCommand({
             all: commandOptions.all,
             cwd: options.cwd,
+            json: commandOptions.json,
             stderr: options.stderr,
             stdout: options.stdout,
         });
@@ -224,6 +230,7 @@ function attachCommandActions(program, options) {
         ?.action(async (commandOptions) => {
         const exitCode = await runCleanCommand({
             cwd: options.cwd,
+            dryRun: commandOptions.dryRun,
             force: commandOptions.force,
             json: commandOptions.json,
             stderr: options.stderr,
@@ -237,6 +244,7 @@ function attachCommandActions(program, options) {
         const exitCode = await runRemoveCommand({
             branch,
             cwd: options.cwd,
+            dryRun: commandOptions.dryRun,
             force: commandOptions.force,
             json: commandOptions.json,
             stderr: options.stderr,

package/dist/go.js

@@ -22,9 +22,13 @@ export function createGoCommand(dependencies = {}) {
             ? worktrees.find((entry) => entry.branch === options.branch)?.path
             : prompted ?? undefined;
         if (!resolvedPath) {
-            options.stderr(options.branch
-                ? `No worktree found for branch: ${options.branch}\n`
-                : 'Aborted\n');
+            if (options.branch) {
+                options.stderr(`No worktree found for branch: ${options.branch}\n`);
+                options.stderr(`Hint: Use 'gji ls' to see available worktrees\n`);
+            }
+            else {
+                options.stderr('Aborted\n');
+            }
             return 1;
         }
         const chosenWorktree = worktrees.find((w) => w.path === resolvedPath);

package/dist/new.d.ts

@@ -5,6 +5,7 @@ export interface NewCommandOptions {
     branch?: string;
     cwd: string;
     detached?: boolean;
+    dryRun?: boolean;
     json?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;

package/dist/new.js

@@ -57,6 +57,7 @@ export function createNewCommand(dependencies = {}) {
                 }
                 else {
                     options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)\n`);
+                    options.stderr(`Hint: Use 'gji remove ${worktreeName}' or 'gji clean' to remove the existing worktree\n`);
                 }
                 return 1;
             }
@@ -68,6 +69,15 @@ export function createNewCommand(dependencies = {}) {
             options.stderr(`Aborted because target worktree path already exists: ${worktreePath}\n`);
             return 1;
         }
+        if (options.dryRun) {
+            if (options.json) {
+                options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath, dryRun: true }, null, 2)}\n`);
+            }
+            else {
+                options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName})\n`);
+            }
+            return 0;
+        }
         await mkdir(dirname(worktreePath), { recursive: true });
         const gitArgs = options.detached
             ? ['worktree', 'add', '--detach', worktreePath]

package/dist/pr.d.ts

@@ -3,6 +3,7 @@ import { type InstallPromptDependencies } from './install-prompt.js';
 export type { PathConflictChoice };
 export interface PrCommandOptions {
     cwd: string;
+    dryRun?: boolean;
     json?: boolean;
     number: string;
     stderr: (chunk: string) => void;

package/dist/pr.js

@@ -50,6 +50,7 @@ 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`);
                 }
                 return 1;
             }
@@ -61,6 +62,15 @@ export function createPrCommand(dependencies = {}) {
             options.stderr(`Aborted because target worktree path already exists: ${worktreePath}\n`);
             return 1;
         }
+        if (options.dryRun) {
+            if (options.json) {
+                options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath, dryRun: true }, null, 2)}\n`);
+            }
+            else {
+                options.stdout(`Would create worktree at ${worktreePath} (branch: ${branchName})\n`);
+            }
+            return 0;
+        }
         try {
             await execFileAsync('git', ['fetch', 'origin', `refs/pull/${prNumber}/head:${remoteRef}`], { cwd: repository.repoRoot });
         }
@@ -71,6 +81,7 @@ export function createPrCommand(dependencies = {}) {
             }
             else {
                 options.stderr(`${message}\n`);
+                options.stderr(`Hint: Verify the remote is reachable: git fetch origin\n`);
             }
             return 1;
         }

package/dist/remove.d.ts

@@ -2,6 +2,7 @@ import type { WorktreeEntry } from './repo.js';
 export interface RemoveCommandOptions {
     branch?: string;
     cwd: string;
+    dryRun?: boolean;
     force?: boolean;
     json?: boolean;
     stderr: (chunk: string) => void;

package/dist/remove.js

@@ -38,7 +38,7 @@ export function createRemoveCommand(dependencies = {}) {
             emitError(options, `No linked worktree found for branch: ${selection}`);
             return 1;
         }
-        if (!options.force && (options.json || isHeadless())) {
+        if (!options.dryRun && !options.force && (options.json || isHeadless())) {
             const message = '--force is required';
             if (options.json) {
                 emitError(options, message);
@@ -48,10 +48,20 @@ export function createRemoveCommand(dependencies = {}) {
             }
             return 1;
         }
-        if (!options.force && !(await confirmRemoval(worktree))) {
+        if (!options.dryRun && !options.force && !(await confirmRemoval(worktree))) {
             options.stderr('Aborted\n');
             return 1;
         }
+        if (options.dryRun) {
+            if (options.json) {
+                options.stdout(`${JSON.stringify({ branch: worktree.branch, path: worktree.path, dryRun: true }, null, 2)}\n`);
+            }
+            else {
+                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);
         const hooks = extractHooks(config);
         await runHook(hooks.beforeRemove, worktree.path, { branch: worktree.branch ?? undefined, path: worktree.path, repo: basename(repository.repoRoot) }, options.stderr);

package/dist/sync.d.ts

@@ -1,6 +1,7 @@
 export interface SyncCommandOptions {
     all?: boolean;
     cwd: string;
+    json?: boolean;
     stderr: (chunk: string) => void;
     stdout: (chunk: string) => void;
 }

package/dist/sync.js

@@ -7,24 +7,47 @@ export async function runSyncCommand(options) {
     const config = await loadEffectiveConfig(repository.repoRoot);
     const worktrees = await listWorktrees(options.cwd);
     const remote = resolveConfiguredString(config.syncRemote) ?? 'origin';
-    const defaultBranch = resolveConfiguredString(config.syncDefaultBranch)
-        ?? await resolveDefaultBranch(repository.repoRoot, remote);
+    let defaultBranch;
+    try {
+        defaultBranch = resolveConfiguredString(config.syncDefaultBranch)
+            ?? await resolveDefaultBranch(repository.repoRoot, remote);
+    }
+    catch {
+        emitError(options, `Unable to reach remote '${remote}'`);
+        if (!options.json) {
+            options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>\n`);
+        }
+        return 1;
+    }
     if (!defaultBranch) {
-        options.stderr('Unable to determine the default branch for sync.\n');
+        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`);
+        }
         return 1;
     }
     const targetWorktrees = selectTargetWorktrees(worktrees, repository.currentRoot, options.all);
     if (targetWorktrees === 'detached') {
-        options.stderr(`Cannot sync detached worktree: ${repository.currentRoot}\n`);
+        emitError(options, `Cannot sync detached worktree: ${repository.currentRoot}`);
         return 1;
     }
     for (const worktree of targetWorktrees) {
         if (await isDirtyWorktree(worktree.path)) {
-            options.stderr(`Cannot sync dirty worktree: ${worktree.path}\n`);
+            emitError(options, `Cannot sync dirty worktree: ${worktree.path}`);
             return 1;
         }
     }
-    await runGit(repository.repoRoot, ['fetch', '--prune', remote]);
+    try {
+        await runGit(repository.repoRoot, ['fetch', '--prune', remote]);
+    }
+    catch {
+        emitError(options, `Failed to fetch from remote '${remote}'`);
+        if (!options.json) {
+            options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>\n`);
+        }
+        return 1;
+    }
+    const updatedWorktrees = [];
     for (const worktree of targetWorktrees) {
         if (worktree.branch === defaultBranch) {
             await runGit(worktree.path, ['merge', '--ff-only', `${remote}/${defaultBranch}`]);
@@ -32,10 +55,25 @@ export async function runSyncCommand(options) {
         else {
             await runGit(worktree.path, ['rebase', `${remote}/${defaultBranch}`]);
         }
-        options.stdout(`${worktree.path}\n`);
+        updatedWorktrees.push(worktree);
+        if (!options.json) {
+            options.stdout(`${worktree.path}\n`);
+        }
+    }
+    if (options.json) {
+        const updated = updatedWorktrees.map((w) => ({ branch: w.branch, path: w.path }));
+        options.stdout(`${JSON.stringify({ updated }, null, 2)}\n`);
     }
     return 0;
 }
+function emitError(options, message) {
+    if (options.json) {
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+    }
+    else {
+        options.stderr(`${message}\n`);
+    }
+}
 function selectTargetWorktrees(worktrees, currentRoot, all) {
     if (all) {
         return worktrees

package/package.json

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