@cod3vil/trunk 0.1.1

package/dist/core/arguments.js

@@ -0,0 +1,93 @@
+/**
+ * The command line surface: the help text and every flag trunk accepts. It is
+ * kept apart from `cli.tsx` so tests can parse an argument list without running
+ * a command, and so the help text stays the single description of the CLI.
+ */
+import process from 'node:process';
+import meow from 'meow';
+import { trunkVersion } from './version.js';
+/** Printed for `trunk` with no command and for `--help`. */
+export const helpText = `
+	Usage
+	  $ trunk clone <url> [dir]   set up a bare-layout project from a remote
+	  $ trunk init [dir]          set up an existing bare-layout project
+	  $ trunk new <name>          create a new project (optionally on GitHub)
+
+	Options
+	  --yes                 accept detected defaults, no form (needed without a TTY)
+	  --prefix <name>       tmux session prefix
+	  --pm <npm|pnpm|bun>   package manager
+	  --agents <a,b>        up to 4 of claude,codex,opencode,copilot,antigravity,pi
+	  --server/--no-server  dev server step
+	  --caddy/--no-caddy    Caddy route step
+	  --tmux/--no-tmux      tmux session hooks
+	  --copy/--no-copy      wt step copy-ignored
+	  --mc/--no-mc          \`wt mc\` alias
+	  --direct              commit on the current branch instead of chore/trunk-setup
+
+	Options for \`trunk new\`
+	  --remote/--no-remote  create the GitHub repository too
+	  --owner <name>        account or organisation that owns it
+	  --public              create it public instead of private
+`;
+/**
+ * Every flag is declared here even when a later phase is what reads it, so that
+ * an unknown flag is always an error rather than silently ignored.
+ */
+export const flagDefinitions = {
+    yes: {
+        type: 'boolean',
+    },
+    prefix: {
+        type: 'string',
+    },
+    pm: {
+        type: 'string',
+    },
+    agents: {
+        type: 'string',
+    },
+    server: {
+        type: 'boolean',
+    },
+    caddy: {
+        type: 'boolean',
+    },
+    tmux: {
+        type: 'boolean',
+    },
+    // Named for the wt step it controls, but spelled `--copy` on the command line.
+    copyIgnored: {
+        type: 'boolean',
+        alias: 'copy',
+    },
+    mc: {
+        type: 'boolean',
+    },
+    direct: {
+        type: 'boolean',
+    },
+    // `trunk new` only.
+    remote: {
+        type: 'boolean',
+    },
+    owner: {
+        type: 'string',
+    },
+    public: {
+        type: 'boolean',
+    },
+};
+export function parseArguments(argv = process.argv.slice(2)) {
+    return meow(helpText, {
+        importMeta: import.meta,
+        argv,
+        version: trunkVersion(),
+        // Booleans stay tri-state: a flag that was never passed reads as
+        // `undefined`, which is how the setup form tells "leave it to me" apart
+        // from an explicit `--no-server`.
+        booleanDefault: undefined,
+        allowUnknownFlags: false,
+        flags: flagDefinitions,
+    });
+}

package/dist/core/detect.d.ts

@@ -0,0 +1,28 @@
+export type PackageManager = 'npm' | 'pnpm' | 'bun';
+export type LockfilePackageManager = PackageManager | 'yarn';
+export type LockfileMatch = Readonly<{
+    file: string;
+    packageManager: LockfilePackageManager;
+}>;
+export type PackageDetection = Readonly<{
+    /** What trunk will use. Falls back to npm when nothing says otherwise. */
+    packageManager: PackageManager;
+    /** Every lockfile found, nearest directory first. */
+    matches: readonly LockfileMatch[];
+    /** Several package managers claim the same directory. */
+    ambiguous: boolean;
+    /** The guess is worth showing the user before it is written down. */
+    needsConfirmation: boolean;
+    /** Script names from package.json, used for the notes in the generated file. */
+    scripts: readonly string[];
+    /** Set when package.json is not at the repository root, e.g. `backend`. */
+    appDir?: string;
+    packageJson?: string;
+    warnings: readonly string[];
+}>;
+/**
+ * Inspects a worktree and reports how to install and run it. Nothing here ever
+ * fails: an unclear project produces a usable default plus warnings, and the
+ * setup form asks the user to confirm.
+ */
+export declare function detectPackageManager(worktreeRoot: string): Promise<PackageDetection>;

