@cod3vil/trunk 0.1.1

package/dist/ui/SetupForm.js

@@ -0,0 +1,354 @@
+/* eslint-disable unicorn/filename-case -- Phase 3 specifies SetupForm.tsx. */
+/** The only interactive surface in trunk: setup fields followed by a preview. */
+import { spawn } from 'node:child_process';
+import process from 'node:process';
+import React, { useRef, useState } from 'react';
+import { Box, Text, render, useApp, useInput } from 'ink';
+import { agentIds, maximumAgents } from '../core/agents.js';
+import { buildRerunCommand, resolve, setupFieldOrder, } from '../core/resolve.js';
+import { supportsInteractiveInput } from '../core/platform.js';
+import { validatePrefix } from '../core/prefix.js';
+import { badUsage, userAborted } from '../core/result.js';
+import { randomWord } from '../core/words.js';
+import Summary from './Summary.js';
+import MultiSelect from './fields/MultiSelect.js';
+import Select from './fields/Select.js';
+import TextInput from './fields/TextInput.js';
+const onOffOptions = Object.freeze([
+    Object.freeze({ value: 'on', label: 'on' }),
+    Object.freeze({ value: 'off', label: 'off' }),
+]);
+export default function SetupForm({ folder, options, randomPrefix = randomWord, onSubmit, onAbort, }) {
+    const { exit } = useApp();
+    const finished = useRef(false);
+    const [values, setValues] = useState(() => valuesFromSettings(resolve({ ...options, acceptDefaults: false }).draft));
+    const [activeField, setActiveField] = useState(() => firstVisibleField(values, options));
+    const [summary, setSummary] = useState();
+    const [formError, setFormError] = useState();
+    const visibleFields = visibleSetupFields(values, options);
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            abort();
+        }
+    });
+    if (summary) {
+        return (React.createElement(Summary, { folder: folder, settings: summary, onConfirm: () => {
+                if (finished.current) {
+                    return;
+                }
+                finished.current = true;
+                onSubmit(summary);
+                exit();
+            }, onBack: () => {
+                setSummary(undefined);
+                setActiveField(visibleFields.at(-1) ?? 'prefix');
+            }, onAbort: abort }));
+    }
+    return (React.createElement(Box, { flexDirection: "column", width: "100%" },
+        React.createElement(Text, { bold: true }, "Configure worktree setup"),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, '  folder'.padEnd(20)),
+            React.createElement(Text, { wrap: "truncate-end" }, folder)),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, visibleFields.map(field => renderField(field))),
+        formError ? (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "red" }, formError))) : null,
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "arrows choose \u00B7 space checks \u00B7 Enter continues \u00B7 Ctrl+C aborts"))));
+    function renderField(field) {
+        const active = field === activeField;
+        switch (field) {
+            case 'prefix': {
+                const validation = validatePrefix(values.prefix);
+                return (React.createElement(TextInput, { key: field, label: "prefix", value: values.prefix, isActive: active, help: "keep it unique across your repos", validationError: validation.valid ? undefined : validation.reason, randomValue: randomPrefix, onChange: value => {
+                        update('prefix', value);
+                    }, onSubmit: () => {
+                        advance(field);
+                    } }));
+            }
+            case 'pm': {
+                return (React.createElement(Select, { key: field, label: "package manager", options: [
+                        { value: 'npm', label: 'npm' },
+                        { value: 'pnpm', label: 'pnpm' },
+                        { value: 'bun', label: 'bun' },
+                    ], value: values.pm, isActive: active, note: options.packageDetection?.needsConfirmation
+                        ? 'confirm'
+                        : undefined, onChange: value => {
+                        update('pm', value);
+                    }, onSubmit: () => {
+                        advance(field);
+                    } }));
+            }
+            case 'tmux': {
+                return booleanField(field, 'tmux session', values.tmux, options.tools?.tmux.path ? undefined : 'not installed');
+            }
+            case 'agents': {
+                return (React.createElement(MultiSelect, { key: field, label: "agents", options: agentIds.map(id => ({
+                        value: id,
+                        label: id,
+                        note: options.tools?.agents[id].path
+                            ? undefined
+                            : 'not installed',
+                    })), value: values.agents, maximum: maximumAgents, isActive: active, onChange: value => {
+                        update('agents', value);
+                    }, onSubmit: () => {
+                        advance(field);
+                    } }));
+            }
+            case 'copyIgnored': {
+                return booleanField(field, 'copy-ignored', values.copyIgnored);
+            }
+            case 'server': {
+                return booleanField(field, 'dev server', values.server);
+            }
+            case 'caddy': {
+                const missing = options.tools?.caddy.path === undefined;
+                return booleanField(field, missing ? 'include anyway' : 'Caddy route', values.caddy, missing ? '(teammates may have it)' : undefined);
+            }
+            case 'mcAlias': {
+                return booleanField(field, 'mc alias', values.mcAlias);
+            }
+        }
+    }
+    function booleanField(field, label, value, note) {
+        return (React.createElement(Select, { key: field, label: label, options: onOffOptions, value: value ? 'on' : 'off', isActive: field === activeField, note: note, onChange: next => {
+                update(field, next === 'on');
+            }, onSubmit: () => {
+                advance(field);
+            } }));
+    }
+    function update(field, value) {
+        setValues(current => ({ ...current, [field]: value }));
+        setFormError(undefined);
+    }
+    function advance(field) {
+        const fields = visibleSetupFields(values, options);
+        const next = fields[fields.indexOf(field) + 1];
+        if (next) {
+            setActiveField(next);
+            return;
+        }
+        try {
+            const resolution = resolve({
+                ...options,
+                acceptDefaults: false,
+                answers: { ...options.answers, ...values },
+            });
+            if (resolution.kind === 'questions') {
+                setActiveField(resolution.questions[0]?.field ?? 'prefix');
+                setFormError('Answer every visible field before continuing.');
+                return;
+            }
+            setSummary(resolution.settings);
+        }
+        catch (error) {
+            setFormError(errorMessage(error));
+        }
+    }
+    function abort() {
+        if (finished.current) {
+            return;
+        }
+        finished.current = true;
+        onAbort();
+        exit();
+    }
+}
+/** Mounts Ink with Ctrl+C routed through the form's normal abort result. */
+export async function runSetupForm(properties) {
+    let outcome;
+    if (!supportsInteractiveInput()) {
+        return {
+            kind: 'unavailable',
+            reason: 'stdin is not an interactive terminal',
+        };
+    }
+    try {
+        const app = render(React.createElement(SetupForm, { ...properties, onSubmit: settings => {
+                outcome = { kind: 'settings', settings };
+            }, onAbort: () => {
+                outcome = { kind: 'aborted' };
+            } }), { exitOnCtrlC: false });
+        await app.waitUntilExit();
+        app.cleanup();
+    }
+    catch (error) {
+        // Ink throws from inside React when raw mode turns out to be unusable,
+        // which would otherwise reach the user as a component stack.
+        return { kind: 'unavailable', reason: errorMessage(error) };
+    }
+    return outcome ?? { kind: 'aborted' };
+}
+/** Chooses the headless path or mounts the form, including the Caddy branch. */
+export async function collectSettings({ folder, resolveOptions, invocation, yes = false, interactive = supportsInteractiveInput(), randomPrefix, installCaddy = streamCaddyInstall, report = line => {
+    process.stderr.write(`${line}\n`);
+}, runForm = runSetupForm, askInstall = askToInstallCaddy, }) {
+    let options = { ...resolveOptions, acceptDefaults: yes };
+    let resolution;
+    try {
+        resolution = resolve(options);
+    }
+    catch (error) {
+        return { kind: 'outcome', outcome: badUsage(errorMessage(error)) };
+    }
+    if (resolution.kind === 'complete') {
+        return { kind: 'settings', settings: resolution.settings };
+    }
+    if (!interactive) {
+        return {
+            kind: 'outcome',
+            outcome: badUsage(missingInputMessage(resolution, invocation)),
+        };
+    }
+    const caddy = resolution.questions.find((question) => question.field === 'caddy');
+    if (caddy?.availability.kind === 'brew-installable') {
+        const answer = await askInstall();
+        if (answer === 'abort') {
+            return { kind: 'outcome', outcome: userAborted() };
+        }
+        if (answer === 'yes') {
+            let installed = false;
+            try {
+                installed = await installCaddy(caddy.availability.executable, caddy.availability.arguments);
+            }
+            catch {
+                // A missing/broken Brew process is the same as a non-zero install.
+            }
+            if (installed) {
+                options = withCaddyInstalled(options);
+                resolution = resolve(options);
+            }
+            else {
+                report('brew install caddy failed; continuing without it.');
+                report(caddyInstallUrl());
+            }
+        }
+        else {
+            report(caddyInstallUrl());
+        }
+    }
+    else if (caddy?.availability.kind === 'missing') {
+        report(caddy.availability.installUrl);
+    }
+    if (resolution.kind === 'complete') {
+        return { kind: 'settings', settings: resolution.settings };
+    }
+    const form = await runForm({ folder, options, randomPrefix });
+    if (form.kind === 'settings') {
+        return form;
+    }
+    if (form.kind === 'unavailable') {
+        return {
+            kind: 'outcome',
+            outcome: badUsage(missingInputMessage(resolution, invocation, form.reason)),
+        };
+    }
+    return { kind: 'outcome', outcome: userAborted() };
+}
+/**
+ * What to say when the questions cannot be asked: the exact command that
+ * answers them, rather than a complaint about the terminal.
+ */
+function missingInputMessage(resolution, invocation, reason) {
+    const rerun = buildRerunCommand(invocation.executable, invocation.arguments, resolution);
+    const cause = reason
+        ? `Interactive setup needs a terminal that can read keys (${reason}).`
+        : 'Interactive setup requires a TTY.';
+    return `${cause} Re-run with --yes, or specify the missing flags:\n  ${rerun.display}`;
+}
+function CaddyInstallPrompt({ onAnswer, }) {
+    const { exit } = useApp();
+    const answered = useRef(false);
+    useInput((input, key) => {
+        let answer;
+        if (key.ctrl && input === 'c') {
+            answer = 'abort';
+        }
+        else if (key.return || input.toLowerCase() === 'y') {
+            answer = 'yes';
+        }
+        else if (input.toLowerCase() === 'n') {
+            answer = 'no';
+        }
+        if (!answer || answered.current) {
+            return;
+        }
+        answered.current = true;
+        onAnswer(answer);
+        exit();
+    });
+    return (React.createElement(Text, null, "? caddy not found. Install with 'brew install caddy'? (Y/n)"));
+}
+async function askToInstallCaddy() {
+    let answer = 'abort';
+    const app = render(React.createElement(CaddyInstallPrompt, { onAnswer: value => {
+            answer = value;
+        } }), { exitOnCtrlC: false });
+    await app.waitUntilExit();
+    app.cleanup();
+    return answer;
+}
+async function streamCaddyInstall(executable, arguments_) {
+    return new Promise(resolve => {
+        // Inherited stdio: the user watches Brew's own progress output.
+        const child = spawn(executable, [...arguments_], { stdio: 'inherit' });
+        child.once('error', () => {
+            resolve(false);
+        });
+        child.once('close', code => {
+            resolve(code === 0);
+        });
+    });
+}
+function withCaddyInstalled(options) {
+    if (!options.tools) {
+        return options;
+    }
+    return {
+        ...options,
+        tools: {
+            ...options.tools,
+            caddy: Object.freeze({ name: 'caddy', path: 'caddy' }),
+        },
+    };
+}
+function visibleSetupFields(values, options) {
+    return setupFieldOrder.filter(field => {
+        if (provided(field, options)) {
+            return false;
+        }
+        return !((field === 'agents' && !values.tmux) ||
+            (field === 'caddy' && !values.server));
+    });
+}
+function firstVisibleField(values, options) {
+    return visibleSetupFields(values, options)[0] ?? 'prefix';
+}
+function provided(field, options) {
+    if (Object.hasOwn(options.answers ?? {}, field)) {
+        return true;
+    }
+    const { flags } = options;
+    if (!flags) {
+        return false;
+    }
+    const value = flags[field];
+    return value !== undefined;
+}
+function valuesFromSettings(settings) {
+    return {
+        prefix: settings.prefix,
+        pm: settings.pm,
+        tmux: settings.tmux,
+        agents: settings.agents,
+        copyIgnored: settings.copyIgnored,
+        server: settings.server,
+        caddy: settings.caddy,
+        mcAlias: settings.mcAlias,
+    };
+}
+function caddyInstallUrl() {
+    return 'https://caddyserver.com/docs/install';
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/ui/Summary.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type Settings } from '../core/settings.js';
+export type SummaryProperties = Readonly<{
+    folder: string;
+    settings: Settings;
+    onConfirm: () => void;
+    onBack: () => void;
+    onAbort: () => void;
+}>;
+export type SummaryRow = Readonly<{
+    label: string;
+    value: string;
+}>;
+export declare function summaryRows(settings: Settings, folder: string): readonly SummaryRow[];
+export default function Summary({ folder, settings, onConfirm, onBack, onAbort, }: SummaryProperties): React.ReactElement;

