@solaqua/gji 0.4.0 → 0.4.1

package/dist/init.d.ts

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

package/dist/init.js

@@ -3,6 +3,7 @@ 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 = [
@@ -43,7 +44,7 @@ const SHELL_WRAPPED_COMMANDS = [
     },
 ];
 export async function runInitCommand(options) {
-    const shell = resolveShell(options.shell, process.env.SHELL);
+    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');
@@ -139,27 +140,6 @@ async function saveWizardConfig(result, cwd, home) {
         await saveGlobalConfig({ ...existing, ...values }, home);
     }
 }
-function resolveShell(requestedShell, detectedShell) {
-    const requested = normalizeShell(requestedShell);
-    if (requested) {
-        return requested;
-    }
-    return normalizeShell(detectedShell);
-}
-function normalizeShell(value) {
-    if (!value) {
-        return null;
-    }
-    const candidate = value.split('/').at(-1)?.toLowerCase();
-    switch (candidate) {
-        case 'bash':
-        case 'fish':
-        case 'zsh':
-            return candidate;
-        default:
-            return null;
-    }
-}
 function resolveShellConfigPath(shell, home) {
     switch (shell) {
         case 'bash':

package/dist/ls.d.ts

@@ -1,8 +1,11 @@
 import { type WorktreeEntry } from './repo.js';
+import { type WorktreeInfo } from './worktree-info.js';
 export interface LsCommandOptions {
+    compact?: boolean;
     cwd: string;
     json?: boolean;
     stdout: (chunk: string) => void;
 }
 export declare function runLsCommand(options: LsCommandOptions): Promise<number>;
+export declare function formatDetailedWorktreeTable(worktrees: WorktreeInfo[]): string;
 export declare function formatWorktreeTable(worktrees: WorktreeEntry[]): string;

package/dist/ls.js

@@ -1,14 +1,58 @@
 import { listWorktrees } from './repo.js';
 import { comparePaths } from './paths.js';
+import { formatLastCommit, formatUpstreamState, readWorktreeInfos, } from './worktree-info.js';
 export async function runLsCommand(options) {
     const worktrees = sortWorktrees(await listWorktrees(options.cwd));
+    if (options.compact) {
+        if (options.json) {
+            options.stdout(`${JSON.stringify(worktrees, null, 2)}\n`);
+            return 0;
+        }
+        options.stdout(`${formatWorktreeTable(worktrees)}\n`);
+        return 0;
+    }
+    const infos = await readWorktreeInfos(worktrees);
     if (options.json) {
-        options.stdout(`${JSON.stringify(worktrees, null, 2)}\n`);
+        options.stdout(`${JSON.stringify(infos, null, 2)}\n`);
         return 0;
     }
-    options.stdout(`${formatWorktreeTable(worktrees)}\n`);
+    options.stdout(`${formatDetailedWorktreeTable(infos)}\n`);
     return 0;
 }
+export function formatDetailedWorktreeTable(worktrees) {
+    const rows = worktrees.map((worktree) => ({
+        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 lines = [
+        '  '
+            + '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);
+    }
+    return lines.join('\n');
+}
 export function formatWorktreeTable(worktrees) {
     const rows = worktrees.map((worktree) => ({
         branch: worktree.branch ?? '(detached)',

package/dist/pr.js

@@ -74,7 +74,7 @@ export function createPrCommand(dependencies = {}) {
             return 0;
         }
         try {
-            await execFileAsync('git', ['fetch', 'origin', `refs/pull/${prNumber}/head:${remoteRef}`], { cwd: repository.repoRoot });
+            await fetchPullRequestRef(repository.repoRoot, options.number, prNumber, remoteRef);
         }
         catch {
             const message = `Failed to fetch PR #${prNumber} from origin`;
@@ -127,6 +127,48 @@ async function localBranchExists(repoRoot, branchName) {
     }
 }
 export const runPrCommand = createPrCommand();
+async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
+    for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
+        try {
+            await execFileAsync('git', ['fetch', 'origin', `${sourceRef}:${remoteRef}`], { cwd: repoRoot });
+            return;
+        }
+        catch {
+            // Try the next forge-specific ref namespace before failing the command.
+        }
+    }
+    throw new Error(`No pull request ref found for #${prNumber}`);
+}
+function listPullRequestSourceRefs(input, prNumber) {
+    const allForges = ['github', 'gitlab', 'bitbucket'];
+    const preferredForge = detectPullRequestForge(input);
+    const orderedForges = preferredForge === 'unknown'
+        ? allForges
+        : [preferredForge, ...allForges.filter((forge) => forge !== preferredForge)];
+    return orderedForges.map((forge) => sourceRefForForge(forge, prNumber));
+}
+function detectPullRequestForge(input) {
+    if (/\/pull-requests\/\d+/.test(input)) {
+        return 'bitbucket';
+    }
+    if (/\/merge_requests\/\d+/.test(input)) {
+        return 'gitlab';
+    }
+    if (/\/pull\/\d+/.test(input)) {
+        return 'github';
+    }
+    return 'unknown';
+}
+function sourceRefForForge(forge, prNumber) {
+    switch (forge) {
+        case 'bitbucket':
+            return `refs/pull-requests/${prNumber}/from`;
+        case 'github':
+            return `refs/pull/${prNumber}/head`;
+        case 'gitlab':
+            return `refs/merge-requests/${prNumber}/head`;
+    }
+}
 async function writeOutput(worktreePath, stdout) {
     await writeShellOutput(PR_OUTPUT_FILE_ENV, worktreePath, stdout);
 }

package/dist/shell-completion.d.ts

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

package/dist/shell-completion.js

@@ -0,0 +1,284 @@
+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: 'go', description: 'print or select a worktree path' },
+    { 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: 'config', description: 'manage global config defaults' },
+];
+const SHELL_NAMES = ['bash', 'fish', 'zsh'];
+const HOOK_NAMES = ['afterCreate', 'afterEnter', 'beforeRemove'];
+const CONFIG_KEYS = [
+    'branchPrefix',
+    'syncRemote',
+    'syncDefaultBranch',
+    'syncFiles',
+    'skipInstallPrompt',
+    'installSaveTarget',
+    'hooks',
+    'repos',
+];
+export function renderShellCompletion(shell) {
+    switch (shell) {
+        case 'bash':
+            return renderBashCompletion();
+        case 'fish':
+            return renderFishCompletion();
+        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(' ');
+    return `__gji_worktree_branches() {
+  command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
+}
+
+_gji_completion() {
+  local cur command_name
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]:-}"
+
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "${topLevelCommands}" -- "$cur") )
+    return 0
+  fi
+
+  command_name="\${COMP_WORDS[1]}"
+
+  case "$command_name" in
+    new)
+      COMPREPLY=( $(compgen -W "--detached --dry-run --json --help" -- "$cur") )
+      ;;
+    init)
+      COMPREPLY=( $(compgen -W "${shells} --write --help" -- "$cur") )
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "${shells} --help" -- "$cur") )
+      ;;
+    pr)
+      COMPREPLY=( $(compgen -W "--dry-run --json --help" -- "$cur") )
+      ;;
+    go)
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --print --help" -- "$cur") )
+      ;;
+    root)
+      COMPREPLY=( $(compgen -W "--print --help" -- "$cur") )
+      ;;
+    status)
+      COMPREPLY=( $(compgen -W "--json --help" -- "$cur") )
+      ;;
+    sync)
+      COMPREPLY=( $(compgen -W "--all --json --help" -- "$cur") )
+      ;;
+    ls)
+      COMPREPLY=( $(compgen -W "--compact --json --help" -- "$cur") )
+      ;;
+    clean)
+      COMPREPLY=( $(compgen -W "-f --force --stale --dry-run --json --help" -- "$cur") )
+      ;;
+    remove|rm)
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) -f --force --dry-run --json --help" -- "$cur") )
+      ;;
+    trigger-hook)
+      COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
+      ;;
+    config)
+      if [ "$COMP_CWORD" -eq 2 ]; then
+        COMPREPLY=( $(compgen -W "get set unset" -- "$cur") )
+        return 0
+      fi
+
+      case "\${COMP_WORDS[2]}" in
+        get|unset)
+          if [ "$COMP_CWORD" -eq 3 ]; then
+            COMPREPLY=( $(compgen -W "${configKeys}" -- "$cur") )
+          fi
+          ;;
+        set)
+          if [ "$COMP_CWORD" -eq 3 ]; then
+            COMPREPLY=( $(compgen -W "${configKeys}" -- "$cur") )
+          fi
+          ;;
+      esac
+      ;;
+  esac
+}
+
+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');
+    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
+
+function __gji_should_complete_config_action
+    set -l tokens (commandline -opc)
+    test (count $tokens) -eq 2
+end
+
+function __gji_should_complete_config_key
+    set -l tokens (commandline -opc)
+    if test (count $tokens) -ne 3
+        return 1
+    end
+
+    if test $tokens[2] != config
+        return 1
+    end
+
+    contains -- $tokens[3] get set unset
+end
+
+complete -c gji -f
+${commandLines}
+
+complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a detached worktree without a branch'
+complete -c gji -n '__fish_seen_subcommand_from new' -l dry-run -d 'show what would be created without executing any git commands or writing files'
+complete -c gji -n '__fish_seen_subcommand_from new' -l json -d 'emit JSON on success or error instead of human-readable output'
+
+complete -c gji -n '__fish_seen_subcommand_from init' -l write -d 'write the integration to the shell config file'
+${shellLines}
+
+complete -c gji -n '__fish_seen_subcommand_from completion' -a 'bash' -d 'shell'
+complete -c gji -n '__fish_seen_subcommand_from completion' -a 'fish' -d 'shell'
+complete -c gji -n '__fish_seen_subcommand_from completion' -a 'zsh' -d 'shell'
+
+complete -c gji -n '__fish_seen_subcommand_from pr' -l dry-run -d 'show what would be created without executing any git commands or writing files'
+complete -c gji -n '__fish_seen_subcommand_from pr' -l json -d 'emit JSON on success or error instead of human-readable output'
+
+complete -c gji -n '__fish_seen_subcommand_from go' -l print -d 'print the resolved worktree path explicitly'
+complete -c gji -n '__fish_seen_subcommand_from go' -a '(__gji_worktree_branches)' -d 'worktree branch'
+
+complete -c gji -n '__fish_seen_subcommand_from root' -l print -d 'print the resolved repository root path explicitly'
+
+complete -c gji -n '__fish_seen_subcommand_from status' -l json -d 'print repository and worktree health as JSON'
+
+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 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'
+
+complete -c gji -n '__fish_seen_subcommand_from clean' -s f -l force -d 'bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches'
+complete -c gji -n '__fish_seen_subcommand_from clean' -l stale -d 'only target clean worktrees whose upstream is gone and branch is merged into the default branch'
+complete -c gji -n '__fish_seen_subcommand_from clean' -l dry-run -d 'show what would be deleted without removing anything'
+complete -c gji -n '__fish_seen_subcommand_from clean' -l json -d 'emit JSON on success or error instead of human-readable output'
+
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -s f -l force -d 'bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch'
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -l dry-run -d 'show what would be deleted without removing anything'
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -l json -d 'emit JSON on success or error instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_branches)' -d 'worktree branch'
+
+${hookLines}
+
+complete -c gji -n '__fish_seen_subcommand_from config; and __gji_should_complete_config_action' -a 'get set unset' -d 'config action'
+${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(' ');
+    return `__gji_worktree_branches() {
+  command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
+}
+
+_gji_completion() {
+  local context state line
+  local -a commands worktree_branches
+
+  commands=(
+    ${commandLines}
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+  fi
+
+  case "\${words[2]}" in
+    new)
+      _arguments '--detached[create a detached worktree without a branch]' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+      ;;
+    init)
+      _arguments '--write[write the integration to the shell config file]' '2:shell:(${shells})'
+      ;;
+    completion)
+      _arguments '2:shell:(${shells})'
+      ;;
+    pr)
+      _arguments '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:ref: '
+      ;;
+    go)
+      _arguments '--print[print the resolved worktree path explicitly]' '2:branch:->worktrees'
+      ;;
+    root)
+      _arguments '--print[print the resolved repository root path explicitly]'
+      ;;
+    status)
+      _arguments '--json[print repository and worktree health as JSON]'
+      ;;
+    sync)
+      _arguments '--all[sync every worktree in the repository]' '--json[emit JSON on success or error instead of human-readable output]'
+      ;;
+    ls)
+      _arguments '--compact[show only branch and path columns]' '--json[print active worktrees as JSON]'
+      ;;
+    clean)
+      _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches]' '--stale[only target clean worktrees whose upstream is gone and branch is merged into the default branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]'
+      ;;
+    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)
+      _arguments "2:hook:(${hooks})"
+      ;;
+    config)
+      if (( CURRENT == 3 )); then
+        _values 'config action' get set unset
+        return
+      fi
+
+      case "\${words[3]}" in
+        get|unset)
+          _arguments '3:key:->config_keys'
+          ;;
+        set)
+          _arguments '3:key:->config_keys' '4:value: '
+          ;;
+      esac
+      ;;
+  esac
+
+  case "$state" in
+    worktrees)
+      worktree_branches=(\${(@f)$(__gji_worktree_branches)})
+      _describe 'worktree branch' worktree_branches
+      ;;
+    config_keys)
+      _values 'config key' ${configKeys}
+      ;;
+  esac
+}
+
+compdef _gji_completion gji`;
+}
+function escapeSingleQuotes(value) {
+    return value.replace(/'/g, `'\\''`);
+}

