@solaqua/gji 0.6.2 → 0.7.1

package/dist/repo.js

@@ -1,9 +1,9 @@
-import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
-import { homedir } from 'node:os';
-import { runGit } from './git.js';
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { runGit } from "./git.js";
 export async function detectRepository(cwd) {
-    const currentRoot = await runGit(cwd, ['rev-parse', '--show-toplevel']);
-    const rawCommonDir = await runGit(cwd, ['rev-parse', '--git-common-dir']);
+    const currentRoot = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    const rawCommonDir = await runGit(cwd, ["rev-parse", "--git-common-dir"]);
     const gitCommonDir = isAbsolute(rawCommonDir)
         ? rawCommonDir
         : resolve(currentRoot, rawCommonDir);
@@ -17,71 +17,72 @@ export async function detectRepository(cwd) {
     };
 }
 export function resolveWorktreePath(repoRoot, branch, basePath) {
-    const segments = branch.split('/').filter(Boolean);
+    const segments = branch.split("/").filter(Boolean);
     if (segments.length === 0) {
-        throw new Error('Branch name must not be empty.');
+        throw new Error("Branch name must not be empty.");
     }
-    if (segments.some((segment) => segment === '.' || segment === '..')) {
+    if (segments.some((segment) => segment === "." || segment === "..")) {
         throw new Error(`Branch name '${branch}' contains an invalid path segment.`);
     }
     const base = basePath
         ? expandTildeInPath(basePath)
-        : join(dirname(repoRoot), 'worktrees', basename(repoRoot));
+        : join(dirname(repoRoot), "worktrees", basename(repoRoot));
     return join(base, ...segments);
 }
 export function validateBranchName(name) {
     if (name.length === 0) {
-        return 'Branch name must not be empty.';
+        return "Branch name must not be empty.";
     }
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional control chars to reject in git branch names
     if (/[\x00-\x1f\x7f ~^:?*[\\\s]/.test(name)) {
         return `Branch name '${name}' contains an invalid character.`;
     }
-    if (name.startsWith('-')) {
+    if (name.startsWith("-")) {
         return `Branch name '${name}' must not start with a dash.`;
     }
-    if (name.startsWith('/') || name.endsWith('/') || name.includes('//')) {
+    if (name.startsWith("/") || name.endsWith("/") || name.includes("//")) {
         return `Branch name '${name}' has invalid slash placement.`;
     }
-    if (name.includes('..')) {
+    if (name.includes("..")) {
         return `Branch name '${name}' must not contain '..'.`;
     }
-    if (name.endsWith('.')) {
+    if (name.endsWith(".")) {
         return `Branch name '${name}' must not end with '.'.`;
     }
-    if (name.includes('@{')) {
+    if (name.includes("@{")) {
         return `Branch name '${name}' must not contain '@{'.`;
     }
-    if (name === '@') {
+    if (name === "@") {
         return "Branch name cannot be '@'.";
     }
-    for (const segment of name.split('/')) {
-        if (segment.startsWith('.')) {
+    for (const segment of name.split("/")) {
+        if (segment.startsWith(".")) {
             return `Branch name '${name}' contains a path component starting with '.'.`;
         }
-        if (segment.endsWith('.lock')) {
+        if (segment.endsWith(".lock")) {
             return `Branch name '${name}' contains a path component ending with '.lock'.`;
         }
     }
     return null;
 }
 function expandTildeInPath(p) {
-    if (p === '~')
+    if (p === "~")
         return homedir();
-    if (p.startsWith('~/'))
+    if (p.startsWith("~/"))
         return join(homedir(), p.slice(2));
     return p;
 }
 export async function listWorktrees(cwd) {
     const [output, currentRoot] = await Promise.all([
-        runGit(cwd, ['worktree', 'list', '--porcelain']),
-        runGit(cwd, ['rev-parse', '--show-toplevel']),
+        runGit(cwd, ["worktree", "list", "--porcelain"]),
+        runGit(cwd, ["rev-parse", "--show-toplevel"]),
     ]);
-    const entries = output.split('\n\n').filter(Boolean);
+    const entries = output.split("\n\n").filter(Boolean);
     return entries.map((entry) => {
-        const path = findPorcelainValue(entry, 'worktree');
-        const branchRef = findOptionalPorcelainValue(entry, 'branch');
+        const path = findPorcelainValue(entry, "worktree");
+        const branchRef = findOptionalPorcelainValue(entry, "branch");
         return {
-            branch: branchRef ? branchRef.replace('refs/heads/', '') : null,
+            branch: branchRef ? branchRef.replace("refs/heads/", "") : null,
             isCurrent: path === currentRoot,
             path,
         };
@@ -105,7 +106,7 @@ function findPorcelainValue(block, key) {
 }
 function findOptionalPorcelainValue(block, key) {
     const line = block
-        .split('\n')
+        .split("\n")
         .find((candidate) => candidate.startsWith(`${key} `));
     if (!line) {
         return null;

package/dist/root.js

@@ -1,6 +1,6 @@
-import { detectRepository } from './repo.js';
-import { writeShellOutput } from './shell-handoff.js';
-const ROOT_OUTPUT_FILE_ENV = 'GJI_ROOT_OUTPUT_FILE';
+import { detectRepository } from "./repo.js";
+import { writeShellOutput } from "./shell-handoff.js";
+const ROOT_OUTPUT_FILE_ENV = "GJI_ROOT_OUTPUT_FILE";
 export async function runRootCommand(options) {
     const repository = await detectRepository(options.cwd);
     if (!options.print && process.env[ROOT_OUTPUT_FILE_ENV]) {

package/dist/run-hook.d.ts

@@ -0,0 +1,6 @@
+export interface RunHookCommandOptions {
+    cwd: string;
+    hook: string;
+    stderr: (chunk: string) => void;
+}
+export declare function runHookCommand(options: RunHookCommandOptions): Promise<number>;

package/dist/{trigger-hook.js → run-hook.js}

@@ -1,16 +1,26 @@
-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 = [
+    "after-create",
+    "after-enter",
+    "before-remove",
+];
+const CAMEL_ALIASES = {
+    afterCreate: "after-create",
+    afterEnter: "after-enter",
+    beforeRemove: "before-remove",
+};
 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`);
+export async function runHookCommand(options) {
+    const normalized = CAMEL_ALIASES[options.hook] ?? options.hook;
+    if (!isValidHook(normalized)) {
+        options.stderr(`gji run-hook: unknown hook '${options.hook}'. Valid hooks: ${VALID_HOOKS.join(", ")}\n`);
         return 1;
     }
-    const hookName = options.hook;
+    const hookName = normalized;
     const repository = await detectRepository(options.cwd);
     const config = await loadEffectiveConfig(repository.repoRoot, undefined, options.stderr);
     const hooks = extractHooks(config);

package/dist/shell-completion.d.ts

@@ -1 +1 @@
-export declare function renderShellCompletion(shell: 'bash' | 'fish' | 'zsh'): string;
+export declare function renderShellCompletion(shell: "bash" | "fish" | "zsh"): string;

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: "run-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 = ["after-create", "after-enter", "before-remove"];
 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") )
       ;;
@@ -97,7 +116,7 @@ _gji_completion() {
     remove|rm)
       COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) -f --force --dry-run --json --help" -- "$cur") )
       ;;
-    trigger-hook)
+    run-hook)
       COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
       ;;
     warp)
@@ -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 run-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]'
     ;;
@@ -281,7 +309,7 @@ case "\${words[2]}" in
   remove|rm)
     _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
     ;;
-  trigger-hook)
+  run-hook)
     _arguments "2:hook:(${hooks})"
     ;;
   warp)

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;
+}