@ohzw/worktree-command-tui 0.1.1 → 0.1.2

package/dist/core/runtime-state.js

@@ -0,0 +1,125 @@
+import path from 'node:path';
+function toLogFileBase(branch) {
+    return branch.replace(/[\\/]/g, '-');
+}
+export function createRuntimeStateActions({ config, paths, adapter }) {
+    const refreshLogs = async () => {
+        const active = await adapter.readActive();
+        return {
+            logs: await adapter.readLogs(active?.logPath ?? null),
+            activePath: active?.worktreePath ?? null,
+            activeBranch: active?.branch ?? null,
+        };
+    };
+    const refreshWithStatus = async (run, preserveRunningStatus) => {
+        const status = await run();
+        const model = await adapter.refresh();
+        if (preserveRunningStatus && model.activePath !== null && status.kind === 'idle') {
+            return {
+                ...model,
+                status: { kind: 'running', message: status.message },
+            };
+        }
+        return {
+            ...model,
+            status,
+        };
+    };
+    const stop = async () => {
+        const active = await adapter.readActive();
+        if (active) {
+            await adapter.stopSession(active);
+            await adapter.clearSession();
+        }
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            activePath: null,
+            activeBranch: null,
+            status: { kind: 'idle', message: active ? 'stopped' : 'already stopped' },
+        };
+    };
+    const setup = async (worktreePath) => {
+        const setupCommand = config.setupCommand;
+        if (setupCommand === undefined) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                status: { kind: 'idle', message: 'setup command is not configured' },
+            };
+        }
+        const branch = await adapter.readWorktreeBranch(worktreePath);
+        const logFileBase = `${toLogFileBase(branch)}.setup`;
+        const setupLogPath = path.join(paths.logsDir, `${logFileBase}.log`);
+        try {
+            await adapter.runSetup({
+                command: setupCommand,
+                cwd: worktreePath,
+                logsDir: paths.logsDir,
+                logFileBase,
+            });
+        }
+        catch (error) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                status: { kind: 'error', message: error instanceof Error ? error.message : String(error) },
+                logs: await adapter.readLogs(setupLogPath),
+            };
+        }
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            status: { kind: model.activePath === null ? 'idle' : 'running', message: `setup complete for ${branch}` },
+            logs: await adapter.readLogs(setupLogPath),
+        };
+    };
+    const start = async (worktreePath) => {
+        const current = await adapter.readActive();
+        if (current?.worktreePath === worktreePath) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                activePath: current.worktreePath,
+                activeBranch: current.branch,
+                status: { kind: 'idle', message: 'already active' },
+            };
+        }
+        const invalidReason = await adapter.getInvalidReason(worktreePath);
+        if (invalidReason) {
+            throw new Error(invalidReason);
+        }
+        if (current) {
+            await adapter.stopSession(current);
+            await adapter.clearSession();
+        }
+        const branch = await adapter.readWorktreeBranch(worktreePath);
+        const started = await adapter.startCommand({
+            command: config.command,
+            cwd: worktreePath,
+            logsDir: paths.logsDir,
+            logFileBase: toLogFileBase(branch),
+        });
+        await adapter.writeSession({
+            namespace: config.namespace,
+            worktreePath,
+            branch,
+            pid: started.pid,
+            pgid: started.pgid,
+            port: config.port,
+            logPath: started.logPath,
+            startedAt: adapter.nowIso(),
+        });
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            activePath: worktreePath,
+            activeBranch: branch,
+            status: { kind: 'running', message: `started ${branch}` },
+        };
+    };
+    const openEditor = async (worktreePath) => refreshWithStatus(() => adapter.openEditor(worktreePath), true);
+    const openPullRequest = async (worktreePath) => refreshWithStatus(() => adapter.openPullRequest(worktreePath), true);
+    const deleteWorktree = async (worktreePath) => refreshWithStatus(() => adapter.deleteWorktree(worktreePath), false);
+    return { setup, start, stop, refresh: adapter.refresh, refreshLogs, openEditor, openPullRequest, deleteWorktree };
+}

