@solaqua/gji 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1,8 +1,13 @@
 import { createRequire } from 'node:module';
 import { Command } from 'commander';
+import updateNotifier from 'update-notifier';
+import { runBackCommand } from './back.js';
 import { runCleanCommand } from './clean.js';
+import { runHistoryCommand } from './history-command.js';
+import { runCompletionCommand } from './completion.js';
 import { runConfigCommand } from './config-command.js';
 import { runGoCommand } from './go.js';
+import { isHeadless } from './headless.js';
 import { runInitCommand } from './init.js';
 import { runLsCommand } from './ls.js';
 import { runNewCommand } from './new.js';
@@ -14,22 +19,26 @@ import { runSyncCommand } from './sync.js';
 import { runTriggerHookCommand } from './trigger-hook.js';
 export function createProgram() {
     const program = new Command();
-    const packageVersion = readPackageVersion();
+    const packageMetadata = readPackageMetadata();
     program
         .name('gji')
         .description('Context switching without the mess.')
-        .version(packageVersion)
+        .version(packageMetadata.version)
         .showHelpAfterError()
         .showSuggestionAfterError();
     registerCommands(program);
     return program;
 }
-function readPackageVersion() {
+function readPackageMetadata() {
     const require = createRequire(import.meta.url);
     const packageJson = require('../package.json');
-    return typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
+    return {
+        name: typeof packageJson.name === 'string' ? packageJson.name : 'gji',
+        version: typeof packageJson.version === 'string' ? packageJson.version : '0.0.0',
+    };
 }
 export async function runCli(argv, options = {}) {
+    await maybeNotifyForUpdates(argv);
     const program = createProgram();
     const cwd = options.cwd ?? process.cwd();
     const stdout = options.stdout ?? (() => undefined);
@@ -55,6 +64,36 @@ export async function runCli(argv, options = {}) {
         throw error;
     }
 }
+async function maybeNotifyForUpdates(argv) {
+    if (shouldSkipUpdateNotification(argv)) {
+        return;
+    }
+    try {
+        defaultNotifyForUpdates(readPackageMetadata());
+    }
+    catch {
+        // Ignore notifier failures so startup behaviour stays stable.
+    }
+}
+function shouldSkipUpdateNotification(argv) {
+    return (argv.length === 0
+        || argv.includes('--json')
+        || argv.some(isHelpOrVersionArgument)
+        || isHeadless()
+        || process.stdout.isTTY !== true
+        || process.stderr.isTTY !== true);
+}
+function isHelpOrVersionArgument(argument) {
+    return (argument === '--help'
+        || argument === '-h'
+        || argument === 'help'
+        || argument === '--version'
+        || argument === '-V');
+}
+function defaultNotifyForUpdates(pkg) {
+    const notifier = updateNotifier({ pkg });
+    notifier.notify();
+}
 function registerCommands(program) {
     program
         .command('new [branch]')
@@ -69,12 +108,26 @@ function registerCommands(program) {
         .description('print or install shell integration')
         .option('--write', 'write the integration to the shell config file')
         .action(notImplemented('init'));
+    program
+        .command('completion [shell]')
+        .description('print shell completion definitions')
+        .action(notImplemented('completion'));
     program
         .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
+        .command('back [n]')
+        .description('navigate to the previously visited worktree, optionally N steps back')
+        .option('--print', 'print the resolved worktree path explicitly')
+        .action(notImplemented('back'));
+    program
+        .command('history')
+        .description('show navigation history')
+        .option('--json', 'print history as JSON')
+        .action(notImplemented('history'));
     program
         .command('go [branch]')
         .description('print or select a worktree path')
@@ -99,12 +152,14 @@ function registerCommands(program) {
     program
         .command('ls')
         .description('list active worktrees')
+        .option('--compact', 'show only branch and path columns')
         .option('--json', 'print active worktrees as JSON')
         .action(notImplemented('ls'));
     program
         .command('clean')
         .description('interactively prune linked worktrees')
         .option('-f, --force', 'bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches')
+        .option('--stale', 'only target clean worktrees whose upstream is gone and branch is merged into the default 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('clean'));
@@ -160,6 +215,18 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
+    program.commands
+        .find((command) => command.name() === 'completion')
+        ?.action(async (shell) => {
+        const exitCode = await runCompletionCommand({
+            shell,
+            stderr: options.stderr,
+            stdout: options.stdout,
+        });
+        if (exitCode !== 0) {
+            throw commanderExit(exitCode);
+        }
+    });
     program.commands
         .find((command) => command.name() === 'pr')
         ?.action(async (number, commandOptions) => {
@@ -168,6 +235,37 @@ function attachCommandActions(program, options) {
             throw commanderExit(exitCode);
         }
     });
+    program.commands
+        .find((command) => command.name() === 'back')
+        ?.action(async (n, commandOptions) => {
+        if (n !== undefined && !/^\d+$/.test(n)) {
+            options.stderr(`gji back: invalid step count: ${n}\n`);
+            throw commanderExit(1);
+        }
+        const steps = n !== undefined ? parseInt(n, 10) : undefined;
+        const exitCode = await runBackCommand({
+            cwd: options.cwd,
+            n: steps,
+            print: commandOptions.print,
+            stderr: options.stderr,
+            stdout: options.stdout,
+        });
+        if (exitCode !== 0) {
+            throw commanderExit(exitCode);
+        }
+    });
+    program.commands
+        .find((command) => command.name() === 'history')
+        ?.action(async (commandOptions) => {
+        const exitCode = await runHistoryCommand({
+            cwd: options.cwd,
+            json: commandOptions.json,
+            stdout: options.stdout,
+        });
+        if (exitCode !== 0) {
+            throw commanderExit(exitCode);
+        }
+    });
     program.commands
         .find((command) => command.name() === 'go')
         ?.action(async (branch, commandOptions) => {
@@ -224,6 +322,7 @@ function attachCommandActions(program, options) {
         .find((command) => command.name() === 'ls')
         ?.action(async (commandOptions) => {
         const exitCode = await runLsCommand({
+            compact: commandOptions.compact,
             cwd: options.cwd,
             json: commandOptions.json,
             stdout: options.stdout,
@@ -240,6 +339,7 @@ function attachCommandActions(program, options) {
             dryRun: commandOptions.dryRun,
             force: commandOptions.force,
             json: commandOptions.json,
+            stale: commandOptions.stale,
             stderr: options.stderr,
             stdout: options.stdout,
         });

package/dist/completion.d.ts

@@ -0,0 +1,6 @@
+export interface CompletionCommandOptions {
+    shell?: string;
+    stderr?: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function runCompletionCommand(options: CompletionCommandOptions): Promise<number>;

package/dist/completion.js

@@ -0,0 +1,11 @@
+import { renderShellCompletion } from './shell-completion.js';
+import { resolveSupportedShell } from './shell.js';
+export async function runCompletionCommand(options) {
+    const shell = resolveSupportedShell(options.shell, process.env.SHELL);
+    if (!shell) {
+        options.stderr?.('Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n');
+        return 1;
+    }
+    options.stdout(renderShellCompletion(shell));
+    return 0;
+}

package/dist/git.d.ts

@@ -8,3 +8,6 @@ export interface WorktreeHealth {
 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 readBranchLastCommitTimestamp(cwd: string, branch: string): Promise<number | null>;

package/dist/git.js

@@ -19,6 +19,39 @@ export async function isDirtyWorktree(cwd) {
     const health = await readWorktreeHealth(cwd);
     return health.status === 'dirty';
 }
+export async function isBranchMergedInto(cwd, branch, base = 'HEAD') {
+    try {
+        await execFileAsync('git', ['merge-base', '--is-ancestor', branch, base], { cwd });
+        return true;
+    }
+    catch (error) {
+        if (hasExitCode(error, 1)) {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function resolveRemoteDefaultBranch(cwd, remote) {
+    const { stdout } = await execFileAsync('git', ['ls-remote', '--symref', remote, 'HEAD'], { cwd });
+    const refLine = stdout
+        .split('\n')
+        .find((line) => line.startsWith('ref: refs/heads/'));
+    if (!refLine) {
+        return null;
+    }
+    const match = /^ref: refs\/heads\/(.+)\tHEAD$/.exec(refLine);
+    return match?.[1] ?? null;
+}
+export async function readBranchLastCommitTimestamp(cwd, branch) {
+    try {
+        const { stdout } = await execFileAsync('git', ['log', '-1', '--format=%ct', branch], { cwd });
+        const timestamp = Number(stdout.trim());
+        return Number.isFinite(timestamp) ? timestamp : null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseWorktreeHealth(output) {
     let ahead = 0;
     let behind = 0;
@@ -52,3 +85,8 @@ function parseWorktreeHealth(output) {
         status: dirty ? 'dirty' : 'clean',
     };
 }
+function hasExitCode(error, code) {
+    return error instanceof Error
+        && 'code' in error
+        && error.code === code;
+}

package/dist/gji

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import('./gji-bundle.mjs').catch(err => {
+  process.stderr.write(err.message + '\n');
+  process.exit(1);
+});