@solaqua/gji 0.4.1 → 0.5.0

package/dist/back.d.ts

@@ -0,0 +1,13 @@
+import { type HistoryEntry } from './history.js';
+export declare const BACK_OUTPUT_FILE_ENV = "GJI_BACK_OUTPUT_FILE";
+export interface BackCommandOptions {
+    cwd: string;
+    home?: string;
+    n?: number;
+    print?: boolean;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function runBackCommand(options: BackCommandOptions): Promise<number>;
+export declare function formatHistoryList(history: HistoryEntry[], cwd: string): string;
+export declare function formatAge(timestamp: number): string;

package/dist/back.js

@@ -0,0 +1,74 @@
+import { access } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { loadEffectiveConfig } from './config.js';
+import { extractHooks, runHook } from './hooks.js';
+import { appendHistory, loadHistory } from './history.js';
+import { detectRepository } from './repo.js';
+import { writeShellOutput } from './shell-handoff.js';
+export const BACK_OUTPUT_FILE_ENV = 'GJI_BACK_OUTPUT_FILE';
+export async function runBackCommand(options) {
+    const history = await loadHistory(options.home);
+    const steps = options.n ?? 1;
+    if (steps < 1) {
+        options.stderr('gji back: step count must be at least 1\n');
+        return 1;
+    }
+    let found = 0;
+    let target;
+    for (const entry of history) {
+        if (entry.path === options.cwd)
+            continue;
+        try {
+            await access(entry.path);
+            found++;
+            if (found === steps) {
+                target = entry;
+                break;
+            }
+        }
+        catch {
+            // Path no longer exists — skip to the next entry
+        }
+    }
+    if (!target) {
+        options.stderr('gji back: no previous worktree in history\n');
+        options.stderr("Hint: Use 'gji go', 'gji new', or 'gji pr' to navigate between worktrees\n");
+        return 1;
+    }
+    try {
+        const repository = await detectRepository(target.path);
+        const config = await loadEffectiveConfig(repository.repoRoot, options.home, options.stderr);
+        const hooks = extractHooks(config);
+        await runHook(hooks.afterEnter, target.path, { branch: target.branch ?? undefined, path: target.path, repo: basename(repository.repoRoot) }, options.stderr);
+    }
+    catch {
+        // Not in a git repo or hooks unavailable — proceed without hook
+    }
+    await appendHistory(target.path, target.branch, options.home);
+    await writeShellOutput(BACK_OUTPUT_FILE_ENV, target.path, options.stdout);
+    return 0;
+}
+export function formatHistoryList(history, cwd) {
+    const branchWidth = Math.max('BRANCH'.length, ...history.map((e) => (e.branch ?? '(detached)').length));
+    const lines = ['  ' + 'BRANCH'.padEnd(branchWidth) + ' WHEN       PATH'];
+    for (const entry of history) {
+        const isCurrent = entry.path === cwd;
+        const branch = (entry.branch ?? '(detached)').padEnd(branchWidth);
+        const when = formatAge(entry.timestamp).padEnd(10);
+        lines.push(`${isCurrent ? '*' : ' '} ${branch} ${when} ${entry.path}`);
+    }
+    return lines.join('\n') + '\n';
+}
+export function formatAge(timestamp) {
+    const seconds = Math.floor((Date.now() - timestamp) / 1000);
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}

package/dist/cli.js

@@ -1,7 +1,9 @@
 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';
@@ -116,6 +118,16 @@ function registerCommands(program) {
         .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')
@@ -223,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) => {