@ohzw/worktree-command-tui 0.1.0

package/dist/core/runtime.js

@@ -0,0 +1,263 @@
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { loadToolConfig } from './config.js';
+import { readWorktrees, sortWorktrees, toShortPath } from './git-worktrees.js';
+import { getInvalidReason } from './validation.js';
+import { getSessionPaths, readSessionRecord, writeSessionRecord, clearSessionRecord } from './session-store.js';
+import { startDetachedCommand } from './command-runner.js';
+import { stopSessionWithFallback } from './process-control.js';
+import { isProcessGroupAlive, killProcessGroup, killPortOwner, killOrphans } from './posix-process.js';
+const execFileAsync = promisify(execFile);
+const SHORT_SHA_LENGTH = 8;
+const GH_TIMEOUT_MS = 2500;
+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([
+        readGitStatusSummary(worktreePath),
+        readPullRequestInfo(worktreePath, branch),
+    ]);
+    return {
+        upstream: statusSummary.upstream,
+        upstreamUnavailable: statusSummary.upstreamUnavailable,
+        workingTree: statusSummary.workingTree,
+        pullRequest,
+    };
+}
+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) {
+        tags.push('main');
+    }
+    if (activePath === worktree.path) {
+        tags.push('active');
+    }
+    if (worktree.isExternal) {
+        tags.push('external');
+    }
+    if (invalidReason) {
+        tags.push('invalid');
+    }
+    return {
+        path: worktree.path,
+        shortPath: toShortPath(mainWorktreePath, worktree.path),
+        branch: worktree.branch,
+        headSha: shortenSha(worktree.headSha),
+        tags,
+        upstream: metadata.upstream,
+        upstreamUnavailable: metadata.upstreamUnavailable,
+        workingTree: metadata.workingTree,
+        pullRequest: metadata.pullRequest,
+        invalidReason: invalidReason ?? undefined,
+    };
+}
+async function buildRows(mainWorktreePath, workspaceRoot, activePath, requiredFiles) {
+    const worktrees = sortWorktrees(await readWorktrees(workspaceRoot, mainWorktreePath), activePath);
+    const rows = await Promise.all(worktrees.map(async (worktree) => {
+        const [invalidReason, metadata] = await Promise.all([
+            getInvalidReason(worktree.path, requiredFiles),
+            readRowMetadata(worktree.path, worktree.branch),
+        ]);
+        return toAppRow(mainWorktreePath, worktree, activePath, invalidReason, metadata);
+    }));
+    return rows;
+}
+async function stopRecordedSession(pgid, port, orphanMatchers) {
+    const stopped = await stopSessionWithFallback({ pgid, port, orphanMatchers }, {
+        killProcessGroup,
+        killPortOwner,
+        killOrphans,
+        isSessionAlive: isProcessGroupAlive,
+    });
+    if (!stopped) {
+        throw new Error(`Failed to stop existing session pgid=${pgid}`);
+    }
+}
+export async function buildInitialModel(cwd) {
+    const { workspaceRoot, mainWorktreePath, gitCommonDir } = await resolveRepoContext(cwd);
+    const config = await loadToolConfig({ repoRoot: workspaceRoot });
+    const paths = getSessionPaths(gitCommonDir, config.namespace);
+    const active = await readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive });
+    return {
+        repoName: path.basename(mainWorktreePath),
+        namespace: config.namespace,
+        rows: await buildRows(mainWorktreePath, workspaceRoot, active?.worktreePath ?? null, config.requiredFiles),
+        activePath: active?.worktreePath ?? null,
+        activeBranch: active?.branch ?? null,
+        status: active ? { kind: 'running', message: `Active: ${active.branch}` } : { kind: 'idle', message: 'ready' },
+    };
+}
+export async function buildActions(cwd) {
+    const { workspaceRoot, gitCommonDir } = 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 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 };
+}

package/dist/core/session-store.d.ts

@@ -0,0 +1,21 @@
+export interface SessionRecord {
+    namespace: string;
+    worktreePath: string;
+    branch: string;
+    pid: number;
+    pgid: number;
+    port: number;
+    logPath: string;
+    startedAt: string;
+}
+export interface SessionPaths {
+    baseDir: string;
+    logsDir: string;
+    sessionFile: string;
+}
+export declare function getSessionPaths(gitCommonDir: string, namespace: string): SessionPaths;
+export declare function readSessionRecord(paths: Pick<SessionPaths, 'sessionFile'>, { isSessionAlive }: {
+    isSessionAlive: (pgid: number) => Promise<boolean>;
+}): Promise<SessionRecord | null>;
+export declare function writeSessionRecord(paths: Pick<SessionPaths, 'baseDir' | 'sessionFile'>, record: SessionRecord): Promise<void>;
+export declare function clearSessionRecord(paths: Pick<SessionPaths, 'sessionFile'>): Promise<void>;

package/dist/core/session-store.js

