open-multi-agent-kit 0.78.0

package/dist/cli/theme/theme-registry.js

@@ -0,0 +1,336 @@
+/**
+ * CLI Theme — Built-in Theme Registry
+ * Maps semantic tokens to ANSI colors. Reuses src/theme/colors.ts exports.
+ */
+import { style } from "../../theme/colors.js";
+// --- omk (full brand) ---
+const omkPalette = {
+    name: "omk",
+    mode: "dark",
+    supportsColor: true,
+    render(token, text) {
+        switch (token) {
+            case "success": return style.mint(text);
+            case "warning": return style.orange(text);
+            case "error": return style.red(text);
+            case "info": return style.blue(text);
+            case "agent": return style.purple(text);
+            case "task": return style.pink(text);
+            case "tool": return style.cyan(text);
+            case "header": return style.purpleBold(text);
+            case "subheader": return style.blueBold(text);
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return style.gray(text);
+            case "bullet": return style.purple("• " + text);
+            case "labelKey": return style.dim + text + style.reset;
+            case "labelValue": return text;
+            default: return text;
+        }
+    },
+};
+// --- night-city (README control image / Night City Ops Console) ---
+const nightCityPalette = {
+    name: "night-city",
+    mode: "dark",
+    supportsColor: true,
+    render(semantic, text) {
+        switch (semantic) {
+            case "success": return style.mintBold(text);
+            case "warning": return style.orangeBold(text);
+            case "error": return style.redBold(text);
+            case "info": return style.blueBold(text);
+            case "agent": return style.lightPurple(text);
+            case "task": return style.pink(text);
+            case "tool": return style.mint(text);
+            case "header": return style.blueBold(text);
+            case "subheader": return style.mintBold(text);
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return style.gray(text);
+            case "bullet": return style.blue("◇ " + text);
+            case "labelKey": return style.gray(text);
+            case "labelValue": return style.cream(text);
+            default: return text;
+        }
+    },
+};
+// --- green-rain (phosphor signal console) ---
+const greenRainPalette = {
+    name: "green-rain",
+    mode: "dark",
+    supportsColor: true,
+    render(semantic, text) {
+        switch (semantic) {
+            case "success": return style.phosphorBold(text);
+            case "warning": return style.orange(text);
+            case "error": return style.red(text);
+            case "info": return style.phosphor(text);
+            case "agent": return style.phosphorBold(text);
+            case "task": return style.phosphor(text);
+            case "tool": return style.blue(text);
+            case "header": return style.phosphorBold(text);
+            case "subheader": return style.phosphor(text);
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return style.matrixDark(text);
+            case "bullet": return style.phosphor("◆ " + text);
+            case "labelKey": return style.dim + text + style.reset;
+            case "labelValue": return style.phosphor(text);
+            default: return text;
+        }
+    },
+};
+// --- matrix (iconic Matrix rain code console) ---
+const matrixPalette = {
+    name: "matrix",
+    mode: "dark",
+    supportsColor: true,
+    render(semantic, text) {
+        switch (semantic) {
+            case "success": return style.rainGreenBold(text);
+            case "warning": return style.rainWarning(text);
+            case "error": return style.rainError(text);
+            case "info": return style.rainGreenDim(text);
+            case "agent": return style.rainGreenBold(text);
+            case "task": return style.rainGreen(text);
+            case "tool": return style.rainGreenDim(text);
+            case "header": return style.rainGreenBold(text);
+            case "subheader": return style.rainGreen(text);
+            case "dim": return style.rainGreenDim(text);
+            case "bold": return style.rainGreenBold(text);
+            case "reset": return style.reset + text;
+            case "separator": return style.rainGreenDim(text);
+            case "bullet": return style.rainGreen("├─ " + text);
+            case "labelKey": return style.rainGreenDim(text);
+            case "labelValue": return style.rainGreen(text);
+            default: return style.rainGreen(text);
+        }
+    },
+};
+// --- neon-circuit (high-energy neon terminal palette) ---
+const neonCircuitPalette = {
+    name: "neon-circuit",
+    mode: "dark",
+    supportsColor: true,
+    render(semantic, text) {
+        switch (semantic) {
+            case "success": return style.mint(text);
+            case "warning": return style.skin(text);
+            case "error": return style.hotPink(text);
+            case "info": return style.cyanBold(text);
+            case "agent": return style.purpleBold(text);
+            case "task": return style.pinkBold(text);
+            case "tool": return style.cyan(text);
+            case "header": return style.pinkBold(text);
+            case "subheader": return style.lightPurple(text);
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return style.gray(text);
+            case "bullet": return style.pink("⟐ " + text);
+            case "labelKey": return style.gray(text);
+            case "labelValue": return style.cream(text);
+            default: return text;
+        }
+    },
+};
+// --- rust-forge (Rust/native safety console) ---
+const rustForgePalette = {
+    name: "rust-forge",
+    mode: "dark",
+    supportsColor: true,
+    render(semantic, text) {
+        switch (semantic) {
+            case "success": return style.cargoGreen(text);
+            case "warning": return style.orangeBold(text);
+            case "error": return style.redBold(text);
+            case "info": return style.rustBold(text);
+            case "agent": return style.rust(text);
+            case "task": return style.cream(text);
+            case "tool": return style.cargoGreen(text);
+            case "header": return style.rustBold(text);
+            case "subheader": return style.cargoGreen(text);
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return style.rustOxide(text);
+            case "bullet": return style.rust("▣ " + text);
+            case "labelKey": return style.gray(text);
+            case "labelValue": return style.cream(text);
+            default: return text;
+        }
+    },
+};
+// --- minimal (basic ANSI, no brand colors) ---
+const minimalPalette = {
+    name: "minimal",
+    mode: "auto",
+    supportsColor: true,
+    render(token, text) {
+        switch (token) {
+            case "success": return style.bold + text + style.reset;
+            case "warning": return text;
+            case "error": return text;
+            case "info": return text;
+            case "agent": return text;
+            case "task": return text;
+            case "tool": return text;
+            case "header": return style.bold + text + style.reset;
+            case "subheader": return style.bold + text + style.reset;
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return text;
+            case "bullet": return "- " + text;
+            case "labelKey": return style.dim + text + style.reset;
+            case "labelValue": return text;
+            default: return text;
+        }
+    },
+};
+// --- mono (no color at all) ---
+const monoPalette = {
+    name: "mono",
+    mode: "mono",
+    supportsColor: false,
+    render(_token, text) {
+        return text;
+    },
+};
+// --- dark (generic dark terminal) ---
+const darkPalette = {
+    name: "dark",
+    mode: "dark",
+    supportsColor: true,
+    render(token, text) {
+        switch (token) {
+            case "success": return style.green(text);
+            case "warning": return style.amber(text);
+            case "error": return style.metricsRed(text);
+            case "info": return style.blue(text);
+            case "agent": return style.violet(text);
+            case "task": return style.cyan(text);
+            case "tool": return style.silver(text);
+            case "header": return style.whiteBold(text);
+            case "subheader": return style.bold + text + style.reset;
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return style.gray(text);
+            case "bullet": return style.dim + "• " + text + style.reset;
+            case "labelKey": return style.dim + text + style.reset;
+            case "labelValue": return text;
+            default: return text;
+        }
+    },
+};
+// --- light (generic light terminal) ---
+const lightPalette = {
+    name: "light",
+    mode: "light",
+    supportsColor: true,
+    render(token, text) {
+        // On light backgrounds, use darker/more saturated variants
+        switch (token) {
+            case "success": return style.greenBold(text);
+            case "warning": return style.amberBold(text);
+            case "error": return style.metricsRedBold(text);
+            case "info": return style.blueBold(text);
+            case "agent": return style.purpleBold(text);
+            case "task": return style.cyanBold(text);
+            case "tool": return style.slate(text);
+            case "header": return style.navy(text);
+            case "subheader": return style.bold + text + style.reset;
+            case "dim": return style.dim + text + style.reset;
+            case "bold": return style.bold + text + style.reset;
+            case "reset": return style.reset + text;
+            case "separator": return style.gray(text);
+            case "bullet": return style.dim + "• " + text + style.reset;
+            case "labelKey": return style.dim + text + style.reset;
+            case "labelValue": return text;
+            default: return text;
+        }
+    },
+};
+const registry = new Map([
+    ["omk", omkPalette],
+    ["night-city", nightCityPalette],
+    ["night-city-ops", nightCityPalette],
+    ["omk-control", nightCityPalette],
+    ["neon-grid", nightCityPalette],
+    ["metrics-control", nightCityPalette],
+    ["green-rain", greenRainPalette],
+    ["matrix", matrixPalette],
+    ["matrix-rain", matrixPalette],
+    ["neo", matrixPalette],
+    ["zion", matrixPalette],
+    ["rain", matrixPalette],
+    ["rust-forge", rustForgePalette],
+    ["rust", rustForgePalette],
+    ["cargo", rustForgePalette],
+    ["oxide", rustForgePalette],
+    ["forge", rustForgePalette],
+    ["rust-native", rustForgePalette],
+    ["neon-circuit", neonCircuitPalette],
+    ["minimal", minimalPalette],
+    ["mono", monoPalette],
+    ["dark", darkPalette],
+    ["light", lightPalette],
+]);
+export function getBuiltinTheme(name) {
+    return registry.get(name);
+}
+export function listBuiltinThemes() {
+    return Array.from(registry.keys());
+}
+export function registerBuiltinTheme(name, palette) {
+    registry.set(name, palette);
+}
+/**
+ * Render a color swatch preview bar for a theme.
+ * Shows success/warning/error/agent/header colors in labeled blocks.
+ */
+export function renderThemePreview(palette, label) {
+    const name = label ?? palette.name;
+    const modeBadge = palette.mode === "mono" ? "[mono]" : palette.mode === "light" ? "[light]" : palette.mode === "dark" ? "[dark]" : "[auto]";
+    const lines = [];
+    // Header line with theme name and mode
+    const headerLine = palette.render("header", `  ${name} ${modeBadge}`);
+    lines.push(headerLine);
+    // Color swatch tokens to display
+    const swatchTokens = [
+        { token: "success", label: "success" },
+        { token: "warning", label: "warning" },
+        { token: "error", label: "error" },
+        { token: "agent", label: "agent" },
+        { token: "header", label: "header" },
+    ];
+    // Render each swatch as: label  ████████ colorSample
+    for (const { token, label: tokenLabel } of swatchTokens) {
+        const coloredBar = palette.render(token, "████████");
+        const labelText = palette.render("dim", tokenLabel.padEnd(9));
+        lines.push(`    ${labelText} ${coloredBar}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Render all built-in themes as color swatch previews.
+ */
+export function renderAllThemePreviews() {
+    const unique = new Map();
+    for (const [, p] of registry) {
+        if (!unique.has(p.name))
+            unique.set(p.name, p);
+    }
+    const lines = [];
+    for (const [name, palette] of unique) {
+        lines.push(renderThemePreview(palette, name));
+        lines.push("");
+    }
+    return lines.filter((l, i, arr) => !(l === "" && i === arr.length - 1)).join("\n");
+}
+export { registry as __registry };

package/dist/cli/theme/theme-resolver.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CLI Theme — Theme Resolver
+ * Resolves the active theme with priority:
+ *   --theme flag → OMK_THEME env → project config → user config → terminal capability default
+ */
+import type { ResolvedTheme } from "../runtime/types.js";
+export interface ResolveThemeOptions {
+    readonly cwd: string;
+    readonly flagTheme?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export declare function resolveTheme(options: ResolveThemeOptions): ResolvedTheme;

package/dist/cli/theme/theme-resolver.js

@@ -0,0 +1,38 @@
+/**
+ * CLI Theme — Theme Resolver
+ * Resolves the active theme with priority:
+ *   --theme flag → OMK_THEME env → project config → user config → terminal capability default
+ */
+import { resolveConfigValue, loadProjectConfig, loadUserConfig, } from "../input/config-loader.js";
+import { getTerminalCapability, defaultThemeForCapability } from "./terminal-capability.js";
+import { getBuiltinTheme, listBuiltinThemes } from "./theme-registry.js";
+function isValidThemeName(name) {
+    return typeof name === "string" && listBuiltinThemes().includes(name);
+}
+function extractThemeName(config) {
+    if (!config)
+        return undefined;
+    if (isValidThemeName(config.theme))
+        return config.theme;
+    if (typeof config.cli === "object"
+        && config.cli !== null
+        && isValidThemeName(config.cli.theme)) {
+        return config.cli.theme;
+    }
+    return undefined;
+}
+export function resolveTheme(options) {
+    const env = options.env ?? process.env;
+    const flagValue = options.flagTheme;
+    const envValue = env.OMK_THEME;
+    const projectCfg = loadProjectConfig(options.cwd);
+    const userCfg = loadUserConfig();
+    const projectValue = extractThemeName(projectCfg?.data);
+    const userValue = extractThemeName(userCfg?.data);
+    const defaultCap = defaultThemeForCapability(getTerminalCapability());
+    const rawName = resolveConfigValue(flagValue, envValue, projectValue, userValue, defaultCap.name);
+    const name = isValidThemeName(rawName) ? rawName : defaultCap.name;
+    const palette = getBuiltinTheme(name);
+    const mode = palette?.mode ?? defaultCap.mode;
+    return { name, mode };
+}

package/dist/cli/ui/event.d.ts

@@ -0,0 +1,65 @@
+export type CliUiEvent = {
+    type: "session:start";
+    runId: string;
+    provider: string;
+    model?: string;
+    layout?: string;
+    root?: string;
+    cwd?: string;
+    rootSource?: string;
+} | {
+    type: "input:submitted";
+    text: string;
+} | {
+    type: "prompt:ready";
+} | {
+    type: "control:output";
+    text: string;
+} | {
+    type: "turn:route";
+    provider: string;
+    model?: string;
+    risk: string;
+    sandbox: string;
+    mcp?: readonly string[];
+    skills?: readonly string[];
+    hooks?: readonly string[];
+} | {
+    type: "turn:start";
+    nodeId: string;
+} | {
+    type: "turn:heartbeat";
+    elapsedMs: number;
+    provider?: string;
+    model?: string;
+    activity?: string;
+} | {
+    type: "assistant:final";
+    text: string;
+} | {
+    type: "turn:error";
+    message: string;
+} | {
+    type: "turn:finish";
+    durationMs: number;
+    exitCode: number;
+} | {
+    type: "session:stop";
+    exitCode: number;
+} | {
+    type: "turn:todo";
+    total: number;
+    done: number;
+    inProgress: number;
+    items: readonly {
+        title: string;
+        status: string;
+    }[];
+} | {
+    type: "turn:reasoning";
+    summary: string;
+    frames: readonly {
+        text: string;
+        elapsedMs?: number;
+    }[];
+};

package/dist/cli/ui/event.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/ui/green-rain-renderer.d.ts

@@ -0,0 +1,17 @@
+import type { CliUiEvent } from "./event.js";
+import type { CliRenderer } from "./renderer.js";
+import { type System24RendererStreams } from "./system24-renderer.js";
+export declare class GreenRainRenderer implements CliRenderer {
+    private readonly base;
+    private readonly err;
+    private readonly noColor;
+    private readonly motion;
+    private started;
+    constructor(streams?: System24RendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary(summary: string | undefined): void;
+    stop(): void;
+    private greenRainHeaderRows;
+    private renderGreenRainHeader;
+}

package/dist/cli/ui/green-rain-renderer.js

@@ -0,0 +1,96 @@
+import gradientString from "gradient-string";
+import { System24Renderer } from "./system24-renderer.js";
+import { GREEN_RAIN_THEME, resolveTuiMotion, shouldUseAnsiColor } from "../../brand/theme.js";
+import { renderMatrixRain } from "../../brand/matrix-rain.js";
+import { renderOmkSparkleText } from "../../ui/omk-sigil.js";
+const ESC = "\x1b[";
+const RST = `${ESC}0m`;
+function stripAnsi(value) {
+    return value.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function visibleLength(value) {
+    return stripAnsi(value).length;
+}
+function line(stream, text, noColor) {
+    stream.write(`${noColor ? stripAnsi(text) : text}\n`);
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, Math.max(0, max - 1))}…` : value;
+}
+function center(text, width) {
+    const pad = Math.max(0, Math.floor((width - visibleLength(text)) / 2));
+    return `${" ".repeat(pad)}${text}`;
+}
+function gradientLine(text, colors, noColor) {
+    return noColor ? text : gradientString(colors).multiline(text);
+}
+export class GreenRainRenderer {
+    base;
+    err;
+    noColor;
+    motion;
+    started = false;
+    constructor(streams = {}) {
+        this.err = streams.stderr ?? process.stderr;
+        this.noColor = !shouldUseAnsiColor();
+        this.motion = resolveTuiMotion();
+        this.base = new System24Renderer(streams, GREEN_RAIN_THEME, {
+            sessionHeader: "compact",
+            noColor: this.noColor,
+            terminalControls: true,
+        });
+    }
+    start() {
+        this.started = true;
+        this.base.start();
+    }
+    emit(event) {
+        if (event.type === "session:start") {
+            this.base.setStickyHeaderPrefixRows(this.greenRainHeaderRows());
+            this.renderGreenRainHeader(event);
+        }
+        this.base.emit(event);
+    }
+    setThinkingSummary(summary) {
+        this.base.setThinkingSummary(summary);
+    }
+    stop() {
+        this.base.stop();
+    }
+    greenRainHeaderRows() {
+        const shouldRenderRain = this.motion !== "off"
+            && this.started
+            && this.err.isTTY !== false
+            && GREEN_RAIN_THEME.motion.rain;
+        return (shouldRenderRain ? 2 : 0) + 4;
+    }
+    renderGreenRainHeader(event) {
+        const width = Math.min(76, Math.max(40, this.err.columns ?? process.stderr.columns ?? 80) - 2);
+        const dim = GREEN_RAIN_THEME.colors.muted;
+        const run = event.runId ? `run#${event.runId.slice(0, 7)}` : "run#pending";
+        const root = event.root ? truncate(event.root, Math.max(12, width - 16)) : "root:unknown";
+        const shouldRenderRain = this.motion !== "off"
+            && this.started
+            && this.err.isTTY !== false
+            && GREEN_RAIN_THEME.motion.rain;
+        const rain = shouldRenderRain
+            ? renderMatrixRain(event.runId ?? "omk", width, 2)
+            : "";
+        const titleLine = center("◢█ OMK GREEN RAIN █◣", width);
+        const mottoLine = center(truncate(GREEN_RAIN_THEME.motto, width), width);
+        const routeLine = truncate(`${GREEN_RAIN_THEME.symbols.signal} ${run} · ${event.provider} · ${event.model ?? "auto"}`, width);
+        const rootLine = truncate(`${GREEN_RAIN_THEME.symbols.pending} root ${root}`, width);
+        if (rain) {
+            for (const rainLine of rain.split("\n"))
+                line(this.err, `${dim}${rainLine}${RST}`, this.noColor);
+        }
+        line(this.err, renderOmkSparkleText(titleLine, {
+            frame: Math.floor(Date.now() / 80),
+            noColor: this.noColor,
+            colors: ["#00FFC2", "#f4ffff", "#ffd166", "#00D6FF", "#9D4EDD"],
+        }), this.noColor);
+        line(this.err, gradientLine(mottoLine, ["#00FFC2", "#00D6FF"], this.noColor), this.noColor);
+        line(this.err, `${dim}${routeLine}${RST}`, this.noColor);
+        line(this.err, `${dim}${rootLine}${RST}`, this.noColor);
+    }
+}

package/dist/cli/ui/neon-grid-renderer.d.ts

@@ -0,0 +1,17 @@
+import type { CliUiEvent } from "./event.js";
+import type { CliRenderer } from "./renderer.js";
+import { type System24RendererStreams } from "./system24-renderer.js";
+export declare class NeonGridRenderer implements CliRenderer {
+    private readonly base;
+    private readonly err;
+    private readonly noColor;
+    private readonly motion;
+    private started;
+    constructor(streams?: System24RendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary(summary: string | undefined): void;
+    stop(): void;
+    private neonGridHeaderRows;
+    private renderNeonGridHeader;
+}