package/dist/core/detect.js

@@ -0,0 +1,169 @@
+/**
+ * Works out how a project installs and runs: which package manager its lockfile
+ * implies, which scripts it defines, and whether the app sits in a subdirectory
+ * rather than at the repository root.
+ */
+import { access, readdir, readFile } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+/**
+ * Order matters: when a directory holds several lockfiles the first match wins,
+ * so this doubles as the tie-break priority. Yarn is listed to be recognised and
+ * reported, not to be used.
+ */
+const lockfiles = [
+    { file: 'bun.lock', packageManager: 'bun' },
+    { file: 'bun.lockb', packageManager: 'bun' },
+    { file: 'pnpm-lock.yaml', packageManager: 'pnpm' },
+    { file: 'package-lock.json', packageManager: 'npm' },
+    { file: 'yarn.lock', packageManager: 'yarn' },
+];
+/**
+ * Inspects a worktree and reports how to install and run it. Nothing here ever
+ * fails: an unclear project produces a usable default plus warnings, and the
+ * setup form asks the user to confirm.
+ */
+export async function detectPackageManager(worktreeRoot) {
+    const warnings = [];
+    const packageDirectories = await findPackageDirectories(worktreeRoot);
+    const packageDirectory = packageDirectories[0] ?? worktreeRoot;
+    if (packageDirectories.length > 1) {
+        warnings.push(`Multiple package directories found (${packageDirectories
+            .map(directory => relativePath(worktreeRoot, directory))
+            .join(', ')}); using ${relativePath(worktreeRoot, packageDirectory)}.`);
+    }
+    // The lockfile usually sits with the package.json, but a repository whose app
+    // lives one level down often keeps it at the root instead. Search both, and
+    // let the deeper directory win when each has one.
+    const searchDirectories = packageDirectory === worktreeRoot
+        ? [packageDirectory]
+        : [packageDirectory, worktreeRoot];
+    const matchesByDirectory = await Promise.all(searchDirectories.map(async (directory) => findLockfiles(directory, worktreeRoot)));
+    const matches = matchesByDirectory.flat();
+    const chosen = matchesByDirectory.find(found => found.length > 0) ?? [];
+    const supportedMatch = chosen.find((match) => match.packageManager !== 'yarn');
+    const yarnFound = chosen.some(match => match.packageManager === 'yarn');
+    const packageManager = supportedMatch?.packageManager ?? 'npm';
+    const ambiguous = new Set(chosen.map(match => match.packageManager)).size > 1;
+    if (chosen.length > 1) {
+        warnings.push(`Multiple lockfiles found (${chosen
+            .map(match => match.file)
+            .join(', ')}); using ${packageManager}.`);
+    }
+    if (chosen.length > 0 && chosen !== matchesByDirectory[0]) {
+        warnings.push(`Lockfile ${chosen[0].file} sits at the repository root while package.json is in ${relativePath(worktreeRoot, packageDirectory)}.`);
+    }
+    if (yarnFound) {
+        warnings.push('Yarn is unsupported; falling back to npm when needed.');
+    }
+    if (matches.length === 0) {
+        warnings.push('No lockfile found; defaulting to npm.');
+    }
+    const packageJsonPath = join(packageDirectory, 'package.json');
+    const packageJsonFound = await pathExists(packageJsonPath);
+    const scripts = packageJsonFound
+        ? await readScripts(packageJsonPath, warnings)
+        : [];
+    const appDirectory = packageDirectories.length > 0 && packageDirectory !== worktreeRoot
+        ? relativePath(worktreeRoot, packageDirectory)
+        : undefined;
+    return Object.freeze({
+        packageManager,
+        matches: Object.freeze(matches),
+        ambiguous,
+        needsConfirmation: chosen.length !== 1 || yarnFound || packageDirectories.length > 1,
+        scripts: Object.freeze(scripts),
+        appDir: appDirectory,
+        packageJson: packageJsonFound
+            ? relativePath(worktreeRoot, packageJsonPath)
+            : undefined,
+        warnings: Object.freeze(warnings),
+    });
+}
+async function findLockfiles(directory, worktreeRoot) {
+    const found = await Promise.all(lockfiles.map(async (lockfile) => {
+        const path = join(directory, lockfile.file);
+        return (await pathExists(path))
+            ? Object.freeze({
+                file: relativePath(worktreeRoot, path),
+                packageManager: lockfile.packageManager,
+            })
+            : undefined;
+    }));
+    return found.filter((match) => match !== undefined);
+}
+/**
+ * Finds where the app lives: the root when it has a package.json, otherwise the
+ * directories one level down that do. Several matches are returned so the caller
+ * can say so; the list is sorted to keep the choice stable between runs.
+ */
+async function findPackageDirectories(root) {
+    if (await pathExists(join(root, 'package.json'))) {
+        return [root];
+    }
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return [];
+        }
+        throw error;
+    }
+    const directories = entries
+        .filter(
+    // Dependencies and tool directories carry package.json files of their
+    // own and are never the project's app.
+    entry => entry.isDirectory() &&
+        !entry.name.startsWith('.') &&
+        entry.name !== 'node_modules')
+        .map(entry => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+    const candidates = await Promise.all(directories.map(async (directory) => {
+        const path = join(root, directory);
+        return (await pathExists(join(path, 'package.json'))) ? path : undefined;
+    }));
+    return candidates.filter((candidate) => candidate !== undefined);
+}
+async function readScripts(path, warnings) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        if (!isRecord(value) || !isRecord(value['scripts'])) {
+            return [];
+        }
+        return Object.entries(value['scripts'])
+            .filter((entry) => typeof entry[1] === 'string')
+            .map(([name]) => name)
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`Could not read ${path}: ${message}`);
+        return [];
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function isMissingFileError(error) {
+    if (!(error instanceof Error) || !('code' in error)) {
+        return false;
+    }
+    return error.code === 'ENOENT' || error.code === 'ENOTDIR';
+}
+function relativePath(root, path) {
+    const value = relative(root, path).split(sep).join('/');
+    return value || '.';
+}

