@ohzw/worktree-command-tui 0.1.1 → 0.1.2

package/dist/components/LogPanel.js

@@ -1,54 +1,260 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-const ANSI_ESCAPE_PATTERN = /(?:\u001B|\u009B)\[[0-?]*[ -/]*[@-~]/gu;
-function sanitizeLogLine(value) {
+import { getScrollbarThumbRows, sliceTailViewport } from '../terminal/viewport.js';
+const ESCAPE = '\u001B';
+const CSI = '\u009B';
+const BEL = '\u0007';
+const STRING_TERMINATOR_PREFIX = '\u001B';
+const STRING_TERMINATOR_SUFFIX = '\\';
+const STRING_TERMINATOR = '\u009C';
+const DEVICE_CONTROL_STRING = '\u0090';
+const START_OF_STRING = '\u0098';
+const OPERATING_SYSTEM_COMMAND = '\u009D';
+const PRIVACY_MESSAGE = '\u009E';
+const APPLICATION_PROGRAM_COMMAND = '\u009F';
+const ANSI_FOREGROUND_COLORS = new Map([
+    [30, 'black'],
+    [31, 'red'],
+    [32, 'green'],
+    [33, 'yellow'],
+    [34, 'blue'],
+    [35, 'magenta'],
+    [36, 'cyan'],
+    [37, 'white'],
+    [90, 'gray'],
+    [91, 'red'],
+    [92, 'green'],
+    [93, 'yellow'],
+    [94, 'blue'],
+    [95, 'magenta'],
+    [96, 'cyan'],
+    [97, 'white'],
+]);
+function sanitizeTextChunk(value) {
     return value
-        .replace(ANSI_ESCAPE_PATTERN, '')
         .replace(/[\r\t\u2028\u2029]+/g, ' ')
         .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, '')
-        .replace(/\p{Cf}/gu, '')
-        .trimEnd();
+        .replace(/\p{Cf}/gu, '');
+}
+function sameStyle(a, b) {
+    return a.color === b.color && a.dimColor === b.dimColor && a.bold === b.bold;
+}
+function appendSegment(segments, text, style) {
+    if (text.length === 0) {
+        return;
+    }
+    const last = segments.at(-1);
+    if (last && sameStyle(last, style)) {
+        last.text += text;
+        return;
+    }
+    segments.push({ ...style, text });
+}
+function skipExtendedColor(codes, index) {
+    const mode = Number(codes[index + 1] ?? Number.NaN);
+    if (mode === 5) {
+        return index + 2;
+    }
+    if (mode === 2) {
+        return index + 4;
+    }
+    return index;
+}
+function applyAnsiSgr(style, parameters) {
+    const codes = parameters.length === 0 ? ['0'] : parameters.split(';');
+    for (let index = 0; index < codes.length; index += 1) {
+        const rawCode = codes[index] ?? '0';
+        if (rawCode.includes(':')) {
+            if (Number(rawCode.split(':', 1)[0]) === 38) {
+                delete style.color;
+            }
+            continue;
+        }
+        const code = Number(rawCode || 0);
+        if (code === 0) {
+            delete style.color;
+            delete style.dimColor;
+            delete style.bold;
+            continue;
+        }
+        if (code === 1) {
+            style.bold = true;
+            continue;
+        }
+        if (code === 2) {
+            style.dimColor = true;
+            continue;
+        }
+        if (code === 22) {
+            delete style.bold;
+            delete style.dimColor;
+            continue;
+        }
+        if (code === 38) {
+            delete style.color;
+            index = skipExtendedColor(codes, index);
+            continue;
+        }
+        if (code === 48 || code === 58) {
+            index = skipExtendedColor(codes, index);
+            continue;
+        }
+        if (code === 39) {
+            delete style.color;
+            continue;
+        }
+        const color = ANSI_FOREGROUND_COLORS.get(code);
+        if (color) {
+            style.color = color;
+        }
+    }
+}
+function trimLineEnd(segments) {
+    const result = [...segments];
+    while (result.length > 0) {
+        const last = result.at(-1);
+        const trimmed = last.text.trimEnd();
+        if (trimmed.length > 0) {
+            if (trimmed.length !== last.text.length) {
+                result[result.length - 1] = { ...last, text: trimmed };
+            }
+            break;
+        }
+        result.pop();
+    }
+    return result;
+}
+function pushLine(lines, segments) {
+    const trimmedSegments = trimLineEnd(segments);
+    lines.push({ segments: trimmedSegments.length > 0 ? trimmedSegments : [{ text: ' ' }] });
+}
+function isAnsiFinalByte(value) {
+    const code = value.charCodeAt(0);
+    return code >= 0x40 && code <= 0x7E;
+}
+function isAnsiIntermediateByte(value) {
+    const code = value.charCodeAt(0);
+    return code >= 0x20 && code <= 0x2F;
+}
+function consumeCsi(value, index, style) {
+    let cursor = index;
+    while (cursor < value.length && !isAnsiFinalByte(value[cursor])) {
+        cursor += 1;
+    }
+    if (cursor >= value.length) {
+        return value.length;
+    }
+    const finalByte = value[cursor];
+    const sequence = value.slice(index, cursor);
+    const hasIntermediate = Array.from(sequence).some(isAnsiIntermediateByte);
+    if (!hasIntermediate && finalByte === 'm') {
+        applyAnsiSgr(style, sequence);
+    }
+    return cursor + 1;
+}
+function consumeStringControl(value, index, allowBelTerminator) {
+    let cursor = index;
+    while (cursor < value.length) {
+        if ((allowBelTerminator && value[cursor] === BEL) || value[cursor] === STRING_TERMINATOR) {
+            return cursor + 1;
+        }
+        if (value[cursor] === STRING_TERMINATOR_PREFIX && value[cursor + 1] === STRING_TERMINATOR_SUFFIX) {
+            return cursor + 2;
+        }
+        cursor += 1;
+    }
+    return value.length;
+}
+function isStringControl(value) {
+    return value === DEVICE_CONTROL_STRING
+        || value === START_OF_STRING
+        || value === OPERATING_SYSTEM_COMMAND
+        || value === PRIVACY_MESSAGE
+        || value === APPLICATION_PROGRAM_COMMAND;
+}
+function consumeEscape(value, index, style) {
+    if (value[index] === CSI) {
+        return consumeCsi(value, index + 1, style);
+    }
+    if (isStringControl(value[index])) {
+        return consumeStringControl(value, index + 1, value[index] === OPERATING_SYSTEM_COMMAND);
+    }
+    const next = value[index + 1];
+    if (next === undefined) {
+        return index + 1;
+    }
+    if (next === '[') {
+        return consumeCsi(value, index + 2, style);
+    }
+    if (next === ']') {
+        return consumeStringControl(value, index + 2, true);
+    }
+    if (next === 'P' || next === '^' || next === '_' || next === 'X') {
+        return consumeStringControl(value, index + 2, false);
+    }
+    let cursor = index + 1;
+    while (cursor < value.length && isAnsiIntermediateByte(value[cursor])) {
+        cursor += 1;
+    }
+    return Math.min(cursor + 1, value.length);
+}
+function parseLogContent(value) {
+    const lines = [];
+    let segments = [];
+    const style = {};
+    let textStart = 0;
+    let index = 0;
+    while (index < value.length) {
+        const character = value[index];
+        if (character === '\n') {
+            appendSegment(segments, sanitizeTextChunk(value.slice(textStart, index)), style);
+            pushLine(lines, segments);
+            segments = [];
+            index += 1;
+            textStart = index;
+            continue;
+        }
+        if (character === ESCAPE || character === CSI || isStringControl(character)) {
+            appendSegment(segments, sanitizeTextChunk(value.slice(textStart, index)), style);
+            index = consumeEscape(value, index, style);
+            textStart = index;
+            continue;
+        }
+        index += 1;
+    }
+    appendSegment(segments, sanitizeTextChunk(value.slice(textStart)), style);
+    pushLine(lines, segments);
+    return lines;
+}
+function plainLine(text, style = {}) {
+    return { segments: [{ ...style, text }] };
+}
+function getLineText(line) {
+    return line.segments.map(segment => segment.text).join('');
 }
 export function buildLogLines(logs) {
     if (logs.length === 0) {
-        return [{ text: 'No *.log files yet.', dimColor: true }];
+        return [plainLine('No *.log files yet.', { dimColor: true })];
     }
     const lines = [];
     for (const [index, log] of logs.entries()) {
         if (index > 0) {
-            lines.push({ text: ' ', dimColor: true });
-        }
-        lines.push({ text: `[${log.name}]`, color: 'cyan' });
-        const contentLines = log.content.length > 0 ? log.content.split('\n') : ['(empty)'];
-        for (const line of contentLines) {
-            lines.push({ text: sanitizeLogLine(line) || ' ' });
+            lines.push(plainLine(' ', { dimColor: true }));
         }
+        lines.push(plainLine(`[${log.name}]`, { color: 'cyan' }));
+        lines.push(...parseLogContent(log.content.length > 0 ? log.content : '(empty)'));
     }
     return lines;
 }
-function getScrollbarThumbRows(totalLines, viewportHeight, scrollOffset) {
-    if (totalLines <= viewportHeight) {
-        return new Set();
-    }
-    const thumbSize = Math.max(1, Math.floor((viewportHeight / totalLines) * viewportHeight));
-    const maxScrollOffset = Math.max(1, totalLines - viewportHeight);
-    const thumbStart = Math.round((scrollOffset / maxScrollOffset) * (viewportHeight - thumbSize));
-    return new Set(Array.from({ length: thumbSize }, (_, index) => thumbStart + index));
-}
 export function LogPanel({ logs, width, height, scrollOffset = 0, title = 'Logs (*.log · tail 120)', }) {
     const lines = buildLogLines(logs);
-    const contentViewportHeight = height === undefined ? lines.length : Math.max(1, height - 3);
-    const maxScrollOffset = contentViewportHeight === undefined ? 0 : Math.max(0, lines.length - contentViewportHeight);
-    const effectiveScrollOffset = Math.min(Math.max(scrollOffset, 0), maxScrollOffset);
-    const startIndex = contentViewportHeight === undefined
-        ? 0
-        : Math.max(0, lines.length - contentViewportHeight - effectiveScrollOffset);
-    const visibleLines = contentViewportHeight === undefined
-        ? lines
-        : lines.slice(startIndex, startIndex + contentViewportHeight);
-    const showScrollbar = contentViewportHeight !== undefined && lines.length > contentViewportHeight;
+    const viewport = sliceTailViewport(lines, height === undefined ? lines.length : height - 3, scrollOffset);
+    const contentViewportHeight = viewport.viewportHeight;
+    const startIndex = viewport.startIndex;
+    const visibleLines = viewport.visibleItems;
+    const showScrollbar = height !== undefined && lines.length > contentViewportHeight;
     const scrollbarThumbRows = showScrollbar
-        ? getScrollbarThumbRows(lines.length, contentViewportHeight, maxScrollOffset - effectiveScrollOffset)
+        ? getScrollbarThumbRows(lines.length, contentViewportHeight, viewport.topScrollOffset)
         : new Set();
-    return (_jsxs(Box, { width: width, height: height, borderStyle: "round", borderColor: "yellow", flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsx(Text, { bold: true, color: "yellow", wrap: "truncate-end", children: title }), _jsx(Box, { height: contentViewportHeight, flexDirection: "column", overflow: "hidden", children: visibleLines.map((line, index) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsx(Text, { color: line.color, dimColor: line.dimColor, wrap: "truncate-end", children: line.text }) }), showScrollbar ? (_jsx(Text, { color: scrollbarThumbRows.has(index) ? 'yellow' : 'gray', dimColor: !scrollbarThumbRows.has(index), children: scrollbarThumbRows.has(index) ? '█' : '│' })) : null] }, `${startIndex + index}-${line.text}`))) })] }));
+    return (_jsxs(Box, { width: width, height: height, borderStyle: "round", borderColor: "yellow", flexDirection: "column", paddingX: 1, overflow: "hidden", children: [_jsx(Text, { bold: true, color: "yellow", wrap: "truncate-end", children: title }), _jsx(Box, { height: contentViewportHeight, flexDirection: "column", overflow: "hidden", children: visibleLines.map((line, index) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsx(Text, { wrap: "truncate-end", children: line.segments.map((segment, segmentIndex) => (_jsx(Text, { color: segment.color, dimColor: segment.dimColor, bold: segment.bold, children: segment.text }, `${segmentIndex}-${segment.text}`))) }) }), showScrollbar ? (_jsx(Text, { color: scrollbarThumbRows.has(index) ? 'yellow' : 'gray', dimColor: !scrollbarThumbRows.has(index), children: scrollbarThumbRows.has(index) ? '█' : '│' })) : null] }, `${startIndex + index}-${getLineText(line)}`))) })] }));
 }

