@solaqua/gji 0.6.2 → 0.7.1

package/dist/ls.js

@@ -1,6 +1,6 @@
-import { listWorktrees } from './repo.js';
-import { comparePaths } from './paths.js';
-import { formatLastCommit, formatUpstreamState, readWorktreeInfos, } from './worktree-info.js';
+import { comparePaths } from "./paths.js";
+import { listWorktrees } from "./repo.js";
+import { formatLastCommit, formatUpstreamState, readWorktreeInfos, } from "./worktree-info.js";
 export async function runLsCommand(options) {
     const worktrees = sortWorktrees(await listWorktrees(options.cwd));
     if (options.compact) {
@@ -21,50 +21,50 @@ export async function runLsCommand(options) {
 }
 export function formatDetailedWorktreeTable(worktrees) {
     const rows = worktrees.map((worktree) => ({
-        branch: worktree.branch ?? '(detached)',
+        branch: worktree.branch ?? "(detached)",
         isCurrent: worktree.isCurrent,
         lastCommit: formatLastCommit(worktree.lastCommitTimestamp),
         path: worktree.path,
         status: worktree.status,
         upstream: formatUpstreamState(worktree.upstream),
     }));
-    const branchWidth = Math.max('BRANCH'.length, ...rows.map((row) => row.branch.length));
-    const statusWidth = Math.max('STATUS'.length, ...rows.map((row) => row.status.length));
-    const upstreamWidth = Math.max('UPSTREAM'.length, ...rows.map((row) => row.upstream.length));
-    const lastCommitWidth = Math.max('LAST'.length, ...rows.map((row) => row.lastCommit.length));
+    const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
+    const statusWidth = Math.max("STATUS".length, ...rows.map((row) => row.status.length));
+    const upstreamWidth = Math.max("UPSTREAM".length, ...rows.map((row) => row.upstream.length));
+    const lastCommitWidth = Math.max("LAST".length, ...rows.map((row) => row.lastCommit.length));
     const lines = [
-        '  '
-            + 'BRANCH'.padEnd(branchWidth, ' ')
-            + ' '
-            + 'STATUS'.padEnd(statusWidth, ' ')
-            + ' '
-            + 'UPSTREAM'.padEnd(upstreamWidth, ' ')
-            + ' '
-            + 'LAST'.padEnd(lastCommitWidth, ' ')
-            + ' PATH',
+        "  " +
+            "BRANCH".padEnd(branchWidth, " ") +
+            " " +
+            "STATUS".padEnd(statusWidth, " ") +
+            " " +
+            "UPSTREAM".padEnd(upstreamWidth, " ") +
+            " " +
+            "LAST".padEnd(lastCommitWidth, " ") +
+            " PATH",
     ];
     for (const row of rows) {
-        lines.push(`${row.isCurrent ? '*' : ' '} `
-            + `${row.branch.padEnd(branchWidth, ' ')} `
-            + `${row.status.padEnd(statusWidth, ' ')} `
-            + `${row.upstream.padEnd(upstreamWidth, ' ')} `
-            + `${row.lastCommit.padEnd(lastCommitWidth, ' ')} `
-            + row.path);
+        lines.push(`${row.isCurrent ? "*" : " "} ` +
+            `${row.branch.padEnd(branchWidth, " ")} ` +
+            `${row.status.padEnd(statusWidth, " ")} ` +
+            `${row.upstream.padEnd(upstreamWidth, " ")} ` +
+            `${row.lastCommit.padEnd(lastCommitWidth, " ")} ` +
+            row.path);
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 export function formatWorktreeTable(worktrees) {
     const rows = worktrees.map((worktree) => ({
-        branch: worktree.branch ?? '(detached)',
+        branch: worktree.branch ?? "(detached)",
         isCurrent: worktree.isCurrent,
         path: worktree.path,
     }));
-    const branchWidth = Math.max('BRANCH'.length, ...rows.map((row) => row.branch.length));
-    const lines = ['  ' + 'BRANCH'.padEnd(branchWidth, ' ') + ' PATH'];
+    const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
+    const lines = ["  " + "BRANCH".padEnd(branchWidth, " ") + " PATH"];
     for (const row of rows) {
-        lines.push(`${row.isCurrent ? '*' : ' '} ${row.branch.padEnd(branchWidth, ' ')} ${row.path}`);
+        lines.push(`${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.path}`);
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 function sortWorktrees(worktrees) {
     return [...worktrees].sort((left, right) => {

package/dist/new.d.ts

@@ -1,5 +1,5 @@
-import { type InstallPromptDependencies } from './install-prompt.js';
-import { type PathConflictChoice } from './conflict.js';
+import { type PathConflictChoice } from "./conflict.js";
+import { type InstallPromptDependencies } from "./install-prompt.js";
 export type { PathConflictChoice };
 export interface NewCommandOptions {
     branch?: string;

package/dist/new.js

@@ -1,20 +1,20 @@
-import { mkdir } from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { isCancel, text } from '@clack/prompts';
-import { loadEffectiveConfig, resolveConfigString } from './config.js';
-import { defaultSpawnEditor, EDITORS } from './editor.js';
-import { syncFiles } from './file-sync.js';
-import { extractHooks, runHook } from './hooks.js';
-import { appendHistory } from './history.js';
-import { isHeadless } from './headless.js';
-import { maybeRunInstallPrompt } from './install-prompt.js';
-import { pathExists, promptForPathConflict } from './conflict.js';
-import { detectRepository, resolveWorktreePath, validateBranchName } from './repo.js';
-import { writeShellOutput } from './shell-handoff.js';
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { promisify } from "node:util";
+import { isCancel, text } from "@clack/prompts";
+import { loadEffectiveConfig, resolveConfigString } from "./config.js";
+import { pathExists, promptForPathConflict, } from "./conflict.js";
+import { defaultSpawnEditor, EDITORS } from "./editor.js";
+import { syncFiles } from "./file-sync.js";
+import { isHeadless } from "./headless.js";
+import { appendHistory } from "./history.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { maybeRunInstallPrompt, } from "./install-prompt.js";
+import { detectRepository, resolveWorktreePath, validateBranchName, } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
 const execFileAsync = promisify(execFile);
-const NEW_OUTPUT_FILE_ENV = 'GJI_NEW_OUTPUT_FILE';
+const NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
 export function createNewCommand(dependencies = {}) {
     const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
     const promptForBranch = dependencies.promptForBranch ?? defaultPromptForBranch;
@@ -25,10 +25,12 @@ export function createNewCommand(dependencies = {}) {
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
         const usesGeneratedDetachedName = options.detached && options.branch === undefined;
         if (options.editor && !options.open) {
-            options.stderr('gji new: --editor has no effect without --open\n');
+            options.stderr("gji new: --editor has no effect without --open\n");
         }
-        if (!options.detached && !options.branch && (options.json || isHeadless())) {
-            const message = 'branch argument is required';
+        if (!options.detached &&
+            !options.branch &&
+            (options.json || isHeadless())) {
+            const message = "branch argument is required";
             if (options.json) {
                 options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
             }
@@ -38,14 +40,14 @@ export function createNewCommand(dependencies = {}) {
             return 1;
         }
         const rawBranch = options.detached
-            ? options.branch ?? createBranchPlaceholder()
-            : options.branch ?? await promptForBranch(createBranchPlaceholder());
+            ? (options.branch ?? createBranchPlaceholder())
+            : (options.branch ?? (await promptForBranch(createBranchPlaceholder())));
         if (!rawBranch) {
             if (options.json) {
-                options.stderr(`${JSON.stringify({ error: 'Aborted' }, null, 2)}\n`);
+                options.stderr(`${JSON.stringify({ error: "Aborted" }, null, 2)}\n`);
             }
             else {
-                options.stderr('Aborted\n');
+                options.stderr("Aborted\n");
             }
             return 1;
         }
@@ -61,19 +63,21 @@ export function createNewCommand(dependencies = {}) {
                 return 1;
             }
         }
-        const rawBasePath = resolveConfigString(config, 'worktreePath');
-        const configuredBasePath = rawBasePath?.startsWith('/') || rawBasePath?.startsWith('~') ? rawBasePath : undefined;
+        const rawBasePath = resolveConfigString(config, "worktreePath");
+        const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~")
+            ? rawBasePath
+            : undefined;
         const worktreeName = options.detached
             ? rawBranch
             : applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
         const worktreePath = usesGeneratedDetachedName
             ? await resolveUniqueDetachedWorktreePath(repository.repoRoot, worktreeName, configuredBasePath)
             : resolveWorktreePath(repository.repoRoot, worktreeName, configuredBasePath);
-        if (!usesGeneratedDetachedName && await pathExists(worktreePath)) {
+        if (!usesGeneratedDetachedName && (await pathExists(worktreePath))) {
             if (options.force) {
                 if (!options.dryRun) {
                     try {
-                        await execFileAsync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: repository.repoRoot });
+                        await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], { cwd: repository.repoRoot });
                     }
                     catch (err) {
                         if (!isNotRegisteredWorktreeError(err)) {
@@ -88,7 +92,9 @@ export function createNewCommand(dependencies = {}) {
                     }
                     if (!options.detached) {
                         try {
-                            await execFileAsync('git', ['branch', '-D', worktreeName], { cwd: repository.repoRoot });
+                            await execFileAsync("git", ["branch", "-D", worktreeName], {
+                                cwd: repository.repoRoot,
+                            });
                         }
                         catch {
                             // Branch may not exist; proceed anyway.
@@ -104,13 +110,13 @@ 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`);
-                    options.stderr(`Hint: Use 'gji trigger-hook afterCreate' inside the worktree to re-run setup hooks\n`);
+                    options.stderr(`Hint: Use 'gji run-hook after-create' inside the worktree to re-run setup hooks\n`);
                 }
                 return 1;
             }
             else {
                 const choice = await prompt(worktreePath);
-                if (choice === 'reuse') {
+                if (choice === "reuse") {
                     appendHistory(worktreePath, worktreeName).catch(() => undefined);
                     await writeOutput(worktreePath, options.stdout);
                     return 0;
@@ -125,23 +131,25 @@ export function createNewCommand(dependencies = {}) {
             }
             else {
                 const resolvedEditor = options.open
-                    ? (options.editor ?? resolveConfigString(config, 'editor'))
+                    ? (options.editor ?? resolveConfigString(config, "editor"))
                     : undefined;
-                const openNote = resolvedEditor ? `, then open in ${resolvedEditor}` : '';
+                const openNote = resolvedEditor
+                    ? `, then open in ${resolvedEditor}`
+                    : "";
                 options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName}${openNote})\n`);
             }
             return 0;
         }
         await mkdir(dirname(worktreePath), { recursive: true });
         const gitArgs = options.detached
-            ? ['worktree', 'add', '--detach', worktreePath]
-            : await localBranchExists(repository.repoRoot, worktreeName)
-                ? ['worktree', 'add', worktreePath, worktreeName]
-                : ['worktree', 'add', '-b', worktreeName, worktreePath];
-        await execFileAsync('git', gitArgs, { cwd: repository.repoRoot });
+            ? ["worktree", "add", "--detach", worktreePath]
+            : (await localBranchExists(repository.repoRoot, worktreeName))
+                ? ["worktree", "add", worktreePath, worktreeName]
+                : ["worktree", "add", "-b", worktreeName, worktreePath];
+        await execFileAsync("git", gitArgs, { cwd: repository.repoRoot });
         // Sync files from main worktree before afterCreate so synced files are available to install scripts.
         const syncPatterns = Array.isArray(config.syncFiles)
-            ? config.syncFiles.filter((p) => typeof p === 'string')
+            ? config.syncFiles.filter((p) => typeof p === "string")
             : [];
         for (const pattern of syncPatterns) {
             try {
@@ -153,7 +161,11 @@ export function createNewCommand(dependencies = {}) {
         }
         await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
         const hooks = extractHooks(config);
-        await runHook(hooks.afterCreate, worktreePath, { branch: worktreeName, path: worktreePath, repo: basename(repository.repoRoot) }, options.stderr);
+        await runHook(hooks["after-create"], worktreePath, {
+            branch: worktreeName,
+            path: worktreePath,
+            repo: basename(repository.repoRoot),
+        }, options.stderr);
         if (options.json) {
             options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}\n`);
         }
@@ -162,7 +174,7 @@ export function createNewCommand(dependencies = {}) {
             await writeOutput(worktreePath, options.stdout);
         }
         if (options.open) {
-            const resolvedEditor = options.editor ?? resolveConfigString(config, 'editor');
+            const resolvedEditor = options.editor ?? resolveConfigString(config, "editor");
             await openWorktree(worktreePath, resolvedEditor, spawnEditor, options.stderr);
         }
         return 0;
@@ -171,48 +183,48 @@ export function createNewCommand(dependencies = {}) {
 export const runNewCommand = createNewCommand();
 export function generateBranchPlaceholder(random = Math.random) {
     const roots = [
-        'socrates',
-        'prometheus',
-        'beethoven',
-        'ada',
-        'turing',
-        'hypatia',
-        'tesla',
-        'curie',
-        'diogenes',
-        'plato',
-        'hephaestus',
-        'athena',
-        'archimedes',
-        'euclid',
-        'heraclitus',
-        'galileo',
-        'newton',
-        'lovelace',
-        'nietzsche',
-        'kafka',
+        "socrates",
+        "prometheus",
+        "beethoven",
+        "ada",
+        "turing",
+        "hypatia",
+        "tesla",
+        "curie",
+        "diogenes",
+        "plato",
+        "hephaestus",
+        "athena",
+        "archimedes",
+        "euclid",
+        "heraclitus",
+        "galileo",
+        "newton",
+        "lovelace",
+        "nietzsche",
+        "kafka",
     ];
     const antics = [
-        'borrowed-a-bike',
-        'brought-snacks',
-        'missed-the-bus',
-        'lost-the-keys',
-        'spilled-the-coffee',
-        'forgot-the-umbrella',
-        'walked-the-dog',
-        'missed-the-train',
-        'wrote-a-poem',
-        'burned-the-toast',
-        'fed-the-pigeons',
-        'watered-the-plants',
-        'washed-the-dishes',
-        'folded-the-laundry',
-        'took-a-nap',
+        "borrowed-a-bike",
+        "brought-snacks",
+        "missed-the-bus",
+        "lost-the-keys",
+        "spilled-the-coffee",
+        "forgot-the-umbrella",
+        "walked-the-dog",
+        "missed-the-train",
+        "wrote-a-poem",
+        "burned-the-toast",
+        "fed-the-pigeons",
+        "watered-the-plants",
+        "washed-the-dishes",
+        "folded-the-laundry",
+        "took-a-nap",
     ];
     return `${pickRandom(roots, random)}-${pickRandom(antics, random)}`;
 }
 function applyConfiguredBranchPrefix(branch, branchPrefix) {
-    if (typeof branchPrefix !== 'string' || branchPrefix.length === 0) {
+    if (typeof branchPrefix !== "string" || branchPrefix.length === 0) {
         return branch;
     }
     if (branch.startsWith(branchPrefix)) {
@@ -225,7 +237,7 @@ async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
     while (true) {
         const candidateName = attempt === 1 ? baseName : `${baseName}-${attempt}`;
         const candidatePath = resolveWorktreePath(repoRoot, candidateName, basePath);
-        if (!await pathExists(candidatePath)) {
+        if (!(await pathExists(candidatePath))) {
             return candidatePath;
         }
         attempt += 1;
@@ -234,7 +246,7 @@ async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
 async function defaultPromptForBranch(placeholder) {
     const choice = await text({
         defaultValue: placeholder,
-        message: 'Name the new branch',
+        message: "Name the new branch",
         placeholder,
         validate: (value) => {
             const trimmed = value.trim();
@@ -252,7 +264,7 @@ function pickRandom(values, random) {
 }
 async function localBranchExists(repoRoot, branchName) {
     try {
-        await execFileAsync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], { cwd: repoRoot });
+        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
         return true;
     }
     catch {
@@ -264,17 +276,20 @@ async function writeOutput(worktreePath, stdout) {
 }
 function isNotRegisteredWorktreeError(error) {
     const stderr = hasExecStderr(error) ? error.stderr : String(error);
-    return stderr.includes('is not a working tree') || stderr.includes('not a linked working tree');
+    return (stderr.includes("is not a working tree") ||
+        stderr.includes("not a linked working tree"));
 }
 function hasExecStderr(error) {
-    return error instanceof Error && 'stderr' in error && typeof error.stderr === 'string';
+    return (error instanceof Error &&
+        "stderr" in error &&
+        typeof error.stderr === "string");
 }
 function toExecMessage(error) {
     return hasExecStderr(error) ? error.stderr.trim() : String(error);
 }
 async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
     if (!editorCli) {
-        stderr('gji new: --open requires --editor <cli> or a saved editor in config\n');
+        stderr("gji new: --open requires --editor <cli> or a saved editor in config\n");
         return;
     }
     const editorDef = EDITORS.find((e) => e.cli === editorCli);

package/dist/open.d.ts

@@ -1,5 +1,5 @@
-import { type EditorDefinition } from './editor.js';
-import { type WorktreeEntry } from './repo.js';
+import { type EditorDefinition } from "./editor.js";
+import { type WorktreeEntry } from "./repo.js";
 export type { EditorDefinition };
 export interface OpenCommandOptions {
     branch?: string;

package/dist/open.js

@@ -1,12 +1,12 @@
-import { execFile } from 'node:child_process';
-import { access, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-import { isCancel, select } from '@clack/prompts';
-import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey } from './config.js';
-import { defaultSpawnEditor, EDITORS } from './editor.js';
-import { isHeadless } from './headless.js';
-import { detectRepository, listWorktrees, sortByCurrentFirst } from './repo.js';
+import { execFile } from "node:child_process";
+import { access, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { isCancel, select } from "@clack/prompts";
+import { loadEffectiveConfig, resolveConfigString, updateGlobalConfigKey, } from "./config.js";
+import { defaultSpawnEditor, EDITORS, } from "./editor.js";
+import { isHeadless } from "./headless.js";
+import { detectRepository, listWorktrees, sortByCurrentFirst, } from "./repo.js";
 const execFileAsync = promisify(execFile);
 export function createOpenCommand(dependencies = {}) {
     const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
@@ -35,14 +35,14 @@ export function createOpenCommand(dependencies = {}) {
         else {
             const chosen = await promptForWorktree(sortByCurrentFirst(worktrees));
             if (!chosen) {
-                options.stderr('Aborted\n');
+                options.stderr("Aborted\n");
                 return 1;
             }
             targetPath = chosen;
         }
         // Resolve which editor to use.
         const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
-        const savedEditor = resolveConfigString(config, 'editor');
+        const savedEditor = resolveConfigString(config, "editor");
         let editorCli;
         if (options.editor) {
             editorCli = options.editor;
@@ -53,7 +53,7 @@ export function createOpenCommand(dependencies = {}) {
         else {
             const installed = await detectEditors();
             if (installed.length === 0) {
-                options.stderr('gji open: no supported editor detected. Use --editor <code|cursor|zed|...> to specify one.\n');
+                options.stderr("gji open: no supported editor detected. Use --editor <code|cursor|zed|...> to specify one.\n");
                 return 1;
             }
             if (installed.length === 1 || isHeadless()) {
@@ -62,7 +62,7 @@ export function createOpenCommand(dependencies = {}) {
             else {
                 const chosen = await promptForEditor(installed);
                 if (!chosen) {
-                    options.stderr('Aborted\n');
+                    options.stderr("Aborted\n");
                     return 1;
                 }
                 editorCli = chosen;
@@ -70,7 +70,7 @@ export function createOpenCommand(dependencies = {}) {
         }
         // Persist editor choice when requested.
         if (options.save && editorCli !== savedEditor) {
-            await updateGlobalConfigKey('editor', editorCli);
+            await updateGlobalConfigKey("editor", editorCli);
             const displayName = EDITORS.find((e) => e.cli === editorCli)?.name ?? editorCli;
             options.stdout(`Saved editor "${displayName}" to global config\n`);
         }
@@ -106,12 +106,15 @@ export function createOpenCommand(dependencies = {}) {
 }
 export const runOpenCommand = createOpenCommand();
 async function detectInstalledEditors() {
-    const results = await Promise.all(EDITORS.map(async (editor) => ({ editor, available: await isCommandAvailable(editor.cli) })));
+    const results = await Promise.all(EDITORS.map(async (editor) => ({
+        editor,
+        available: await isCommandAvailable(editor.cli),
+    })));
     return results.filter((r) => r.available).map((r) => r.editor);
 }
 async function isCommandAvailable(command) {
     try {
-        await execFileAsync('which', [command]);
+        await execFileAsync("which", [command]);
         return true;
     }
     catch {
@@ -120,10 +123,10 @@ async function isCommandAvailable(command) {
 }
 async function defaultPromptForWorktree(worktrees) {
     const choice = await select({
-        message: 'Choose a worktree to open',
+        message: "Choose a worktree to open",
         options: worktrees.map((w) => ({
             value: w.path,
-            label: w.branch ?? '(detached)',
+            label: w.branch ?? "(detached)",
             hint: w.isCurrent ? `${w.path} (current)` : w.path,
         })),
     });
@@ -133,7 +136,7 @@ async function defaultPromptForWorktree(worktrees) {
 }
 async function defaultPromptForEditor(editors) {
     const choice = await select({
-        message: 'Choose an editor',
+        message: "Choose an editor",
         options: editors.map((e) => ({ value: e.cli, label: e.name })),
     });
     if (isCancel(choice))
@@ -149,7 +152,7 @@ async function ensureWorkspaceFile(worktreePath, repoName) {
     catch {
         // File doesn't exist yet — create it.
     }
-    const workspace = { folders: [{ path: '.' }], settings: {} };
-    await writeFile(workspacePath, `${JSON.stringify(workspace, null, 2)}\n`, 'utf8');
+    const workspace = { folders: [{ path: "." }], settings: {} };
+    await writeFile(workspacePath, `${JSON.stringify(workspace, null, 2)}\n`, "utf8");
     return workspacePath;
 }