package/dist/core/diff.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A line diff for the one screen that shows one: the confirmation before an
+ * existing `wt.toml` is overwritten.
+ *
+ * Anything trunk cannot model is lost on overwrite — a repo-specific hook, a
+ * second alias, a comment someone wrote for their team. This is the user's only
+ * chance to notice, so removed lines have to be visible and countable.
+ */
+export type DiffLineKind = 'added' | 'removed' | 'context';
+export type DiffLine = Readonly<{
+    kind: DiffLineKind;
+    text: string;
+}>;
+export type Diff = Readonly<{
+    lines: readonly DiffLine[];
+    added: number;
+    removed: number;
+    /** True when the two texts are identical, so the screen can be skipped. */
+    unchanged: boolean;
+}>;
+/**
+ * Longest-common-subsequence diff. The files involved are a few hundred lines
+ * at most, so the quadratic table costs nothing and the output is minimal,
+ * which matters more here than speed.
+ */
+export declare function diffLines(before: string, after: string): Diff;
+/**
+ * The changed lines with a little surrounding context, so a long file does not
+ * bury what actually changed. Runs of unchanged lines longer than twice the
+ * context collapse to a single marker.
+ */
+export declare function collapseContext(diff: Diff, context?: number): ReadonlyArray<DiffLine | Readonly<{
+    kind: 'skipped';
+    count: number;
+}>>;
+/** `+`/`-`/space prefixes, for a terminal without colour. */
+export declare function formatDiff(diff: Diff, context?: number): readonly string[];

package/dist/core/diff.js

