@solaqua/gji 0.6.2 → 0.7.0

package/dist/init.js

@@ -1,67 +1,67 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { intro, isCancel, outro, select, text } from '@clack/prompts';
-import { loadConfig, loadGlobalConfig, saveGlobalConfig, saveLocalConfig, updateGlobalConfigKey } from './config.js';
-import { resolveSupportedShell } from './shell.js';
-const START_MARKER = '# >>> gji init >>>';
-const END_MARKER = '# <<< gji init <<<';
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { intro, isCancel, outro, select, text } from "@clack/prompts";
+import { loadConfig, loadGlobalConfig, saveGlobalConfig, saveLocalConfig, updateGlobalConfigKey, } from "./config.js";
+import { resolveSupportedShell } from "./shell.js";
+const START_MARKER = "# >>> gji init >>>";
+const END_MARKER = "# <<< gji init <<<";
 const SHELL_WRAPPED_COMMANDS = [
     {
-        bypassOptions: ['--help'],
-        commandName: 'new',
-        envVar: 'GJI_NEW_OUTPUT_FILE',
-        names: ['new'],
-        tempPrefix: 'gji-new',
+        bypassOptions: ["--help"],
+        commandName: "new",
+        envVar: "GJI_NEW_OUTPUT_FILE",
+        names: ["new"],
+        tempPrefix: "gji-new",
     },
     {
-        bypassOptions: ['--help'],
-        commandName: 'pr',
-        envVar: 'GJI_PR_OUTPUT_FILE',
-        names: ['pr'],
-        tempPrefix: 'gji-pr',
+        bypassOptions: ["--help"],
+        commandName: "pr",
+        envVar: "GJI_PR_OUTPUT_FILE",
+        names: ["pr"],
+        tempPrefix: "gji-pr",
     },
     {
-        bypassOptions: ['--print'],
-        commandName: 'back',
-        envVar: 'GJI_BACK_OUTPUT_FILE',
-        names: ['back'],
-        tempPrefix: 'gji-back',
+        bypassOptions: ["--print"],
+        commandName: "back",
+        envVar: "GJI_BACK_OUTPUT_FILE",
+        names: ["back"],
+        tempPrefix: "gji-back",
     },
     {
-        bypassOptions: ['--print'],
-        commandName: 'go',
-        envVar: 'GJI_GO_OUTPUT_FILE',
-        names: ['go', 'jump'],
-        tempPrefix: 'gji-go',
+        bypassOptions: ["--print"],
+        commandName: "go",
+        envVar: "GJI_GO_OUTPUT_FILE",
+        names: ["go", "jump"],
+        tempPrefix: "gji-go",
     },
     {
-        bypassOptions: ['--print'],
-        commandName: 'root',
-        envVar: 'GJI_ROOT_OUTPUT_FILE',
-        names: ['root'],
-        tempPrefix: 'gji-root',
+        bypassOptions: ["--print"],
+        commandName: "root",
+        envVar: "GJI_ROOT_OUTPUT_FILE",
+        names: ["root"],
+        tempPrefix: "gji-root",
     },
     {
-        bypassOptions: ['--help'],
-        commandName: 'remove',
-        envVar: 'GJI_REMOVE_OUTPUT_FILE',
-        names: ['remove', 'rm'],
-        tempPrefix: 'gji-remove',
+        bypassOptions: ["--help"],
+        commandName: "remove",
+        envVar: "GJI_REMOVE_OUTPUT_FILE",
+        names: ["remove", "rm"],
+        tempPrefix: "gji-remove",
     },
     {
-        bypassOptions: ['--print', '--json'],
-        commandName: 'warp',
-        envVar: 'GJI_WARP_OUTPUT_FILE',
-        names: ['warp'],
-        tempPrefix: 'gji-warp',
+        bypassOptions: ["--print", "--json"],
+        commandName: "warp",
+        envVar: "GJI_WARP_OUTPUT_FILE",
+        names: ["warp"],
+        tempPrefix: "gji-warp",
     },
 ];
 export async function runInitCommand(options) {
     const shell = resolveSupportedShell(options.shell, process.env.SHELL);
     const home = options.home ?? homedir();
     if (!shell) {
-        options.stderr?.('Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n');
+        options.stderr?.("Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n");
         return 1;
     }
     const script = renderShellIntegration(shell);
@@ -73,29 +73,29 @@ export async function runInitCommand(options) {
     await mkdir(dirname(rcPath), { recursive: true });
     const current = await readExistingConfig(rcPath);
     const next = upsertShellIntegration(current, script);
-    await writeFile(rcPath, next, 'utf8');
+    await writeFile(rcPath, next, "utf8");
     options.stdout(`${rcPath}\n`);
     // Run the setup wizard on the first-ever init (not on subsequent re-runs).
     const { config: globalConfig } = await loadGlobalConfig(home);
-    const alreadyConfigured = 'shellIntegration' in globalConfig || 'installSaveTarget' in globalConfig;
+    const alreadyConfigured = "shellIntegration" in globalConfig || "installSaveTarget" in globalConfig;
     const hasCustomPrompt = options.promptForSetup !== undefined;
     const canPrompt = hasCustomPrompt || process.stdout.isTTY === true;
     if (!alreadyConfigured && canPrompt) {
         const prompt = options.promptForSetup ?? defaultPromptForSetup;
         const result = await prompt();
         if (result) {
-            await updateGlobalConfigKey('installSaveTarget', result.installSaveTarget, home);
+            await updateGlobalConfigKey("installSaveTarget", result.installSaveTarget, home);
             await saveWizardConfig(result, options.cwd, home);
         }
     }
     // Mark shell integration as installed so the first-run nudge is suppressed.
-    await updateGlobalConfigKey('shellIntegration', true, home);
+    await updateGlobalConfigKey("shellIntegration", true, home);
     return 0;
 }
 export function renderShellIntegration(shell) {
-    const commandBlocks = SHELL_WRAPPED_COMMANDS.map((command) => shell === 'fish' ? renderFishWrapper(command) : renderPosixWrapper(command)).join('\n\n');
+    const commandBlocks = SHELL_WRAPPED_COMMANDS.map((command) => shell === "fish" ? renderFishWrapper(command) : renderPosixWrapper(command)).join("\n\n");
     switch (shell) {
-        case 'fish':
+        case "fish":
             return `${START_MARKER}
 function gji --wraps gji --description 'gji shell integration'
 ${indentBlock(commandBlocks, 4)}
@@ -104,8 +104,8 @@ ${indentBlock(commandBlocks, 4)}
 end
 ${END_MARKER}
 `;
-        case 'bash':
-        case 'zsh':
+        case "bash":
+        case "zsh":
             return `${START_MARKER}
 gji() {
 ${indentBlock(commandBlocks, 2)}
@@ -118,7 +118,7 @@ ${END_MARKER}
 }
 export function upsertShellIntegration(existingConfig, script) {
     const trimmedScript = script.trimEnd();
-    const blockPattern = new RegExp(`${escapeForRegExp(START_MARKER)}[\\s\\S]*?${escapeForRegExp(END_MARKER)}\\n?`, 'm');
+    const blockPattern = new RegExp(`${escapeForRegExp(START_MARKER)}[\\s\\S]*?${escapeForRegExp(END_MARKER)}\\n?`, "m");
     if (blockPattern.test(existingConfig)) {
         return ensureTrailingNewline(existingConfig.replace(blockPattern, `${trimmedScript}\n`));
     }
@@ -145,7 +145,7 @@ async function saveWizardConfig(result, cwd, home) {
         values.hooks = hooks;
     if (Object.keys(values).length === 0)
         return;
-    if (result.installSaveTarget === 'local') {
+    if (result.installSaveTarget === "local") {
         const loaded = await loadConfig(cwd);
         await saveLocalConfig(cwd, { ...loaded.config, ...values });
     }
@@ -156,43 +156,43 @@ async function saveWizardConfig(result, cwd, home) {
 }
 function resolveShellConfigPath(shell, home) {
     switch (shell) {
-        case 'bash':
-            return join(home, '.bashrc');
-        case 'fish':
-            return join(home, '.config', 'fish', 'config.fish');
-        case 'zsh':
-            return join(home, '.zshrc');
+        case "bash":
+            return join(home, ".bashrc");
+        case "fish":
+            return join(home, ".config", "fish", "config.fish");
+        case "zsh":
+            return join(home, ".zshrc");
     }
 }
 async function readExistingConfig(path) {
     try {
-        return await readFile(path, 'utf8');
+        return await readFile(path, "utf8");
     }
     catch (error) {
         if (isMissingFileError(error)) {
-            return '';
+            return "";
         }
         throw error;
     }
 }
 function ensureTrailingNewline(value) {
-    return value.endsWith('\n') ? value : `${value}\n`;
+    return value.endsWith("\n") ? value : `${value}\n`;
 }
 function escapeForRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function isMissingFileError(error) {
-    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function renderFishWrapper(command) {
     const nameTests = command.names.map((name) => `test $argv[1] = ${name}`);
     const nameCondition = nameTests.length === 1
         ? nameTests[0]
-        : `begin; ${nameTests.join('; or ')}; end`;
+        : `begin; ${nameTests.join("; or ")}; end`;
     const bypassTests = command.bypassOptions.map((opt) => `test $argv[1] = ${opt}`);
     const bypassCondition = bypassTests.length === 1
         ? bypassTests[0]
-        : `begin; ${bypassTests.join('; or ')}; end`;
+        : `begin; ${bypassTests.join("; or ")}; end`;
     return `if test (count $argv) -gt 0; and ${nameCondition}
     set -e argv[1]
     if test (count $argv) -gt 0; and ${bypassCondition}
@@ -215,8 +215,12 @@ function renderFishWrapper(command) {
 end`;
 }
 function renderPosixWrapper(command) {
-    const tests = command.names.map((name) => `[ "$1" = "${name}" ]`).join(' || ');
-    const bypassTests = command.bypassOptions.map((opt) => `[ "\${1:-}" = "${opt}" ]`).join(' || ');
+    const tests = command.names
+        .map((name) => `[ "$1" = "${name}" ]`)
+        .join(" || ");
+    const bypassTests = command.bypassOptions
+        .map((opt) => `[ "\${1:-}" = "${opt}" ]`)
+        .join(" || ");
     return `if ${tests}; then
   shift
   if ${bypassTests}; then
@@ -235,66 +239,74 @@ function renderPosixWrapper(command) {
 fi`;
 }
 function indentBlock(value, spaces) {
-    const prefix = ' '.repeat(spaces);
+    const prefix = " ".repeat(spaces);
     return value
-        .split('\n')
-        .map((line) => line.length === 0 ? '' : `${prefix}${line}`)
-        .join('\n');
+        .split("\n")
+        .map((line) => (line.length === 0 ? "" : `${prefix}${line}`))
+        .join("\n");
 }
 async function defaultPromptForSetup() {
-    intro('gji setup');
+    intro("gji setup");
     const installSaveTarget = await select({
-        message: 'Where should preferences be saved?',
+        message: "Where should preferences be saved?",
         options: [
-            { value: 'global', label: '~/.config/gji/config.json', hint: 'personal — never committed' },
-            { value: 'local', label: '.gji.json', hint: 'repo — committed with the project' },
+            {
+                value: "global",
+                label: "~/.config/gji/config.json",
+                hint: "personal — never committed",
+            },
+            {
+                value: "local",
+                label: ".gji.json",
+                hint: "repo — committed with the project",
+            },
         ],
     });
     if (isCancel(installSaveTarget)) {
-        outro('Setup skipped.');
+        outro("Setup skipped.");
         return null;
     }
     const branchPrefix = await text({
-        message: 'Default branch prefix?',
-        placeholder: 'e.g. feat/ or fix/ — leave blank to skip',
+        message: "Default branch prefix?",
+        placeholder: "e.g. feat/ or fix/ — leave blank to skip",
     });
     if (isCancel(branchPrefix)) {
-        outro('Setup skipped.');
+        outro("Setup skipped.");
         return null;
     }
     const worktreePath = await text({
-        message: 'Worktree base path?',
-        placeholder: 'leave blank to use the default path',
+        message: "Worktree base path?",
+        placeholder: "leave blank to use the default path",
     });
     if (isCancel(worktreePath)) {
-        outro('Setup skipped.');
+        outro("Setup skipped.");
         return null;
     }
     const afterCreate = await text({
-        message: 'afterCreate hook — run after creating a worktree?',
-        placeholder: 'e.g. pnpm install — leave blank to skip',
+        message: "afterCreate hook — run after creating a worktree?",
+        placeholder: "e.g. pnpm install — leave blank to skip",
     });
     if (isCancel(afterCreate)) {
-        outro('Setup skipped.');
+        outro("Setup skipped.");
         return null;
     }
     const afterEnter = await text({
-        message: 'afterEnter hook — run after entering a worktree?',
-        placeholder: 'e.g. nvm use — leave blank to skip',
+        message: "afterEnter hook — run after entering a worktree?",
+        placeholder: "e.g. nvm use — leave blank to skip",
     });
     if (isCancel(afterEnter)) {
-        outro('Setup skipped.');
+        outro("Setup skipped.");
         return null;
     }
     const beforeRemove = await text({
-        message: 'beforeRemove hook — run before removing a worktree?',
-        placeholder: 'leave blank to skip',
+        message: "beforeRemove hook — run before removing a worktree?",
+        placeholder: "leave blank to skip",
     });
     if (isCancel(beforeRemove)) {
-        outro('Setup skipped.');
+        outro("Setup skipped.");
         return null;
     }
-    outro('Setup complete!');
+    outro("Setup complete!");
     const hooks = {};
     if (afterCreate)
         hooks.afterCreate = afterCreate;

package/dist/install-prompt.d.ts

@@ -1,6 +1,6 @@
-import { type GjiConfig } from './config.js';
-import { type PackageManager } from './package-manager.js';
-export type InstallChoice = 'yes' | 'no' | 'always' | 'never';
+import { type GjiConfig } from "./config.js";
+import { type PackageManager } from "./package-manager.js";
+export type InstallChoice = "yes" | "no" | "always" | "never";
 export interface InstallPromptDependencies {
     detectInstallPackageManager?: (root: string) => Promise<PackageManager | null>;
     promptForInstallChoice?: (pm: PackageManager) => Promise<InstallChoice | null>;

package/dist/install-prompt.js

@@ -1,8 +1,8 @@
-import { spawn } from 'node:child_process';
-import { isCancel, select } from '@clack/prompts';
-import { loadConfig, loadGlobalConfig, updateGlobalRepoConfigKey, updateLocalConfigKey } from './config.js';
-import { isHeadless } from './headless.js';
-import { detectPackageManager } from './package-manager.js';
+import { spawn } from "node:child_process";
+import { isCancel, select } from "@clack/prompts";
+import { loadConfig, loadGlobalConfig, updateGlobalRepoConfigKey, updateLocalConfigKey, } from "./config.js";
+import { isHeadless } from "./headless.js";
+import { detectPackageManager, } from "./package-manager.js";
 export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dependencies = {}, nonInteractive = false) {
     // Skip in non-interactive mode — no prompt can be shown.
     if (isHeadless() || nonInteractive) {
@@ -24,10 +24,10 @@ export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stde
     }
     const prompt = dependencies.promptForInstallChoice ?? defaultPromptForInstallChoice;
     const choice = await prompt(pm);
-    if (!choice || choice === 'no') {
+    if (!choice || choice === "no") {
         return;
     }
-    if (choice === 'yes' || choice === 'always') {
+    if (choice === "yes" || choice === "always") {
         const runner = dependencies.runInstallCommand ?? defaultRunInstallCommand;
         try {
             await runner(pm.installCommand, worktreePath, stderr);
@@ -36,34 +36,42 @@ export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stde
             stderr(`gji: install command failed: ${error instanceof Error ? error.message : String(error)}\n`);
         }
     }
-    const saveGlobal = config.installSaveTarget === 'global';
+    const saveGlobal = config.installSaveTarget === "global";
     const writeKey = dependencies.writeConfigKey ?? defaultWriteConfigKey;
     const writeGlobalKey = dependencies.writeGlobalRepoConfigKey ?? defaultWriteGlobalRepoConfigKey;
-    if (choice === 'always') {
+    if (choice === "always") {
         try {
             if (saveGlobal) {
                 // Deep-merge with any existing per-repo global hooks so other keys are preserved.
                 const existingHooks = await loadExistingGlobalRepoHooks(repoRoot);
-                await writeGlobalKey(repoRoot, 'hooks', { ...existingHooks, afterCreate: pm.installCommand });
+                await writeGlobalKey(repoRoot, "hooks", {
+                    ...existingHooks,
+                    afterCreate: pm.installCommand,
+                });
             }
             else {
                 // Read local config hooks to deep-merge so other hook keys (e.g. afterEnter) are preserved.
                 const { config: localConfig } = await loadConfig(repoRoot);
-                const existingLocalHooks = isPlainObject(localConfig.hooks) ? localConfig.hooks : {};
-                await writeKey(repoRoot, 'hooks', { ...existingLocalHooks, afterCreate: pm.installCommand });
+                const existingLocalHooks = isPlainObject(localConfig.hooks)
+                    ? localConfig.hooks
+                    : {};
+                await writeKey(repoRoot, "hooks", {
+                    ...existingLocalHooks,
+                    afterCreate: pm.installCommand,
+                });
             }
         }
         catch (error) {
             stderr(`gji: failed to save config: ${error instanceof Error ? error.message : String(error)}\n`);
         }
     }
-    if (choice === 'never') {
+    if (choice === "never") {
         try {
             if (saveGlobal) {
-                await writeGlobalKey(repoRoot, 'skipInstallPrompt', true);
+                await writeGlobalKey(repoRoot, "skipInstallPrompt", true);
             }
             else {
-                await writeKey(repoRoot, 'skipInstallPrompt', true);
+                await writeKey(repoRoot, "skipInstallPrompt", true);
             }
         }
         catch (error) {
@@ -73,11 +81,15 @@ export async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stde
 }
 async function defaultRunInstallCommand(command, cwd, stderr) {
     await new Promise((resolve, reject) => {
-        const child = spawn(command, { cwd, shell: true, stdio: ['ignore', 'inherit', 'pipe'] });
-        child.stderr.on('data', (chunk) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            stdio: ["ignore", "inherit", "pipe"],
+        });
+        child.stderr.on("data", (chunk) => {
             stderr(chunk.toString());
         });
-        child.on('close', (code) => {
+        child.on("close", (code) => {
             if (code !== 0) {
                 reject(new Error(`exited with code ${code}`));
             }
@@ -85,7 +97,7 @@ async function defaultRunInstallCommand(command, cwd, stderr) {
                 resolve();
             }
         });
-        child.on('error', (err) => {
+        child.on("error", (err) => {
             reject(err);
         });
     });
@@ -99,17 +111,23 @@ async function defaultWriteGlobalRepoConfigKey(repoRoot, key, value) {
 async function loadExistingGlobalRepoHooks(repoRoot) {
     const { config: globalConfig } = await loadGlobalConfig();
     const repos = isPlainObject(globalConfig.repos) ? globalConfig.repos : {};
-    const perRepo = isPlainObject(repos[repoRoot]) ? repos[repoRoot] : {};
+    const perRepo = isPlainObject(repos[repoRoot])
+        ? repos[repoRoot]
+        : {};
     return isPlainObject(perRepo.hooks) ? perRepo.hooks : {};
 }
 async function defaultPromptForInstallChoice(pm) {
     const choice = await select({
         message: `Run \`${pm.installCommand}\` in the new worktree?`,
         options: [
-            { value: 'yes', label: 'Yes', hint: 'run once' },
-            { value: 'no', label: 'No', hint: 'skip this time' },
-            { value: 'always', label: 'Always', hint: 'save as afterCreate hook' },
-            { value: 'never', label: 'Never', hint: 'disable this prompt for this repo' },
+            { value: "yes", label: "Yes", hint: "run once" },
+            { value: "no", label: "No", hint: "skip this time" },
+            { value: "always", label: "Always", hint: "save as afterCreate hook" },
+            {
+                value: "never",
+                label: "Never",
+                hint: "disable this prompt for this repo",
+            },
         ],
     });
     if (isCancel(choice)) {
@@ -118,13 +136,13 @@ async function defaultPromptForInstallChoice(pm) {
     return choice;
 }
 function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isConfiguredHookCommand(value) {
-    if (typeof value === 'string')
+    if (typeof value === "string")
         return value.length > 0;
     return (Array.isArray(value) &&
         value.length > 0 &&
-        value[0] !== '' &&
-        value.every((item) => typeof item === 'string'));
+        value[0] !== "" &&
+        value.every((item) => typeof item === "string"));
 }

package/dist/ls.d.ts

@@ -1,5 +1,5 @@
-import { type WorktreeEntry } from './repo.js';
-import { type WorktreeInfo } from './worktree-info.js';
+import { type WorktreeEntry } from "./repo.js";
+import { type WorktreeInfo } from "./worktree-info.js";
 export interface LsCommandOptions {
     compact?: boolean;
     cwd: string;

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;