package/dist/components/WorktreeList.js

@@ -1,45 +1,30 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { projectWorktreeListRow, sanitizeInlineText } from '../core/worktree-projection.js';
+import { getScrollbarThumbRows, sliceListViewport } from '../terminal/viewport.js';
 const MIN_BRANCH_WIDTH = 24;
-function sanitizeInlineText(value) {
-    return value
-        .replace(/[\r\n\t\u2028\u2029]+/g, ' ')
-        .replace(/[\u0000-\u001f\u007f-\u009f]/g, '')
-        .replace(/\p{Cf}/gu, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-function getIndicator(row) {
-    if (row.tags.includes('active')) {
+function getIndicator(state) {
+    if (state === 'active') {
         return '*';
     }
-    if (row.tags.includes('invalid')) {
+    if (state === 'invalid') {
         return '!';
     }
-    if (row.tags.includes('external')) {
+    if (state === 'external') {
         return '^';
     }
-    if (row.tags.includes('main')) {
-        return '#';
-    }
     return '-';
 }
-function getRowColor(row, isSelected) {
-    if (row.tags.includes('active')) {
+function getRowColor(projection) {
+    if (projection.state === 'active') {
         return 'green';
     }
-    if (isSelected) {
+    if (projection.isSelected) {
         return 'cyan';
     }
-    if (row.tags.includes('invalid')) {
+    if (projection.state === 'invalid') {
         return 'red';
     }
-    if (row.tags.includes('external')) {
-        return 'yellow';
-    }
-    if (row.tags.includes('main')) {
-        return 'blue';
-    }
     return undefined;
 }
 function truncateLabel(value, width) {
@@ -48,26 +33,21 @@ function truncateLabel(value, width) {
     }
     return `${value.slice(0, Math.max(width - 1, 0))}…`;
 }
-function getScrollbarThumbRows(totalLines, viewportHeight, scrollOffset) {
-    if (totalLines <= viewportHeight) {
-        return new Set();
-    }
-    const thumbSize = Math.max(1, Math.floor((viewportHeight / totalLines) * viewportHeight));
-    const maxScrollOffset = Math.max(1, totalLines - viewportHeight);
-    const thumbStart = Math.round((scrollOffset / maxScrollOffset) * (viewportHeight - thumbSize));
-    return new Set(Array.from({ length: thumbSize }, (_, index) => thumbStart + index));
-}
 export function WorktreeList({ rows, selectedIndex, width, height, stacked, scrollOffset = 0, }) {
     const branchWidth = Math.max(MIN_BRANCH_WIDTH, (width ?? 34) - 7);
-    const contentViewportHeight = height === undefined ? rows.length : Math.max(1, height - 3);
-    const maxScrollOffset = Math.max(0, rows.length - contentViewportHeight);
-    const effectiveScrollOffset = Math.min(Math.max(scrollOffset, 0), maxScrollOffset);
-    const visibleRows = rows.slice(effectiveScrollOffset, effectiveScrollOffset + contentViewportHeight);
+    const viewport = sliceListViewport(rows, height === undefined ? rows.length : height - 3, scrollOffset);
+    const contentViewportHeight = viewport.viewportHeight;
+    const effectiveScrollOffset = viewport.scrollOffset;
+    const visibleRows = viewport.visibleItems;
     const showScrollbar = height !== undefined && rows.length > contentViewportHeight;
     const scrollbarThumbRows = showScrollbar ? getScrollbarThumbRows(rows.length, contentViewportHeight, effectiveScrollOffset) : new Set();
     return (_jsxs(Box, { width: width, height: height, flexGrow: stacked ? 0 : 1, marginRight: stacked ? 0 : 1, borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1, overflowY: "hidden", children: [_jsx(Text, { bold: true, color: "cyan", children: "Worktrees" }), visibleRows.map((row, index) => {
                 const isSelected = index + effectiveScrollOffset === selectedIndex;
-                const line = `${isSelected ? '>' : ' '} ${getIndicator(row)} ${truncateLabel(sanitizeInlineText(row.branch), branchWidth)}`;
-                return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsx(Text, { color: getRowColor(row, isSelected), dimColor: !isSelected && getRowColor(row, isSelected) === undefined, wrap: "truncate-end", children: line }, row.path) }), showScrollbar ? (_jsx(Text, { color: scrollbarThumbRows.has(index) ? 'cyan' : 'gray', dimColor: !scrollbarThumbRows.has(index), children: scrollbarThumbRows.has(index) ? '█' : '│' })) : null] }, row.path));
+                const projection = projectWorktreeListRow(row, isSelected);
+                const tagSuffix = projection.isMain ? ' [root]' : '';
+                const color = getRowColor(projection);
+                const branchText = sanitizeInlineText(row.branch);
+                const line = `${isSelected ? '>' : ' '} ${getIndicator(projection.state)} ${truncateLabel(branchText, Math.max(1, branchWidth - tagSuffix.length))}${tagSuffix}`;
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsx(Text, { color: color, dimColor: !isSelected && color === undefined, bold: projection.state === 'active', wrap: "truncate-end", children: line }, row.path) }), showScrollbar ? (_jsx(Text, { color: scrollbarThumbRows.has(index) ? 'cyan' : 'gray', dimColor: !scrollbarThumbRows.has(index), children: scrollbarThumbRows.has(index) ? '█' : '│' })) : null] }, row.path));
             })] }));
 }