@@ -0,0 +1,140 @@
+/**
+ * A line diff for the one screen that shows one: the confirmation before an
+ * existing `wt.toml` is overwritten.
+ *
+ * Anything trunk cannot model is lost on overwrite — a repo-specific hook, a
+ * second alias, a comment someone wrote for their team. This is the user's only
+ * chance to notice, so removed lines have to be visible and countable.
+ */
+/**
+ * Longest-common-subsequence diff. The files involved are a few hundred lines
+ * at most, so the quadratic table costs nothing and the output is minimal,
+ * which matters more here than speed.
+ */
+export function diffLines(before, after) {
+    const source = splitLines(before);
+    const target = splitLines(after);
+    const common = longestCommonSubsequence(source, target);
+    const lines = [];
+    let added = 0;
+    let removed = 0;
+    let sourceIndex = 0;
+    let targetIndex = 0;
+    for (const anchor of common) {
+        while (sourceIndex < anchor.source) {
+            lines.push({ kind: 'removed', text: source[sourceIndex] });
+            removed += 1;
+            sourceIndex += 1;
+        }
+        while (targetIndex < anchor.target) {
+            lines.push({ kind: 'added', text: target[targetIndex] });
+            added += 1;
+            targetIndex += 1;
+        }
+        lines.push({ kind: 'context', text: source[sourceIndex] });
+        sourceIndex += 1;
+        targetIndex += 1;
+    }
+    while (sourceIndex < source.length) {
+        lines.push({ kind: 'removed', text: source[sourceIndex] });
+        removed += 1;
+        sourceIndex += 1;
+    }
+    while (targetIndex < target.length) {
+        lines.push({ kind: 'added', text: target[targetIndex] });
+        added += 1;
+        targetIndex += 1;
+    }
+    return Object.freeze({
+        lines: Object.freeze(lines.map(line => Object.freeze(line))),
+        added,
+        removed,
+        unchanged: added === 0 && removed === 0,
+    });
+}
+/**
+ * The changed lines with a little surrounding context, so a long file does not
+ * bury what actually changed. Runs of unchanged lines longer than twice the
+ * context collapse to a single marker.
+ */
+export function collapseContext(diff, context = 2) {
+    const keep = new Set();
+    for (const [index, line] of diff.lines.entries()) {
+        if (line.kind === 'context') {
+            continue;
+        }
+        for (let nearby = Math.max(0, index - context); nearby <= Math.min(diff.lines.length - 1, index + context); nearby += 1) {
+            keep.add(nearby);
+        }
+    }
+    const output = [];
+    let skipped = 0;
+    for (const [index, line] of diff.lines.entries()) {
+        if (keep.has(index)) {
+            if (skipped > 0) {
+                output.push(Object.freeze({ kind: 'skipped', count: skipped }));
+                skipped = 0;
+            }
+            output.push(line);
+        }
+        else {
+            skipped += 1;
+        }
+    }
+    if (skipped > 0) {
+        output.push(Object.freeze({ kind: 'skipped', count: skipped }));
+    }
+    return Object.freeze(output);
+}
+/** `+`/`-`/space prefixes, for a terminal without colour. */
+export function formatDiff(diff, context = 2) {
+    return Object.freeze(collapseContext(diff, context).map(line => {
+        switch (line.kind) {
+            case 'added': {
+                return `+ ${line.text}`;
+            }
+            case 'removed': {
+                return `- ${line.text}`;
+            }
+            case 'skipped': {
+                return `  … ${line.count} unchanged ${line.count === 1 ? 'line' : 'lines'}`;
+            }
+            default: {
+                return `  ${line.text}`;
+            }
+        }
+    }));
+}
+function splitLines(value) {
+    const lines = value.split(/\r?\n/);
+    // A trailing newline is a line terminator, not an empty final line.
+    return lines.at(-1) === '' ? lines.slice(0, -1) : lines;
+}
+function longestCommonSubsequence(source, target) {
+    const lengths = Array.from({ length: source.length + 1 }, () => Array.from({ length: target.length + 1 }, () => 0));
+    for (let row = source.length - 1; row >= 0; row -= 1) {
+        for (let column = target.length - 1; column >= 0; column -= 1) {
+            lengths[row][column] =
+                source[row] === target[column]
+                    ? lengths[row + 1][column + 1] + 1
+                    : Math.max(lengths[row + 1][column], lengths[row][column + 1]);
+        }
+    }
+    const anchors = [];
+    let row = 0;
+    let column = 0;
+    while (row < source.length && column < target.length) {
+        if (source[row] === target[column]) {
+            anchors.push(Object.freeze({ source: row, target: column }));
+            row += 1;
+            column += 1;
+        }
+        else if (lengths[row + 1][column] >= lengths[row][column + 1]) {
+            row += 1;
+        }
+        else {
+            column += 1;
+        }
+    }
+    return Object.freeze(anchors);
+}