@@ -0,0 +1,51 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+function isPositiveInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+function isSessionRecord(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const record = value;
+    return (typeof record.namespace === 'string' &&
+        typeof record.worktreePath === 'string' &&
+        typeof record.branch === 'string' &&
+        isPositiveInteger(record.pid) &&
+        isPositiveInteger(record.pgid) &&
+        isPositiveInteger(record.port) &&
+        typeof record.logPath === 'string' &&
+        typeof record.startedAt === 'string');
+}
+export function getSessionPaths(gitCommonDir, namespace) {
+    const baseDir = path.join(gitCommonDir, 'worktree-command-tui');
+    return {
+        baseDir,
+        logsDir: path.join(baseDir, 'logs'),
+        sessionFile: path.join(baseDir, `${namespace}.json`),
+    };
+}
+export async function readSessionRecord(paths, { isSessionAlive }) {
+    try {
+        const parsed = JSON.parse(await readFile(paths.sessionFile, 'utf8'));
+        if (!isSessionRecord(parsed)) {
+            await rm(paths.sessionFile, { force: true });
+            return null;
+        }
+        if (!(await isSessionAlive(parsed.pgid))) {
+            await rm(paths.sessionFile, { force: true });
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeSessionRecord(paths, record) {
+    await mkdir(paths.baseDir, { recursive: true });
+    await writeFile(paths.sessionFile, JSON.stringify(record, null, 2));
+}
+export async function clearSessionRecord(paths) {
+    await rm(paths.sessionFile, { force: true });
+}

package/dist/core/validation.d.ts

@@ -0,0 +1 @@
+export declare function getInvalidReason(worktreePath: string, requiredFiles: string[]): Promise<string | null>;

package/dist/core/validation.js

@@ -0,0 +1,14 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+export async function getInvalidReason(worktreePath, requiredFiles) {
+    const missing = new Set();
+    for (const relativePath of requiredFiles) {
+        try {
+            await access(path.join(worktreePath, relativePath));
+        }
+        catch {
+            missing.add(relativePath);
+        }
+    }
+    return missing.size === 0 ? null : `Missing required files: ${[...missing].join(', ')}`;
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createConfigForRepo, parseInitArgs } from './core/init.js';
+import { CONFIG_FILE_NAME, CONFIG_FILE_NAMES } from './core/config.js';
+import { render } from 'ink';
+import { App } from './app.js';
+import { buildActions, buildInitialModel } from './core/runtime.js';
+import { APP_RENDER_OPTIONS } from './render-options.js';
+const cwd = process.cwd();
+const args = process.argv.slice(2);
+const [, , subcommand] = process.argv;
+function printUsage() {
+    console.log('Usage:');
+    console.log('  wctui [args...]');
+    console.log('  wctui init [--force]');
+    console.log('  (alias: worktree-command-tui)');
+}
+function isConfigMissingError(error) {
+    const err = error;
+    return err.code === 'ENOENT' && typeof err.path === 'string' && CONFIG_FILE_NAMES.some(fileName => err.path?.endsWith(fileName));
+}
+function describeError(error) {
+    if (error instanceof Error) {
+        if (isConfigMissingError(error)) {
+            return `${error.message}
+Run "wctui init" to generate ${CONFIG_FILE_NAME} before starting the TUI.`;
+        }
+        return error.message;
+    }
+    return 'An unexpected error occurred';
+}
+async function handleInitCommand() {
+    let parsed;
+    try {
+        parsed = parseInitArgs(args.slice(1));
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+    if (parsed.help) {
+        printUsage();
+        return;
+    }
+    try {
+        const result = await createConfigForRepo({ cwd, force: parsed.force });
+        console.log(`Created ${result.path}`);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+if (subcommand === 'init') {
+    await handleInitCommand();
+    process.exit(0);
+}
+if (args.includes('-h') || args.includes('--help')) {
+    printUsage();
+    process.exit(0);
+}
+if (subcommand !== undefined) {
+    console.error(`Unknown command: ${subcommand}`);
+    process.exit(1);
+}
+try {
+    const [initialModel, actions] = await Promise.all([buildInitialModel(cwd), buildActions(cwd)]);
+    render(_jsx(App, { initialModel: initialModel, actions: actions }), APP_RENDER_OPTIONS);
+}
+catch (error) {
+    console.error(describeError(error));
+    process.exit(1);
+}

package/dist/render-options.d.ts

@@ -0,0 +1,4 @@
+export declare const APP_RENDER_OPTIONS: {
+    readonly alternateScreen: true;
+    readonly exitOnCtrlC: true;
+};

package/dist/render-options.js

@@ -0,0 +1,4 @@
+export const APP_RENDER_OPTIONS = {
+    alternateScreen: true,
+    exitOnCtrlC: true,
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@ohzw/worktree-command-tui",
+  "version": "0.1.0",
+  "description": "A TUI for managing git worktrees",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "author": "ohzw",
+  "homepage": "https://github.com/ohzw/worktree-command-tui#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohzw/worktree-command-tui.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ohzw/worktree-command-tui/issues"
+  },
+  "keywords": [
+    "cli",
+    "git",
+    "worktree",
+    "tui",
+    "terminal"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "init": "tsx src/main.tsx init",
+    "start": "tsx src/main.tsx",
+    "start:built": "node dist/main.js",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "bin": {
+    "wctui": "./dist/main.js",
+    "worktree-command-tui": "./dist/main.js"
+  },
+  "main": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/main.js",
+      "default": "./dist/main.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ink": "^7.0.4",
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.2.0",
+    "ink-testing-library": "^4.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}