@cod3vil/trunk 0.1.1

package/dist/core/gh.js

@@ -0,0 +1,101 @@
+/**
+ * Publishing the setup branch. `gh` is optional throughout: without it, or
+ * against a host it cannot speak to, trunk pushes and prints the compare URL
+ * so the user can open the pull request themselves.
+ */
+import { runCommand } from './process.js';
+/**
+ * `gh` only authenticates against GitHub, so an SSH alias is resolved to its
+ * real host before deciding. A non-GitHub remote still gets a push and a URL.
+ */
+export function canOpenPullRequest(remote, ghInstalled) {
+    return (ghInstalled && remote.kind === 'hosted' && remote.realHost === 'github.com');
+}
+/** Where the user opens the pull request when trunk cannot do it for them. */
+export function compareUrl(remote, branch) {
+    if (remote.kind !== 'hosted') {
+        return undefined;
+    }
+    return `https://${remote.realHost}/${remote.owner}/${remote.repo}/compare/${encodeURIComponent(branch)}?expand=1`;
+}
+export async function pushBranch(worktreePath, branch, options = {}) {
+    return (options.run ?? runCommand)(options.gitPath ?? 'git', ['-C', worktreePath, 'push', '-u', 'origin', branch], { env: options.env });
+}
+/**
+ * `--fill` reuses the commit message, which is why the commit body is written
+ * for teammates: it becomes the pull request description.
+ */
+export async function createPullRequest(worktreePath, options = {}) {
+    return (options.run ?? runCommand)(options.ghPath ?? 'gh', ['pr', 'create', '--fill'], { cwd: worktreePath, env: options.env });
+}
+/** The two commands trunk prints when it stops after the commit. */
+export function publishCommands(branch, withPullRequest) {
+    const commands = [`git push -u origin ${branch}`];
+    if (withPullRequest) {
+        commands.push('gh pr create --fill');
+    }
+    return Object.freeze(commands);
+}
+/**
+ * The accounts a repository can be created under: the signed-in user first,
+ * then the organisations they belong to. An empty list means gh could not
+ * answer, which the caller treats as "ask for the owner instead of guessing".
+ */
+export async function listOwners(options = {}) {
+    const run = options.run ?? runCommand;
+    const gh = options.ghPath ?? 'gh';
+    const [user, orgs] = await Promise.all([
+        run(gh, ['api', 'user', '--jq', '.login'], { env: options.env }),
+        run(gh, ['api', 'user/orgs', '--jq', '.[].login'], { env: options.env }),
+    ]);
+    const owners = [];
+    const login = user.code === 0 ? user.stdout.trim() : '';
+    if (login) {
+        owners.push(Object.freeze({ login, kind: 'user' }));
+    }
+    if (orgs.code === 0) {
+        for (const line of orgs.stdout.split(/\r?\n/)) {
+            const value = line.trim();
+            if (value) {
+                owners.push(Object.freeze({ login: value, kind: 'org' }));
+            }
+        }
+    }
+    return Object.freeze(owners);
+}
+/** Which account gh would act as, for the confirmation and for auth errors. */
+export async function activeAccount(options = {}) {
+    const result = await (options.run ?? runCommand)(options.ghPath ?? 'gh', ['api', 'user', '--jq', '.login'], { env: options.env });
+    return result.code === 0 ? result.stdout.trim() || undefined : undefined;
+}
+/**
+ * Creates the repository and nothing else: no push, no clone, no source. trunk
+ * builds the local side itself, so gh only has to make the remote exist.
+ */
+export async function createRepository(owner, name, options = {}) {
+    return (options.run ?? runCommand)(options.ghPath ?? 'gh', [
+        'repo',
+        'create',
+        `${owner}/${name}`,
+        `--${options.visibility ?? 'private'}`,
+        '--disable-wiki',
+    ], { env: options.env });
+}
+/** What to run by hand; trunk never deletes a remote repository itself. */
+export function deleteRepositoryCommand(owner, name) {
+    return `gh repo delete ${owner}/${name} --yes`;
+}
+/**
+ * The SSH URL to use for a new remote. gh reports an https URL, but someone
+ * with several accounts reaches each through its own ssh alias, so the alias
+ * whose resolved host matches is preferred — and among those, one a sibling
+ * project already uses, since that is demonstrably the right account.
+ */
+export function sshRemoteUrl(owner, name, options) {
+    const { realHost, aliases, siblingHosts = [] } = options;
+    const matching = Object.entries(aliases)
+        .filter(([, hostName]) => hostName.toLowerCase() === realHost.toLowerCase())
+        .map(([alias]) => alias);
+    const preferred = matching.find(alias => siblingHosts.includes(alias)) ?? matching[0];
+    return `git@${preferred ?? realHost}:${owner}/${name}.git`;
+}