package/dist/core/env.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Which tools this machine has. Nothing here is assumed to exist: every tool is
+ * looked up on PATH at run time, git and wt are the only hard requirements, and
+ * the rest merely shape the defaults trunk offers.
+ */
+import { type Stats } from 'node:fs';
+import { type AgentId } from './agents.js';
+import { type CommandRunner } from './process.js';
+import { type Outcome } from './result.js';
+export type Tool = Readonly<{
+    name: string;
+    path?: string;
+    version?: string;
+}>;
+export type ToolProbe = Readonly<{
+    git: Tool;
+    wt: Tool;
+    tmux: Tool;
+    caddy: Tool;
+    brew: Tool;
+    gh: Tool;
+    agents: Readonly<Record<AgentId, Tool>>;
+}>;
+export type SemanticVersion = Readonly<{
+    major: number;
+    minor: number;
+    patch: number;
+}>;
+export type ProbeOptions = Readonly<{
+    path?: string;
+    access?: (path: string, mode: number) => Promise<void>;
+    stat?: (path: string) => Promise<Pick<Stats, 'isFile'>>;
+    run?: CommandRunner;
+}>;
+/** The wt release trunk's templates were written against. Older only warns. */
+export declare const minimumWtVersion: Readonly<{
+    major: 0;
+    minor: 77;
+    patch: 0;
+}>;
+/**
+ * Looks up every tool trunk cares about in one pass. The options exist so tests
+ * can supply their own PATH, filesystem and command runner.
+ */
+export declare function probe(options?: ProbeOptions): Promise<ToolProbe>;
+/**
+ * `which`, done in-process. Walking PATH ourselves rather than shelling out
+ * means the answer does not depend on the user's shell, its aliases or its
+ * startup files, and it behaves the same when no shell exists at all.
+ */
+export declare function resolveExecutable(command: string, pathValue?: string, accessExecutable?: (path: string, mode: number) => Promise<void>, statPath?: (path: string) => Promise<Pick<Stats, 'isFile'>>): Promise<string | undefined>;
+/**
+ * Git and wt are the two tools trunk cannot work around. Everything else is
+ * optional and only turns a step off or softens a default.
+ */
+export declare function checkRequiredTools(tools: ToolProbe): Outcome | undefined;
+/** Reads a version out of a line like `wt v0.77.0`. */
+export declare function parseWtVersion(version: string | undefined): SemanticVersion | undefined;
+/**
+ * Warns when wt is older than the templates expect. Patch releases are ignored,
+ * and a version that cannot be parsed is left alone rather than guessed at.
+ */
+export declare function wtVersionWarning(version: string | undefined): string | undefined;

package/dist/core/env.js

