@solaqua/gji 0.6.2 → 0.7.0

package/dist/shell-completion.js

@@ -1,43 +1,56 @@
-import { KNOWN_GLOBAL_CONFIG_KEYS } from './config.js';
+import { KNOWN_GLOBAL_CONFIG_KEYS } from "./config.js";
 const TOP_LEVEL_COMMANDS = [
-    { name: 'new', description: 'create a new branch or detached linked worktree' },
-    { name: 'init', description: 'print or install shell integration' },
-    { name: 'completion', description: 'print shell completion definitions' },
-    { name: 'pr', description: 'fetch a pull request into a linked worktree' },
-    { name: 'back', description: 'navigate to the previously visited worktree' },
-    { name: 'history', description: 'show navigation history' },
-    { name: 'open', description: 'open the worktree in an editor' },
-    { name: 'go', description: 'print or select a worktree path' },
-    { name: 'jump', description: 'alias of go' },
-    { name: 'root', description: 'print the main repository root path' },
-    { name: 'status', description: 'summarize repository and worktree health' },
-    { name: 'sync', description: 'fetch and update one or all worktrees' },
-    { name: 'ls', description: 'list active worktrees' },
-    { name: 'clean', description: 'interactively prune linked worktrees' },
-    { name: 'remove', description: 'remove a linked worktree and delete its branch when present' },
-    { name: 'rm', description: 'alias of remove' },
-    { name: 'trigger-hook', description: 'run a named hook in the current worktree' },
-    { name: 'warp', description: 'jump to any worktree across all known repos' },
-    { name: 'config', description: 'manage global config defaults' },
+    {
+        name: "new",
+        description: "create a new branch or detached linked worktree",
+    },
+    { name: "init", description: "print or install shell integration" },
+    { name: "completion", description: "print shell completion definitions" },
+    { name: "pr", description: "fetch a pull request into a linked worktree" },
+    { name: "back", description: "navigate to the previously visited worktree" },
+    { name: "history", description: "show navigation history" },
+    { name: "open", description: "open the worktree in an editor" },
+    { name: "go", description: "print or select a worktree path" },
+    { name: "jump", description: "alias of go" },
+    { name: "root", description: "print the main repository root path" },
+    { name: "status", description: "summarize repository and worktree health" },
+    { name: "sync", description: "fetch and update one or all worktrees" },
+    {
+        name: "sync-files",
+        description: "manage local files copied into new worktrees",
+    },
+    { name: "ls", description: "list active worktrees" },
+    { name: "clean", description: "interactively prune linked worktrees" },
+    {
+        name: "remove",
+        description: "remove a linked worktree and delete its branch when present",
+    },
+    { name: "rm", description: "alias of remove" },
+    {
+        name: "trigger-hook",
+        description: "run a named hook in the current worktree",
+    },
+    { name: "warp", description: "jump to any worktree across all known repos" },
+    { name: "config", description: "manage global config defaults" },
 ];