package/dist/ui/Summary.js

@@ -0,0 +1,74 @@
+/* eslint-disable unicorn/filename-case -- Phase 3 specifies Summary.tsx. */
+/** Final preview shown before a command is allowed to write wt.toml. */
+import { homedir } from 'node:os';
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+import { developmentCommand, installCommand } from '../core/generate/steps.js';
+import { routeUrl } from '../core/generate/proxy.js';
+import { usesCaddy } from '../core/settings.js';
+export function summaryRows(settings, folder) {
+    const steps = [
+        settings.tmux ? 'tmux' : undefined,
+        settings.copyIgnored ? 'copy-ignored' : undefined,
+        'install',
+        settings.server ? 'server' : undefined,
+        usesCaddy(settings) ? 'proxy' : undefined,
+        settings.mcAlias ? 'mc' : undefined,
+    ].filter((step) => step !== undefined);
+    return Object.freeze([
+        Object.freeze({ label: 'folder', value: displayPath(folder) }),
+        Object.freeze({
+            label: 'prefix',
+            value: `${settings.prefix}    session ${settings.tmux ? `${settings.prefix}_<branch>` : 'off'}`,
+        }),
+        Object.freeze({ label: 'install', value: installCommand(settings) }),
+        Object.freeze({
+            label: 'server',
+            value: settings.server
+                ? developmentCommand(settings, '<hash of repo+branch>')
+                : 'off',
+        }),
+        Object.freeze({
+            label: 'route',
+            value: usesCaddy(settings) ? routeUrl(settings, '<branch>') : 'off',
+        }),
+        Object.freeze({
+            label: 'agents',
+            value: settings.agents.length > 0 ? settings.agents.join(', ') : 'none',
+        }),
+        Object.freeze({ label: 'steps', value: steps.join(' · ') }),
+    ]);
+}
+export default function Summary({ folder, settings, onConfirm, onBack, onAbort, }) {
+    useInput((input, key) => {
+        if (key.return) {
+            onConfirm();
+        }
+        else if (input === 'b') {
+            onBack();
+        }
+        else if (input === 'q') {
+            onAbort();
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", width: "100%" },
+        React.createElement(Text, { bold: true }, "Review setup"),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, summaryRows(settings, folder).map(row => (React.createElement(Box, { key: row.label, width: "100%" },
+            React.createElement(Box, { width: 10, flexShrink: 0 },
+                React.createElement(Text, { dimColor: true }, row.label)),
+            React.createElement(Box, { flexGrow: 1 },
+                React.createElement(Text, { wrap: "truncate-end" }, row.value)))))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "cyan" }, "[Enter]"),
+            React.createElement(Text, null, " write \u00B7 "),
+            React.createElement(Text, { color: "cyan" }, "[b]"),
+            React.createElement(Text, null, " back \u00B7 "),
+            React.createElement(Text, { color: "cyan" }, "[q]"),
+            React.createElement(Text, null, " abort"))));
+}
+function displayPath(path) {
+    const home = homedir();
+    return path === home || path.startsWith(`${home}/`)
+        ? `~${path.slice(home.length)}`
+        : path;
+}