@@ -0,0 +1,140 @@
+/**
+ * Which tools this machine has. Nothing here is assumed to exist: every tool is
+ * looked up on PATH at run time, git and wt are the only hard requirements, and
+ * the rest merely shape the defaults trunk offers.
+ */
+import { constants } from 'node:fs';
+import { access, stat } from 'node:fs/promises';
+import { delimiter, resolve } from 'node:path';
+import process from 'node:process';
+import { agentCommands } from './agents.js';
+import { runCommand } from './process.js';
+import { unsupportedEnvironment } from './result.js';
+/** The wt release trunk's templates were written against. Older only warns. */
+export const minimumWtVersion = Object.freeze({ major: 0, minor: 77, patch: 0 });
+/** Each tool spells its version query differently; brew's is too slow to ask. */
+const versionArguments = Object.freeze({
+    git: ['--version'],
+    wt: ['--version'],
+    tmux: ['-V'],
+    caddy: ['version'],
+    gh: ['--version'],
+});
+/**
+ * Looks up every tool trunk cares about in one pass. The options exist so tests
+ * can supply their own PATH, filesystem and command runner.
+ */
+export async function probe(options = {}) {
+    const pathValue = options.path ?? process.env['PATH'] ?? '';
+    const accessExecutable = options.access ?? access;
+    const statPath = options.stat ?? stat;
+    const run = options.run ?? runCommand;
+    const context = { pathValue, accessExecutable, statPath, run };
+    const toolNames = ['git', 'wt', 'tmux', 'caddy', 'brew', 'gh'];
+    const toolEntries = await Promise.all(toolNames.map(async (name) => [
+        name,
+        await probeTool(name, versionArguments[name], context),
+    ]));
+    const tools = Object.fromEntries(toolEntries);
+    const agentEntries = await Promise.all(Object.entries(agentCommands).map(async ([id, command]) => [id, await probeTool(command, undefined, context)]));
+    const agents = Object.freeze(Object.fromEntries(agentEntries));
+    return Object.freeze({ ...tools, agents });
+}
+/**
+ * `which`, done in-process. Walking PATH ourselves rather than shelling out
+ * means the answer does not depend on the user's shell, its aliases or its
+ * startup files, and it behaves the same when no shell exists at all.
+ */
+export async function resolveExecutable(command, pathValue = process.env['PATH'] ?? '', accessExecutable = access, statPath = stat) {
+    const directories = pathValue.split(delimiter);
+    const visit = async (index) => {
+        if (index >= directories.length) {
+            return undefined;
+        }
+        const directory = directories[index] ?? '';
+        // An empty PATH entry means the working directory, as in a POSIX shell.
+        const candidate = resolve(directory || '.', command);
+        try {
+            await accessExecutable(candidate, constants.X_OK);
+            const status = await statPath(candidate);
+            // Directories are executable too, so the file check is what matters.
+            if (status.isFile()) {
+                return candidate;
+            }
+            return await visit(index + 1);
+        }
+        catch {
+            return visit(index + 1);
+        }
+    };
+    return visit(0);
+}
+/**
+ * Git and wt are the two tools trunk cannot work around. Everything else is
+ * optional and only turns a step off or softens a default.
+ */
+export function checkRequiredTools(tools) {
+    const missing = [tools.git, tools.wt]
+        .filter(tool => tool.path === undefined)
+        .map(tool => tool.name);
+    if (missing.length === 0) {
+        return undefined;
+    }
+    return unsupportedEnvironment(`Missing required ${missing.length === 1 ? 'tool' : 'tools'}: ${missing.join(', ')}. Install Git and Worktrunk before continuing: https://worktrunk.dev`);
+}
+/** Reads a version out of a line like `wt v0.77.0`. */
+export function parseWtVersion(version) {
+    const match = /\b(?:wt\s+)?v?(\d+)\.(\d+)(?:\.(\d+))?\b/i.exec(version ?? '');
+    if (!match) {
+        return undefined;
+    }
+    return Object.freeze({
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3] ?? 0),
+    });
+}
+/**
+ * Warns when wt is older than the templates expect. Patch releases are ignored,
+ * and a version that cannot be parsed is left alone rather than guessed at.
+ */
+export function wtVersionWarning(version) {
+    const parsed = parseWtVersion(version);
+    if (!parsed) {
+        return undefined;
+    }
+    if (parsed.major > minimumWtVersion.major ||
+        (parsed.major === minimumWtVersion.major &&
+            parsed.minor >= minimumWtVersion.minor)) {
+        return undefined;
+    }
+    return `Worktrunk ${version} is older than the tested ${formatVersion(minimumWtVersion)}; generated templates may need adjustment.`;
+}
+async function probeTool(name, arguments_, context) {
+    const path = await resolveExecutable(name, context.pathValue, context.accessExecutable, context.statPath);
+    if (!path) {
+        return Object.freeze({ name });
+    }
+    if (!arguments_) {
+        return Object.freeze({ name, path });
+    }
+    try {
+        const result = await context.run(path, arguments_);
+        // Some tools print their version on stderr, and a version is never
+        // required, so a tool that fails this call still counts as present.
+        const version = firstLine(result.stdout) ?? firstLine(result.stderr);
+        return Object.freeze({ name, path, version });
+    }
+    catch {
+        return Object.freeze({ name, path });
+    }
+}
+function firstLine(value) {
+    return value
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .find(Boolean);
+}
+function formatVersion(version) {
+    return `v${version.major}.${version.minor}.${version.patch}`;
+}

package/dist/core/generate/aliases.d.ts

@@ -0,0 +1,7 @@
+/** Project-level convenience commands assembled from the enabled hooks. */
+import { type Settings } from '../settings.js';
+export declare function generateAliases(settings: Settings): string | undefined;
+export declare function upCommand(settings: Settings): string | undefined;
+export declare function urlAliasBody(settings: Settings): string;
+/** Keep this quoting aligned with Worktrunk's documented editor alias. */
+export declare const mcAliasBody = "WORKTRUNK_COMMIT__GENERATION__COMMAND='f=$(mktemp); printf \"\\n\\n\" > \"$f\"; sed \"s/^/# /\" >> \"$f\"; ${EDITOR:-vi} \"$f\" < /dev/tty > /dev/tty; grep -v \"^#\" \"$f\"' wt merge";