package/dist/core/runtime.d.ts

@@ -1,29 +1,8 @@
 import { type WorktreeRow } from './git-worktrees.js';
+import { type UpstreamInfo, type WorkingTreeInfo } 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';
-export interface UpstreamInfo {
-    branch: string;
-    ahead: number;
-    behind: number;
-}
-export interface WorkingTreeInfo {
-    staged: number;
-    unstaged: number;
-    untracked: number;
-    conflicts: number;
-}
-export type PullRequestInfo = {
-    kind: 'found';
-    number: number;
-    title: string;
-    url: string;
-    state: 'OPEN' | 'CLOSED' | 'MERGED';
-    isDraft: boolean;
-    baseBranch: string;
-} | {
-    kind: 'none';
-} | {
-    kind: 'unavailable';
-};
 export interface AppRow {
     path: string;
     shortPath: string;
@@ -34,17 +13,14 @@ export interface AppRow {
     upstreamUnavailable?: boolean;
     workingTree?: WorkingTreeInfo;
     pullRequest?: PullRequestInfo;
+    branchCreatedAtMs?: number;
     invalidReason?: string;
 }
 export interface AppStatus {
-    kind: 'idle' | 'starting' | 'running' | 'stopping' | 'error';
+    kind: 'idle' | 'setting-up' | 'starting' | 'running' | 'stopping' | 'error';
     message: string;
 }
-export interface AppLogEntry {
-    name: string;
-    path: string;
-    content: string;
-}
+export type AppLogEntry = LogEntry;
 export interface AppModel {
     repoName: string;
     namespace: string;
@@ -52,21 +28,25 @@ export interface AppModel {
     activePath: string | null;
     activeBranch: string | null;
     status: AppStatus;
+    setupAvailable: boolean;
+    editorAvailable: boolean;
+    logs: AppLogEntry[];
+}
+export interface AppLogRefresh {
     logs: AppLogEntry[];
+    activePath: string | null;
+    activeBranch: string | null;
 }
 export interface AppActions {
+    setup: (worktreePath: string) => Promise<AppModel>;
     start: (worktreePath: string) => Promise<AppModel>;
     stop: () => Promise<AppModel>;
     refresh: () => Promise<AppModel>;
-    refreshLogs: () => Promise<AppLogEntry[]>;
-}
-interface GitStatusSummary {
-    upstream?: UpstreamInfo;
-    upstreamUnavailable: boolean;
-    workingTree?: WorkingTreeInfo;
+    refreshLogs: () => Promise<AppLogRefresh>;
+    openEditor: (worktreePath: string) => Promise<AppModel>;
+    openPullRequest: (worktreePath: string) => Promise<AppModel>;
+    deleteWorktree: (worktreePath: string) => Promise<AppModel>;
 }
-export declare function parseGitStatusSummary(output: string): GitStatusSummary;
-export declare function toAppRow(mainWorktreePath: string, worktree: WorktreeRow, activePath: string | null, invalidReason: string | null, metadata: Pick<AppRow, 'upstream' | 'upstreamUnavailable' | 'workingTree' | 'pullRequest'>): AppRow;
+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 buildInitialModel(cwd: string): Promise<AppModel>;
 export declare function buildActions(cwd: string): Promise<AppActions>;
-export {};

package/dist/core/runtime.js

@@ -1,136 +1,36 @@
+import { execFile, spawn } from 'node:child_process';
 import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { readdir, readFile, stat } from 'node:fs/promises';
 import { promisify } from 'node:util';
-import { loadToolConfig } from './config.js';
+import { loadToolConfig } from './config-lifecycle.js';
 import { readWorktrees, sortWorktrees, toShortPath } from './git-worktrees.js';
+import { readGitStatusSummary, readBranchCreatedAtMs, resolveRepoContext } from './git-metadata.js';
+import { readPullRequestInfo } from './github-metadata.js';
+import { readLogs } from './log-reader.js';
 import { getInvalidReason } from './validation.js';
 import { getSessionPaths, readSessionRecord, writeSessionRecord, clearSessionRecord } from './session-store.js';
-import { startDetachedCommand } from './command-runner.js';
+import { runCommandToLog, startDetachedCommand } from './command-runner.js';
 import { stopSessionWithFallback } from './process-control.js';
 import { isProcessGroupAlive, killProcessGroup, killPortOwner, killOrphans } from './posix-process.js';
+import { createRuntimeStateActions } from './runtime-state.js';
 const execFileAsync = promisify(execFile);
 const SHORT_SHA_LENGTH = 8;
-const GH_TIMEOUT_MS = 2500;
-const MAX_LOG_BYTES = 16 * 1024;
-const MAX_LOG_LINES = 120;
 function shortenSha(headSha) {
     return headSha.slice(0, SHORT_SHA_LENGTH);
 }
-function createEmptyWorkingTree() {
-    return { staged: 0, unstaged: 0, untracked: 0, conflicts: 0 };
-}
-export function parseGitStatusSummary(output) {
-    const workingTree = createEmptyWorkingTree();
-    let upstreamBranch;
-    let ahead = 0;
-    let behind = 0;
-    for (const line of output.split('\n')) {
-        if (line.startsWith('# branch.upstream ')) {
-            upstreamBranch = line.slice('# branch.upstream '.length).trim();
-            continue;
-        }
-        if (line.startsWith('# branch.ab ')) {
-            const match = /# branch\.ab \+(\d+) -(\d+)/.exec(line);
-            ahead = Number(match?.[1] ?? 0);
-            behind = Number(match?.[2] ?? 0);
-            continue;
-        }
-        if (line.startsWith('1 ') || line.startsWith('2 ')) {
-            const [, xy = '..'] = line.split(' ', 3);
-            if (xy[0] !== '.') {
-                workingTree.staged += 1;
-            }
-            if (xy[1] !== '.') {
-                workingTree.unstaged += 1;
-            }
-            continue;
-        }
-        if (line.startsWith('u ')) {
-            workingTree.conflicts += 1;
-            continue;
-        }
-        if (line.startsWith('? ')) {
-            workingTree.untracked += 1;
-        }
-    }
-    return {
-        upstream: upstreamBranch ? { branch: upstreamBranch, ahead, behind } : undefined,
-        upstreamUnavailable: false,
-        workingTree,
-    };
-}
-async function readGitStatusSummary(cwd) {
-    try {
-        const { stdout } = await execFileAsync('git', ['status', '--branch', '--porcelain=v2'], { cwd });
-        return parseGitStatusSummary(stdout);
-    }
-    catch {
-        return { upstreamUnavailable: true };
-    }
-}
-async function readPullRequestList(cwd, branch, state) {
-    const { stdout } = await execFileAsync('gh', [
-        'pr',
-        'list',
-        '--head',
-        branch,
-        '--state',
-        state,
-        '--limit',
-        '1',
-        '--json',
-        'number,title,url,state,isDraft,baseRefName',
-    ], { cwd, timeout: GH_TIMEOUT_MS });
-    return JSON.parse(stdout);
-}
-async function readPullRequestInfo(cwd, branch) {
-    if (branch.startsWith('(')) {
-        return { kind: 'none' };
-    }
-    try {
-        const openPullRequests = await readPullRequestList(cwd, branch, 'open');
-        const parsed = openPullRequests.length > 0 ? openPullRequests : await readPullRequestList(cwd, branch, 'all');
-        const pr = parsed[0];
-        if (!pr) {
-            return { kind: 'none' };
-        }
-        return {
-            kind: 'found',
-            number: pr.number,
-            title: pr.title,
-            url: pr.url,
-            state: pr.state,
-            isDraft: pr.isDraft,
-            baseBranch: pr.baseRefName,
-        };
-    }
-    catch {
-        return { kind: 'unavailable' };
-    }
-}
 async function readRowMetadata(worktreePath, branch) {
-    const [statusSummary, pullRequest] = await Promise.all([
+    const [statusSummary, pullRequest, branchCreatedAtMs] = await Promise.all([
         readGitStatusSummary(worktreePath),
         readPullRequestInfo(worktreePath, branch),
+        readBranchCreatedAtMs(worktreePath, branch),
     ]);
     return {
         upstream: statusSummary.upstream,
         upstreamUnavailable: statusSummary.upstreamUnavailable,
         workingTree: statusSummary.workingTree,
         pullRequest,
+        branchCreatedAtMs: branchCreatedAtMs ?? undefined,
     };
 }
-async function resolveRepoContext(cwd) {
-    const [{ stdout: workspaceRootRaw }, { stdout: gitCommonDirRaw }] = await Promise.all([
-        execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd }),
-        execFileAsync('git', ['rev-parse', '--git-common-dir'], { cwd }),
-    ]);
-    const workspaceRoot = workspaceRootRaw.trim();
-    const gitCommonDir = path.resolve(workspaceRoot, gitCommonDirRaw.trim());
-    const mainWorktreePath = path.dirname(gitCommonDir);
-    return { workspaceRoot, mainWorktreePath, gitCommonDir };
-}
 export function toAppRow(mainWorktreePath, worktree, activePath, invalidReason, metadata) {
     const tags = [];
     if (worktree.isMain) {
@@ -155,6 +55,7 @@ export function toAppRow(mainWorktreePath, worktree, activePath, invalidReason,
         upstreamUnavailable: metadata.upstreamUnavailable,
         workingTree: metadata.workingTree,
         pullRequest: metadata.pullRequest,
+        branchCreatedAtMs: metadata.branchCreatedAtMs,
         invalidReason: invalidReason ?? undefined,
     };
 }
@@ -180,45 +81,42 @@ async function stopRecordedSession(pgid, port, orphanMatchers) {
         throw new Error(`Failed to stop existing session pgid=${pgid}`);
     }
 }
-function tailLogContent(content) {
-    const byteTrimmed = content.length > MAX_LOG_BYTES ? content.slice(-MAX_LOG_BYTES) : content;
-    const lines = byteTrimmed.replace(/\r\n/g, '\n').split('\n');
-    const tailLines = lines.length > MAX_LOG_LINES ? lines.slice(-MAX_LOG_LINES) : lines;
-    return tailLines.join('\n').trimEnd();
-}
-async function readLogs(logsDir, activeLogPath) {
-    try {
-        const entries = (await readdir(logsDir, { withFileTypes: true }))
-            .filter(entry => entry.isFile() && entry.name.endsWith('.log'))
-            .map(entry => ({ name: entry.name, path: path.join(logsDir, entry.name) }));
-        if (entries.length === 0) {
-            return [];
-        }
-        let selectedEntries = entries;
-        if (activeLogPath !== null) {
-            const activeEntry = entries.find(entry => entry.path === activeLogPath);
-            if (activeEntry) {
-                selectedEntries = [activeEntry];
-            }
-        }
-        else {
-            const withStats = await Promise.all(entries.map(async (entry) => ({
-                ...entry,
-                mtimeMs: (await stat(entry.path)).mtimeMs,
-            })));
-            withStats.sort((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name));
-            selectedEntries = [withStats[0]];
+async function launchDetachedCommand(command, cwd) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    let settled = false;
+    const child = spawn(command[0], command.slice(1), { cwd, detached: true, stdio: 'ignore' });
+    const finalize = (callback) => {
+        if (settled) {
+            return;
         }
-        return await Promise.all(selectedEntries.map(async (entry) => ({
-            name: entry.name,
-            path: entry.path,
-            content: tailLogContent(await readFile(entry.path, 'utf8')),
-        })));
-    }
-    catch {
-        return [];
+        settled = true;
+        callback();
+    };
+    child.once('error', error => {
+        finalize(() => reject(error));
+    });
+    child.once('spawn', () => {
+        finalize(() => {
+            child.unref();
+            resolve();
+        });
+    });
+    await promise;
+}
+function getBrowserOpenCommand(url) {
+    switch (process.platform) {
+        case 'darwin':
+            return ['open', url];
+        case 'win32':
+            return ['cmd', '/c', 'start', '', url];
+        default:
+            return ['xdg-open', url];
     }
 }
+async function readSelectedWorktree(workspaceRoot, mainWorktreePath, worktreePath) {
+    const rows = await readWorktrees(workspaceRoot, mainWorktreePath);
+    return rows.find(row => row.path === worktreePath) ?? null;
+}
 export async function buildInitialModel(cwd) {
     const { workspaceRoot, mainWorktreePath, gitCommonDir } = await resolveRepoContext(cwd);
     const config = await loadToolConfig({ repoRoot: workspaceRoot });
@@ -231,80 +129,78 @@ export async function buildInitialModel(cwd) {
         activePath: active?.worktreePath ?? null,
         activeBranch: active?.branch ?? null,
         status: active ? { kind: 'running', message: `Active: ${active.branch}` } : { kind: 'idle', message: 'ready' },
+        setupAvailable: config.setupCommand !== undefined,
+        editorAvailable: config.editorCommand !== undefined,
         logs: await readLogs(paths.logsDir, active?.logPath ?? null),
     };
 }
 export async function buildActions(cwd) {
-    const { workspaceRoot, gitCommonDir } = await resolveRepoContext(cwd);
+    const { workspaceRoot, gitCommonDir, mainWorktreePath } = await resolveRepoContext(cwd);
     const config = await loadToolConfig({ repoRoot: workspaceRoot });
     const paths = getSessionPaths(gitCommonDir, config.namespace);
-    const mainWorktreePath = path.dirname(gitCommonDir);
-    const refresh = async () => buildInitialModel(cwd);
-    const refreshLogs = async () => {
-        const active = await readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive });
-        return readLogs(paths.logsDir, active?.logPath ?? null);
-    };
-    const stop = async () => {
-        const active = await readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive });
-        if (active) {
-            await stopRecordedSession(active.pgid, active.port, config.orphanMatchers);
-            await clearSessionRecord(paths);
-        }
-        const model = await refresh();
-        return {
-            ...model,
-            activePath: null,
-            activeBranch: null,
-            status: { kind: 'idle', message: active ? 'stopped' : 'already stopped' },
-        };
-    };
-    const start = async (worktreePath) => {
-        const current = await readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive });
-        if (current?.worktreePath === worktreePath) {
-            const model = await refresh();
-            return {
-                ...model,
-                activePath: current.worktreePath,
-                activeBranch: current.branch,
-                status: { kind: 'idle', message: 'already active' },
-            };
-        }
-        const invalidReason = await getInvalidReason(worktreePath, config.requiredFiles);
-        if (invalidReason) {
-            throw new Error(invalidReason);
-        }
-        if (current) {
-            await stopRecordedSession(current.pgid, current.port, config.orphanMatchers);
-            await clearSessionRecord(paths);
-        }
-        const rows = await readWorktrees(workspaceRoot, mainWorktreePath);
-        const selected = rows.find(row => row.path === worktreePath);
-        if (!selected) {
-            throw new Error(`Worktree disappeared: ${worktreePath}`);
-        }
-        const started = await startDetachedCommand({
-            command: config.command,
-            cwd: worktreePath,
-            logsDir: paths.logsDir,
-            logFileBase: selected.branch.replace(/[\\/]/g, '-'),
-        });
-        await writeSessionRecord(paths, {
-            namespace: config.namespace,
-            worktreePath,
-            branch: selected.branch,
-            pid: started.pid,
-            pgid: started.pgid,
-            port: config.port,
-            logPath: started.logPath,
-            startedAt: new Date().toISOString(),
-        });
-        const model = await refresh();
-        return {
-            ...model,
-            activePath: worktreePath,
-            activeBranch: selected.branch,
-            status: { kind: 'running', message: `started ${selected.branch}` },
-        };
-    };
-    return { start, stop, refresh, refreshLogs };
+    return createRuntimeStateActions({
+        config,
+        paths,
+        adapter: {
+            refresh: async () => buildInitialModel(cwd),
+            readActive: async () => readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive }),
+            readLogs: async (logPath) => readLogs(paths.logsDir, logPath),
+            readWorktreeBranch: async (worktreePath) => {
+                const selected = await readSelectedWorktree(workspaceRoot, mainWorktreePath, worktreePath);
+                if (!selected) {
+                    throw new Error(`Worktree disappeared: ${worktreePath}`);
+                }
+                return selected.branch;
+            },
+            getInvalidReason: async (worktreePath) => getInvalidReason(worktreePath, config.requiredFiles),
+            runSetup: runCommandToLog,
+            startCommand: startDetachedCommand,
+            stopSession: async (active) => stopRecordedSession(active.pgid, active.port, config.orphanMatchers),
+            clearSession: async () => clearSessionRecord(paths),
+            writeSession: async (record) => writeSessionRecord(paths, record),
+            openEditor: async (worktreePath) => {
+                const selected = await readSelectedWorktree(workspaceRoot, mainWorktreePath, worktreePath);
+                if (!selected) {
+                    return { kind: 'idle', message: 'worktree no longer exists' };
+                }
+                if (config.editorCommand === undefined) {
+                    return { kind: 'idle', message: 'editor command is not configured' };
+                }
+                await launchDetachedCommand([...config.editorCommand, worktreePath], worktreePath);
+                return { kind: 'idle', message: `opened editor for ${selected.branch}` };
+            },
+            openPullRequest: async (worktreePath) => {
+                const selected = await readSelectedWorktree(workspaceRoot, mainWorktreePath, worktreePath);
+                if (!selected) {
+                    return { kind: 'idle', message: 'worktree no longer exists' };
+                }
+                const pullRequest = await readPullRequestInfo(worktreePath, selected.branch);
+                if (pullRequest.kind === 'none') {
+                    return { kind: 'idle', message: `no pull request found for ${selected.branch}` };
+                }
+                if (pullRequest.kind === 'unavailable') {
+                    return { kind: 'error', message: `pull request metadata is unavailable for ${selected.branch}` };
+                }
+                await launchDetachedCommand(getBrowserOpenCommand(pullRequest.url), worktreePath);
+                return { kind: 'idle', message: `opened pull request #${pullRequest.number} for ${selected.branch}` };
+            },
+            deleteWorktree: async (worktreePath) => {
+                const selected = await readSelectedWorktree(workspaceRoot, mainWorktreePath, worktreePath);
+                if (!selected) {
+                    return { kind: 'idle', message: 'worktree no longer exists' };
+                }
+                if (selected.isMain) {
+                    return { kind: 'idle', message: 'cannot delete the main worktree' };
+                }
+                const active = await readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive });
+                if (active?.worktreePath === worktreePath) {
+                    await stopRecordedSession(active.pgid, active.port, config.orphanMatchers);
+                    await clearSessionRecord(paths);
+                }
+                await execFileAsync('git', ['worktree', 'remove', worktreePath], { cwd: workspaceRoot });
+                return { kind: 'idle', message: `deleted ${selected.branch}` };
+            },
+            nowIso: () => new Date().toISOString(),
+        },
+    });
 }

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

@@ -0,0 +1,31 @@
+import type { AppRow, AppStatus } from './runtime.js';
+export type EnterInteractionDecision = {
+    kind: 'ignore';
+} | {
+    kind: 'set-status';
+    status: AppStatus;
+    suppressesBackgroundRefreshes: true;
+} | {
+    kind: 'start';
+    path: string;
+    status: AppStatus;
+};
+export type SetupInteractionDecision = {
+    kind: 'ignore';
+} | {
+    kind: 'setup';
+    path: string;
+    status: AppStatus;
+};
+export interface AsyncInteractionState {
+    generation: number;
+    currentGeneration: number;
+    userActionInFlight: boolean;
+    blocksInput: boolean;
+}
+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 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;