package/dist/ui/fields/MultiSelect.d.ts

@@ -0,0 +1,17 @@
+/** Fixed-order checkboxes with an enforced selection limit. */
+import React from 'react';
+export type MultiSelectOption<Value extends string> = Readonly<{
+    value: Value;
+    label: string;
+    note?: string;
+}>;
+export type MultiSelectProperties<Value extends string> = Readonly<{
+    label: string;
+    options: ReadonlyArray<MultiSelectOption<Value>>;
+    value: readonly Value[];
+    maximum: number;
+    isActive: boolean;
+    onChange: (value: readonly Value[]) => void;
+    onSubmit: () => void;
+}>;
+export default function MultiSelect<Value extends string>({ label, options, value, maximum, isActive, onChange, onSubmit, }: MultiSelectProperties<Value>): React.ReactElement;

package/dist/ui/fields/MultiSelect.js

@@ -0,0 +1,66 @@
+/* eslint-disable unicorn/filename-case -- Phase 3 specifies MultiSelect.tsx. */
+/** Fixed-order checkboxes with an enforced selection limit. */
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export default function MultiSelect({ label, options, value, maximum, isActive, onChange, onSubmit, }) {
+    const [cursor, setCursor] = useState(0);
+    const [error, setError] = useState();
+    useInput((input, key) => {
+        if (key.return) {
+            onSubmit();
+            return;
+        }
+        if (key.upArrow || key.leftArrow) {
+            setCursor(current => (current - 1 + options.length) % options.length);
+            setError(undefined);
+            return;
+        }
+        if (key.downArrow || key.rightArrow) {
+            setCursor(current => (current + 1) % options.length);
+            setError(undefined);
+            return;
+        }
+        if (input !== ' ' || options.length === 0) {
+            return;
+        }
+        const selected = options[cursor].value;
+        if (value.includes(selected)) {
+            onChange(value.filter(item => item !== selected));
+            setError(undefined);
+            return;
+        }
+        if (value.length >= maximum) {
+            setError(`max ${maximum} (2×2 grid)`);
+            return;
+        }
+        const next = new Set([...value, selected]);
+        onChange(options.map(option => option.value).filter(item => next.has(item)));
+        setError(undefined);
+    }, { isActive });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, null,
+            React.createElement(Text, { color: isActive ? 'cyan' : undefined },
+                isActive ? '›' : ' ',
+                " ",
+                label),
+            error ? React.createElement(Text, { color: "red" },
+                " ",
+                error) : null),
+        React.createElement(Box, { flexDirection: "column", marginLeft: 2 }, Array.from({ length: Math.ceil(options.length / 2) }, (_, row) => (React.createElement(Box, { key: row }, [options[row * 2], options[row * 2 + 1]]
+            .filter((option) => option !== undefined)
+            .map(option => {
+            const index = options.indexOf(option);
+            const checked = value.includes(option.value);
+            return (React.createElement(Box, { key: option.value, width: 36 },
+                React.createElement(Text, { color: isActive && cursor === index ? 'cyan' : undefined },
+                    isActive && cursor === index ? '›' : ' ',
+                    ' ',
+                    checked ? '[x]' : '[ ]',
+                    " ",
+                    option.label),
+                option.note ? (React.createElement(Text, { dimColor: true },
+                    " (",
+                    option.note,
+                    ")")) : null));
+        })))))));
+}