package/dist/core/command-runner.d.ts

@@ -1,3 +1,13 @@
+interface CommandLogOptions {
+    command: string[];
+    cwd: string;
+    logsDir: string;
+    logFileBase: string;
+    errorLabel?: string;
+}
+export declare function runCommandToLog({ command, cwd, logsDir, logFileBase, errorLabel, }: CommandLogOptions): Promise<{
+    logPath: string;
+}>;
 export declare function startDetachedCommand({ command, cwd, logsDir, logFileBase, }: {
     command: string[];
     cwd: string;
@@ -8,3 +18,4 @@ export declare function startDetachedCommand({ command, cwd, logsDir, logFileBas
     pgid: number;
     logPath: string;
 }>;
+export {};

package/dist/core/command-runner.js

@@ -1,6 +1,49 @@
 import { closeSync, mkdirSync, openSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
+function getLogEnvironment() {
+    return {
+        ...process.env,
+        FORCE_COLOR: process.env.FORCE_COLOR ?? '1',
+        CLICOLOR_FORCE: process.env.CLICOLOR_FORCE ?? '1',
+    };
+}
+export function runCommandToLog({ command, cwd, logsDir, logFileBase, errorLabel = 'setup command', }) {
+    mkdirSync(logsDir, { recursive: true });
+    const logPath = path.join(logsDir, `${logFileBase}.log`);
+    const fd = openSync(logPath, 'a');
+    const { promise, resolve, reject } = Promise.withResolvers();
+    let settled = false;
+    const finalize = () => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        closeSync(fd);
+    };
+    const child = spawn(command[0], command.slice(1), {
+        cwd,
+        env: getLogEnvironment(),
+        stdio: ['ignore', fd, fd],
+    });
+    child.once('error', error => {
+        finalize();
+        reject(error);
+    });
+    child.once('exit', (code, signal) => {
+        finalize();
+        if (code === 0) {
+            resolve({ logPath });
+            return;
+        }
+        if (code !== null) {
+            reject(new Error(`${errorLabel} exited with code ${code}; see ${logPath}`));
+            return;
+        }
+        reject(new Error(`${errorLabel} exited due to signal ${signal ?? 'unknown'}; see ${logPath}`));
+    });
+    return promise;
+}
 export function startDetachedCommand({ command, cwd, logsDir, logFileBase, }) {
     mkdirSync(logsDir, { recursive: true });
     const logPath = path.join(logsDir, `${logFileBase}.log`);
@@ -10,6 +53,7 @@ export function startDetachedCommand({ command, cwd, logsDir, logFileBase, }) {
     const child = spawn(command[0], command.slice(1), {
         cwd,
         detached: true,
+        env: getLogEnvironment(),
         stdio: ['ignore', fd, fd],
     });
     const finalize = () => {

package/dist/core/config-lifecycle.d.ts

@@ -0,0 +1,25 @@
+import { type ToolConfig } from './config.js';
+export interface DefaultToolConfigOptions {
+    namespaceSeed: string;
+    packageManager: 'bun' | 'pnpm' | 'yarn' | 'npm';
+    script: string;
+}
+export interface ConfigInitResult {
+    path: string;
+    config: ToolConfig;
+}
+export interface ConfigInitOptions {
+    workspaceRoot: string;
+    force: boolean;
+    config: ToolConfig;
+}
+export declare function isSafeNamespace(value: unknown): value is string;
+export declare function toSafeNamespace(value: string): string;
+export declare function validateToolConfig(raw: unknown): ToolConfig;
+export declare function createDefaultToolConfig(options: DefaultToolConfigOptions): ToolConfig;
+export declare function loadToolConfig({ repoRoot }: {
+    repoRoot: string;
+}): Promise<ToolConfig>;
+export declare function renderConfigJsonc(config: ToolConfig): string;
+export declare function findExistingConfigPath(workspaceRoot: string, fileExists: (filePath: string) => Promise<boolean>): Promise<string | null>;
+export declare function writeToolConfigForRepo({ workspaceRoot, force, config }: ConfigInitOptions, fileExists: (filePath: string) => Promise<boolean>): Promise<ConfigInitResult>;

package/dist/core/config-lifecycle.js

@@ -0,0 +1,143 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { CONFIG_FILE_NAME, CONFIG_FILE_NAMES, parseJsonc } from './config.js';
+const SAFE_NAMESPACE_PATTERN = /^[A-Za-z0-9._-]+$/u;
+const UNSAFE_NAMESPACE_RUN_PATTERN = /[^A-Za-z0-9._-]+/gu;
+const LEADING_NAMESPACE_HYPHENS_PATTERN = /^-+/u;
+const TRAILING_NAMESPACE_HYPHENS_PATTERN = /-+$/u;
+const SAFE_NAMESPACE_DESCRIPTION = '[A-Za-z0-9._-]+';
+const DEFAULT_NAMESPACE = 'worktree-command-tui';
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+export function isSafeNamespace(value) {
+    return isNonEmptyString(value) && SAFE_NAMESPACE_PATTERN.test(value);
+}
+export function toSafeNamespace(value) {
+    const replaced = value.replace(UNSAFE_NAMESPACE_RUN_PATTERN, '-');
+    const trimmed = replaced.replace(LEADING_NAMESPACE_HYPHENS_PATTERN, '').replace(TRAILING_NAMESPACE_HYPHENS_PATTERN, '');
+    return isSafeNamespace(trimmed) ? trimmed : DEFAULT_NAMESPACE;
+}
+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 readRequiredCommand(value, fieldName) {
+    if (!Array.isArray(value) || value.length === 0 || value.some(part => !isNonEmptyString(part))) {
+        throw new Error(`${fieldName} must be a non-empty string array`);
+    }
+    return value;
+}
+function readOptionalCommand(value, fieldName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.length === 0 || value.some(part => !isNonEmptyString(part))) {
+        throw new Error(`${fieldName} must be a non-empty string array when set`);
+    }
+    return value;
+}
+function readPort(value) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535) {
+        throw new Error('port must be an integer between 1 and 65535');
+    }
+    return value;
+}
+export function validateToolConfig(raw) {
+    const config = (raw ?? {});
+    const command = readRequiredCommand(config.command, 'command');
+    if (!isSafeNamespace(config.namespace)) {
+        throw new Error(`namespace must match ${SAFE_NAMESPACE_DESCRIPTION}`);
+    }
+    return {
+        namespace: config.namespace,
+        command,
+        setupCommand: readOptionalCommand(config.setupCommand, 'setupCommand'),
+        editorCommand: readOptionalCommand(config.editorCommand, 'editorCommand'),
+        port: readPort(config.port),
+        requiredFiles: readStringList(config.requiredFiles, 'requiredFiles'),
+        orphanMatchers: readStringList(config.orphanMatchers, 'orphanMatchers'),
+    };
+}
+export function createDefaultToolConfig(options) {
+    return validateToolConfig({
+        namespace: toSafeNamespace(options.namespaceSeed),
+        command: [options.packageManager, 'run', options.script],
+        setupCommand: [options.packageManager, 'install'],
+        editorCommand: ['code'],
+        port: 3000,
+        requiredFiles: ['package.json'],
+        orphanMatchers: [],
+    });
+}
+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 }) {
+    return validateToolConfig(parseJsonc(await readFirstConfig(repoRoot)));
+}
+export function renderConfigJsonc(config) {
+    const setupCommandSection = config.setupCommand === undefined ? '' : `
+  // Optional command run manually with the setup key in the selected worktree.
+  // Useful for first-time dependency installation without doing it on every switch.
+  "setupCommand": ${JSON.stringify(config.setupCommand)},
+`;
+    const editorCommandSection = config.editorCommand === undefined ? '' : `
+  // Optional command that opens the selected worktree path in an editor.
+  // The selected worktree path is appended as the final argv entry.
+  "editorCommand": ${JSON.stringify(config.editorCommand)},
+`;
+    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)},
+${setupCommandSection}${editorCommandSection}
+  // 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)},
+}
+`;
+}
+export async function findExistingConfigPath(workspaceRoot, fileExists) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+        const configPath = path.join(workspaceRoot, fileName);
+        if (await fileExists(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+export async function writeToolConfigForRepo({ workspaceRoot, force, config }, fileExists) {
+    const configPath = path.join(workspaceRoot, CONFIG_FILE_NAME);
+    const existingConfigPath = await findExistingConfigPath(workspaceRoot, fileExists);
+    if (!force && existingConfigPath) {
+        throw new Error(`Config file already exists: ${existingConfigPath}`);
+    }
+    const validatedConfig = validateToolConfig(config);
+    await writeFile(configPath, renderConfigJsonc(validatedConfig), 'utf8');
+    return { path: configPath, config: validatedConfig };
+}

package/dist/core/config.d.ts

@@ -4,11 +4,10 @@ export declare const CONFIG_FILE_NAMES: readonly [".worktree-command-tui.jsonc",
 export interface ToolConfig {
     namespace: string;
     command: string[];
+    setupCommand?: string[];
+    editorCommand?: string[];
     port: number;
     requiredFiles: string[];
     orphanMatchers: string[];
 }
 export declare function parseJsonc(source: string): unknown;
-export declare function loadToolConfig({ repoRoot }: {
-    repoRoot: string;
-}): Promise<ToolConfig>;