@ohzw/worktree-command-tui 0.1.0

package/dist/core/config.js

@@ -0,0 +1,152 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+export const CONFIG_FILE_NAME = '.worktree-command-tui.jsonc';
+export const LEGACY_CONFIG_FILE_NAME = '.worktree-command-tui.json';
+export const CONFIG_FILE_NAMES = [CONFIG_FILE_NAME, LEGACY_CONFIG_FILE_NAME];
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isSafeNamespace(value) {
+    return isNonEmptyString(value) && /^[A-Za-z0-9._-]+$/u.test(value);
+}
+function readStringList(value, fieldName) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) || value.some(item => !isNonEmptyString(item))) {
+        throw new Error(`${fieldName} must be a string array`);
+    }
+    return value;
+}
+function stripJsoncComments(source) {
+    let result = '';
+    let inString = false;
+    let escaping = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const current = source[index];
+        const next = source[index + 1];
+        if (inLineComment) {
+            if (current === '\n' || current === '\r') {
+                inLineComment = false;
+                result += current;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (current === '*' && next === '/') {
+                inBlockComment = false;
+                index += 1;
+                continue;
+            }
+            result += current === '\n' || current === '\r' ? current : ' ';
+            continue;
+        }
+        if (inString) {
+            result += current;
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (current === '\\') {
+                escaping = true;
+                continue;
+            }
+            if (current === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            result += current;
+            continue;
+        }
+        if (current === '/' && next === '/') {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (current === '/' && next === '*') {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        result += current;
+    }
+    return result;
+}
+function stripTrailingCommas(source) {
+    let result = '';
+    let inString = false;
+    let escaping = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const current = source[index];
+        if (inString) {
+            result += current;
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (current === '\\') {
+                escaping = true;
+                continue;
+            }
+            if (current === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            result += current;
+            continue;
+        }
+        if (current === ',') {
+            let lookahead = index + 1;
+            while (lookahead < source.length && /\s/u.test(source[lookahead] ?? '')) {
+                lookahead += 1;
+            }
+            if (source[lookahead] === '}' || source[lookahead] === ']') {
+                continue;
+            }
+        }
+        result += current;
+    }
+    return result;
+}
+export function parseJsonc(source) {
+    return JSON.parse(stripTrailingCommas(stripJsoncComments(source)));
+}
+async function readFirstConfig(repoRoot) {
+    let firstError;
+    for (const fileName of CONFIG_FILE_NAMES) {
+        try {
+            return await readFile(path.join(repoRoot, fileName), 'utf8');
+        }
+        catch (error) {
+            firstError ??= error;
+        }
+    }
+    throw firstError;
+}
+export async function loadToolConfig({ repoRoot }) {
+    const raw = parseJsonc(await readFirstConfig(repoRoot));
+    if (!Array.isArray(raw.command) || raw.command.length === 0 || raw.command.some(part => !isNonEmptyString(part))) {
+        throw new Error('command must be a non-empty string array');
+    }
+    if (!isSafeNamespace(raw.namespace)) {
+        throw new Error('namespace must match [A-Za-z0-9._-]+');
+    }
+    if (typeof raw.port !== 'number' || !Number.isInteger(raw.port) || raw.port < 1 || raw.port > 65535) {
+        throw new Error('port must be an integer between 1 and 65535');
+    }
+    return {
+        namespace: raw.namespace,
+        command: raw.command,
+        port: raw.port,
+        requiredFiles: readStringList(raw.requiredFiles, 'requiredFiles'),
+        orphanMatchers: readStringList(raw.orphanMatchers, 'orphanMatchers'),
+    };
+}

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

@@ -0,0 +1,11 @@
+export interface WorktreeRow {
+    path: string;
+    branch: string;
+    headSha: string;
+    isMain: boolean;
+    isExternal: boolean;
+}
+export declare function parseWorktreeListPorcelain(input: string, mainWorktreePath: string): WorktreeRow[];
+export declare function sortWorktrees(rows: WorktreeRow[], activePath: string | null): WorktreeRow[];
+export declare function readWorktrees(cwd: string, mainWorktreePath: string): Promise<WorktreeRow[]>;
+export declare function toShortPath(mainWorktreePath: string, worktreePath: string): string;

package/dist/core/git-worktrees.js

@@ -0,0 +1,60 @@
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+function isExternalWorktree(mainWorktreePath, worktreePath) {
+    const relativePath = path.relative(mainWorktreePath, worktreePath);
+    return relativePath !== '' && (relativePath === '..' || relativePath.startsWith(`..${path.sep}`));
+}
+export function parseWorktreeListPorcelain(input, mainWorktreePath) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed
+        .split(/\n\s*\n/)
+        .filter(Boolean)
+        .map(block => {
+        const lines = block.split('\n');
+        const pathLine = lines.find(line => line.startsWith('worktree '));
+        const headLine = lines.find(line => line.startsWith('HEAD '));
+        const branchLine = lines.find(line => line.startsWith('branch '));
+        const detached = lines.includes('detached');
+        const worktreePath = pathLine?.slice('worktree '.length) ?? '';
+        const fullRef = branchLine?.slice('branch '.length) ?? '';
+        return {
+            path: worktreePath,
+            branch: branchLine ? fullRef.replace('refs/heads/', '') : detached ? '(detached)' : '(unknown)',
+            headSha: headLine?.slice('HEAD '.length) ?? '',
+            isMain: worktreePath === mainWorktreePath,
+            isExternal: isExternalWorktree(mainWorktreePath, worktreePath),
+        };
+    });
+}
+export function sortWorktrees(rows, activePath) {
+    return [...rows].sort((left, right) => {
+        if (left.isMain !== right.isMain) {
+            return left.isMain ? -1 : 1;
+        }
+        const leftActive = activePath !== null && left.path === activePath;
+        const rightActive = activePath !== null && right.path === activePath;
+        if (leftActive !== rightActive) {
+            return leftActive ? -1 : 1;
+        }
+        const branchCompare = left.branch.localeCompare(right.branch);
+        return branchCompare !== 0 ? branchCompare : left.path.localeCompare(right.path);
+    });
+}
+export async function readWorktrees(cwd, mainWorktreePath) {
+    const { stdout } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], { cwd });
+    return parseWorktreeListPorcelain(stdout, mainWorktreePath);
+}
+export function toShortPath(mainWorktreePath, worktreePath) {
+    if (worktreePath === mainWorktreePath) {
+        return '.';
+    }
+    if (worktreePath.startsWith(`${mainWorktreePath}${path.sep}`)) {
+        return path.relative(mainWorktreePath, worktreePath);
+    }
+    return worktreePath;
+}