package/dist/ui/fields/Select.d.ts

@@ -0,0 +1,17 @@
+/** A compact single-choice field controlled with either pair of arrow keys. */
+import React from 'react';
+export type SelectOption<Value extends string> = Readonly<{
+    value: Value;
+    label: string;
+    note?: string;
+}>;
+export type SelectProperties<Value extends string> = Readonly<{
+    label: string;
+    options: ReadonlyArray<SelectOption<Value>>;
+    value: Value;
+    isActive: boolean;
+    note?: string;
+    onChange: (value: Value) => void;
+    onSubmit: () => void;
+}>;
+export default function Select<Value extends string>({ label, options, value, isActive, note, onChange, onSubmit, }: SelectProperties<Value>): React.ReactElement;

package/dist/ui/fields/Select.js

@@ -0,0 +1,37 @@
+/* eslint-disable unicorn/filename-case -- Phase 3 specifies Select.tsx. */
+/** A compact single-choice field controlled with either pair of arrow keys. */
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+export default function Select({ label, options, value, isActive, note, onChange, onSubmit, }) {
+    useInput((_input, key) => {
+        if (key.return) {
+            onSubmit();
+            return;
+        }
+        const offset = key.leftArrow || key.upArrow
+            ? -1
+            : key.rightArrow || key.downArrow
+                ? 1
+                : 0;
+        if (offset === 0 || options.length === 0) {
+            return;
+        }
+        const current = options.findIndex(option => option.value === value);
+        const index = (current + offset + options.length) % options.length;
+        onChange(options[index].value);
+    }, { isActive });
+    const selected = options.find(option => option.value === value) ?? options[0];
+    return (React.createElement(Box, null,
+        React.createElement(Text, { color: isActive ? 'cyan' : undefined },
+            isActive ? '›' : ' ',
+            " ",
+            label.padEnd(17)),
+        React.createElement(Text, { bold: isActive }, selected?.label ?? value),
+        selected?.note ? React.createElement(Text, { dimColor: true },
+            " (",
+            selected.note,
+            ")") : null,
+        note ? React.createElement(Text, { color: "yellow" },
+            " ",
+            note) : null));
+}

