@solaqua/gji 0.6.1 → 0.7.0

package/dist/go.d.ts

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

package/dist/go.js

@@ -1,14 +1,14 @@
-import { basename } from 'node:path';
-import { isCancel, select } from '@clack/prompts';
-import { loadEffectiveConfig } from './config.js';
-import { readWorktreeHealth } from './git.js';
-import { isHeadless } from './headless.js';
-import { extractHooks, runHook } from './hooks.js';
-import { appendHistory } from './history.js';
-import { detectRepository, listWorktrees, sortByCurrentFirst } from './repo.js';
-import { writeShellOutput } from './shell-handoff.js';
-import { resolveWarpTarget } from './warp.js';
-const GO_OUTPUT_FILE_ENV = 'GJI_GO_OUTPUT_FILE';
+import { basename } from "node:path";
+import { isCancel, select } from "@clack/prompts";
+import { loadEffectiveConfig } from "./config.js";
+import { readWorktreeHealth } from "./git.js";
+import { isHeadless } from "./headless.js";
+import { appendHistory } from "./history.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { detectRepository, listWorktrees, sortByCurrentFirst, } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
+import { resolveWarpTarget } from "./warp.js";
+const GO_OUTPUT_FILE_ENV = "GJI_GO_OUTPUT_FILE";
 export function createGoCommand(dependencies = {}) {
     const prompt = dependencies.promptForWorktree ?? promptForWorktree;
     return async function runGoCommand(options) {
@@ -23,10 +23,13 @@ export function createGoCommand(dependencies = {}) {
         catch {
             // Not inside a git repo — fall back to cross-repo navigation.
             if (isHeadless() && !options.branch) {
-                options.stderr('gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n');
+                options.stderr("gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n");
                 return 1;
             }
-            const target = await resolveWarpTarget({ ...options, commandName: 'gji go' });
+            const target = await resolveWarpTarget({
+                ...options,
+                commandName: "gji go",
+            });
             if (!target)
                 return 1;
             appendHistory(target.path, target.branch).catch(() => undefined);
@@ -34,27 +37,33 @@ export function createGoCommand(dependencies = {}) {
             return 0;
         }
         if (!options.branch && isHeadless()) {
-            options.stderr('gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n');
+            options.stderr("gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n");
             return 1;
         }
-        const prompted = options.branch ? null : await prompt(sortByCurrentFirst(worktrees));
+        const prompted = options.branch
+            ? null
+            : await prompt(sortByCurrentFirst(worktrees));
         const resolvedPath = options.branch
             ? worktrees.find((entry) => entry.branch === options.branch)?.path
-            : prompted ?? undefined;
+            : (prompted ?? undefined);
         if (!resolvedPath) {
             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');
+                options.stderr("Aborted\n");
             }
             return 1;
         }
         const chosenWorktree = worktrees.find((w) => w.path === resolvedPath);
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterEnter, resolvedPath, { branch: chosenWorktree?.branch ?? undefined, path: resolvedPath, repo: basename(repository.repoRoot) }, options.stderr);
+        await runHook(hooks.afterEnter, resolvedPath, {
+            branch: chosenWorktree?.branch ?? undefined,
+            path: resolvedPath,
+            repo: basename(repository.repoRoot),
+        }, options.stderr);
         appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(() => undefined);
         await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
         return 0;
@@ -64,14 +73,18 @@ export const runGoCommand = createGoCommand();
 async function promptForWorktree(worktrees) {
     const healthResults = await Promise.allSettled(worktrees.map((w) => readWorktreeHealth(w.path)));
     const choice = await select({
-        message: 'Choose a worktree',
+        message: "Choose a worktree",
         options: worktrees.map((worktree, i) => {
-            const health = healthResults[i].status === 'fulfilled' ? healthResults[i].value : null;
-            const pathHint = worktree.isCurrent ? `${worktree.path} (current)` : worktree.path;
-            const upstream = health ? formatUpstreamHint(worktree.branch, health) : null;
+            const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
+            const pathHint = worktree.isCurrent
+                ? `${worktree.path} (current)`
+                : worktree.path;
+            const upstream = health
+                ? formatUpstreamHint(worktree.branch, health)
+                : null;
             return {
                 value: worktree.path,
-                label: worktree.branch ?? '(detached)',
+                label: worktree.branch ?? "(detached)",
                 hint: upstream ? `${upstream} · ${pathHint}` : pathHint,
             };
         }),
@@ -85,11 +98,11 @@ export function formatUpstreamHint(branch, health) {
     if (branch === null)
         return null;
     if (!health.hasUpstream)
-        return 'no upstream';
+        return "no upstream";
     if (health.upstreamGone)
-        return 'upstream gone';
+        return "upstream gone";
     if (health.ahead === 0 && health.behind === 0)
-        return 'up to date';
+        return "up to date";
     if (health.ahead === 0)
         return `behind ${health.behind}`;
     if (health.behind === 0)

package/dist/headless.js

@@ -4,5 +4,5 @@
  * Commands that would otherwise hang waiting for input must fail fast instead.
  */
 export function isHeadless() {
-    return process.env.GJI_NO_TUI === '1';
+    return process.env.GJI_NO_TUI === "1";
 }

package/dist/history-command.js

@@ -1,5 +1,5 @@
-import { loadHistory } from './history.js';
-import { formatHistoryList } from './back.js';
+import { formatHistoryList } from "./back.js";
+import { loadHistory } from "./history.js";
 export async function runHistoryCommand(options) {
     const history = await loadHistory(options.home);
     if (options.json) {
@@ -7,7 +7,7 @@ export async function runHistoryCommand(options) {
         return 0;
     }
     if (history.length === 0) {
-        options.stdout('No navigation history.\n');
+        options.stdout("No navigation history.\n");
         return 0;
     }
     options.stdout(formatHistoryList(history, options.cwd));

package/dist/history.js

@@ -1,8 +1,8 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { GLOBAL_CONFIG_DIRECTORY } from './config.js';
-export const HISTORY_FILE_NAME = 'history.json';
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { GLOBAL_CONFIG_DIRECTORY } from "./config.js";
+export const HISTORY_FILE_NAME = "history.json";
 const MAX_HISTORY_ENTRIES = 50;
 export function HISTORY_FILE_PATH(home = homedir()) {
     const configDir = process.env.GJI_CONFIG_DIR;
@@ -14,7 +14,7 @@ export function HISTORY_FILE_PATH(home = homedir()) {
 export async function loadHistory(home = homedir()) {
     const path = HISTORY_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 [];
@@ -34,13 +34,13 @@ export async function appendHistory(path, branch, home = homedir()) {
     const entry = { branch, path, timestamp: Date.now() };
     const next = [entry, ...existing].slice(0, MAX_HISTORY_ENTRIES);
     await mkdir(dirname(historyPath), { recursive: true });
-    await writeFile(historyPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+    await writeFile(historyPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
 function isHistoryEntry(value) {
-    return (typeof value === 'object' &&
+    return (typeof value === "object" &&
         value !== null &&
-        'path' in value &&
-        typeof value.path === 'string' &&
-        'timestamp' in value &&
-        typeof value.timestamp === 'number');
+        "path" in value &&
+        typeof value.path === "string" &&
+        "timestamp" in value &&
+        typeof value.timestamp === "number");
 }

package/dist/hooks.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import { spawn } from "node:child_process";
 export async function runHook(hookCmd, cwd, context, stderr) {
     if (!hookCmd)
         return;
@@ -11,26 +11,26 @@ export async function runHook(hookCmd, cwd, context, stderr) {
 async function runArgvHook(hookCmd, cwd, context, stderr) {
     const [command, ...args] = hookCmd.map((arg) => interpolate(arg, context));
     if (!command) {
-        stderr('gji: hook argv command must include a non-empty command\n');
+        stderr("gji: hook argv command must include a non-empty command\n");
         return;
     }
     await new Promise((resolve) => {
         const child = spawn(command, args, {
             cwd,
             shell: false,
-            stdio: ['ignore', 'inherit', 'pipe'],
+            stdio: ["ignore", "inherit", "pipe"],
             env: hookEnvironment(context),
         });
-        child.stderr.on('data', (chunk) => {
+        child.stderr.on("data", (chunk) => {
             stderr(chunk.toString());
         });
-        child.on('close', (code) => {
+        child.on("close", (code) => {
             if (code !== 0) {
                 stderr(`gji: hook exited with code ${code}: ${formatArgvHook(command, args)}\n`);
             }
             resolve();
         });
-        child.on('error', (err) => {
+        child.on("error", (err) => {
             stderr(`gji: hook failed to start: ${err.message}\n`);
             resolve();
         });
@@ -42,19 +42,19 @@ async function runShellHook(hookCmd, cwd, context, stderr) {
         const child = spawn(interpolated, {
             cwd,
             shell: true,
-            stdio: ['ignore', 'inherit', 'pipe'],
+            stdio: ["ignore", "inherit", "pipe"],
             env: hookEnvironment(context),
         });
-        child.stderr.on('data', (chunk) => {
+        child.stderr.on("data", (chunk) => {
             stderr(chunk.toString());
         });
-        child.on('close', (code) => {
+        child.on("close", (code) => {
             if (code !== 0) {
                 stderr(`gji: hook exited with code ${code}: ${interpolated}\n`);
             }
             resolve();
         });
-        child.on('error', (err) => {
+        child.on("error", (err) => {
             stderr(`gji: hook failed to start: ${err.message}\n`);
             resolve();
         });
@@ -63,7 +63,7 @@ async function runShellHook(hookCmd, cwd, context, stderr) {
 function hookEnvironment(context) {
     return {
         ...process.env,
-        GJI_BRANCH: context.branch ?? '',
+        GJI_BRANCH: context.branch ?? "",
         GJI_PATH: context.path,
         GJI_REPO: context.repo,
     };
@@ -73,13 +73,13 @@ function formatArgvHook(command, args) {
 }
 export function interpolate(template, context) {
     return template
-        .replace(/\{\{branch\}\}/g, context.branch ?? '')
+        .replace(/\{\{branch\}\}/g, context.branch ?? "")
         .replace(/\{\{path\}\}/g, context.path)
         .replace(/\{\{repo\}\}/g, context.repo);
 }
 export function extractHooks(config) {
     const raw = config.hooks;
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return {};
     }
     const hooks = raw;
@@ -90,12 +90,12 @@ export function extractHooks(config) {
     };
 }
 function parseHookCommand(value) {
-    if (typeof value === 'string')
+    if (typeof value === "string")
         return value;
     if (Array.isArray(value) &&
         value.length > 0 &&
-        value[0] !== '' &&
-        value.every((item) => typeof item === 'string')) {
+        value[0] !== "" &&
+        value.every((item) => typeof item === "string")) {
         return value;
     }
     return undefined;

package/dist/index.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
-import { homedir } from 'node:os';
-import { loadGlobalConfig } from './config.js';
-import { runCli } from './cli.js';
+import { homedir } from "node:os";
+import { runCli } from "./cli.js";
+import { loadGlobalConfig } from "./config.js";
 async function main() {
     try {
         const argv = process.argv.slice(2);
         // Warn once (until fixed) when shell integration hasn't been set up.
         // Only shown in interactive terminals — suppressed in pipes and after gji init --write.
-        const isMetaArg = argv[0] === 'init'
-            || argv[0] === '--version' || argv[0] === '-V'
-            || argv[0] === '--help' || argv[0] === '-h';
+        const isMetaArg = argv[0] === "init" ||
+            argv[0] === "--version" ||
+            argv[0] === "-V" ||
+            argv[0] === "--help" ||
+            argv[0] === "-h";
         if (process.stderr.isTTY === true && !isMetaArg) {
             await warnIfMissingShellIntegration();
         }
@@ -20,7 +22,7 @@ async function main() {
         process.exitCode = result.exitCode;
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : 'An unknown error occurred.';
+        const message = error instanceof Error ? error.message : "An unknown error occurred.";
         process.stderr.write(`${message}\n`);
         process.exitCode = 1;
     }
@@ -29,8 +31,10 @@ async function warnIfMissingShellIntegration() {
     try {
         const { config } = await loadGlobalConfig(homedir());
         if (!config.shellIntegration) {
-            const shellBin = (process.env.SHELL ?? '').split('/').at(-1);
-            const shellArg = shellBin && ['bash', 'zsh', 'fish'].includes(shellBin) ? ` ${shellBin}` : '';
+            const shellBin = (process.env.SHELL ?? "").split("/").at(-1);
+            const shellArg = shellBin && ["bash", "zsh", "fish"].includes(shellBin)
+                ? ` ${shellBin}`
+                : "";
             process.stderr.write(`gji: shell integration not set up — run \`gji init${shellArg} --write\` to enable automatic cd.\n`);
         }
     }

package/dist/init.d.ts

@@ -1,5 +1,5 @@
-import { type SupportedShell } from './shell.js';
-export type InstallSaveTarget = 'local' | 'global';
+import { type SupportedShell } from "./shell.js";
+export type InstallSaveTarget = "local" | "global";
 export interface SetupWizardResult {
     branchPrefix?: string;
     hooks?: {