-const SHELL_NAMES = ['bash', 'fish', 'zsh'];
-const HOOK_NAMES = ['afterCreate', 'afterEnter', 'beforeRemove'];
+const SHELL_NAMES = ["bash", "fish", "zsh"];
+const HOOK_NAMES = ["afterCreate", "afterEnter", "beforeRemove"];
 const CONFIG_KEYS = Array.from(KNOWN_GLOBAL_CONFIG_KEYS);
 export function renderShellCompletion(shell) {
     switch (shell) {
-        case 'bash':
+        case "bash":
             return renderBashCompletion();
-        case 'fish':
+        case "fish":
             return renderFishCompletion();
-        case 'zsh':
+        case "zsh":
             return renderZshCompletion();
     }
 }
 function renderBashCompletion() {
-    const topLevelCommands = TOP_LEVEL_COMMANDS.map((command) => command.name).join(' ');
-    const shells = SHELL_NAMES.join(' ');
-    const hooks = HOOK_NAMES.join(' ');
-    const configKeys = CONFIG_KEYS.join(' ');
+    const topLevelCommands = TOP_LEVEL_COMMANDS.map((command) => command.name).join(" ");
+    const shells = SHELL_NAMES.join(" ");
+    const hooks = HOOK_NAMES.join(" ");
+    const configKeys = CONFIG_KEYS.join(" ");
     return `__gji_worktree_branches() {
   command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 }
@@ -88,6 +101,12 @@ _gji_completion() {
     sync)
       COMPREPLY=( $(compgen -W "--all --json --help" -- "$cur") )
       ;;
+    sync-files)
+      if [ "$COMP_CWORD" -eq 2 ]; then
+        COMPREPLY=( $(compgen -W "list add remove rm --json --help" -- "$cur") )
+        return 0
+      fi
+      ;;
     ls)
       COMPREPLY=( $(compgen -W "--compact --json --help" -- "$cur") )
       ;;
@@ -128,10 +147,10 @@ _gji_completion() {
 complete -F _gji_completion gji`;
 }
 function renderFishCompletion() {
-    const commandLines = TOP_LEVEL_COMMANDS.map((command) => `complete -c gji -n '__fish_use_subcommand' -a '${command.name}' -d '${escapeSingleQuotes(command.description)}'`).join('\n');
-    const shellLines = SHELL_NAMES.map((shell) => `complete -c gji -n '__fish_seen_subcommand_from init' -a '${shell}' -d 'shell'`).join('\n');
-    const hookLines = HOOK_NAMES.map((hook) => `complete -c gji -n '__fish_seen_subcommand_from trigger-hook' -a '${hook}' -d 'hook'`).join('\n');
-    const configKeyLines = CONFIG_KEYS.map((key) => `complete -c gji -n '__gji_should_complete_config_key' -a '${key}' -d 'config key'`).join('\n');
+    const commandLines = TOP_LEVEL_COMMANDS.map((command) => `complete -c gji -n '__fish_use_subcommand' -a '${command.name}' -d '${escapeSingleQuotes(command.description)}'`).join("\n");
+    const shellLines = SHELL_NAMES.map((shell) => `complete -c gji -n '__fish_seen_subcommand_from init' -a '${shell}' -d 'shell'`).join("\n");
+    const hookLines = HOOK_NAMES.map((hook) => `complete -c gji -n '__fish_seen_subcommand_from trigger-hook' -a '${hook}' -d 'hook'`).join("\n");
+    const configKeyLines = CONFIG_KEYS.map((key) => `complete -c gji -n '__gji_should_complete_config_key' -a '${key}' -d 'config key'`).join("\n");
     return `function __gji_worktree_branches
     command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 end
@@ -193,6 +212,12 @@ complete -c gji -n '__fish_seen_subcommand_from status' -l json -d 'print reposi
 complete -c gji -n '__fish_seen_subcommand_from sync' -l all -d 'sync every worktree in the repository'
 complete -c gji -n '__fish_seen_subcommand_from sync' -l json -d 'emit JSON on success or error instead of human-readable output'
 
+complete -c gji -n '__fish_seen_subcommand_from sync-files' -a 'list add remove rm' -d 'sync-files action'
+complete -c gji -n '__fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from list; and __fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from add; and __fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from remove rm; and __fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+
 complete -c gji -n '__fish_seen_subcommand_from ls' -l compact -d 'show only branch and path columns'
 complete -c gji -n '__fish_seen_subcommand_from ls' -l json -d 'print active worktrees as JSON'
 
@@ -216,10 +241,10 @@ complete -c gji -n '__fish_seen_subcommand_from config; and __gji_should_complet
 ${configKeyLines}`;
 }
 function renderZshCompletion() {
-    const commandLines = TOP_LEVEL_COMMANDS.map((command) => `'${command.name}:${escapeSingleQuotes(command.description)}'`).join('\n    ');
-    const configKeys = CONFIG_KEYS.join(' ');
-    const shells = SHELL_NAMES.join(' ');
-    const hooks = HOOK_NAMES.join(' ');
+    const commandLines = TOP_LEVEL_COMMANDS.map((command) => `'${command.name}:${escapeSingleQuotes(command.description)}'`).join("\n    ");
+    const configKeys = CONFIG_KEYS.join(" ");
+    const shells = SHELL_NAMES.join(" ");
+    const hooks = HOOK_NAMES.join(" ");
     return `#compdef gji
 
 __gji_worktree_branches() {
@@ -272,6 +297,9 @@ case "\${words[2]}" in
   sync)
     _arguments '--all[sync every worktree in the repository]' '--json[emit JSON on success or error instead of human-readable output]'
     ;;
+  sync-files)
+    _arguments '--json[emit JSON instead of human-readable output]' '2:action:(list add remove rm)' '*:path: '
+    ;;
   ls)
     _arguments '--compact[show only branch and path columns]' '--json[print active worktrees as JSON]'
     ;;

package/dist/shell-handoff.js

@@ -1,8 +1,8 @@
-import { writeFile } from 'node:fs/promises';
+import { writeFile } from "node:fs/promises";
 export async function writeShellOutput(envVar, value, stdout) {
     const output = `${value}\n`;
     if (process.env[envVar]) {
-        await writeFile(process.env[envVar], output, 'utf8');
+        await writeFile(process.env[envVar], output, "utf8");
         return;
     }
     stdout(output);

package/dist/shell.d.ts

@@ -1,2 +1,2 @@
-export type SupportedShell = 'bash' | 'fish' | 'zsh';
+export type SupportedShell = "bash" | "fish" | "zsh";
 export declare function resolveSupportedShell(requestedShell: string | undefined, detectedShell: string | undefined): SupportedShell | null;

package/dist/shell.js

@@ -9,11 +9,11 @@ function normalizeShell(value) {
     if (!value) {
         return null;
     }
-    const candidate = value.split('/').at(-1)?.toLowerCase();
+    const candidate = value.split("/").at(-1)?.toLowerCase();
     switch (candidate) {
-        case 'bash':
-        case 'fish':
-        case 'zsh':
+        case "bash":
+        case "fish":
+        case "zsh":
             return candidate;
         default:
             return null;

package/dist/status.d.ts

@@ -7,17 +7,17 @@ interface WorktreeStatusRow {
     branch: string | null;
     current: boolean;
     path: string;
-    status: 'clean' | 'dirty';
+    status: "clean" | "dirty";
     upstream: UpstreamState;
 }
 type UpstreamState = {
-    kind: 'detached';
+    kind: "detached";
 } | {
-    kind: 'no-upstream';
+    kind: "no-upstream";
 } | {
-    kind: 'stale';
+    kind: "stale";
 } | {
-    kind: 'tracked';
+    kind: "tracked";
     ahead: number;
     behind: number;
 };

package/dist/status.js

@@ -1,6 +1,6 @@
-import { detectRepository, listWorktrees } from './repo.js';
-import { readWorktreeHealth } from './git.js';
-import { comparePaths } from './paths.js';
+import { readWorktreeHealth } from "./git.js";
+import { comparePaths } from "./paths.js";
+import { detectRepository, listWorktrees } from "./repo.js";
 export async function runStatusCommand(options) {
     const repository = await detectRepository(options.cwd);
     const worktrees = sortWorktreesByPath(await listWorktrees(options.cwd));
@@ -13,20 +13,20 @@ export async function runStatusCommand(options) {
     return 0;
 }
 export function formatStatusOutput(repoRoot, currentRoot, rows) {
-    const currentWidth = Math.max('CURRENT'.length, ...rows.map((row) => row.current ? 1 : 0));
-    const branchWidth = Math.max('BRANCH'.length, ...rows.map((row) => formatBranch(row.branch).length));
-    const statusWidth = Math.max('STATUS'.length, ...rows.map((row) => row.status.length));
-    const upstreamWidth = Math.max('UPSTREAM'.length, ...rows.map((row) => formatUpstreamState(row.upstream).length));
+    const currentWidth = Math.max("CURRENT".length, ...rows.map((row) => (row.current ? 1 : 0)));
+    const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => formatBranch(row.branch).length));
+    const statusWidth = Math.max("STATUS".length, ...rows.map((row) => row.status.length));
+    const upstreamWidth = Math.max("UPSTREAM".length, ...rows.map((row) => formatUpstreamState(row.upstream).length));
     const lines = [
         `REPO ${repoRoot}`,
         `CURRENT ${currentRoot}`,
-        '',
-        `${'CURRENT'.padEnd(currentWidth, ' ')} ${'BRANCH'.padEnd(branchWidth, ' ')} ${'STATUS'.padEnd(statusWidth, ' ')} ${'UPSTREAM'.padEnd(upstreamWidth, ' ')} PATH`,
+        "",
+        `${"CURRENT".padEnd(currentWidth, " ")} ${"BRANCH".padEnd(branchWidth, " ")} ${"STATUS".padEnd(statusWidth, " ")} ${"UPSTREAM".padEnd(upstreamWidth, " ")} PATH`,
     ];
     for (const row of rows) {
-        lines.push(`${(row.current ? '*' : '').padEnd(currentWidth, ' ')} ${formatBranch(row.branch).padEnd(branchWidth, ' ')} ${row.status.padEnd(statusWidth, ' ')} ${formatUpstreamState(row.upstream).padEnd(upstreamWidth, ' ')} ${row.path}`);
+        lines.push(`${(row.current ? "*" : "").padEnd(currentWidth, " ")} ${formatBranch(row.branch).padEnd(branchWidth, " ")} ${row.status.padEnd(statusWidth, " ")} ${formatUpstreamState(row.upstream).padEnd(upstreamWidth, " ")} ${row.path}`);
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 export function formatStatusJson(repoRoot, currentRoot, rows) {
     return {
@@ -49,36 +49,36 @@ function sortWorktreesByPath(worktrees) {
     return [...worktrees].sort((left, right) => comparePaths(left.path, right.path));
 }
 function formatBranch(branch) {
-    return branch ?? '(detached)';
+    return branch ?? "(detached)";
 }
 function buildUpstreamState(branch, health) {
     if (branch === null) {
-        return { kind: 'detached' };
+        return { kind: "detached" };
     }
     if (!health.hasUpstream) {
-        return { kind: 'no-upstream' };
+        return { kind: "no-upstream" };
     }
     if (health.upstreamGone) {
-        return { kind: 'stale' };
+        return { kind: "stale" };
     }
     return {
         ahead: health.ahead,
         behind: health.behind,
-        kind: 'tracked',
+        kind: "tracked",
     };
 }
 function formatUpstreamState(upstream) {
-    if (upstream.kind === 'detached') {
-        return 'n/a';
+    if (upstream.kind === "detached") {
+        return "n/a";
     }
-    if (upstream.kind === 'no-upstream') {
-        return 'no-upstream';
+    if (upstream.kind === "no-upstream") {
+        return "no-upstream";
     }
-    if (upstream.kind === 'stale') {
-        return 'gone';
+    if (upstream.kind === "stale") {
+        return "gone";
     }
     if (upstream.ahead === 0 && upstream.behind === 0) {
-        return 'up to date';
+        return "up to date";
     }
     if (upstream.ahead === 0) {
         return `behind ${upstream.behind}`;

package/dist/sync-files-command.d.ts

@@ -0,0 +1,10 @@
+export interface SyncFilesCommandOptions {
+    action?: string;
+    cwd: string;
+    home?: string;
+    json?: boolean;
+    paths?: string[];
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function runSyncFilesCommand(options: SyncFilesCommandOptions): Promise<number>;

package/dist/sync-files-command.js

@@ -0,0 +1,137 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { loadGlobalConfig, saveGlobalConfig, } from "./config.js";
+import { validateSyncFilePattern } from "./file-sync.js";
+import { detectRepository } from "./repo.js";
+export async function runSyncFilesCommand(options) {
+    const repository = await detectRepository(options.cwd);
+    const home = options.home ?? homedir();
+    const loaded = await loadGlobalConfig(home);
+    const repoEntry = findRepoConfigEntry(loaded.config, repository.repoRoot, home);
+    const repoConfig = repoEntry?.config ?? {};
+    switch (options.action) {
+        case undefined:
+        case "list": {
+            writeSyncFiles(options.stdout, readSyncFiles(repoConfig), !!options.json);
+            return 0;
+        }
+        case "add": {
+            const paths = validatePaths(options.paths ?? [], options);
+            if (!paths)
+                return 1;
+            const nextFiles = mergeSyncFiles(readSyncFiles(repoConfig), paths);
+            await saveRepoSyncFiles(loaded.config, repoEntry?.key ?? repository.repoRoot, nextFiles, home);
+            writeSyncFiles(options.stdout, nextFiles, !!options.json);
+            return 0;
+        }
+        case "remove": {
+            const paths = validatePaths(options.paths ?? [], options);
+            if (!paths)
+                return 1;
+            const existingFiles = readSyncFiles(repoConfig);
+            const nextFiles = removeSyncFiles(existingFiles, paths);
+            if (repoEntry && nextFiles.length !== existingFiles.length) {
+                await saveRepoSyncFiles(loaded.config, repoEntry.key, nextFiles, home);
+            }
+            writeSyncFiles(options.stdout, nextFiles, !!options.json);
+            return 0;
+        }
+    }
+    writeError(options, `unknown action: ${options.action}`);
+    return 1;
+}
+function findRepoConfigEntry(config, repoRoot, home) {
+    const repos = config.repos;
+    if (!isPlainObject(repos))
+        return null;
+    for (const [key, value] of Object.entries(repos)) {
+        if (expandTilde(key, home) === repoRoot && isPlainObject(value)) {
+            return { config: value, key };
+        }
+    }
+    return null;
+}
+function readSyncFiles(config) {
+    const syncFiles = config.syncFiles;
+    if (!Array.isArray(syncFiles))
+        return [];
+    return syncFiles.filter((item) => typeof item === "string");
+}
+function writeSyncFiles(stdout, files, json) {
+    if (json) {
+        stdout(`${JSON.stringify(files, null, 2)}\n`);
+        return;
+    }
+    if (files.length === 0) {
+        stdout("No sync files configured for this repo.\n");
+        return;
+    }
+    stdout(`${files.join("\n")}\n`);
+}
+function validatePaths(paths, options) {
+    if (paths.length === 0) {
+        writeError(options, "at least one path is required");
+        return null;
+    }
+    const validatedPaths = [];
+    for (const path of paths) {
+        try {
+            validatedPaths.push(validateSyncFilePattern(path));
+        }
+        catch (error) {
+            writeError(options, error instanceof Error ? error.message : String(error));
+            return null;
+        }
+    }
+    return validatedPaths;
+}
+function mergeSyncFiles(existing, additions) {
+    const nextFiles = [...existing];
+    for (const path of additions) {
+        if (!nextFiles.includes(path)) {
+            nextFiles.push(path);
+        }
+    }
+    return nextFiles;
+}
+function removeSyncFiles(existing, removals) {
+    const removalSet = new Set(removals);
+    return existing.filter((path) => !removalSet.has(path));
+}
+async function saveRepoSyncFiles(config, repoKey, syncFiles, home) {
+    const repos = isPlainObject(config.repos) ? { ...config.repos } : {};
+    const repoConfig = isPlainObject(repos[repoKey])
+        ? repos[repoKey]
+        : {};
+    const nextRepoConfig = { ...repoConfig };
+    if (syncFiles.length > 0) {
+        nextRepoConfig.syncFiles = syncFiles;
+    }
+    else {
+        delete nextRepoConfig.syncFiles;
+    }
+    if (Object.keys(nextRepoConfig).length > 0) {
+        repos[repoKey] = nextRepoConfig;
+    }
+    else {
+        delete repos[repoKey];
+    }
+    await saveGlobalConfig({ ...config, repos }, home);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function writeError(options, message) {
+    if (options.json) {
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+        return;
+    }
+    options.stderr(`gji sync-files: ${message}\n`);
+}
+function expandTilde(value, home) {
+    if (value === "~")
+        return home;
+    if (value.startsWith("~/"))
+        return join(home, value.slice(2));
+    return value;
+}

package/dist/sync.js

@@ -1,16 +1,17 @@
-import { loadEffectiveConfig } from './config.js';
-import { isDirtyWorktree, resolveRemoteDefaultBranch, runGit } from './git.js';
-import { comparePaths } from './paths.js';
-import { detectRepository, listWorktrees } from './repo.js';
+import { loadEffectiveConfig } from "./config.js";
+import { isDirtyWorktree, resolveRemoteDefaultBranch, runGit } from "./git.js";
+import { comparePaths } from "./paths.js";
+import { detectRepository, listWorktrees } from "./repo.js";
 export async function runSyncCommand(options) {
     const repository = await detectRepository(options.cwd);
     const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
     const worktrees = await listWorktrees(options.cwd);
-    const remote = resolveConfiguredString(config.syncRemote) ?? 'origin';
+    const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
     let defaultBranch;
     try {
-        defaultBranch = resolveConfiguredString(config.syncDefaultBranch)
-            ?? await resolveRemoteDefaultBranch(repository.repoRoot, remote);
+        defaultBranch =
+            resolveConfiguredString(config.syncDefaultBranch) ??
+                (await resolveRemoteDefaultBranch(repository.repoRoot, remote));
     }
     catch {
         emitError(options, `Unable to reach remote '${remote}'`);
@@ -20,14 +21,14 @@ export async function runSyncCommand(options) {
         return 1;
     }
     if (!defaultBranch) {
-        emitError(options, 'Unable to determine the default branch for sync.');
+        emitError(options, "Unable to determine the default branch for sync.");
         if (!options.json) {
             options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>\n`);
         }
         return 1;
     }
     const targetWorktrees = selectTargetWorktrees(worktrees, repository.currentRoot, options.all);