package/dist/ui/fields/TextInput.d.ts

@@ -0,0 +1,13 @@
+/** Prefix entry with random/custom shortcuts and live validation. */
+import React from 'react';
+export type TextInputProperties = Readonly<{
+    label: string;
+    value: string;
+    isActive: boolean;
+    help: string;
+    validationError?: string;
+    randomValue: () => string;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+}>;
+export default function TextInput({ label, value, isActive, help, validationError, randomValue, onChange, onSubmit, }: TextInputProperties): React.ReactElement;

package/dist/ui/fields/TextInput.js

@@ -0,0 +1,50 @@
+/* eslint-disable unicorn/filename-case -- Phase 3 specifies TextInput.tsx. */
+/** Prefix entry with random/custom shortcuts and live validation. */
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export default function TextInput({ label, value, isActive, help, validationError, randomValue, onChange, onSubmit, }) {
+    const [custom, setCustom] = useState(false);
+    useInput((input, key) => {
+        if (key.ctrl || key.meta) {
+            return;
+        }
+        if (key.return) {
+            if (!validationError) {
+                onSubmit();
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setCustom(true);
+            onChange(value.slice(0, -1));
+            return;
+        }
+        if (!custom && input === 'r') {
+            onChange(randomValue());
+            return;
+        }
+        if (!custom && input === 'c') {
+            setCustom(true);
+            onChange('');
+            return;
+        }
+        if (input &&
+            !key.upArrow &&
+            !key.downArrow &&
+            !key.leftArrow &&
+            !key.rightArrow) {
+            setCustom(true);
+            onChange(`${value}${input}`);
+        }
+    }, { isActive });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, null,
+            React.createElement(Text, { color: isActive ? 'cyan' : undefined },
+                isActive ? '›' : ' ',
+                " ",
+                label.padEnd(17)),
+            React.createElement(Text, { bold: isActive }, value),
+            isActive ? React.createElement(Text, { color: "cyan" }, "\u258C") : null),
+        React.createElement(Box, { marginLeft: 20 },
+            React.createElement(Text, { color: validationError ? 'red' : undefined, dimColor: !validationError }, validationError ?? `[r] random · [c] custom · ${help}`))));
+}