package/dist/core/git.d.ts

@@ -0,0 +1,79 @@
+import { type AttachedRunner, type CommandResult, type CommandRunner } from './process.js';
+export type GitOptions = Readonly<{
+    gitPath?: string;
+    run?: CommandRunner;
+}>;
+export declare class GitCommandError extends Error {
+    readonly arguments: readonly string[];
+    readonly result: CommandResult;
+    constructor(arguments_: readonly string[], result: CommandResult);
+}
+export declare function runGit(arguments_: readonly string[], options?: GitOptions): Promise<CommandResult>;
+/**
+ * The repository's shared git directory. For a linked worktree this is the main
+ * one rather than the worktree's own, which is what identifies the project.
+ * Returns undefined when the path is not a repository at all.
+ */
+export declare function gitCommonDirectory(gitDirectory: string, options?: GitOptions): Promise<string | undefined>;
+export declare function isBareRepository(gitDirectory: string, options?: GitOptions): Promise<boolean | undefined>;
+/**
+ * The default branch of a repository that is already on disk. HEAD answers it
+ * normally; the git config key wt maintains covers a repository whose HEAD is
+ * detached. Never assume `main` — plenty of projects use something else.
+ */
+export declare function existingDefaultBranch(gitDirectory: string, options?: GitOptions): Promise<string | undefined>;
+/** The refspec a bare clone leaves out, which `wt step copy-ignored` needs. */
+export declare const originFetchRefspec = "+refs/heads/*:refs/remotes/origin/*";
+/**
+ * Clones into `<project>/.git`, the layout trunk sets up: a bare repository
+ * with the worktrees as siblings rather than inside it.
+ */
+export declare function cloneBare(url: string, gitDirectory: string, options?: GitOptions & {
+    attach?: AttachedRunner;
+}): Promise<number>;
+/**
+ * A bare clone has no fetch refspec, so `origin/*` never appears and anything
+ * comparing against the remote silently sees nothing. Set it, then fetch once
+ * to populate the refs.
+ */
+export declare function configureOriginFetch(gitDirectory: string, options?: GitOptions): Promise<CommandResult>;
+/** Points the bare repository's HEAD at the branch the remote considers default. */
+export declare function setHeadBranch(gitDirectory: string, branch: string, options?: GitOptions): Promise<CommandResult>;
+/**
+ * Adds a worktree beside the bare repository, the sibling layout trunk sets up.
+ * `createBranch` starts a new branch from HEAD instead of checking out one that
+ * already exists.
+ */
+export declare function addWorktree(gitDirectory: string, path: string, branch: string, options?: GitOptions & {
+    createBranch?: boolean;
+}): Promise<CommandResult>;
+export type WorktreeEntry = Readonly<{
+    path: string;
+    branch?: string;
+}>;
+/**
+ * Every worktree with the branch it holds. Finding a worktree by its branch is
+ * the only reliable way to know where wt put one, since wt may place it beside
+ * the git directory rather than where trunk proposed.
+ */
+export declare function listWorktreeEntries(gitDirectory: string, options?: GitOptions): Promise<readonly WorktreeEntry[]>;
+/** Absolute worktree paths, used to check where wt actually put one. */
+export declare function listWorktrees(gitDirectory: string, options?: GitOptions): Promise<readonly string[]>;
+/**
+ * Commits one path and nothing else, so an unrelated file the user was already
+ * working on is never swept into trunk's commit.
+ */
+export declare function commitPath(worktreePath: string, path: string, message: string, options?: GitOptions): Promise<CommandResult>;
+/** Pulls the branch out of `ls-remote --symref` output: `ref: refs/heads/x HEAD`. */
+export declare function parseRemoteDefaultBranch(output: string): string | undefined;
+/**
+ * Asks the remote which branch its HEAD points at. This is the one call that
+ * needs network and credentials, so its raw git error is passed through
+ * untouched: for an auth failure that message is the actionable part.
+ */
+export declare function remoteDefaultBranch(url: string, options?: GitOptions): Promise<string>;
+/**
+ * Wraps {@link remoteDefaultBranch} with a per-run cache so one trunk run hits
+ * the network once per URL. Failures are evicted so a retry can succeed.
+ */
+export declare function createRemoteDefaultBranchResolver(options?: GitOptions): (url: string) => Promise<string>;

