@ohzw/worktree-command-tui 0.1.1 → 0.1.3

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/session-store.js

@@ -1,7 +1,11 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-function isPositiveInteger(value) {
-    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+const MAX_SESSION_BYTES = 16 * 1024;
+function isSafeProcessId(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 1;
+}
+function isValidPort(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 && value <= 65535;
 }
 function isSessionRecord(value) {
     if (typeof value !== 'object' || value === null) {
@@ -11,9 +15,9 @@ function isSessionRecord(value) {
     return (typeof record.namespace === 'string' &&
         typeof record.worktreePath === 'string' &&
         typeof record.branch === 'string' &&
-        isPositiveInteger(record.pid) &&
-        isPositiveInteger(record.pgid) &&
-        isPositiveInteger(record.port) &&
+        isSafeProcessId(record.pid) &&
+        isSafeProcessId(record.pgid) &&
+        isValidPort(record.port) &&
         typeof record.logPath === 'string' &&
         typeof record.startedAt === 'string');
 }
@@ -25,9 +29,20 @@ export function getSessionPaths(gitCommonDir, namespace) {
         sessionFile: path.join(baseDir, `${namespace}.json`),
     };
 }
+async function readSessionFile(sessionFile) {
+    if ((await stat(sessionFile)).size > MAX_SESSION_BYTES) {
+        await rm(sessionFile, { force: true });
+        return null;
+    }
+    return readFile(sessionFile, 'utf8');
+}
 export async function readSessionRecord(paths, { isSessionAlive }) {
     try {
-        const parsed = JSON.parse(await readFile(paths.sessionFile, 'utf8'));
+        const source = await readSessionFile(paths.sessionFile);
+        if (source === null) {
+            return null;
+        }
+        const parsed = JSON.parse(source);
         if (!isSessionRecord(parsed)) {
             await rm(paths.sessionFile, { force: true });
             return null;

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;

package/dist/core/tui-interaction.js

@@ -0,0 +1,59 @@
+export function getNextSelectedPath(rows, currentPath) {
+    if (rows.length === 0) {
+        return null;
+    }
+    if (currentPath && rows.some(row => row.path === currentPath)) {
+        return currentPath;
+    }
+    return rows[0].path;
+}
+export function getSelectedIndex(rows, selectedPath) {
+    if (selectedPath === null) {
+        return 0;
+    }
+    const foundIndex = rows.findIndex(row => row.path === selectedPath);
+    return foundIndex >= 0 ? foundIndex : 0;
+}
+export function clampSelectionIndex(nextIndex, rowCount) {
+    if (rowCount <= 0) {
+        return null;
+    }
+    return Math.min(Math.max(nextIndex, 0), rowCount - 1);
+}
+export function decideEnterInteraction(selected, activePath) {
+    if (selected === undefined) {
+        return { kind: 'ignore' };
+    }
+    if (selected.invalidReason) {
+        return {
+            kind: 'set-status',
+            status: { kind: 'error', message: selected.invalidReason },
+            suppressesBackgroundRefreshes: true,
+        };
+    }
+    if (selected.path === activePath) {
+        return {
+            kind: 'set-status',
+            status: { kind: 'idle', message: 'already active' },
+            suppressesBackgroundRefreshes: true,
+        };
+    }
+    return {
+        kind: 'start',
+        path: selected.path,
+        status: { kind: 'starting', message: `Starting ${selected.branch}...` },
+    };
+}
+export function decideSetupInteraction(selected, setupAvailable) {
+    if (selected === undefined || !setupAvailable) {
+        return { kind: 'ignore' };
+    }
+    return {
+        kind: 'setup',
+        path: selected.path,
+        status: { kind: 'setting-up', message: `Running setup for ${selected.branch}...` },
+    };
+}
+export function shouldApplyAsyncResult(state) {
+    return state.blocksInput || (state.generation === state.currentGeneration && !state.userActionInFlight);
+}

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

@@ -0,0 +1,76 @@
+import type { AppRow, RowTag } from './runtime.js';
+export type ProjectionSeverity = 'success' | 'error' | 'info';
+export type ProjectionTag = RowTag | string;
+export type WorktreeListRowState = 'active' | 'invalid' | 'external' | 'normal';
+export interface WorktreeListRowProjection {
+    state: WorktreeListRowState;
+    isSelected: boolean;
+    isMain: boolean;
+}
+export interface TagProjection {
+    tag: ProjectionTag;
+}
+export type ActionProjection = {
+    kind: 'blocked';
+    severity: 'error';
+} | {
+    kind: 'active';
+    severity: 'success';
+} | {
+    kind: 'startable';
+    severity: 'error' | 'info';
+};
+export type NoteProjection = {
+    kind: 'invalid';
+    severity: 'error';
+    invalidReason: string;
+} | {
+    kind: 'external';
+    severity: 'info';
+} | {
+    kind: 'ready';
+    severity: 'error' | 'info';
+};
+export type UpstreamProjection = {
+    kind: 'unavailable';
+} | {
+    kind: 'none';
+} | {
+    kind: 'found';
+    branch: string;
+    ahead: number;
+    behind: number;
+};
+export type WorkingTreePartKind = 'staged' | 'unstaged' | 'untracked' | 'conflicts';
+export type WorkingTreeProjection = {
+    kind: 'unavailable';
+} | {
+    kind: 'clean';
+} | {
+    kind: 'dirty';
+    parts: Array<{
+        kind: WorkingTreePartKind;
+        count: number;
+    }>;
+};
+export type PullRequestProjection = {
+    kind: 'none';
+} | {
+    kind: 'unavailable';
+} | {
+    kind: 'found';
+    number: number;
+    title: string;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    isDraft: boolean;
+    baseBranch: string;
+    isHistorical: boolean;
+};
+export declare function sanitizeInlineText(value: string): string;
+export declare function projectWorktreeListRow(row: AppRow, isSelected: boolean): WorktreeListRowProjection;
+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;
+export declare function projectUpstream(row: AppRow): UpstreamProjection;
+export declare function projectWorkingTree(row: AppRow): WorkingTreeProjection;
+export declare function projectPullRequest(row: AppRow): PullRequestProjection;