@ohzw/worktree-command-tui 0.1.5 → 0.1.6

package/dist/app.d.ts

@@ -1,4 +1,4 @@
-import type { AppActions, AppModel } from './core/runtime.js';
+import type { AppActions, AppLogRefresh, AppModel } from './core/runtime.js';
 export interface ShellDimensions {
     rootWidth: number;
     rootHeight: number;
@@ -14,9 +14,12 @@ export declare function getMouseWheelDelta(input: string): number;
 export declare function getShellDimensions(columns: number, rows: number): ShellDimensions;
 export declare function shouldUseCompactLayout(_columns: number, _rows: number, _worktreeCount?: number): boolean;
 export declare function shouldUseMinimalLayout(columns: number, rows: number): boolean;
+export declare const RESIZE_DEBOUNCE_MS = 100;
 export declare function shouldStackPanes(columns: number, rows: number, _worktreeCount?: number): boolean;
-export declare function App({ initialModel, actions, windowSizeOverride, }: {
+export declare function getModelAfterLogRefresh(current: AppModel, refresh: AppLogRefresh): AppModel;
+export declare function App({ initialModel, actions, windowSizeOverride, resizeDebounceMs, }: {
     initialModel: AppModel;
     actions: AppActions;
     windowSizeOverride?: AppWindowSize;
+    resizeDebounceMs?: number;
 }): import("react").JSX.Element;

package/dist/app.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Alert, Spinner } from '@inkjs/ui';
-import { useEffect, useMemo, useRef, useState } from 'react';
-import { Box, Text, useApp, useInput, useStdin, useStdout, useWindowSize } from 'ink';
+import { memo, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text, useApp, useInput, useStdin, useStdout } from 'ink';
 import { ActionPanel } from './components/ActionPanel.js';
 import { ContextBar } from './components/ContextBar.js';
 import { Header } from './components/Header.js';
@@ -9,7 +9,7 @@ import { HelpWindow } from './components/HelpWindow.js';
 import { FloatingLogWindow } from './components/FloatingLogWindow.js';
 import { LogPanel, buildLogLines } from './components/LogPanel.js';
 import { WorktreeList } from './components/WorktreeList.js';
-import { clampSelectionIndex, decideEnterInteraction, decideSetupInteraction, getNextSelectedPath, getSelectedIndex } from './core/tui-interaction.js';
+import { clampSelectionIndex, decideEnterInteraction, decideSetupInteraction, getNextSelectedPath, getSelectedIndex, wrapSelectionIndex } from './core/tui-interaction.js';
 import { sanitizeInlineText } from './core/worktree-projection.js';
 const ENABLE_MOUSE_TRACKING = '\u001B[?1000h\u001B[?1006h';
 const DISABLE_MOUSE_TRACKING = '\u001B[?1000l\u001B[?1006l';
@@ -55,6 +55,7 @@ const HEADER_HEIGHT = 5;
 const CONTEXT_BAR_HEIGHT = 4;
 const PANE_GAP_WIDTH = 1;
 const MIN_STACKED_PANE_HEIGHT = 9;
+export const RESIZE_DEBOUNCE_MS = 100;
 export function shouldStackPanes(columns, rows, _worktreeCount = 0) {
     // Header + context bar consume the fixed chrome; each stacked pane still keeps ~6 visible content lines at the minimum height.
     return columns < 96 && rows >= STACKED_LAYOUT_FRAME_ROWS + (MIN_STACKED_PANE_HEIGHT * 2);
@@ -86,9 +87,11 @@ function rowMatchesFilter(row, normalizedQuery) {
         return true;
     }
     const pullRequest = row.pullRequest?.kind === 'found' ? row.pullRequest : null;
+    const headCommit = `${row.headSha ?? ''} ${row.headCommit?.message ?? ''}`.toLowerCase();
     return row.branch.toLowerCase().includes(normalizedQuery)
         || row.path.toLowerCase().includes(normalizedQuery)
         || row.shortPath.toLowerCase().includes(normalizedQuery)
+        || headCommit.includes(normalizedQuery)
         || (pullRequest !== null && (`${pullRequest.number} ${pullRequest.title}`).toLowerCase().includes(normalizedQuery));
 }
 function filterRows(rows, query) {
@@ -116,12 +119,99 @@ function getStatusAfterLogRefresh(current, refresh) {
     }
     return { kind: 'running', message: 'running' };
 }
-export function App({ initialModel, actions, windowSizeOverride, }) {
+function areLogsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((entry, index) => {
+        const other = right[index];
+        return other !== undefined
+            && entry.name === other.name
+            && entry.path === other.path
+            && entry.content === other.content;
+    });
+}
+export function getModelAfterLogRefresh(current, refresh) {
+    const activeChanged = current.activePath !== refresh.activePath || current.activeBranch !== refresh.activeBranch;
+    const status = getStatusAfterLogRefresh(current, refresh);
+    const logsChanged = !areLogsEqual(current.logs, refresh.logs);
+    const statusChanged = current.status.kind !== status.kind || current.status.message !== status.message;
+    const rows = activeChanged ? syncActiveTags(current.rows, refresh.activePath) : current.rows;
+    if (!activeChanged && !logsChanged && !statusChanged) {
+        return current;
+    }
+    return {
+        ...current,
+        logs: refresh.logs,
+        activePath: refresh.activePath,
+        activeBranch: refresh.activeBranch,
+        status,
+        rows,
+    };
+}
+function readWindowSize(stdout) {
+    return {
+        columns: stdout.columns || process.stdout.columns || 80,
+        rows: stdout.rows || process.stdout.rows || 24,
+    };
+}
+function useDebouncedWindowSize(windowSizeOverride, debounceMs) {
+    const { stdout } = useStdout();
+    const resizeTimerRef = useRef(undefined);
+    const [stableWindowSize, setStableWindowSize] = useState(() => windowSizeOverride ?? readWindowSize(stdout));
+    useEffect(() => {
+        return () => {
+            clearTimeout(resizeTimerRef.current);
+        };
+    }, []);
+    useEffect(() => {
+        if (windowSizeOverride === undefined) {
+            return;
+        }
+        clearTimeout(resizeTimerRef.current);
+        if (stableWindowSize.columns === windowSizeOverride.columns && stableWindowSize.rows === windowSizeOverride.rows) {
+            return;
+        }
+        resizeTimerRef.current = setTimeout(() => {
+            resizeTimerRef.current = undefined;
+            setStableWindowSize({ columns: windowSizeOverride.columns, rows: windowSizeOverride.rows });
+        }, debounceMs);
+    }, [windowSizeOverride?.columns, windowSizeOverride?.rows, debounceMs, stableWindowSize.columns, stableWindowSize.rows]);
+    useEffect(() => {
+        if (windowSizeOverride !== undefined) {
+            return;
+        }
+        const scheduleResize = () => {
+            const nextWindowSize = readWindowSize(stdout);
+            clearTimeout(resizeTimerRef.current);
+            if (stableWindowSize.columns === nextWindowSize.columns && stableWindowSize.rows === nextWindowSize.rows) {
+                return;
+            }
+            resizeTimerRef.current = setTimeout(() => {
+                resizeTimerRef.current = undefined;
+                setStableWindowSize(nextWindowSize);
+            }, debounceMs);
+        };
+        scheduleResize();
+        stdout.on('resize', scheduleResize);
+        return () => {
+            stdout.off('resize', scheduleResize);
+        };
+    }, [stdout, windowSizeOverride, debounceMs, stableWindowSize.columns, stableWindowSize.rows]);
+    return stableWindowSize;
+}
+export function App({ initialModel, actions, windowSizeOverride, resizeDebounceMs, }) {
+    const stableWindowSize = useDebouncedWindowSize(windowSizeOverride, resizeDebounceMs ?? RESIZE_DEBOUNCE_MS);
+    return _jsx(MemoizedAppShell, { initialModel: initialModel, actions: actions, windowSize: stableWindowSize });
+}
+function AppShell(props) {
+    return _jsx(AppShellContent, { ...props });
+}
+function AppShellContent({ initialModel, actions, windowSize, }) {
     const { exit } = useApp();
     const { stdin } = useStdin();
     const { stdout } = useStdout();
-    const liveWindowSize = useWindowSize();
-    const { columns, rows } = windowSizeOverride ?? liveWindowSize;
+    const { columns, rows } = windowSize;
     const [model, setModel] = useState(initialModel);
     const [filterQuery, setFilterQuery] = useState('');
     const [isFilterInputOpen, setIsFilterInputOpen] = useState(false);
@@ -189,18 +279,7 @@ export function App({ initialModel, actions, windowSizeOverride, }) {
                 if (generation !== actionGenerationRef.current || userActionInFlightRef.current) {
                     return;
                 }
-                setModel(current => {
-                    const activeChanged = current.activePath !== refresh.activePath || current.activeBranch !== refresh.activeBranch;
-                    const status = getStatusAfterLogRefresh(current, refresh);
-                    return {
-                        ...current,
-                        logs: refresh.logs,
-                        activePath: refresh.activePath,
-                        activeBranch: refresh.activeBranch,
-                        status,
-                        rows: activeChanged ? syncActiveTags(current.rows, refresh.activePath) : current.rows,
-                    };
-                });
+                setModel(current => getModelAfterLogRefresh(current, refresh));
             })
                 .catch(() => { })
                 .finally(() => {
@@ -236,12 +315,14 @@ export function App({ initialModel, actions, windowSizeOverride, }) {
         : showLogPanel ? Math.max(1, logPaneHeight - 3) : 0;
     const maxLogScrollOffset = Math.max(0, logLineCount - logViewportHeight);
     const logScrollPageSize = Math.max(1, Math.floor((logViewportHeight || rootHeight) / 2));
-    function moveSelection(nextIndex) {
-        const clampedIndex = clampSelectionIndex(nextIndex, visibleRows.length);
-        if (clampedIndex === null) {
+    function moveSelection(nextIndex, mode = 'clamp') {
+        const nextSelectionIndex = mode === 'wrap'
+            ? wrapSelectionIndex(nextIndex, visibleRows.length)
+            : clampSelectionIndex(nextIndex, visibleRows.length);
+        if (nextSelectionIndex === null) {
             return;
         }
-        setSelectedPath(visibleRows[clampedIndex].path);
+        setSelectedPath(visibleRows[nextSelectionIndex].path);
     }
     function clearFilter() {
         setFilterQuery('');
@@ -371,11 +452,11 @@ export function App({ initialModel, actions, windowSizeOverride, }) {
                 return;
             }
             if (key.upArrow) {
-                moveSelection(selectedIndex - 1);
+                moveSelection(selectedIndex - 1, 'wrap');
                 return;
             }
             if (key.downArrow) {
-                moveSelection(selectedIndex + 1);
+                moveSelection(selectedIndex + 1, 'wrap');
                 return;
             }
             if (key.pageDown) {
@@ -408,11 +489,11 @@ export function App({ initialModel, actions, windowSizeOverride, }) {
             return;
         }
         if (key.upArrow || input === 'k') {
-            moveSelection(selectedIndex - 1);
+            moveSelection(selectedIndex - 1, 'wrap');
             return;
         }
         if (key.downArrow || input === 'j') {
-            moveSelection(selectedIndex + 1);
+            moveSelection(selectedIndex + 1, 'wrap');
             return;
         }
         if (input === 'g') {
@@ -633,3 +714,4 @@ export function App({ initialModel, actions, windowSizeOverride, }) {
     }
     return (_jsxs(Box, { width: rootWidth, height: rootHeight, flexDirection: "column", children: [_jsx(Header, { repoName: model.repoName, namespace: model.namespace, activeBranch: model.activeBranch }), _jsxs(Box, { flexDirection: stackedLayout ? 'column' : 'row', flexGrow: stackedLayout ? 0 : 1, flexShrink: 1, children: [_jsx(WorktreeList, { rows: visibleRows, selectedIndex: selectedIndex, width: stackedLayout ? bodyWidth : listWidth, height: paneHeight, stacked: stackedLayout, scrollOffset: worktreeScrollOffset, filterQuery: filterQuery, isFilterInputOpen: isFilterInputOpen, totalRowCount: model.rows.length }), _jsx(ActionPanel, { selectedRow: selected, activePath: model.activePath, setupAvailable: model.setupAvailable, stacked: stackedLayout, width: stackedLayout ? bodyWidth : actionWidth, height: paneHeight, compactDetails: compactDetailPane, scrollOffset: selectionScrollOffset })] }), showLogPanel ? _jsx(LogPanel, { logs: model.logs, width: bodyWidth, height: logPaneHeight, scrollOffset: logScrollOffset }) : null, _jsx(ContextBar, { status: visibleStatus, setupAvailable: model.setupAvailable, editorAvailable: model.editorAvailable, confirmationOpen: confirmationOpen }), safeCompletedAlert ? (_jsx(Box, { position: "absolute", top: 1, right: 2, children: _jsx(Alert, { variant: "success", children: safeCompletedAlert }) })) : null] }));
 }
+const MemoizedAppShell = memo(AppShell);

package/dist/components/ActionPanel.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { getOrderedNonActiveTags, projectAction, projectNote, projectPullRequest, projectUpstream, projectWorkingTree, sanitizeInlineText, } from '../core/worktree-projection.js';
+import { getOrderedNonActiveTags, projectAction, projectHeadCommit, projectNote, projectPullRequest, projectUpstream, projectWorkingTree, sanitizeInlineText, } from '../core/worktree-projection.js';
 import { getScrollbarThumbRows, sliceListViewport } from '../terminal/viewport.js';
 export function getActionVariant(selectedRow, activePath) {
     return projectAction(selectedRow, activePath).severity;
@@ -72,6 +72,13 @@ function formatPullRequest(selectedRow) {
     const stateText = pullRequest.state.toLowerCase();
     return `#${pullRequest.number} ${draft}${stateText} → ${pullRequest.baseBranch}`;
 }
+function formatHeadCommit(selectedRow) {
+    const headCommit = projectHeadCommit(selectedRow);
+    if (headCommit.kind === 'unavailable') {
+        return '-';
+    }
+    return headCommit.label;
+}
 function getPullRequestColorFromProjection(pullRequest) {
     if (pullRequest.kind === 'unavailable') {
         return 'red';
@@ -150,7 +157,7 @@ function getPanelLines(selectedRow, activePath, setupAvailable, compactDetails)
     if (showFullPath) {
         lines.push({ text: `Full Path: ${sanitizeInlineText(selectedRow.path)}` });
     }
-    lines.push({ text: `HEAD: ${selectedRow.headSha || '-'}` });
+    lines.push({ text: `HEAD: ${formatHeadCommit(selectedRow)}` });
     lines.push({ text: `Branch Created: ${formatUtcDateTime(selectedRow.branchCreatedAtMs)}` });
     if (showTags) {
         for (const { tag } of getOrderedNonActiveTags(selectedRow.tags)) {

package/dist/core/debounced-resize.d.ts

@@ -0,0 +1,7 @@
+type ResizeListener = (...args: unknown[]) => void;
+interface ResizeEventSource {
+    on(event: string | symbol, listener: ResizeListener): ResizeEventSource;
+    off(event: string | symbol, listener: ResizeListener): ResizeEventSource;
+}
+export declare function debounceResizeListeners(source: ResizeEventSource, debounceMs: number): () => void;
+export {};

package/dist/core/debounced-resize.js

@@ -0,0 +1,39 @@
+export function debounceResizeListeners(source, debounceMs) {
+    const originalOn = source.on.bind(source);
+    const originalOff = source.off.bind(source);
+    const resizeListeners = new Set();
+    let resizeTimer;
+    let latestArgs = [];
+    const emitDebouncedResize = (...args) => {
+        latestArgs = args;
+        clearTimeout(resizeTimer);
+        resizeTimer = setTimeout(() => {
+            resizeTimer = undefined;
+            const listeners = [...resizeListeners];
+            for (const listener of listeners) {
+                listener(...latestArgs);
+            }
+        }, debounceMs);
+    };
+    originalOn('resize', emitDebouncedResize);
+    source.on = ((event, listener) => {
+        if (event === 'resize') {
+            resizeListeners.add(listener);
+            return source;
+        }
+        return originalOn(event, listener);
+    });
+    source.off = ((event, listener) => {
+        if (event === 'resize') {
+            resizeListeners.delete(listener);
+            return source;
+        }
+        return originalOff(event, listener);
+    });
+    return () => {
+        clearTimeout(resizeTimer);
+        originalOff('resize', emitDebouncedResize);
+        source.on = originalOn;
+        source.off = originalOff;
+    };
+}

package/dist/core/git-metadata.d.ts

@@ -14,6 +14,9 @@ export interface GitStatusSummary {
     upstreamUnavailable: boolean;
     workingTree?: WorkingTreeInfo;
 }
+export interface HeadCommitInfo {
+    message: string;
+}
 export interface RepoContext {
     workspaceRoot: string;
     mainWorktreePath: string;
@@ -22,4 +25,5 @@ export interface RepoContext {
 export declare function parseGitStatusSummary(output: string): GitStatusSummary;
 export declare function readGitStatusSummary(cwd: string): Promise<GitStatusSummary>;
 export declare function readBranchCreatedAtMs(cwd: string, branch: string): Promise<number | null>;
+export declare function readHeadCommitInfo(cwd: string): Promise<HeadCommitInfo | null>;
 export declare function resolveRepoContext(cwd: string): Promise<RepoContext>;

package/dist/core/git-metadata.js

@@ -72,6 +72,15 @@ export async function readBranchCreatedAtMs(cwd, branch) {
         return null;
     }
 }
+export async function readHeadCommitInfo(cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', ['log', '-1', '--format=%s'], { cwd });
+        return { message: stdout.trim() };
+    }
+    catch {
+        return null;
+    }
+}
 export async function resolveRepoContext(cwd) {
     const [{ stdout: workspaceRootRaw }, { stdout: gitCommonDirRaw }] = await Promise.all([
         execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd }),

package/dist/core/runtime.d.ts

@@ -1,5 +1,5 @@
 import { type WorktreeRow } from './git-worktrees.js';
-import { type UpstreamInfo, type WorkingTreeInfo } from './git-metadata.js';
+import { type UpstreamInfo, type WorkingTreeInfo, type HeadCommitInfo } from './git-metadata.js';
 import { type PullRequestInfo } from './github-metadata.js';
 import { type LogEntry } from './log-reader.js';
 export type RowTag = 'main' | 'active' | 'invalid' | 'external' | 'legacy';
@@ -8,6 +8,7 @@ export interface AppRow {
     shortPath: string;
     branch: string;
     headSha?: string;
+    headCommit?: HeadCommitInfo;
     tags: RowTag[];
     upstream?: UpstreamInfo;
     upstreamUnavailable?: boolean;
@@ -47,6 +48,6 @@ export interface AppActions {
     openPullRequest: (worktreePath: string) => Promise<AppModel>;
     deleteWorktree: (worktreePath: string) => Promise<AppModel>;
 }
-export declare function toAppRow(mainWorktreePath: string, worktree: WorktreeRow, activePath: string | null, invalidReason: string | null, metadata: Pick<AppRow, 'upstream' | 'upstreamUnavailable' | 'workingTree' | 'pullRequest' | 'branchCreatedAtMs'>): AppRow;
+export declare function toAppRow(mainWorktreePath: string, worktree: WorktreeRow, activePath: string | null, invalidReason: string | null, metadata: Pick<AppRow, 'upstream' | 'upstreamUnavailable' | 'workingTree' | 'pullRequest' | 'branchCreatedAtMs' | 'headCommit'>): AppRow;
 export declare function buildInitialModel(cwd: string): Promise<AppModel>;
 export declare function buildActions(cwd: string): Promise<AppActions>;

package/dist/core/runtime.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { loadToolConfig } from './config-lifecycle.js';
 import { readWorktrees, sortWorktrees, toShortPath } from './git-worktrees.js';
-import { readGitStatusSummary, readBranchCreatedAtMs, resolveRepoContext } from './git-metadata.js';
+import { readGitStatusSummary, readBranchCreatedAtMs, readHeadCommitInfo, resolveRepoContext } from './git-metadata.js';
 import { readPullRequestInfo } from './github-metadata.js';
 import { readLogs } from './log-reader.js';
 import { getInvalidReason } from './validation.js';
@@ -18,10 +18,11 @@ function shortenSha(headSha) {
     return headSha.slice(0, SHORT_SHA_LENGTH);
 }
 async function readRowMetadata(worktreePath, branch) {
-    const [statusSummary, pullRequest, branchCreatedAtMs] = await Promise.all([
+    const [statusSummary, pullRequest, branchCreatedAtMs, headCommit] = await Promise.all([
         readGitStatusSummary(worktreePath),
         readPullRequestInfo(worktreePath, branch),
         readBranchCreatedAtMs(worktreePath, branch),
+        readHeadCommitInfo(worktreePath),
     ]);
     return {
         upstream: statusSummary.upstream,
@@ -29,6 +30,7 @@ async function readRowMetadata(worktreePath, branch) {
         workingTree: statusSummary.workingTree,
         pullRequest,
         branchCreatedAtMs: branchCreatedAtMs ?? undefined,
+        headCommit: headCommit ?? undefined,
     };
 }
 export function toAppRow(mainWorktreePath, worktree, activePath, invalidReason, metadata) {
@@ -56,6 +58,7 @@ export function toAppRow(mainWorktreePath, worktree, activePath, invalidReason,
         workingTree: metadata.workingTree,
         pullRequest: metadata.pullRequest,
         branchCreatedAtMs: metadata.branchCreatedAtMs,
+        headCommit: metadata.headCommit,
         invalidReason: invalidReason ?? undefined,
     };
 }

package/dist/core/tui-interaction.d.ts

@@ -26,6 +26,7 @@ export interface AsyncInteractionState {
 export declare function getNextSelectedPath(rows: readonly AppRow[], currentPath: string | null): string | null;
 export declare function getSelectedIndex(rows: readonly AppRow[], selectedPath: string | null): number;
 export declare function clampSelectionIndex(nextIndex: number, rowCount: number): number | null;
+export declare function wrapSelectionIndex(nextIndex: number, rowCount: number): number | null;
 export declare function decideEnterInteraction(selected: AppRow | undefined, activePath: string | null): EnterInteractionDecision;
 export declare function decideSetupInteraction(selected: AppRow | undefined, setupAvailable: boolean): SetupInteractionDecision;
 export declare function shouldApplyAsyncResult(state: AsyncInteractionState): boolean;

package/dist/core/tui-interaction.js

@@ -20,6 +20,12 @@ export function clampSelectionIndex(nextIndex, rowCount) {
     }
     return Math.min(Math.max(nextIndex, 0), rowCount - 1);
 }
+export function wrapSelectionIndex(nextIndex, rowCount) {
+    if (rowCount <= 0) {
+        return null;
+    }
+    return ((nextIndex % rowCount) + rowCount) % rowCount;
+}
 export function decideEnterInteraction(selected, activePath) {
     if (selected === undefined) {
         return { kind: 'ignore' };

package/dist/core/worktree-projection.d.ts

@@ -41,6 +41,14 @@ export type UpstreamProjection = {
     ahead: number;
     behind: number;
 };
+export type HeadCommitProjection = {
+    kind: 'unavailable';
+} | {
+    kind: 'found';
+    hash?: string;
+    message?: string;
+    label: string;
+};
 export type WorkingTreePartKind = 'staged' | 'unstaged' | 'untracked' | 'conflicts';
 export type WorkingTreeProjection = {
     kind: 'unavailable';
@@ -68,6 +76,7 @@ export type PullRequestProjection = {
 };
 export declare function sanitizeInlineText(value: string): string;
 export declare function projectWorktreeListRow(row: AppRow, isSelected: boolean): WorktreeListRowProjection;
+export declare function projectHeadCommit(row: AppRow): HeadCommitProjection;
 export declare function getOrderedNonActiveTags(tags: readonly string[]): TagProjection[];
 export declare function projectAction(row: AppRow, activePath: string | null): ActionProjection;
 export declare function projectNote(row: AppRow): NoteProjection;

package/dist/core/worktree-projection.js

@@ -43,6 +43,19 @@ export function projectWorktreeListRow(row, isSelected) {
         isMain: hasTag(row, 'main'),
     };
 }
+export function projectHeadCommit(row) {
+    const hash = sanitizeInlineText(row.headSha ?? '');
+    const message = sanitizeInlineText(row.headCommit?.message ?? '');
+    if (hash.length === 0 && message.length === 0) {
+        return { kind: 'unavailable' };
+    }
+    return {
+        kind: 'found',
+        hash: hash.length === 0 ? undefined : hash,
+        message: message.length === 0 ? undefined : message,
+        label: [hash, message].filter(part => part.length > 0).join(' '),
+    };
+}
 export function getOrderedNonActiveTags(tags) {
     return tags
         .filter(tag => tag !== 'active')

package/dist/main.js

@@ -6,8 +6,9 @@ import { sanitizeInlineText } from './core/worktree-projection.js';
 import { ThemeProvider } from '@inkjs/ui';
 import { render } from 'ink';
 import { APP_RENDER_OPTIONS } from './render-options.js';
-import { App } from './app.js';
+import { App, RESIZE_DEBOUNCE_MS } from './app.js';
 import { buildActions, buildInitialModel } from './core/runtime.js';
+import { debounceResizeListeners } from './core/debounced-resize.js';
 import { appTheme } from './ui-theme.js';
 const cwd = process.cwd();
 const args = process.argv.slice(2);
@@ -66,31 +67,22 @@ if (subcommand !== undefined) {
     console.error(`Unknown command: ${sanitizeInlineText(subcommand)}`);
     process.exit(1);
 }
+let restoreStdoutResize = () => { };
 try {
     const [initialModel, actions] = await Promise.all([buildInitialModel(cwd), buildActions(cwd)]);
     const createApp = () => (_jsx(ThemeProvider, { theme: appTheme, children: _jsx(App, { initialModel: initialModel, actions: actions }) }));
+    if (process.stdout.isTTY) {
+        restoreStdoutResize = debounceResizeListeners(process.stdout, RESIZE_DEBOUNCE_MS);
+    }
     const instance = render(createApp(), APP_RENDER_OPTIONS);
-    let repaintTimer;
-    const repaintAfterResize = () => {
-        // Give Ink/useWindowSize one tick to observe the new size, then force a fresh root render.
-        if (repaintTimer) {
-            clearTimeout(repaintTimer);
-        }
-        repaintTimer = setTimeout(() => {
-            instance.rerender(createApp());
-        }, 25);
-    };
     if (process.stdout.isTTY) {
-        process.stdout.on('resize', repaintAfterResize);
         void instance.waitUntilExit().finally(() => {
-            if (repaintTimer) {
-                clearTimeout(repaintTimer);
-            }
-            process.stdout.off('resize', repaintAfterResize);
+            restoreStdoutResize();
         });
     }
 }
 catch (error) {
+    restoreStdoutResize();
     console.error(sanitizeInlineText(describeError(error)));
     process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohzw/worktree-command-tui",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A TUI for managing git worktrees",
   "private": false,
   "type": "module",