@cod3vil/trunk 0.1.1

package/dist/core/pipeline.d.ts

@@ -0,0 +1,119 @@
+import { collectSettings } from '../ui/SetupForm.js';
+import type { CliFlags } from './arguments.js';
+import type { ToolProbe } from './env.js';
+import { type GitOptions } from './git.js';
+import { Journal } from './journal.js';
+import type { ParsedRemote } from './repo.js';
+import { type SetupValues } from './resolve.js';
+import { type Outcome } from './result.js';
+import { type AttachedRunner, type CommandRunner } from './process.js';
+import type { Settings } from './settings.js';
+export declare const setupBranch = "chore/trunk-setup";
+export declare const configPath = ".config/wt.toml";
+export declare const commitMessage: string;
+export type SetupPrompts = Readonly<{
+    /** Returns undefined when the user aborts rather than choosing. */
+    choose: (question: string, options: readonly string[]) => Promise<string | undefined>;
+    confirm: (question: string) => Promise<boolean | undefined>;
+}>;
+export type SetupDependencies = Readonly<{
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    run?: CommandRunner;
+    attach?: AttachedRunner;
+    report?: (kind: 'success' | 'error' | 'info' | 'warning', line: string) => void;
+    interactive?: boolean;
+    prompts?: SetupPrompts;
+    collect?: typeof collectSettings;
+    now?: () => Date;
+    invocation?: Readonly<{
+        executable: string;
+        arguments: readonly string[];
+    }>;
+}>;
+export type SetupContext = Readonly<{
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    git: GitOptions;
+    attach: AttachedRunner;
+    run: CommandRunner;
+    report: NonNullable<SetupDependencies['report']>;
+    interactive: boolean;
+    prompts?: SetupPrompts;
+    collect: typeof collectSettings;
+    now: () => Date;
+    invocation: Readonly<{
+        executable: string;
+        arguments: readonly string[];
+    }>;
+    tools: ToolProbe;
+    flags: CliFlags;
+    journal: Journal;
+    wtPath: string;
+}>;
+/**
+ * Steps 6 and 7 followed by the write: decide what to do about a config that is
+ * already there, resolve the settings for one that is not, and hand over to the
+ * branch that receives them. Shared so `clone` and `init` cannot diverge.
+ */
+export declare function configureProject(context: SetupContext, project: Readonly<{
+    remote: ParsedRemote;
+    projectDirectory: string;
+    gitDirectory: string;
+    defaultWorktree: string;
+    defaultBranch: string;
+    /** Values read back out of a config that already exists. */
+    adopted?: Partial<SetupValues>;
+    copyIgnoredExclude?: readonly string[];
+    /**
+     * Runs once the settings are known and before anything is written, for
+     * work that depends on what the user chose — `init` uses it to offer the
+     * tmux session renames a prefix change needs.
+     */
+    onSettings?: (settings: Settings) => Promise<void>;
+}>): Promise<Outcome>;
+/**
+ * Creates the worktree that receives the config, writes it, lets wt check it,
+ * and only then commits. Separate because it is the part that touches the
+ * repository's history.
+ */
+export declare function setUpBranch(context: SetupContext, plan: Readonly<{
+    remote: ParsedRemote;
+    projectDirectory: string;
+    gitDirectory: string;
+    defaultWorktree: string;
+    settings: Settings;
+    /**
+     * The config the repository has now. It lives in the default worktree,
+     * not in the freshly created setup worktree, so it is passed in rather
+     * than read from where the new file is about to go.
+     */
+    replacing?: string;
+}>): Promise<Outcome>;
+export declare function warnAboutWorktreePath(context: SetupContext, remote: ParsedRemote, actual: string): void;
+/** Spelled out because the fix belongs in the user's config, not in trunk's. */
+export declare function worktreePathWarning(identifier: string, actualPath: string): readonly string[];
+/**
+ * Where a worktree actually landed. git reports resolved paths, so on a system
+ * where a temp or home directory is a symlink the string trunk proposed and the
+ * string git prints differ; both sides are resolved before comparing.
+ */
+export declare function locateWorktree(gitDirectory: string, expected: string, options: GitOptions, branch?: string): Promise<string>;
+export declare function decideExistingConfig(context: SetupContext): Promise<'keep' | 'overwrite' | 'abort'>;
+export declare function confirmStep(context: SetupContext, question: string): Promise<boolean | undefined>;
+/** Step 11: approvals and the smoke test, both optional and both attached. */
+export declare function finish(context: SetupContext, projectDirectory: string, worktree: string, branch: string): Promise<Outcome>;
+/**
+ * Step 12. Every failure and abort lands here, where the journal turns into
+ * either a resume hint or a precise undo.
+ */
+export declare function interrupted(context: SetupContext, projectDirectory: string, reason: string): Promise<Outcome>;
+export declare function readExistingConfig(worktree: string): Promise<string | undefined>;
+export declare function folderState(path: string): Promise<'missing' | 'empty' | 'occupied'>;
+export declare function createContext(flags: CliFlags, tools: ToolProbe, dependencies: SetupDependencies): SetupContext;
+export declare function today(date: Date): string;
+export declare function outputOf(result: Readonly<{
+    stdout: string;
+    stderr: string;
+}>): string;
+export declare function errorMessage(error: unknown): string;