-    if (targetWorktrees === 'detached') {
+    if (targetWorktrees === "detached") {
         emitError(options, `Cannot sync detached worktree: ${repository.currentRoot}`);
         return 1;
     }
@@ -38,7 +39,7 @@ export async function runSyncCommand(options) {
         }
     }
     try {
-        await runGit(repository.repoRoot, ['fetch', '--prune', remote]);
+        await runGit(repository.repoRoot, ["fetch", "--prune", remote]);
     }
     catch {
         emitError(options, `Failed to fetch from remote '${remote}'`);
@@ -50,10 +51,14 @@ export async function runSyncCommand(options) {
     const updatedWorktrees = [];
     for (const worktree of targetWorktrees) {
         if (worktree.branch === defaultBranch) {
-            await runGit(worktree.path, ['merge', '--ff-only', `${remote}/${defaultBranch}`]);
+            await runGit(worktree.path, [
+                "merge",
+                "--ff-only",
+                `${remote}/${defaultBranch}`,
+            ]);
         }
         else {
-            await runGit(worktree.path, ['rebase', `${remote}/${defaultBranch}`]);
+            await runGit(worktree.path, ["rebase", `${remote}/${defaultBranch}`]);
         }
         updatedWorktrees.push(worktree);
         if (!options.json) {
@@ -61,7 +66,10 @@ export async function runSyncCommand(options) {
         }
     }
     if (options.json) {
-        const updated = updatedWorktrees.map((w) => ({ branch: w.branch, path: w.path }));
+        const updated = updatedWorktrees.map((w) => ({
+            branch: w.branch,
+            path: w.path,
+        }));
         options.stdout(`${JSON.stringify({ updated }, null, 2)}\n`);
     }
     return 0;
@@ -85,10 +93,10 @@ function selectTargetWorktrees(worktrees, currentRoot, all) {
         return [];
     }
     if (!currentWorktree.branch) {
-        return 'detached';
+        return "detached";
     }
     return [currentWorktree];
 }
 function resolveConfiguredString(value) {
-    return typeof value === 'string' && value.length > 0 ? value : null;
+    return typeof value === "string" && value.length > 0 ? value : null;
 }

package/dist/trigger-hook.js

@@ -1,13 +1,17 @@
-import { loadEffectiveConfig } from './config.js';
-import { extractHooks, runHook } from './hooks.js';
-import { detectRepository, listWorktrees } from './repo.js';
-const VALID_HOOKS = ['afterCreate', 'afterEnter', 'beforeRemove'];
+import { loadEffectiveConfig } from "./config.js";
+import { extractHooks, runHook } from "./hooks.js";
+import { detectRepository, listWorktrees } from "./repo.js";
+const VALID_HOOKS = [
+    "afterCreate",
+    "afterEnter",
+    "beforeRemove",
+];
 function isValidHook(hook) {
     return VALID_HOOKS.includes(hook);
 }
 export async function runTriggerHookCommand(options) {
     if (!isValidHook(options.hook)) {
-        options.stderr(`gji trigger-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(', ')}\n`);
+        options.stderr(`gji trigger-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(", ")}\n`);
         return 1;
     }
     const hookName = options.hook;