package/dist/core/git.js

@@ -0,0 +1,211 @@
+/**
+ * Thin wrappers over the git commands trunk needs to read. Every call passes an
+ * explicit `--git-dir` instead of changing directory, so a command can never be
+ * answered by whatever repository the process happens to sit in.
+ */
+import { isAbsolute, resolve } from 'node:path';
+import { runAttached, runCommand, } from './process.js';
+export class GitCommandError extends Error {
+    arguments;
+    result;
+    constructor(arguments_, result) {
+        const detail = result.stderr.trim() || result.stdout.trim() || 'unknown error';
+        super(`git ${arguments_.join(' ')} failed: ${detail}`);
+        this.name = 'GitCommandError';
+        this.arguments = arguments_;
+        this.result = result;
+    }
+}
+export async function runGit(arguments_, options = {}) {
+    return (options.run ?? runCommand)(options.gitPath ?? 'git', arguments_);
+}
+/**
+ * The repository's shared git directory. For a linked worktree this is the main
+ * one rather than the worktree's own, which is what identifies the project.
+ * Returns undefined when the path is not a repository at all.
+ */
+export async function gitCommonDirectory(gitDirectory, options = {}) {
+    const result = await runGit(['--git-dir', gitDirectory, 'rev-parse', '--git-common-dir'], options);
+    if (result.code !== 0) {
+        return undefined;
+    }
+    const value = result.stdout.trim();
+    if (!value) {
+        return undefined;
+    }
+    return isAbsolute(value) ? value : resolve(gitDirectory, value);
+}
+export async function isBareRepository(gitDirectory, options = {}) {
+    const result = await runGit(['--git-dir', gitDirectory, 'rev-parse', '--is-bare-repository'], options);
+    if (result.code !== 0) {
+        return undefined;
+    }
+    const value = result.stdout.trim();
+    return value === 'true' ? true : value === 'false' ? false : undefined;
+}
+/**
+ * The default branch of a repository that is already on disk. HEAD answers it
+ * normally; the git config key wt maintains covers a repository whose HEAD is
+ * detached. Never assume `main` — plenty of projects use something else.
+ */
+export async function existingDefaultBranch(gitDirectory, options = {}) {
+    const symbolic = await runGit(['--git-dir', gitDirectory, 'symbolic-ref', '--short', 'HEAD'], options);
+    if (symbolic.code === 0 && symbolic.stdout.trim()) {
+        return symbolic.stdout.trim();
+    }
+    const configured = await runGit(['--git-dir', gitDirectory, 'config', '--get', 'worktrunk.default-branch'], options);
+    return configured.code === 0 && configured.stdout.trim()
+        ? configured.stdout.trim()
+        : undefined;
+}
+/** The refspec a bare clone leaves out, which `wt step copy-ignored` needs. */
+export const originFetchRefspec = '+refs/heads/*:refs/remotes/origin/*';
+/**
+ * Clones into `<project>/.git`, the layout trunk sets up: a bare repository
+ * with the worktrees as siblings rather than inside it.
+ */
+export async function cloneBare(url, gitDirectory, options = {}) {
+    return (options.attach ?? runAttached)(options.gitPath ?? 'git', [
+        'clone',
+        '--bare',
+        '--progress',
+        url,
+        gitDirectory,
+    ]);
+}
+/**
+ * A bare clone has no fetch refspec, so `origin/*` never appears and anything
+ * comparing against the remote silently sees nothing. Set it, then fetch once
+ * to populate the refs.
+ */
+export async function configureOriginFetch(gitDirectory, options = {}) {
+    const configured = await runGit([
+        '--git-dir',
+        gitDirectory,
+        'config',
+        'remote.origin.fetch',
+        originFetchRefspec,
+    ], options);
+    if (configured.code !== 0) {
+        return configured;
+    }
+    return runGit(['--git-dir', gitDirectory, 'fetch', 'origin', '--prune'], options);
+}
+/** Points the bare repository's HEAD at the branch the remote considers default. */
+export async function setHeadBranch(gitDirectory, branch, options = {}) {
+    return runGit(['--git-dir', gitDirectory, 'symbolic-ref', 'HEAD', `refs/heads/${branch}`], options);
+}
+/**
+ * Adds a worktree beside the bare repository, the sibling layout trunk sets up.
+ * `createBranch` starts a new branch from HEAD instead of checking out one that
+ * already exists.
+ */
+export async function addWorktree(gitDirectory, path, branch, options = {}) {
+    const arguments_ = options.createBranch
+        ? ['worktree', 'add', '-b', branch, path]
+        : ['worktree', 'add', path, branch];
+    return runGit(['--git-dir', gitDirectory, ...arguments_], options);
+}
+/**
+ * Every worktree with the branch it holds. Finding a worktree by its branch is
+ * the only reliable way to know where wt put one, since wt may place it beside
+ * the git directory rather than where trunk proposed.
+ */
+export async function listWorktreeEntries(gitDirectory, options = {}) {
+    const result = await runGit(['--git-dir', gitDirectory, 'worktree', 'list', '--porcelain'], options);
+    if (result.code !== 0) {
+        return Object.freeze([]);
+    }
+    const entries = [];
+    let path;
+    let branch;
+    const flush = () => {
+        if (path) {
+            entries.push(Object.freeze({ path, branch }));
+        }
+        path = undefined;
+        branch = undefined;
+    };
+    for (const line of result.stdout.split(/\r?\n/)) {
+        if (line.startsWith('worktree ')) {
+            flush();
+            path = line.slice('worktree '.length).trim();
+        }
+        else if (line.startsWith('branch refs/heads/')) {
+            branch = line.slice('branch refs/heads/'.length).trim();
+        }
+    }
+    flush();
+    return Object.freeze(entries);
+}
+/** Absolute worktree paths, used to check where wt actually put one. */
+export async function listWorktrees(gitDirectory, options = {}) {
+    const result = await runGit(['--git-dir', gitDirectory, 'worktree', 'list', '--porcelain'], options);
+    if (result.code !== 0) {
+        return Object.freeze([]);
+    }
+    return Object.freeze(result.stdout
+        .split(/\r?\n/)
+        .filter(line => line.startsWith('worktree '))
+        .map(line => line.slice('worktree '.length).trim())
+        .filter(Boolean));
+}
+/**
+ * Commits one path and nothing else, so an unrelated file the user was already
+ * working on is never swept into trunk's commit.
+ */
+export async function commitPath(worktreePath, path, message, options = {}) {
+    const staged = await runGit(['-C', worktreePath, 'add', '--', path], options);
+    if (staged.code !== 0) {
+        return staged;
+    }
+    return runGit(['-C', worktreePath, 'commit', '--only', '--message', message, '--', path], options);
+}
+/** Pulls the branch out of `ls-remote --symref` output: `ref: refs/heads/x HEAD`. */
+export function parseRemoteDefaultBranch(output) {
+    for (const line of output.split(/\r?\n/)) {
+        const match = /^ref:\s+refs\/heads\/(.+?)\s+HEAD$/.exec(line.trim());
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+/**
+ * Asks the remote which branch its HEAD points at. This is the one call that
+ * needs network and credentials, so its raw git error is passed through
+ * untouched: for an auth failure that message is the actionable part.
+ */
+export async function remoteDefaultBranch(url, options = {}) {
+    const result = await runGit(['ls-remote', '--symref', url, 'HEAD'], options);
+    if (result.code !== 0) {
+        throw new GitCommandError(['ls-remote', '--symref', url, 'HEAD'], result);
+    }
+    const branch = parseRemoteDefaultBranch(result.stdout);
+    if (!branch) {
+        throw new Error(`Remote HEAD did not name a branch: ${url}`);
+    }
+    return branch;
+}
+/**
+ * Wraps {@link remoteDefaultBranch} with a per-run cache so one trunk run hits
+ * the network once per URL. Failures are evicted so a retry can succeed.
+ */
+export function createRemoteDefaultBranchResolver(options = {}) {
+    const cache = new Map();
+    return async (url) => {
+        const cached = cache.get(url);
+        if (cached) {
+            return cached;
+        }
+        const pending = remoteDefaultBranch(url, options);
+        cache.set(url, pending);
+        try {
+            return await pending;
+        }
+        catch (error) {
+            cache.delete(url);
+            throw error;
+        }
+    };
+}

package/dist/core/journal.d.ts

@@ -0,0 +1,54 @@
+export type JournalEntryKind = 
+/** The project folder itself, and whether trunk is the one that made it. */
+'folder' | 'bare-repo' | 'worktree'
+/** A worktree together with the branch created for it. */
+ | 'branch-worktree'
+/** A repository created on GitHub, which rollback never deletes. */
+ | 'github-repo';
+export type JournalEntry = Readonly<{
+    kind: JournalEntryKind;
+    path: string;
+    branch?: string;
+    /** Trails the description, e.g. `wt.toml uncommitted`. */
+    note?: string;
+}>;
+export type UndoCommand = Readonly<{
+    executable: string;
+    arguments: readonly string[];
+    /** What the command is for, shown when the user keeps the run instead. */
+    purpose: string;
+    /**
+     * Printed for the user to run, never run by trunk. Deleting a repository
+     * someone may already have pushed to is not trunk's call to make.
+     */
+    manual?: boolean;
+}>;
+export declare class Journal {
+    private readonly records;
+    /** Called before the step that creates the thing, never after. */
+    record(entry: JournalEntry): void;
+    /**
+     * Corrects an entry after the fact, for when wt placed a worktree somewhere
+     * other than where trunk proposed. Rollback has to target the real path.
+     */
+    relocate(from: string, to: string): void;
+    /** Adds a trailing note to the most recent matching entry. */
+    annotate(path: string, note: string): void;
+    get entries(): readonly JournalEntry[];
+    get isEmpty(): boolean;
+    /** True only when trunk created the folder, which gates removing it. */
+    get createdFolder(): string | undefined;
+    /**
+     * The `created by this run:` block, with the paths in one column. Paths are
+     * shown relative to the working directory because that is how the user typed
+     * them and how the resume command will repeat them.
+     */
+    describe(workingDirectory: string): readonly string[];
+}
+/**
+ * How to undo the run, newest first: a worktree cannot be removed after the
+ * repository it belongs to is gone.
+ */
+export declare function undoCommands(journal: Journal, projectDirectory: string, wtPath?: string, gitPath?: string): readonly UndoCommand[];
+/** How to pick the run back up after keeping what it created. */
+export declare function resumeCommand(projectDirectory: string, workingDirectory: string): string;

package/dist/core/journal.js

@@ -0,0 +1,147 @@
+/**
+ * A record of what one run created, written before each step acts rather than
+ * after it succeeds. An interrupted run can then say exactly what exists and
+ * undo precisely that, without guessing from the state on disk.
+ *
+ * The journal only describes work; it never performs it. The command owns the
+ * running, so the order and the wording stay reviewable in one place.
+ */
+import { relative } from 'node:path';
+const descriptions = {
+    folder: 'project folder',
+    'bare-repo': 'bare repo',
+    worktree: 'worktree',
+    'branch-worktree': 'worktree + branch',
+    'github-repo': 'GitHub repository',
+};
+export class Journal {
+    records = [];
+    /** Called before the step that creates the thing, never after. */
+    record(entry) {
+        this.records.push(Object.freeze({ ...entry }));
+    }
+    /**
+     * Corrects an entry after the fact, for when wt placed a worktree somewhere
+     * other than where trunk proposed. Rollback has to target the real path.
+     */
+    relocate(from, to) {
+        const index = this.records.findIndex(record => record.path === from);
+        if (index !== -1) {
+            this.records[index] = Object.freeze({ ...this.records[index], path: to });
+        }
+    }
+    /** Adds a trailing note to the most recent matching entry. */
+    annotate(path, note) {
+        const entry = this.records.findLast(record => record.path === path);
+        if (entry) {
+            this.records[this.records.indexOf(entry)] = Object.freeze({
+                ...entry,
+                note,
+            });
+        }
+    }
+    get entries() {
+        return Object.freeze([...this.records]);
+    }
+    get isEmpty() {
+        return this.records.length === 0;
+    }
+    /** True only when trunk created the folder, which gates removing it. */
+    get createdFolder() {
+        return this.records.find(entry => entry.kind === 'folder')?.path;
+    }
+    /**
+     * The `created by this run:` block, with the paths in one column. Paths are
+     * shown relative to the working directory because that is how the user typed
+     * them and how the resume command will repeat them.
+     */
+    describe(workingDirectory) {
+        const rows = this.records.map(entry => ({
+            path: entry.kind === 'github-repo'
+                ? entry.path
+                : displayPath(entry.path, workingDirectory),
+            description: describeEntry(entry),
+        }));
+        const width = Math.max(0, ...rows.map(row => row.path.length));
+        return Object.freeze(rows.map(row => `${row.path.padEnd(width)}  ${row.description}`));
+    }
+}
+/**
+ * How to undo the run, newest first: a worktree cannot be removed after the
+ * repository it belongs to is gone.
+ */
+export function undoCommands(journal, projectDirectory, wtPath = 'wt', gitPath = 'git') {
+    const commands = [];
+    for (const entry of [...journal.entries].reverse()) {
+        switch (entry.kind) {
+            case 'branch-worktree': {
+                commands.push({
+                    executable: wtPath,
+                    arguments: [
+                        '-C',
+                        projectDirectory,
+                        'remove',
+                        entry.branch ?? '',
+                        '--no-hooks',
+                        '--yes',
+                    ],
+                    purpose: `remove the ${entry.branch ?? 'setup'} worktree and branch`,
+                });
+                break;
+            }
+            case 'worktree': {
+                commands.push({
+                    executable: gitPath,
+                    arguments: [
+                        '-C',
+                        projectDirectory,
+                        'worktree',
+                        'remove',
+                        entry.path,
+                        '--force',
+                    ],
+                    purpose: 'remove the default worktree',
+                });
+                break;
+            }
+            case 'folder': {
+                commands.push({
+                    executable: 'rm',
+                    arguments: ['-rf', entry.path],
+                    purpose: 'remove the project folder trunk created',
+                });
+                break;
+            }
+            case 'github-repo': {
+                commands.push({
+                    executable: 'gh',
+                    arguments: ['repo', 'delete', entry.path, '--yes'],
+                    purpose: 'delete the GitHub repository trunk created',
+                    manual: true,
+                });
+                break;
+            }
+            case 'bare-repo': {
+                // Removed with the folder; deleting it alone would strand the
+                // worktrees that point at it.
+                break;
+            }
+        }
+    }
+    return Object.freeze(commands);
+}
+/** How to pick the run back up after keeping what it created. */
+export function resumeCommand(projectDirectory, workingDirectory) {
+    return `trunk init ${displayPath(projectDirectory, workingDirectory)}`;
+}
+function describeEntry(entry) {
+    const description = descriptions[entry.kind];
+    return entry.note ? `${description} (${entry.note})` : description;
+}
+function displayPath(path, workingDirectory) {
+    const value = relative(workingDirectory, path);
+    if (!value) {
+        return '.';
+    }
+    return value.startsWith('.') ? value : `./${value}`;
+}

package/dist/core/log.d.ts

@@ -0,0 +1,8 @@
+import { type Outcome } from './result.js';
+type StepKind = 'success' | 'error' | 'info' | 'warning';
+export declare function step(kind: StepKind, message: string): void;
+/** One JSON line on stdout, for callers that parse trunk's output. */
+export declare function result(value: unknown): void;
+/** Prints a command's closing line. A message-less Outcome stays silent. */
+export declare function reportOutcome(outcome: Outcome): void;
+export {};

package/dist/core/log.js

@@ -0,0 +1,38 @@
+/**
+ * Plain-text progress reporting. Human-readable step lines go to stderr and
+ * machine-readable results to stdout, so a caller can pipe trunk's output
+ * somewhere useful while the person still sees what happened. It deliberately
+ * avoids Ink: `--yes` runs never mount a UI.
+ */
+import process from 'node:process';
+import { exitCodes } from './result.js';
+/** ANSI colour numbers, applied only when the terminal will render them. */
+const stepStyles = {
+    success: { symbol: '✓', color: 32 },
+    error: { symbol: '✗', color: 31 },
+    info: { symbol: '→', color: 36 },
+    warning: { symbol: '⚠', color: 33 },
+};
+export function step(kind, message) {
+    const { symbol, color } = stepStyles[kind];
+    const decoratedSymbol = shouldUseColor()
+        ? `\u001B[${color}m${symbol}\u001B[39m`
+        : symbol;
+    process.stderr.write(`${decoratedSymbol} ${message}\n`);
+}
+/** One JSON line on stdout, for callers that parse trunk's output. */
+export function result(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+/** Prints a command's closing line. A message-less Outcome stays silent. */
+export function reportOutcome(outcome) {
+    if (!outcome.message) {
+        return;
+    }
+    step(outcome.code === exitCodes.success ? 'success' : 'error', outcome.message);
+}
+function shouldUseColor() {
+    // Step lines go to stderr, so that is the stream whose TTY state matters.
+    // NO_COLOR only counts when it is set to a non-empty value.
+    return !process.env['NO_COLOR'] && Boolean(process.stderr.isTTY);
+}