package/dist/core/pipeline.js

@@ -0,0 +1,473 @@
+/**
+ * The part of setup that every command shares: deciding what to do about a
+ * config that already exists, resolving the settings, creating the worktree
+ * that receives them, writing, validating, committing, publishing, and the
+ * approvals and smoke test afterwards.
+ *
+ * `trunk clone` reaches this after cloning; `trunk init` reaches it after
+ * finding an existing project. Both hand it the same shape, so the two commands
+ * cannot drift apart in how they set a repository up.
+ */
+import { mkdir, readFile, readdir, realpath, stat, writeFile, } from 'node:fs/promises';
+import { join } from 'node:path';
+import process from 'node:process';
+import { collectSettings } from '../ui/SetupForm.js';
+import { detectPackageManager } from './detect.js';
+import { diffLines, formatDiff } from './diff.js';
+import { compose } from './generate/index.js';
+import { canOpenPullRequest, compareUrl, createPullRequest, publishCommands, } from './gh.js';
+import { addWorktree, commitPath, listWorktreeEntries, } from './git.js';
+import { Journal, resumeCommand, undoCommands, } from './journal.js';
+import { step as reportStep } from './log.js';
+import { supportsInteractiveInput } from './platform.js';
+import { setupFlagsFromCli } from './resolve.js';
+import { exitCodes, operationFailed, succeed, userAborted, } from './result.js';
+import { runAttached, runCommand, } from './process.js';
+import { validateGeneratedConfig } from './validate.js';
+import { trunkVersion } from './version.js';
+import { approvalsAdd, hookLogPath, runHook, switchCreateAttached, } from './wt.js';
+export const setupBranch = 'chore/trunk-setup';
+export const configPath = '.config/wt.toml';
+export const commitMessage = `Add worktree automation
+
+Generated by trunk ${trunkVersion()}: tmux session, dependency install, dev server and
+Caddy route for each worktree. Run \`wt config approvals add\` after checking out.`;
+/**
+ * Steps 6 and 7 followed by the write: decide what to do about a config that is
+ * already there, resolve the settings for one that is not, and hand over to the
+ * branch that receives them. Shared so `clone` and `init` cannot diverge.
+ */
+export async function configureProject(context, project) {
+    const { remote, projectDirectory, gitDirectory, defaultWorktree, defaultBranch, } = project;
+    // An existing config belongs to the repository, not to this run.
+    const existing = await readExistingConfig(defaultWorktree);
+    if (existing !== undefined) {
+        const decision = await decideExistingConfig(context);
+        if (decision === 'abort') {
+            return interrupted(context, projectDirectory, 'aborted');
+        }
+        if (decision === 'keep') {
+            context.report('info', 'wt.toml exists → kept');
+            return finish(context, projectDirectory, defaultWorktree, defaultBranch);
+        }
+    }
+    // Detection and resolution happen inside the default worktree.
+    const detection = await detectPackageManager(defaultWorktree);
+    for (const warning of detection.warnings) {
+        context.report('warning', warning);
+    }
+    const collected = await context.collect({
+        folder: defaultWorktree,
+        resolveOptions: {
+            fixed: {
+                trunkVersion: trunkVersion(),
+                generatedOn: today(context.now()),
+                repoName: remote.repo,
+                hostLabel: remote.repo.toLowerCase(),
+                appDir: detection.appDir,
+                scripts: detection.scripts,
+            },
+            flags: setupFlagsFromCli(context.flags),
+            existing: project.adopted,
+            packageDetection: detection,
+            tools: context.tools,
+        },
+        invocation: context.invocation,
+        yes: context.flags.yes ?? false,
+        interactive: context.interactive,
+    });
+    if (collected.kind === 'outcome') {
+        return collected.outcome.code === exitCodes.userAborted
+            ? interrupted(context, projectDirectory, 'aborted')
+            : collected.outcome;
+    }
+    const settings = project.copyIgnoredExclude
+        ? { ...collected.settings, copyIgnoredExclude: project.copyIgnoredExclude }
+        : collected.settings;
+    await project.onSettings?.(settings);
+    return setUpBranch(context, {
+        remote,
+        projectDirectory,
+        gitDirectory,
+        defaultWorktree,
+        settings,
+        replacing: existing,
+    });
+}
+/**
+ * Shows what overwriting would change and asks. Without a terminal there is
+ * nobody to ask, and the run only reaches here because a flag already said to
+ * overwrite, so it proceeds and prints the diff for the log.
+ */
+async function confirmOverwrite(context, existing, settings) {
+    const diff = diffLines(existing, compose(settings));
+    if (diff.unchanged) {
+        context.report('info', `${configPath} is already up to date`);
+        return true;
+    }
+    context.report('info', `${configPath} changes: ${diff.added} added, ${diff.removed} removed`);
+    for (const line of formatDiff(diff)) {
+        context.report('info', line);
+    }
+    if (!context.interactive) {
+        return true;
+    }
+    const answer = await context.prompts?.confirm('write this config?');
+    return answer ?? true;
+}
+/**
+ * Creates the worktree that receives the config, writes it, lets wt check it,
+ * and only then commits. Separate because it is the part that touches the
+ * repository's history.
+ */
+export async function setUpBranch(context, plan) {
+    const { remote, projectDirectory, gitDirectory, defaultWorktree, settings } = plan;
+    // The config is unapproved until it is reviewed, so the worktree that
+    // receives it is created without hooks.
+    const direct = context.flags.direct ?? false;
+    const target = direct
+        ? defaultWorktree
+        : join(projectDirectory, setupBranch.replaceAll('/', '-'));
+    if (!direct) {
+        context.journal.record({
+            kind: 'branch-worktree',
+            path: target,
+            branch: setupBranch,
+            note: 'wt.toml uncommitted',
+        });
+        const created = await createSetupWorktree(context, projectDirectory, gitDirectory, target);
+        if (created !== 0) {
+            return interrupted(context, projectDirectory, `could not create the ${setupBranch} worktree`);
+        }
+    }
+    let worktree = defaultWorktree;
+    if (!direct) {
+        worktree = await locateWorktree(gitDirectory, target, context.git);
+        if (worktree !== target) {
+            context.journal.relocate(target, worktree);
+            warnAboutWorktreePath(context, remote, worktree);
+        }
+    }
+    // Anything trunk cannot model is lost here, so the user sees what changes
+    // before it is written, and can still say no.
+    const replacing = plan.replacing ?? (await readExistingConfig(worktree));
+    if (replacing !== undefined) {
+        const approved = await confirmOverwrite(context, replacing, settings);
+        if (!approved) {
+            return interrupted(context, projectDirectory, 'left the existing config');
+        }
+    }
+    // Write, then let wt check its own file before anything is committed.
+    await writeConfig(worktree, settings);
+    context.report('success', `wrote ${configPath}`);
+    try {
+        const validation = await validateGeneratedConfig(worktree, settings, {
+            wtPath: context.wtPath,
+            env: context.env,
+        });
+        reportPreview(context, validation.preview);
+    }
+    catch (error) {
+        return interrupted(context, projectDirectory, errorMessage(error));
+    }
+    const shouldCommit = await confirmStep(context, 'commit the generated config?');
+    if (shouldCommit === undefined) {
+        return interrupted(context, projectDirectory, 'aborted');
+    }
+    if (!shouldCommit) {
+        return interrupted(context, projectDirectory, 'left uncommitted');
+    }
+    const committed = await commitPath(worktree, configPath, commitMessage, context.git);
+    if (committed.code !== 0) {
+        return interrupted(context, projectDirectory, `commit failed: ${outputOf(committed)}`);
+    }
+    context.journal.annotate(worktree, 'wt.toml committed');
+    context.report('success', 'committed the generated config');
+    await publish(context, remote, worktree, direct ? undefined : setupBranch);
+    return finish(context, projectDirectory, worktree, setupBranch);
+}
+/**
+ * Interactive runs let wt place the worktree, the same way the first one is
+ * placed. Without a terminal wt cannot ask where worktrees belong and would
+ * fall back to `.git.<branch>`, so plain git keeps the sibling layout whole.
+ */
+async function createSetupWorktree(context, projectDirectory, gitDirectory, target) {
+    if (context.interactive) {
+        return switchCreateAttached(projectDirectory, setupBranch, {
+            wtPath: context.wtPath,
+            attach: context.attach,
+            env: context.env,
+        });
+    }
+    const added = await addWorktree(gitDirectory, target, setupBranch, {
+        ...context.git,
+        createBranch: true,
+    });
+    return added.code ?? 1;
+}
+export function warnAboutWorktreePath(context, remote, actual) {
+    for (const line of worktreePathWarning(remote.identifier, actual)) {
+        context.report('warning', line);
+    }
+}
+/** Spelled out because the fix belongs in the user's config, not in trunk's. */
+export function worktreePathWarning(identifier, actualPath) {
+    return Object.freeze([
+        `worktree-path is not configured for ${identifier}.`,
+        `  Agents and scripts will create ${actualPath} instead of a sibling worktree.`,
+        '  Fix: run `wt switch <branch>` in a terminal once, or add to ~/.config/worktrunk/config.toml:',
+        `    [projects."${identifier}"]`,
+        '    worktree-path = "{{ repo_path }}/../{{ branch | sanitize }}"',
+    ]);
+}
+/**
+ * Where a worktree actually landed. git reports resolved paths, so on a system
+ * where a temp or home directory is a symlink the string trunk proposed and the
+ * string git prints differ; both sides are resolved before comparing.
+ */
+export async function locateWorktree(gitDirectory, expected, options, branch) {
+    const entries = await listWorktreeEntries(gitDirectory, options);
+    const target = await canonicalPath(expected);
+    const resolved = await Promise.all(entries.map(async (entry) => [entry, await canonicalPath(entry.path)]));
+    const match = resolved.find(([, canonical]) => canonical === target);
+    if (match) {
+        return match[0].path;
+    }
+    // Worktrunk may have placed it beside the git directory instead. The branch
+    // it holds identifies it; position in the list does not.
+    const byBranch = branch
+        ? entries.find(entry => entry.branch === branch)
+        : undefined;
+    return byBranch?.path ?? expected;
+}
+async function canonicalPath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        return path;
+    }
+}
+export async function decideExistingConfig(context) {
+    if (!context.interactive || (context.flags.yes ?? false)) {
+        return 'keep';
+    }
+    const answer = await context.prompts?.choose(`${configPath} already exists. Keep it, or overwrite with the generated one?`, ['keep', 'overwrite']);
+    if (answer === undefined) {
+        return 'abort';
+    }
+    return answer === 'overwrite' ? 'overwrite' : 'keep';
+}
+export async function confirmStep(context, question) {
+    if (!context.interactive || (context.flags.yes ?? false)) {
+        return true;
+    }
+    return context.prompts?.confirm(question) ?? true;
+}
+/**
+ * Publishing is opt-in without a terminal: `--yes` alone stops after the commit
+ * and prints the commands, so a scripted run never pushes by surprise.
+ */
+async function publish(context, remote, worktree, branch) {
+    if (!branch) {
+        return;
+    }
+    const withPullRequest = canOpenPullRequest(remote, context.tools.gh.path !== undefined);
+    const wanted = context.flags.yes ?? false
+        ? false
+        : await confirmStep(context, 'push and open a pull request?');
+    if (!wanted) {
+        for (const command of publishCommands(branch, withPullRequest)) {
+            context.report('info', command);
+        }
+        const url = compareUrl(remote, branch);
+        if (url && !withPullRequest) {
+            context.report('info', url);
+        }
+        return;
+    }
+    const pushed = await context.run(context.git.gitPath ?? 'git', ['-C', worktree, 'push', '-u', 'origin', branch], { env: context.env });
+    if (pushed.code !== 0) {
+        context.report('error', `push failed: ${outputOf(pushed)}`);
+        return;
+    }
+    if (!withPullRequest) {
+        const url = compareUrl(remote, branch);
+        if (url) {
+            context.report('info', url);
+        }
+        return;
+    }
+    const pullRequest = await createPullRequest(worktree, {
+        ghPath: context.tools.gh.path,
+        run: context.run,
+        env: context.env,
+    });
+    context.report(pullRequest.code === 0 ? 'success' : 'error', outputOf(pullRequest));
+}
+/** Step 11: approvals and the smoke test, both optional and both attached. */
+export async function finish(context, projectDirectory, worktree, branch) {
+    if (!context.interactive || (context.flags.yes ?? false)) {
+        context.report('info', `next: wt config approvals add (in ${worktree})`);
+        return succeed(`set up ${projectDirectory}`);
+    }
+    const approve = await confirmStep(context, 'run `wt config approvals add` now?');
+    if (approve) {
+        await approvalsAdd(worktree, {
+            wtPath: context.wtPath,
+            attach: context.attach,
+            env: context.env,
+        });
+    }
+    context.report('info', 'the smoke test starts a real dev server and Caddy route; stop them with `wt remove` or the `up` alias');
+    const smoke = await confirmStep(context, 'run the hooks once as a smoke test?');
+    if (!smoke) {
+        return succeed(`set up ${projectDirectory}`);
+    }
+    for (const hook of ['pre-start', 'post-start']) {
+        // eslint-disable-next-line no-await-in-loop
+        const code = await runHook(worktree, hook, {
+            wtPath: context.wtPath,
+            attach: context.attach,
+            env: context.env,
+        });
+        if (code !== 0) {
+            context.report('error', `${hook} failed`);
+            context.report('info', hookLogPath(projectDirectory, branch, hook));
+            return operationFailed(`${hook} failed in ${worktree}`);
+        }
+    }
+    return succeed(`set up ${projectDirectory}`);
+}
+/**
+ * Step 12. Every failure and abort lands here, where the journal turns into
+ * either a resume hint or a precise undo.
+ */
+export async function interrupted(context, projectDirectory, reason) {
+    context.report('error', reason);
+    if (context.journal.isEmpty) {
+        return operationFailed(reason);
+    }
+    context.report('info', 'created by this run:');
+    for (const line of context.journal.describe(context.cwd)) {
+        context.report('info', `  ${line}`);
+    }
+    const undo = undoCommands(context.journal, projectDirectory, context.wtPath, context.git.gitPath ?? 'git');
+    const choice = context.interactive
+        ? await context.prompts?.choose('keep, or roll back what this run created?', ['keep', 'rollback'])
+        : 'keep';
+    if (choice === 'rollback') {
+        await rollback(context, projectDirectory, undo);
+        return userAborted(`rolled back ${projectDirectory}`);
+    }
+    context.report('info', `resume: ${resumeCommand(projectDirectory, context.cwd)}`);
+    for (const command of undo) {
+        context.report('info', `  ${describeUndo(command)}`);
+    }
+    return operationFailed(reason);
+}
+async function rollback(context, projectDirectory, commands) {
+    for (const command of commands) {
+        if (command.manual) {
+            context.report('warning', `not undone: ${command.purpose}. Run it yourself if you want to: ${describeCommand(command)}`);
+            continue;
+        }
+        // Rollback is ordered newest first, so the steps cannot run in parallel.
+        // eslint-disable-next-line no-await-in-loop
+        const result = await context.run(command.executable, command.arguments, {
+            env: context.env,
+        });
+        context.report(result.code === 0 ? 'success' : 'warning', `${command.purpose}${result.code === 0 ? '' : ` — failed: ${outputOf(result)}`}`);
+    }
+    await reportWorktrunkTrash(context, projectDirectory);
+}
+/**
+ * `wt remove` keeps a copy of what it removed, which is a good safety net and a
+ * bad surprise. When the folder survives the rollback, say the copy is there and
+ * whose it is, rather than deleting someone else's undo behind their back.
+ */
+async function reportWorktrunkTrash(context, projectDirectory) {
+    const trash = join(projectDirectory, '.git', 'wt', 'trash');
+    try {
+        await stat(trash);
+    }
+    catch {
+        return;
+    }
+    context.report('info', `worktrunk kept a copy of the removed worktree in ${trash}; delete it once you are sure you do not need it`);
+}
+function describeCommand(command) {
+    return `${command.executable} ${command.arguments.join(' ')}`;
+}
+function describeUndo(command) {
+    return `${command.executable} ${command.arguments.join(' ')}   # ${command.purpose}`;
+}
+async function writeConfig(worktree, settings) {
+    await mkdir(join(worktree, '.config'), { recursive: true });
+    await writeFile(join(worktree, configPath), compose(settings));
+}
+export async function readExistingConfig(worktree) {
+    try {
+        return await readFile(join(worktree, configPath), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function reportPreview(context, preview) {
+    for (const [label, value] of [
+        ['session', preview.session],
+        ['port', preview.port],
+        ['url', preview.url],
+    ]) {
+        if (value !== undefined) {
+            context.report('info', `${label} ${value}`);
+        }
+    }
+}
+export async function folderState(path) {
+    try {
+        const entries = await readdir(path);
+        return entries.every(entry => ignorable.has(entry)) ? 'empty' : 'occupied';
+    }
+    catch {
+        return 'missing';
+    }
+}
+const ignorable = new Set(['.DS_Store', '.localized', 'Thumbs.db']);
+export function createContext(flags, tools, dependencies) {
+    const report = dependencies.report ??
+        ((kind, line) => {
+            reportStep(kind, line);
+        });
+    return {
+        cwd: dependencies.cwd ?? process.cwd(),
+        env: dependencies.env,
+        git: { gitPath: tools.git.path, run: dependencies.run },
+        attach: dependencies.attach ?? runAttached,
+        run: dependencies.run ?? runCommand,
+        report,
+        interactive: dependencies.interactive ??
+            (supportsInteractiveInput() && !(flags.yes ?? false)),
+        prompts: dependencies.prompts,
+        collect: dependencies.collect ?? collectSettings,
+        now: dependencies.now ?? (() => new Date()),
+        invocation: dependencies.invocation ?? {
+            executable: 'trunk',
+            arguments: process.argv.slice(2),
+        },
+        tools,
+        flags,
+        journal: new Journal(),
+        wtPath: tools.wt.path ?? 'wt',
+    };
+}
+export function today(date) {
+    return date.toISOString().slice(0, 10);
+}
+export function outputOf(result) {
+    return result.stderr.trim() || result.stdout.trim() || 'no output';
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/core/platform.d.ts

@@ -0,0 +1,10 @@
+import { type Outcome } from './result.js';
+/** Returns an Outcome to stop on, or undefined when the platform is supported. */
+export declare function guardPlatform(platform?: NodeJS.Platform): Outcome | undefined;
+/**
+ * Whether trunk can show an interactive form. Ink puts the terminal into raw
+ * mode to read keys, which needs more than a TTY: a process whose stdin is a
+ * pipe, or a terminal that does not support it, throws on mount. Checking first
+ * means the user gets the re-run command instead of a React stack trace.
+ */
+export declare function supportsInteractiveInput(stdin?: NodeJS.ReadStream): boolean;

package/dist/core/platform.js

@@ -0,0 +1,26 @@
+/**
+ * The one hard platform rule. Everything trunk generates is POSIX shell run by
+ * tmux and wt hooks, which native Windows cannot execute; WSL reports itself as
+ * linux and is fine.
+ */
+import process from 'node:process';
+import { exitCodes } from './result.js';
+/** Returns an Outcome to stop on, or undefined when the platform is supported. */
+export function guardPlatform(platform = process.platform) {
+    if (platform !== 'win32') {
+        return undefined;
+    }
+    return {
+        code: exitCodes.unsupportedEnvironment,
+        message: 'trunk supports macOS and Linux (including WSL).',
+    };
+}
+/**
+ * Whether trunk can show an interactive form. Ink puts the terminal into raw
+ * mode to read keys, which needs more than a TTY: a process whose stdin is a
+ * pipe, or a terminal that does not support it, throws on mount. Checking first
+ * means the user gets the re-run command instead of a React stack trace.
+ */
+export function supportsInteractiveInput(stdin = process.stdin) {
+    return Boolean(stdin.isTTY) && typeof stdin.setRawMode === 'function';
+}

package/dist/core/prefix.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The tmux session prefix. Sessions are named `<prefix>_<branch>`, so the prefix
+ * is what keeps one repository's sessions apart from another's, and it has to
+ * survive tmux's own naming rules.
+ */
+export type PrefixValidation = Readonly<{
+    valid: true;
+}> | Readonly<{
+    valid: false;
+    reason: string;
+}>;
+/**
+ * Suggests a prefix from a repository name: the first word in full, then the
+ * initial of each word after it (`acme-web-backend` becomes `acme-wb`). Short
+ * enough to read in a tmux status line, and stable for a given name.
+ *
+ * Two repositories can suggest the same prefix; the setup form shows the value
+ * so the user can change it.
+ */
+export declare function initials(name: string): string;
+/**
+ * Checks a prefix the user typed. Each rule explains itself, and nothing is
+ * silently rewritten: a surprising prefix is worse than an error message.
+ */
+export declare function validatePrefix(prefix: string): PrefixValidation;