package/dist/shell.d.ts

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

package/dist/shell.js

@@ -0,0 +1,21 @@
+export function resolveSupportedShell(requestedShell, detectedShell) {
+    const requested = normalizeShell(requestedShell);
+    if (requested) {
+        return requested;
+    }
+    return normalizeShell(detectedShell);
+}
+function normalizeShell(value) {
+    if (!value) {
+        return null;
+    }
+    const candidate = value.split('/').at(-1)?.toLowerCase();
+    switch (candidate) {
+        case 'bash':
+        case 'fish':
+        case 'zsh':
+            return candidate;
+        default:
+            return null;
+    }
+}

package/dist/sync.js

@@ -1,5 +1,5 @@
 import { loadEffectiveConfig } from './config.js';
-import { isDirtyWorktree, runGit } from './git.js';
+import { isDirtyWorktree, resolveRemoteDefaultBranch, runGit } from './git.js';
 import { comparePaths } from './paths.js';
 import { detectRepository, listWorktrees } from './repo.js';
 export async function runSyncCommand(options) {
@@ -10,7 +10,7 @@ export async function runSyncCommand(options) {
     let defaultBranch;
     try {
         defaultBranch = resolveConfiguredString(config.syncDefaultBranch)
-            ?? await resolveDefaultBranch(repository.repoRoot, remote);
+            ?? await resolveRemoteDefaultBranch(repository.repoRoot, remote);
     }
     catch {
         emitError(options, `Unable to reach remote '${remote}'`);
@@ -89,17 +89,6 @@ function selectTargetWorktrees(worktrees, currentRoot, all) {
     }
     return [currentWorktree];
 }
-async function resolveDefaultBranch(repoRoot, remote) {
-    const stdout = await runGit(repoRoot, ['ls-remote', '--symref', remote, 'HEAD']);
-    const refLine = stdout
-        .split('\n')
-        .find((line) => line.startsWith('ref: refs/heads/'));
-    if (!refLine) {
-        return null;
-    }
-    const match = /^ref: refs\/heads\/(.+)\tHEAD$/.exec(refLine);
-    return match?.[1] ?? null;
-}
 function resolveConfiguredString(value) {
     return typeof value === 'string' && value.length > 0 ? value : null;
 }

package/dist/worktree-info.d.ts

@@ -0,0 +1,33 @@
+import { type WorktreeHealth } from './git.js';
+import type { WorktreeEntry } from './repo.js';
+export interface WorktreeInfo extends WorktreeEntry {
+    lastCommitTimestamp: number | null;
+    status: WorktreeHealth['status'] | 'unknown';
+    upstream: UpstreamState;
+}
+export interface SerializedWorktreeInfo {
+    branch: string | null;
+    lastCommitTimestamp: number | null;
+    path: string;
+    status: WorktreeInfo['status'];
+    upstream: UpstreamState;
+}
+export type UpstreamState = {
+    kind: 'detached';
+} | {
+    kind: 'no-upstream';
+} | {
+    kind: 'stale';
+} | {
+    kind: 'tracked';
+    ahead: number;
+    behind: number;
+} | {
+    kind: 'unknown';
+};
+export declare function readWorktreeInfos(worktrees: WorktreeEntry[]): Promise<WorktreeInfo[]>;
+export declare function serializeWorktreeInfo(info: WorktreeInfo): SerializedWorktreeInfo;
+export declare function formatWorktreeHint(info: WorktreeInfo): string;
+export declare function formatUpstreamState(upstream: UpstreamState): string;
+export declare function formatLastCommit(timestampSeconds: number | null): string;
+export declare function formatRelativeAge(timestampSeconds: number): string;

package/dist/worktree-info.js

@@ -0,0 +1,105 @@
+import { readBranchLastCommitTimestamp, readWorktreeHealth } from './git.js';
+export async function readWorktreeInfos(worktrees) {
+    return Promise.all(worktrees.map((worktree) => readWorktreeInfo(worktree)));
+}
+async function readWorktreeInfo(worktree) {
+    const [healthResult, lastCommitResult] = await Promise.allSettled([
+        readWorktreeHealth(worktree.path),
+        worktree.branch === null ? null : readBranchLastCommitTimestamp(worktree.path, worktree.branch),
+    ]);
+    const health = healthResult.status === 'fulfilled' ? healthResult.value : null;
+    const lastCommitTimestamp = lastCommitResult.status === 'fulfilled'
+        ? lastCommitResult.value
+        : null;
+    return {
+        ...worktree,
+        lastCommitTimestamp,
+        status: health?.status ?? 'unknown',
+        upstream: buildUpstreamState(worktree.branch, health),
+    };
+}
+function buildUpstreamState(branch, health) {
+    if (branch === null) {
+        return { kind: 'detached' };
+    }
+    if (health === null) {
+        return { kind: 'unknown' };
+    }
+    if (!health.hasUpstream) {
+        return { kind: 'no-upstream' };
+    }
+    if (health.upstreamGone) {
+        return { kind: 'stale' };
+    }
+    return {
+        ahead: health.ahead,
+        behind: health.behind,
+        kind: 'tracked',
+    };
+}
+export function serializeWorktreeInfo(info) {
+    return {
+        branch: info.branch,
+        lastCommitTimestamp: info.lastCommitTimestamp,
+        path: info.path,
+        status: info.status,
+        upstream: info.upstream,
+    };
+}
+export function formatWorktreeHint(info) {
+    const details = [
+        `status: ${info.status}`,
+        `upstream: ${formatUpstreamState(info.upstream)}`,
+    ];
+    if (info.lastCommitTimestamp !== null) {
+        details.push(`last: ${formatRelativeAge(info.lastCommitTimestamp)}`);
+    }
+    return `${info.path} (${details.join(', ')})`;
+}
+export function formatUpstreamState(upstream) {
+    if (upstream.kind === 'detached') {
+        return 'n/a';
+    }
+    if (upstream.kind === 'no-upstream') {
+        return 'no-upstream';
+    }
+    if (upstream.kind === 'stale') {
+        return 'gone';
+    }
+    if (upstream.kind === 'unknown') {
+        return 'unknown';
+    }
+    return formatAheadBehind(upstream.ahead, upstream.behind);
+}
+function formatAheadBehind(ahead, behind) {
+    if (ahead === 0 && behind === 0) {
+        return 'up to date';
+    }
+    if (ahead === 0) {
+        return `behind ${behind}`;
+    }
+    if (behind === 0) {
+        return `ahead ${ahead}`;
+    }
+    return `ahead ${ahead}, behind ${behind}`;
+}
+export function formatLastCommit(timestampSeconds) {
+    return timestampSeconds === null ? 'n/a' : formatRelativeAge(timestampSeconds);
+}
+export function formatRelativeAge(timestampSeconds) {
+    const ageSeconds = Math.max(0, Math.floor(Date.now() / 1000) - timestampSeconds);
+    const units = [
+        { label: 'y', seconds: 365 * 24 * 60 * 60 },
+        { label: 'mo', seconds: 30 * 24 * 60 * 60 },
+        { label: 'd', seconds: 24 * 60 * 60 },
+        { label: 'h', seconds: 60 * 60 },
+        { label: 'm', seconds: 60 },
+    ];
+    for (const unit of units) {
+        const value = Math.floor(ageSeconds / unit.seconds);
+        if (value > 0) {
+            return `${value}${unit.label} ago`;
+        }
+    }
+    return 'just now';
+}