@lawrence369/loop-cli 0.1.0

package/dist/terminal/iterm2-adapter.js

@@ -0,0 +1,120 @@
+/**
+ * iTerm2 adapter.
+ *
+ * Uses osascript with iTerm2's AppleScript API to create new sessions
+ * (tabs / splits) and run commands.  Supports activation (bring to front)
+ * and text injection via `write text`.
+ *
+ * Reference: https://iterm2.com/documentation-scripting.html
+ */
+import { execFile, spawn } from "node:child_process";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function osascript(script) {
+    return new Promise((resolve, reject) => {
+        execFile("osascript", ["-e", script], { timeout: 10_000 }, (err, stdout) => {
+            if (err)
+                return reject(err);
+            resolve((stdout ?? "").trim());
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class ITerm2Adapter {
+    mode = "iterm2";
+    capabilities = {
+        supportsActivate: true,
+        supportsInjection: true,
+        supportsSessionReuse: true,
+        supportsResize: false,
+    };
+    async launch(command, args, opts) {
+        // Sanitize for AppleScript: escape backslashes, quotes, AND newlines
+        // to prevent AppleScript injection via crafted arguments.
+        const escapeAS = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "").replace(/\r/g, "");
+        const escaped = [command, ...args].map(escapeAS).join(" ");
+        const cwd = escapeAS(opts.cwd);
+        // Create a new iTerm2 tab and run the command there.
+        const script = `
+      tell application "iTerm2"
+        activate
+        tell current window
+          set newTab to (create tab with default profile)
+          tell current session of newTab
+            write text "cd \\"${cwd}\\" && ${escaped}"
+          end tell
+        end tell
+      end tell
+    `;
+        await osascript(script);
+        // Spawn a local child process for lifecycle tracking, same pattern as
+        // NativeTerminalAdapter.
+        const child = spawn(command, args, {
+            cwd: opts.cwd,
+            env: {
+                ...process.env,
+                ...(opts.env ?? {}),
+                // Preserve iTerm2 session id so child processes can detect the terminal
+                ITERM_SESSION_ID: process.env.ITERM_SESSION_ID ?? "",
+                TERM_PROGRAM: process.env.TERM_PROGRAM ?? "",
+                TERM_PROGRAM_VERSION: process.env.TERM_PROGRAM_VERSION ?? "",
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const dataHandlers = [];
+        const exitHandlers = [];
+        child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            for (const h of dataHandlers)
+                h(text);
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            for (const h of dataHandlers)
+                h(text);
+        });
+        child.on("exit", (code) => {
+            const exitCode = code ?? 1;
+            for (const h of exitHandlers)
+                h(exitCode);
+        });
+        return {
+            pid: child.pid ?? 0,
+            write(data) {
+                child.stdin?.write(data);
+            },
+            resize(_cols, _rows) {
+                // iTerm2 resize via AppleScript is unreliable; no-op for now
+            },
+            kill() {
+                child.kill();
+            },
+            onData(handler) {
+                dataHandlers.push(handler);
+            },
+            onExit(handler) {
+                exitHandlers.push(handler);
+            },
+        };
+    }
+    async inject(processOrId, command) {
+        const escaped = command.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "").replace(/\r/g, "");
+        // Write text to the current iTerm2 session
+        const script = `
+      tell application "iTerm2"
+        tell current session of current window
+          write text "${escaped}"
+        end tell
+      end tell
+    `;
+        await osascript(script);
+        void processOrId;
+    }
+    async activate(_processOrId) {
+        await osascript('tell application "iTerm2" to activate');
+    }
+}
+//# sourceMappingURL=iterm2-adapter.js.map

package/dist/terminal/pty-adapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Internal PTY adapter (default fallback).
+ *
+ * Uses `node-pty` to spawn a pseudo-terminal without any visible terminal
+ * window — fully headless.  This is the most commonly used adapter and serves
+ * as the default when no specific terminal environment is detected.
+ *
+ * Ported from ufoo's adapters/internalPtyAdapter.js.
+ */
+import type { AdapterLaunchOptions, LaunchedProcess, TerminalAdapter, TerminalCapabilities } from "./adapter.js";
+import type { LaunchMode } from "./detect.js";
+export declare class PtyAdapter implements TerminalAdapter {
+    readonly mode: LaunchMode;
+    readonly capabilities: TerminalCapabilities;
+    launch(command: string, args: string[], opts: AdapterLaunchOptions): Promise<LaunchedProcess>;
+    inject(_processOrId: number | string, command: string): Promise<void>;
+}
+//# sourceMappingURL=pty-adapter.d.ts.map

package/dist/terminal/pty-adapter.js

@@ -0,0 +1,84 @@
+/**
+ * Internal PTY adapter (default fallback).
+ *
+ * Uses `node-pty` to spawn a pseudo-terminal without any visible terminal
+ * window — fully headless.  This is the most commonly used adapter and serves
+ * as the default when no specific terminal environment is detected.
+ *
+ * Ported from ufoo's adapters/internalPtyAdapter.js.
+ */
+import pty from "node-pty";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class PtyAdapter {
+    mode = "pty";
+    capabilities = {
+        supportsActivate: false,
+        supportsInjection: true,
+        supportsSessionReuse: false,
+        supportsResize: true,
+    };
+    async launch(command, args, opts) {
+        const cols = opts.cols ?? process.stdout.columns ?? 80;
+        const rows = opts.rows ?? process.stdout.rows ?? 24;
+        const ptyProcess = pty.spawn(command, args, {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: opts.cwd,
+            env: { ...process.env, ...(opts.env ?? {}) },
+        });
+        const dataHandlers = [];
+        const exitHandlers = [];
+        ptyProcess.onData((data) => {
+            for (const h of dataHandlers)
+                h(data);
+        });
+        ptyProcess.onExit(({ exitCode }) => {
+            for (const h of exitHandlers)
+                h(exitCode);
+        });
+        return {
+            pid: ptyProcess.pid,
+            write(data) {
+                try {
+                    ptyProcess.write(data);
+                }
+                catch {
+                    // Process may have exited
+                }
+            },
+            resize(c, r) {
+                try {
+                    ptyProcess.resize(c, r);
+                }
+                catch {
+                    // Process may have exited
+                }
+            },
+            kill() {
+                try {
+                    ptyProcess.kill();
+                }
+                catch {
+                    // Already dead
+                }
+            },
+            onData(handler) {
+                dataHandlers.push(handler);
+            },
+            onExit(handler) {
+                exitHandlers.push(handler);
+            },
+        };
+    }
+    async inject(_processOrId, command) {
+        // For the internal PTY, injection is just writing to the PTY stdin.
+        // The caller must hold a reference to the LaunchedProcess to use write().
+        // This method exists for symmetry but cannot reach an arbitrary process.
+        void command;
+        throw new Error("PtyAdapter.inject requires direct LaunchedProcess.write()");
+    }
+}
+//# sourceMappingURL=pty-adapter.js.map

package/dist/terminal/terminal-adapter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Native Terminal.app adapter (macOS).
+ *
+ * Opens a new Terminal.app window via `osascript` and runs the given command
+ * inside it. Supports bringing the terminal to the foreground.
+ *
+ * Ported from ufoo's adapters/terminalAdapter.js.
+ */
+import type { AdapterLaunchOptions, LaunchedProcess, TerminalAdapter, TerminalCapabilities } from "./adapter.js";
+import type { LaunchMode } from "./detect.js";
+export declare class NativeTerminalAdapter implements TerminalAdapter {
+    readonly mode: LaunchMode;
+    readonly capabilities: TerminalCapabilities;
+    launch(command: string, args: string[], opts: AdapterLaunchOptions): Promise<LaunchedProcess>;
+    activate(_processOrId: number | string): Promise<void>;
+}
+//# sourceMappingURL=terminal-adapter.d.ts.map

package/dist/terminal/terminal-adapter.js

@@ -0,0 +1,94 @@
+/**
+ * Native Terminal.app adapter (macOS).
+ *
+ * Opens a new Terminal.app window via `osascript` and runs the given command
+ * inside it. Supports bringing the terminal to the foreground.
+ *
+ * Ported from ufoo's adapters/terminalAdapter.js.
+ */
+import { execFile, spawn } from "node:child_process";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function osascript(script) {
+    return new Promise((resolve, reject) => {
+        execFile("osascript", ["-e", script], { timeout: 10_000 }, (err, stdout) => {
+            if (err)
+                return reject(err);
+            resolve((stdout ?? "").trim());
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class NativeTerminalAdapter {
+    mode = "terminal";
+    capabilities = {
+        supportsActivate: true,
+        supportsInjection: false,
+        supportsSessionReuse: true,
+        supportsResize: false,
+    };
+    async launch(command, args, opts) {
+        // Build full shell command string (escaped for AppleScript)
+        const escaped = [command, ...args]
+            .map((a) => a.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "'\\''"))
+            .join(" ");
+        const cwd = opts.cwd.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "'\\''");
+        // Use osascript to open a new Terminal window and run the command
+        const script = `
+      tell application "Terminal"
+        activate
+        set newTab to do script "cd '${cwd}' && ${escaped}"
+      end tell
+    `;
+        await osascript(script);
+        // Terminal.app does not expose the child PID easily via AppleScript.
+        // We fall back to spawning the process ourselves so we can track I/O.
+        const child = spawn(command, args, {
+            cwd: opts.cwd,
+            env: { ...process.env, ...(opts.env ?? {}) },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const dataHandlers = [];
+        const exitHandlers = [];
+        child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            for (const h of dataHandlers)
+                h(text);
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            for (const h of dataHandlers)
+                h(text);
+        });
+        child.on("exit", (code) => {
+            const exitCode = code ?? 1;
+            for (const h of exitHandlers)
+                h(exitCode);
+        });
+        return {
+            pid: child.pid ?? 0,
+            write(data) {
+                child.stdin?.write(data);
+            },
+            resize(_cols, _rows) {
+                // Terminal.app does not support programmatic resize
+            },
+            kill() {
+                child.kill();
+            },
+            onData(handler) {
+                dataHandlers.push(handler);
+            },
+            onExit(handler) {
+                exitHandlers.push(handler);
+            },
+        };
+    }
+    async activate(_processOrId) {
+        await osascript('tell application "Terminal" to activate');
+    }
+}
+//# sourceMappingURL=terminal-adapter.js.map

package/dist/terminal/tmux-adapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * tmux pane adapter.
+ *
+ * Spawns commands inside tmux panes using `tmux split-window` and supports
+ * text injection via `tmux send-keys`.
+ *
+ * Ported from ufoo's adapters/tmuxAdapter.js.
+ */
+import type { AdapterLaunchOptions, LaunchedProcess, TerminalAdapter, TerminalCapabilities } from "./adapter.js";
+import type { LaunchMode } from "./detect.js";
+export declare class TmuxAdapter implements TerminalAdapter {
+    readonly mode: LaunchMode;
+    readonly capabilities: TerminalCapabilities;
+    launch(command: string, args: string[], opts: AdapterLaunchOptions): Promise<LaunchedProcess>;
+    inject(processOrId: number | string, command: string): Promise<void>;
+    activate(processOrId: number | string): Promise<void>;
+}
+//# sourceMappingURL=tmux-adapter.d.ts.map

package/dist/terminal/tmux-adapter.js

@@ -0,0 +1,127 @@
+/**
+ * tmux pane adapter.
+ *
+ * Spawns commands inside tmux panes using `tmux split-window` and supports
+ * text injection via `tmux send-keys`.
+ *
+ * Ported from ufoo's adapters/tmuxAdapter.js.
+ */
+import { execFile, spawn } from "node:child_process";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function tmuxCommand(args) {
+    return new Promise((resolve, reject) => {
+        execFile("tmux", args, { timeout: 10_000 }, (err, stdout) => {
+            if (err)
+                return reject(err);
+            resolve((stdout ?? "").trim());
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class TmuxAdapter {
+    mode = "tmux";
+    capabilities = {
+        supportsActivate: true,
+        supportsInjection: true,
+        supportsSessionReuse: true,
+        supportsResize: true,
+    };
+    async launch(command, args, opts) {
+        // Shell-quote each argument to prevent injection when tmux interprets
+        // the command string via the shell.
+        const shellQuote = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
+        const fullCommand = [command, ...args].map(shellQuote).join(" ");
+        // Split a new pane and run the command.  tmux split-window returns the
+        // pane ID (e.g. %5) when using -P -F.
+        const paneId = await tmuxCommand([
+            "split-window",
+            "-h",
+            "-c",
+            opts.cwd,
+            "-P",
+            "-F",
+            "#{pane_id}",
+            fullCommand,
+        ]);
+        // Resolve the PID of the initial command running inside the new pane.
+        let pid = 0;
+        try {
+            const pidStr = await tmuxCommand([
+                "display-message",
+                "-t",
+                paneId,
+                "-p",
+                "#{pane_pid}",
+            ]);
+            pid = Number.parseInt(pidStr, 10) || 0;
+        }
+        catch {
+            // Non-fatal — PID tracking is best-effort
+        }
+        // We also spawn the command locally so we can attach I/O handlers.
+        // This mirrors what the terminal-adapter does: osascript opens the
+        // window, but a local child_process tracks the lifecycle.
+        const child = spawn(command, args, {
+            cwd: opts.cwd,
+            env: { ...process.env, ...(opts.env ?? {}) },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const dataHandlers = [];
+        const exitHandlers = [];
+        child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            for (const h of dataHandlers)
+                h(text);
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            for (const h of dataHandlers)
+                h(text);
+        });
+        child.on("exit", (code) => {
+            const exitCode = code ?? 1;
+            for (const h of exitHandlers)
+                h(exitCode);
+        });
+        const effectivePid = child.pid ?? pid;
+        return {
+            pid: effectivePid,
+            write(data) {
+                child.stdin?.write(data);
+            },
+            resize(cols, rows) {
+                // Resize the tmux pane
+                tmuxCommand(["resize-pane", "-t", paneId, "-x", String(cols), "-y", String(rows)]).catch(() => {
+                    // Resize failure is non-fatal
+                });
+            },
+            kill() {
+                child.kill();
+                // Also kill the tmux pane to avoid orphans
+                tmuxCommand(["kill-pane", "-t", paneId]).catch(() => {
+                    // Best-effort cleanup
+                });
+            },
+            onData(handler) {
+                dataHandlers.push(handler);
+            },
+            onExit(handler) {
+                exitHandlers.push(handler);
+            },
+        };
+    }
+    async inject(processOrId, command) {
+        const target = String(processOrId);
+        // Use tmux send-keys to inject text. We send the text first, then Enter.
+        await tmuxCommand(["send-keys", "-t", target, command, "Enter"]);
+    }
+    async activate(processOrId) {
+        const target = String(processOrId);
+        await tmuxCommand(["select-pane", "-t", target]);
+    }
+}
+//# sourceMappingURL=tmux-adapter.js.map

package/dist/ui/banner.d.ts

@@ -0,0 +1,3 @@
+export declare function renderBanner(): string;
+export declare function renderEngineStatus(): void;
+//# sourceMappingURL=banner.d.ts.map

package/dist/ui/banner.js

@@ -0,0 +1,145 @@
+import gradient from "gradient-string";
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { orange, gBlue, gGreen, dim, bold } from "./colors.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"));
+        return `v${pkg.version}`;
+    }
+    catch {
+        return "v0.0.0";
+    }
+}
+// 5-line block-letter logo for "loop"
+const LARGE_LOGO = [
+    " ██╗      ██████╗  ██████╗ ██████╗ ",
+    " ██║     ██╔═══██╗██╔═══██╗██╔══██╗",
+    " ██║     ██║   ██║██║   ██║██████╔╝",
+    " ██║     ██║   ██║██║   ██║██╔═══╝ ",
+    " ███████╗╚██████╔╝╚██████╔╝██║     ",
+    " ╚══════╝ ╚═════╝  ╚═════╝ ╚═╝     ",
+];
+const loopGradient = gradient(["#F07623", "#4285F4", "#10A37F"]);
+function detectEngines() {
+    const engines = [
+        { cmd: "claude", label: "Claude", colorFn: orange },
+        { cmd: "gemini", label: "Gemini", colorFn: gBlue },
+        { cmd: "codex", label: "Codex", colorFn: gGreen },
+    ];
+    return engines.map(({ cmd, label, colorFn }) => {
+        let version = null;
+        try {
+            version = execFileSync(cmd, ["--version"], {
+                encoding: "utf-8",
+                timeout: 5000,
+            }).trim();
+        }
+        catch {
+            // not installed
+        }
+        return { name: cmd, label, version, colorFn };
+    });
+}
+export function renderBanner() {
+    const cols = process.stdout.columns || 80;
+    const engines = detectEngines();
+    if (cols >= 50) {
+        return renderLarge(cols, engines);
+    }
+    else {
+        return renderCompact(cols, engines);
+    }
+}
+export function renderEngineStatus() {
+    const engines = detectEngines();
+    for (const e of engines) {
+        const dot = e.version ? e.colorFn("\u25CF") : dim("\u25CB");
+        const label = e.version ? e.colorFn(e.label) : dim(e.label);
+        const ver = e.version ? dim(` (${e.version})`) : dim(" (not found)");
+        console.log(`   ${dot} ${label}${ver}`);
+    }
+}
+function renderLarge(cols, engines) {
+    const VERSION = getVersion();
+    const maxLogoWidth = Math.max(...LARGE_LOGO.map((l) => l.length));
+    const boxWidth = maxLogoWidth + 6;
+    const hBar = "\u2550".repeat(boxWidth - 2);
+    const frameLine = (content, visibleLen) => {
+        const vLen = visibleLen ?? content.replace(/\x1b\[[0-9;]*m/g, "").length;
+        const padding = Math.max(0, boxWidth - 4 - vLen);
+        return `  \u2551  ${content}${" ".repeat(padding)}\u2551`;
+    };
+    const emptyLine = frameLine("", 0);
+    // Apply gradient to logo lines
+    const logoLines = LARGE_LOGO.map((line) => {
+        const padded = line + " ".repeat(maxLogoWidth - line.length);
+        const gradientLine = loopGradient(padded);
+        return frameLine(gradientLine, maxLogoWidth);
+    });
+    // Tagline + version on same line
+    const tagline = "Iterative multi-engine AI orchestration";
+    const version = VERSION;
+    const innerWidth = boxWidth - 4;
+    const tagVersionGap = Math.max(1, innerWidth - tagline.length - version.length);
+    const tagVersionLine = `  \u2551  ${dim(tagline)}${" ".repeat(tagVersionGap)}${bold(version)}\u2551`;
+    // Engine status lines
+    const engineLines = engines.map((e) => {
+        const dot = e.version ? e.colorFn("\u25CF") : dim("\u25CB");
+        const label = e.version ? e.colorFn(e.label) : dim(e.label);
+        const ver = e.version ? dim(` (${e.version})`) : dim(" (not found)");
+        const content = `   ${dot} ${label}${ver}`;
+        const visLen = 5 + e.label.length + (e.version ? ` (${e.version})`.length : " (not found)".length);
+        return frameLine(content, visLen);
+    });
+    // Build engine header
+    const engLabel = "  Engines";
+    const engLabelLine = `  \u2551${dim(engLabel)}${" ".repeat(Math.max(0, boxWidth - 2 - engLabel.length))}\u2551`;
+    // Adapt to small columns by not rendering if too narrow
+    if (cols < boxWidth + 4) {
+        return renderCompact(cols, engines);
+    }
+    return [
+        "",
+        `  \u2554${hBar}\u2557`,
+        emptyLine,
+        ...logoLines,
+        emptyLine,
+        tagVersionLine,
+        emptyLine,
+        `  \u2560${hBar}\u2563`,
+        engLabelLine,
+        emptyLine,
+        ...engineLines,
+        emptyLine,
+        `  \u255A${hBar}\u255D`,
+        "",
+    ].join("\n");
+}
+function renderCompact(cols, engines) {
+    const VERSION = getVersion();
+    const boxWidth = Math.min(cols - 2, 40);
+    const hBar = "\u2550".repeat(Math.max(0, boxWidth - 2));
+    const engineDots = engines
+        .map((e) => {
+        const dot = e.version ? e.colorFn("\u25CF") : dim("\u25CB");
+        return `${dot} ${e.version ? e.colorFn(e.label) : dim(e.label)}`;
+    })
+        .join("  ");
+    const title = loopGradient("\u25C8 loop");
+    const version = bold(VERSION);
+    return [
+        "",
+        `  \u2554${hBar}\u2557`,
+        `  \u2551  ${title}  ${version}${" ".repeat(Math.max(0, boxWidth - 20))}\u2551`,
+        `  \u2551  ${dim("AI orchestration")}${" ".repeat(Math.max(0, boxWidth - 22))}\u2551`,
+        `  \u2560${hBar}\u2563`,
+        `  \u2551  ${engineDots}${" ".repeat(Math.max(0, boxWidth - 30))}\u2551`,
+        `  \u255A${hBar}\u255D`,
+        "",
+    ].join("\n");
+}
+//# sourceMappingURL=banner.js.map

package/dist/ui/colors.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Brand colors and ANSI formatting helpers.
+ *
+ * Uses raw ANSI escape codes for zero external dependencies.
+ */
+/** Claude brand orange (#F07623) */
+export declare const claude: (s: string) => string;
+/** Gemini brand blue (#4285F4) */
+export declare const gemini: (s: string) => string;
+/** Codex brand green (#10A37F) */
+export declare const codex: (s: string) => string;
+/** Loop brand cyan (#00D4FF) */
+export declare const loop: (s: string) => string;
+/** Green for success messages */
+export declare const success: (s: string) => string;
+/** Red for error messages */
+export declare const error: (s: string) => string;
+/** Yellow for warnings */
+export declare const warn: (s: string) => string;
+/** Gray / dim text */
+export declare const dim: (s: string) => string;
+/** Bold text */
+export declare const bold: (s: string) => string;
+export declare const orange: (s: string) => string;
+export declare const gBlue: (s: string) => string;
+export declare const gGreen: (s: string) => string;
+export declare const red: (s: string) => string;
+export declare const green: (s: string) => string;
+export declare const yellow: (s: string) => string;
+export declare const cyan: (s: string) => string;
+export declare const blue: (s: string) => string;
+/**
+ * Return the brand-color function for an engine name.
+ * Falls back to `loop` cyan for unknown engines.
+ */
+export declare function brandColor(engine: string): (s: string) => string;
+/**
+ * Format a byte count for human-readable display.
+ */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=colors.d.ts.map