open-multi-agent-kit 0.79.1 → 0.80.0

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

@@ -0,0 +1,97 @@
+import gradientString from "gradient-string";
+import { System24Renderer } from "./system24-renderer.js";
+import { GREEN_RAIN_THEME, resolveTuiMotion, shouldUseAnsiColor } from "../../brand/theme.js";
+import { BRAND_HEX } from "../../brand/palette.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: [BRAND_HEX.mint, BRAND_HEX.sparkleWhite, BRAND_HEX.sparkleGold, BRAND_HEX.cyan, BRAND_HEX.purple],
+        }), this.noColor);
+        line(this.err, gradientLine(mottoLine, [BRAND_HEX.mint, BRAND_HEX.cyan], 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,25 @@
+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 headerTimer;
+    private started;
+    constructor(streams?: System24RendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary(summary: string | undefined): void;
+    stop(): void;
+    private neonGridHeaderRows;
+    private canAnimateHeader;
+    private shouldRenderScanline;
+    private currentFrame;
+    private startHeaderAnimation;
+    private stopHeaderAnimation;
+    private repaintNeonGridHeader;
+    private renderNeonGridHeader;
+    private neonGridHeaderLines;
+}

package/dist/cli/ui/neon-grid-renderer.js

@@ -0,0 +1,170 @@
+import gradientString from "gradient-string";
+import { System24Renderer } from "./system24-renderer.js";
+import { NEON_GRID_THEME, resolveTuiMotion, shouldUseAnsiColor } from "../../brand/theme.js";
+import { BRAND_HEX } from "../../brand/palette.js";
+import { renderOmkSparkleText } from "../../ui/omk-sigil.js";
+import { renderChalkAnimationKeyframe, renderInkGradientFallback, renderTerminalKitCapabilityBadge } from "../../theme/library-effects.js";
+const ESC = "\x1b[";
+const RST = `${ESC}0m`;
+const SAVE_CURSOR = "\x1b7";
+const RESTORE_CURSOR = "\x1b8";
+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 normalizeEntryBrandLabel(value) {
+    const stripped = stripAnsi(value ?? "")
+        .replace(/[\x00-\x1F\x7F]/g, "")
+        .trim();
+    return stripped.length > 0 ? truncate(stripped, 20) : undefined;
+}
+function center(text, width) {
+    const pad = Math.max(0, Math.floor((width - visibleLength(text)) / 2));
+    return `${" ".repeat(pad)}${text}`;
+}
+function signalScanline(seed, width) {
+    const glyphs = ["◇", "◆", "●", "○", "▣", "⟁", "⟐", "⟡"];
+    let hash = 0;
+    for (const char of seed)
+        hash = (hash * 33 + char.charCodeAt(0)) >>> 0;
+    const chars = [];
+    for (let i = 0; i < width; i += 1) {
+        hash = (hash * 1664525 + 1013904223) >>> 0;
+        chars.push(hash % 7 === 0 ? glyphs[hash % glyphs.length] : hash % 5 === 0 ? "─" : " ");
+    }
+    return chars.join("").trimEnd();
+}
+function gradientLine(text, colors, noColor) {
+    return noColor ? text : gradientString(colors).multiline(text);
+}
+export class NeonGridRenderer {
+    base;
+    err;
+    noColor;
+    motion;
+    headerTimer = null;
+    started = false;
+    constructor(streams = {}) {
+        this.err = streams.stderr ?? process.stderr;
+        this.noColor = !shouldUseAnsiColor();
+        this.motion = resolveTuiMotion();
+        this.base = new System24Renderer(streams, NEON_GRID_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.neonGridHeaderRows());
+            this.renderNeonGridHeader(event);
+            this.base.emit(event);
+            this.startHeaderAnimation(event);
+            return;
+        }
+        this.base.emit(event);
+    }
+    setThinkingSummary(summary) {
+        this.base.setThinkingSummary(summary);
+    }
+    stop() {
+        this.stopHeaderAnimation();
+        this.base.stop();
+    }
+    neonGridHeaderRows() {
+        return this.neonGridHeaderLines({
+            type: "session:start",
+            runId: "",
+            provider: "auto",
+            model: "auto",
+        }).length;
+    }
+    canAnimateHeader() {
+        const requested = process.env.OMK_EXPERIMENTAL_HEADER_REPAINT;
+        const enabled = /^(1|true|yes|on)$/i.test(requested ?? "");
+        return enabled && this.motion !== "off" && this.started && this.err.isTTY === true && !this.noColor;
+    }
+    shouldRenderScanline() {
+        return this.motion !== "off" && this.started && this.err.isTTY !== false;
+    }
+    currentFrame() {
+        return Math.floor(Date.now() / 80);
+    }
+    startHeaderAnimation(event) {
+        this.stopHeaderAnimation();
+        if (!this.canAnimateHeader())
+            return;
+        this.headerTimer = setInterval(() => this.repaintNeonGridHeader(event), 120);
+        this.headerTimer.unref?.();
+    }
+    stopHeaderAnimation() {
+        if (!this.headerTimer)
+            return;
+        clearInterval(this.headerTimer);
+        this.headerTimer = null;
+    }
+    repaintNeonGridHeader(event) {
+        if (!this.canAnimateHeader())
+            return;
+        const maxRows = Math.max(0, (this.err.rows ?? process.stderr.rows ?? Number.POSITIVE_INFINITY) - 1);
+        const rows = this.neonGridHeaderLines(event, this.currentFrame()).slice(0, maxRows);
+        const repaint = rows
+            .map((row, index) => `${ESC}${index + 1};1H${ESC}2K${row}`)
+            .join("");
+        this.err.write(SAVE_CURSOR + repaint + RESTORE_CURSOR);
+    }
+    renderNeonGridHeader(event) {
+        for (const row of this.neonGridHeaderLines(event, this.currentFrame())) {
+            line(this.err, row, this.noColor);
+        }
+    }
+    neonGridHeaderLines(event, frame = 0) {
+        const width = Math.min(76, Math.max(40, this.err.columns ?? process.stderr.columns ?? 80) - 2);
+        const dim = NEON_GRID_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 entryBrand = normalizeEntryBrandLabel(event.brandLabel);
+        const titleLine = center(entryBrand ? `◢█ ${entryBrand} █◣` : "◢█ OMK//CONTROL █◣", width);
+        const controlLine = center(entryBrand ? `${entryBrand}://CONTROL` : "OMK://CONTROL", width);
+        const coreLine = center("CYBERPUNK OPS CORE", width);
+        const gridLine = center("MATRIX RAIN // NEON GRID ONLINE", width);
+        const variantLine = center("NIGHT-CITY-MATRIX-V3", width);
+        const mottoLine = center(truncate(NEON_GRID_THEME.motto, width), width);
+        const stateLine = truncate(`state: ● ready · route: route · evidence · loop · control`, Math.max(12, width - 18));
+        const routeLine = truncate(`${NEON_GRID_THEME.symbols.signal} ROUTE ${run} · provider:${event.provider} · model:${event.model ?? "auto"}`, width);
+        const rootLine = truncate(`${NEON_GRID_THEME.symbols.pending} PENDING root ${root}`, width);
+        const rows = [];
+        if (this.shouldRenderScanline()) {
+            const seed = `${event.runId ?? (entryBrand ? `${entryBrand}-control` : "omk-control")}:${frame}`;
+            rows.push(`${dim}${signalScanline(seed, width)}${RST}`);
+        }
+        rows.push(renderOmkSparkleText(titleLine, {
+            frame,
+            noColor: this.noColor,
+            colors: [BRAND_HEX.cyan, BRAND_HEX.sparkleWhite, BRAND_HEX.sparkleGold, BRAND_HEX.magenta, BRAND_HEX.mint],
+        }));
+        rows.push(renderChalkAnimationKeyframe(controlLine, "rainbow", frame, { noColor: this.noColor }));
+        rows.push(renderChalkAnimationKeyframe(coreLine, "karaoke", frame, { noColor: this.noColor }));
+        rows.push(renderInkGradientFallback(gridLine, "pastel", { noColor: this.noColor }));
+        rows.push(`${dim}${variantLine}${RST}`);
+        rows.push(renderInkGradientFallback(mottoLine, "cristal", { noColor: this.noColor }));
+        rows.push(this.noColor
+            ? gradientLine(stateLine, [BRAND_HEX.mint, BRAND_HEX.cyan], this.noColor)
+            : renderTerminalKitCapabilityBadge(gradientLine(stateLine, [BRAND_HEX.mint, BRAND_HEX.cyan], this.noColor)));
+        rows.push(`${dim}${routeLine}${RST}`);
+        rows.push(`${dim}${rootLine}${RST}`);
+        return rows;
+    }
+}

package/dist/cli/ui/plain-renderer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * PlainModernRenderer — opencode-style minimal CLI output.
+ *
+ * Pattern: `> provider · model` header + clean output.
+ * No route cards, no box drawing, no verbose banners.
+ */
+import type { CliUiEvent } from "./event.js";
+import type { CliRenderer } from "./renderer.js";
+interface WritableStreamLike {
+    write(chunk: string): unknown;
+    isTTY?: boolean;
+    rows?: number;
+}
+export interface PlainRendererStreams {
+    stdout?: WritableStreamLike;
+    stderr?: WritableStreamLike;
+}
+export declare function renderRouteCard(event: Extract<CliUiEvent, {
+    type: "turn:route";
+}>): string;
+export declare function renderAssistantCard(text: string): string;
+export declare class PlainModernRenderer implements CliRenderer {
+    private readonly stdout;
+    private readonly stderr;
+    private heartbeatOpen;
+    private promptOpen;
+    private alternateScreenActive;
+    private stickyScrollRegionActive;
+    constructor(streams?: PlainRendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary(_summary: string | undefined): void;
+    private writeStderrControl;
+    private activateStickyScrollRegion;
+    stop(): void;
+}
+export {};

package/dist/cli/ui/plain-renderer.js

@@ -0,0 +1,162 @@
+import { sanitizeUserVisibleOutput } from "../../util/user-visible-output.js";
+import { isUnsupportedRuntimeError, renderRouteBlockedPanel } from "./route-blocked-panel.js";
+const ESC = "\x1b[";
+function ensureTrailingNewline(text) {
+    return text.endsWith("\n") ? text : `${text}\n`;
+}
+function termRows(stream) {
+    const rows = stream.rows ?? process.stderr.rows ?? 24;
+    return Number.isFinite(rows) ? Math.max(10, rows) : 24;
+}
+function shouldUseTerminalControls(stream) {
+    const requested = process.env.OMK_TUI_ALT_SCREEN ?? process.env.OMK_TUI_TERMINAL_CONTROLS;
+    const enabled = /^(1|true|yes|on|full|alt-screen)$/i.test(requested ?? "");
+    return enabled && stream.isTTY === true && process.env.TERM !== "dumb";
+}
+function countRows(chunk) {
+    return (chunk.match(/\n/g) ?? []).length;
+}
+function joinList(values) {
+    return values && values.length > 0 ? values.join(", ") : "none";
+}
+export function renderRouteCard(event) {
+    const lines = [
+        "◇ Route",
+        `provider  ${event.provider}`,
+        `model     ${event.model ?? "auto"}`,
+        `risk      ${event.risk}`,
+        `sandbox   ${event.sandbox}`,
+        `mcp       ${joinList(event.mcp)}`,
+        `skills    ${joinList(event.skills)}`,
+        `hooks     ${joinList(event.hooks)}`,
+    ];
+    return `${lines.join("\n")}\n`;
+}
+export function renderAssistantCard(text) {
+    return `\n● Assistant\n${ensureTrailingNewline(sanitizeUserVisibleOutput(text))}`;
+}
+export class PlainModernRenderer {
+    stdout;
+    stderr;
+    heartbeatOpen = false;
+    promptOpen = false;
+    alternateScreenActive = false;
+    stickyScrollRegionActive = false;
+    constructor(streams = {}) {
+        this.stdout = streams.stdout ?? process.stdout;
+        this.stderr = streams.stderr ?? process.stderr;
+    }
+    start() {
+        this.stickyScrollRegionActive = false;
+        this.alternateScreenActive = shouldUseTerminalControls(this.stderr);
+        if (this.alternateScreenActive) {
+            this.writeStderrControl(`${ESC}?1049h${ESC}2J${ESC}H`);
+        }
+    }
+    emit(event) {
+        switch (event.type) {
+            case "session:start": {
+                const provider = event.provider === "auto" ? "omk" : event.provider;
+                const model = event.model ?? "auto";
+                const header = `\nOMK Agent Console\n> ${provider} · ${model}\n\n`;
+                this.stderr.write(header);
+                this.activateStickyScrollRegion(countRows(header));
+                break;
+            }
+            case "input:submitted":
+                if (this.promptOpen) {
+                    if (!this.stderr.isTTY)
+                        this.stderr.write(event.text);
+                    this.stderr.write("\n\n");
+                    this.promptOpen = false;
+                }
+                else {
+                    this.stderr.write(`› ${event.text}\n\n`);
+                }
+                break;
+            case "prompt:ready":
+                if (!this.promptOpen) {
+                    this.stderr.write("› ");
+                    this.promptOpen = true;
+                }
+                break;
+            case "control:output":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\n");
+                    this.heartbeatOpen = false;
+                }
+                this.stderr.write(sanitizeUserVisibleOutput(event.text));
+                break;
+            case "turn:route":
+                this.stderr.write(renderRouteCard(event));
+                break;
+            case "turn:heartbeat": {
+                const seconds = Math.floor(event.elapsedMs / 1000);
+                const activity = event.activity ?? `routing ${event.provider ?? "auto"} turn`;
+                const truncated = activity.length > 72 ? activity.slice(0, 69) + "..." : activity;
+                const line = `◌ ${truncated} · ${seconds}s`;
+                if (this.stderr.isTTY) {
+                    this.stderr.write(`\r${line}   `);
+                    this.heartbeatOpen = true;
+                }
+                else {
+                    this.stderr.write(`${line}\n`);
+                }
+                break;
+            }
+            case "assistant:final":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r                    \r");
+                    this.heartbeatOpen = false;
+                }
+                this.stdout.write(renderAssistantCard(event.text));
+                break;
+            case "turn:error":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r                    \r");
+                    this.heartbeatOpen = false;
+                }
+                {
+                    const errMsg = sanitizeUserVisibleOutput(event.message);
+                    const rendered = isUnsupportedRuntimeError(errMsg)
+                        ? renderRouteBlockedPanel(errMsg)
+                        : `  ✖ ${errMsg}`;
+                    this.stderr.write(`\n${rendered}\n\n`);
+                }
+                break;
+            case "turn:finish":
+                if (this.heartbeatOpen) {
+                    this.stderr.write("\r                    \r");
+                    this.heartbeatOpen = false;
+                }
+                this.stderr.write(`● Finished ${(event.durationMs / 1000).toFixed(1)}s · exit ${event.exitCode}\n`);
+                break;
+            case "turn:start":
+                break;
+            case "session:stop":
+                // opencode shows nothing on session end
+                break;
+        }
+    }
+    setThinkingSummary(_summary) { }
+    writeStderrControl(chunk) {
+        this.stderr.write(chunk);
+    }
+    activateStickyScrollRegion(headerRows) {
+        if (!this.alternateScreenActive || this.stickyScrollRegionActive)
+            return;
+        const rows = termRows(this.stderr);
+        const top = Math.min(rows - 1, Math.max(2, headerRows + 1));
+        if (top >= rows)
+            return;
+        this.writeStderrControl(`${ESC}${top};${rows}r${ESC}${top};1H`);
+        this.stickyScrollRegionActive = true;
+    }
+    stop() {
+        if (this.alternateScreenActive) {
+            this.writeStderrControl(`${ESC}r${ESC}?1049l`);
+            this.alternateScreenActive = false;
+            this.stickyScrollRegionActive = false;
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { CliUiEvent } from "./event.js";
+export interface CliRenderer {
+    start(): Promise<void> | void;
+    emit(event: CliUiEvent): void;
+    setThinkingSummary?(summary: string | undefined): void;
+    stop(): Promise<void> | void;
+}

package/dist/cli/ui/renderer.js

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

package/dist/cli/ui/rich-renderer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * RichRenderer — theme-integrated CLI output with markdown rendering.
+ *
+ * Uses OMK theme primitives (style, layout) for visual richness.
+ * Renders inline markdown: **bold**, `code`, ```code blocks```, # headers, - lists.
+ * Shows thinking/reasoning frames with visual indicators.
+ */
+import type { CliUiEvent } from "./event.js";
+import type { CliRenderer } from "./renderer.js";
+interface WritableStreamLike {
+    write(chunk: string): unknown;
+    isTTY?: boolean;
+}
+export interface RichRendererStreams {
+    stdout?: WritableStreamLike;
+    stderr?: WritableStreamLike;
+}
+export declare class RichRenderer implements CliRenderer {
+    private readonly stdout;
+    private readonly stderr;
+    private heartbeatOpen;
+    private promptOpen;
+    private thinkingSummary;
+    private sessionStartTime;
+    constructor(streams?: RichRendererStreams);
+    start(): void;
+    emit(event: CliUiEvent): void;
+    /** Update thinking summary from reasoning NLP (called externally) */
+    setThinkingSummary(summary: string | undefined): void;
+    stop(): void;
+}
+export {};