package/dist/core/init.d.ts

@@ -0,0 +1,22 @@
+import { type ToolConfig } from './config.js';
+export declare function buildDefaultConfig(repoRoot: string): Promise<ToolConfig>;
+export declare function renderConfigJsonc(config: ToolConfig): string;
+export interface InitResult {
+    path: string;
+    config: ToolConfig;
+}
+export interface InitOptions {
+    workspaceRoot: string;
+    force: boolean;
+}
+export declare function runInit(options: InitOptions): Promise<InitResult>;
+export interface CliInitOptions {
+    cwd: string;
+    force: boolean;
+}
+export declare function createConfigForRepo(options: CliInitOptions): Promise<InitResult>;
+export interface InitArgParseResult {
+    force: boolean;
+    help: boolean;
+}
+export declare function parseInitArgs(args: string[]): InitArgParseResult;

package/dist/core/init.js

@@ -0,0 +1,157 @@
+import { access, readFile, writeFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { CONFIG_FILE_NAME, CONFIG_FILE_NAMES } from './config.js';
+const execFileAsync = promisify(execFile);
+function isSafeNamespace(value) {
+    return /^[A-Za-z0-9._-]+$/u.test(value);
+}
+function toSafeNamespace(value) {
+    const replaced = value.replace(/[^A-Za-z0-9._-]+/gu, '-');
+    const trimmed = replaced.replace(/^-+/, '').replace(/-+$/, '');
+    return trimmed.length > 0 && isSafeNamespace(trimmed) ? trimmed : 'worktree-command-tui';
+}
+async function resolveRepositoryRoot(cwd) {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd });
+    return stdout.trim();
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readPackageJson(root) {
+    try {
+        const source = await readFile(path.join(root, 'package.json'), 'utf8');
+        return JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+}
+function getPackageManagerFromField(packageManagerValue) {
+    if (!packageManagerValue) {
+        return null;
+    }
+    if (packageManagerValue.startsWith('bun@')) {
+        return 'bun';
+    }
+    if (packageManagerValue.startsWith('pnpm@')) {
+        return 'pnpm';
+    }
+    if (packageManagerValue.startsWith('yarn@')) {
+        return 'yarn';
+    }
+    if (packageManagerValue.startsWith('npm@')) {
+        return 'npm';
+    }
+    return null;
+}
+async function detectPackageManager(root, packageJson) {
+    const declared = getPackageManagerFromField(packageJson?.packageManager);
+    if (declared) {
+        return declared;
+    }
+    if (await fileExists(path.join(root, 'bun.lockb')) || await fileExists(path.join(root, 'bun.lock'))) {
+        return 'bun';
+    }
+    if (await fileExists(path.join(root, 'pnpm-lock.yaml'))) {
+        return 'pnpm';
+    }
+    if (await fileExists(path.join(root, 'yarn.lock'))) {
+        return 'yarn';
+    }
+    return 'npm';
+}
+function selectDefaultScript(scripts) {
+    if (typeof scripts?.dev === 'string' && scripts.dev.length > 0) {
+        return 'dev';
+    }
+    if (typeof scripts?.start === 'string' && scripts.start.length > 0) {
+        return 'start';
+    }
+    if (typeof scripts?.serve === 'string' && scripts.serve.length > 0) {
+        return 'serve';
+    }
+    const fallback = Object.entries(scripts ?? {}).find(([, script]) => typeof script === 'string' && script.length > 0)?.[0];
+    return fallback ?? 'start';
+}
+export async function buildDefaultConfig(repoRoot) {
+    const packageJson = await readPackageJson(repoRoot);
+    const packageManager = await detectPackageManager(repoRoot, packageJson);
+    const command = [packageManager, 'run', selectDefaultScript(packageJson?.scripts)];
+    const namespaceSeed = packageJson?.name ?? path.basename(repoRoot);
+    return {
+        namespace: toSafeNamespace(namespaceSeed),
+        command,
+        port: 3000,
+        requiredFiles: ['package.json'],
+        orphanMatchers: [],
+    };
+}
+export function renderConfigJsonc(config) {
+    return `{
+  // Session namespace used for git-common-dir state files and logs.
+  // Keep this filesystem-safe: letters, numbers, dots, underscores, and hyphens only.
+  "namespace": ${JSON.stringify(config.namespace)},
+
+  // Command launched in the selected worktree.
+  // Use argv form so spaces and shell metacharacters are passed safely.
+  "command": ${JSON.stringify(config.command)},
+
+  // TCP port owned by the command, used when stopping stale/orphaned processes.
+  "port": ${JSON.stringify(config.port)},
+
+  // Files that must exist in a worktree before the command can be started there.
+  "requiredFiles": ${JSON.stringify(config.requiredFiles)},
+
+  // Extra process command-line substrings treated as orphans for cleanup.
+  // Example: ["node --watch", "vite --host 0.0.0.0"]
+  "orphanMatchers": ${JSON.stringify(config.orphanMatchers)},
+}
+`;
+}
+async function findExistingConfigPath(workspaceRoot) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+        const configPath = path.join(workspaceRoot, fileName);
+        if (await fileExists(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+export async function runInit(options) {
+    const configPath = path.join(options.workspaceRoot, CONFIG_FILE_NAME);
+    const existingConfigPath = await findExistingConfigPath(options.workspaceRoot);
+    if (!options.force && existingConfigPath) {
+        throw new Error(`Config file already exists: ${existingConfigPath}`);
+    }
+    const config = await buildDefaultConfig(options.workspaceRoot);
+    await writeFile(configPath, renderConfigJsonc(config), 'utf8');
+    return { path: configPath, config };
+}
+export async function createConfigForRepo(options) {
+    const workspaceRoot = await resolveRepositoryRoot(options.cwd);
+    return runInit({ workspaceRoot, force: options.force });
+}
+export function parseInitArgs(args) {
+    const result = { force: false, help: false };
+    for (const arg of args) {
+        if (arg === '--force') {
+            result.force = true;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            result.help = true;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return result;
+}

package/dist/core/posix-process.d.ts

@@ -0,0 +1,4 @@
+export declare function isProcessGroupAlive(pgid: number): Promise<boolean>;
+export declare function killProcessGroup(pgid: number, signal?: NodeJS.Signals): Promise<void>;
+export declare function killPortOwner(port: number): Promise<void>;
+export declare function killOrphans(matcher: string): Promise<void>;

package/dist/core/posix-process.js

@@ -0,0 +1,42 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export async function isProcessGroupAlive(pgid) {
+    try {
+        process.kill(-pgid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function killProcessGroup(pgid, signal = 'SIGTERM') {
+    try {
+        process.kill(-pgid, signal);
+    }
+    catch {
+        // Process group already gone.
+    }
+}
+export async function killPortOwner(port) {
+    try {
+        const { stdout } = await execFileAsync('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t']);
+        for (const pid of stdout
+            .split('\n')
+            .map(line => line.trim())
+            .filter(Boolean)) {
+            await execFileAsync('kill', [pid]);
+        }
+    }
+    catch {
+        // Port not owned or lsof found nothing.
+    }
+}
+export async function killOrphans(matcher) {
+    try {
+        await execFileAsync('pkill', ['-f', matcher]);
+    }
+    catch {
+        // No matching orphan process.
+    }
+}

package/dist/core/process-control.d.ts

@@ -0,0 +1,11 @@
+export interface CleanupDeps {
+    killProcessGroup: (pgid: number, signal?: NodeJS.Signals) => Promise<void>;
+    killPortOwner: (port: number) => Promise<void>;
+    killOrphans: (matcher: string) => Promise<void>;
+    isSessionAlive: (pgid: number) => Promise<boolean>;
+}
+export declare function stopSessionWithFallback(input: {
+    pgid: number;
+    port: number;
+    orphanMatchers: string[];
+}, deps: CleanupDeps): Promise<boolean>;

package/dist/core/process-control.js

@@ -0,0 +1,15 @@
+export async function stopSessionWithFallback(input, deps) {
+    await deps.killProcessGroup(input.pgid, 'SIGTERM');
+    if (!(await deps.isSessionAlive(input.pgid))) {
+        return true;
+    }
+    await deps.killPortOwner(input.port);
+    for (const matcher of input.orphanMatchers) {
+        await deps.killOrphans(matcher);
+    }
+    if (!(await deps.isSessionAlive(input.pgid))) {
+        return true;
+    }
+    await deps.killProcessGroup(input.pgid, 'SIGKILL');
+    return !(await deps.isSessionAlive(input.pgid));
+}

package/dist/core/runtime.d.ts

@@ -0,0 +1,65 @@
+import { type WorktreeRow } from './git-worktrees.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;
+    branch: string;
+    headSha?: string;
+    tags: RowTag[];
+    upstream?: UpstreamInfo;
+    upstreamUnavailable?: boolean;
+    workingTree?: WorkingTreeInfo;
+    pullRequest?: PullRequestInfo;
+    invalidReason?: string;
+}
+export interface AppStatus {
+    kind: 'idle' | 'starting' | 'running' | 'stopping' | 'error';
+    message: string;
+}
+export interface AppModel {
+    repoName: string;
+    namespace: string;
+    rows: AppRow[];
+    activePath: string | null;
+    activeBranch: string | null;
+    status: AppStatus;
+}
+export interface AppActions {
+    start: (worktreePath: string) => Promise<AppModel>;
+    stop: () => Promise<AppModel>;
+    refresh: () => Promise<AppModel>;
+}
+interface GitStatusSummary {
+    upstream?: UpstreamInfo;
+    upstreamUnavailable: boolean;
+    workingTree?: WorkingTreeInfo;
+}
+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 buildInitialModel(cwd: string): Promise<AppModel>;
+export declare function buildActions(cwd: string): Promise<AppActions>;
+export {};