voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/render/utils/duration.js

@@ -0,0 +1,37 @@
+import { resolveLifecycleExecutionDurationMs, } from "../../domain/shared/lifecycle.js";
+export function resolveRenderLifecycleDurationMs(options) {
+    return resolveLifecycleExecutionDurationMs(options.lifecycle, {
+        statusGroups: {
+            running: ["running"],
+            terminal: options.terminalStatuses,
+        },
+        now: options.now,
+    });
+}
+export function formatRenderLifecycleDuration(options) {
+    const durationMs = resolveRenderLifecycleDurationMs(options);
+    if (durationMs === undefined) {
+        return undefined;
+    }
+    return formatDurationLabel(durationMs);
+}
+export function formatDurationLabel(durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs < 0) {
+        return undefined;
+    }
+    const totalSeconds = Math.round(durationMs / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+    }
+    if (seconds > 0 || parts.length === 0) {
+        parts.push(`${seconds}s`);
+    }
+    return parts.join(" ");
+}

package/dist/render/utils/interactive-frame.d.ts

@@ -0,0 +1,6 @@
+type CliWriter = Pick<NodeJS.WriteStream, "write">;
+export interface InteractiveFrameRenderer {
+    render(lines: readonly string[]): void;
+}
+export declare function createInteractiveFrameRenderer(stdout: CliWriter): InteractiveFrameRenderer;
+export {};

package/dist/render/utils/interactive-frame.js

@@ -0,0 +1,38 @@
+const ERASE_LINE = "\u001b[2K";
+const CURSOR_COLUMN_START = "\u001b[0G";
+export function createInteractiveFrameRenderer(stdout) {
+    let blockInitialized = false;
+    let lastRenderedLines = 0;
+    return {
+        render(lines) {
+            if (lines.length === 0) {
+                return;
+            }
+            if (!blockInitialized) {
+                stdout.write(lines.join("\n"));
+                lastRenderedLines = lines.length;
+                blockInitialized = true;
+                return;
+            }
+            const linesToRewind = Math.max(0, lastRenderedLines - 1);
+            if (linesToRewind > 0) {
+                stdout.write(cursorUp(linesToRewind));
+            }
+            stdout.write(CURSOR_COLUMN_START);
+            const totalLines = Math.max(lastRenderedLines, lines.length);
+            const rewrittenLines = [];
+            for (let index = 0; index < totalLines; index += 1) {
+                const line = lines[index] ?? "";
+                rewrittenLines.push(CURSOR_COLUMN_START, ERASE_LINE, line);
+                if (index < totalLines - 1) {
+                    rewrittenLines.push("\n");
+                }
+            }
+            stdout.write(rewrittenLines.join(""));
+            lastRenderedLines = totalLines;
+        },
+    };
+}
+function cursorUp(lines) {
+    return `\u001b[${lines}F`;
+}

package/dist/render/utils/records.js

@@ -1,6 +1,5 @@
-const RUN_TIME_ZONE = "America/Los_Angeles";
-const RUN_TIMESTAMP_FORMAT = new Intl.DateTimeFormat("en-CA", {
-    timeZone: RUN_TIME_ZONE,
+import { createLocalDateTimeFormatter, formatLocalTimeZoneLabel, } from "./timezone.js";
+const RUN_TIMESTAMP_FORMAT = createLocalDateTimeFormatter({
     year: "numeric",
     month: "2-digit",
     day: "2-digit",
@@ -24,7 +23,8 @@ export function formatRunTimestamp(isoTimestamp) {
         if (!year || !month || !day || !hour || !minute) {
             return isoTimestamp;
         }
-        return `${year}-${month}-${day} ${hour}:${minute}`;
+        const timeZoneLabel = formatLocalTimeZoneLabel(date);
+        return `${year}-${month}-${day} ${hour}:${minute} ${timeZoneLabel}`;
     }
     catch {
         return isoTimestamp;

package/dist/render/utils/runs.d.ts

@@ -1,16 +1,10 @@
 import type { RunStatus } from "../../status/index.js";
+import type { TranscriptShellStyleOptions } from "./transcript-shell.js";
 export interface RunDisplayInfo {
     runId: string;
     status?: RunStatus;
-    specPath?: string;
     workspacePath?: string;
+    elapsed?: string;
     createdAt?: string;
-    baseRevisionSha?: string;
 }
-type RunMetadataRow = {
-    label: string;
-    value: string;
-};
-export declare function getRunMetadata(info: RunDisplayInfo): RunMetadataRow[];
-export declare function buildRunMetadataSection(info: RunDisplayInfo): string[];
-export {};
+export declare function buildRunMetadataSectionWithStyle(info: RunDisplayInfo, style?: TranscriptShellStyleOptions): string[];

package/dist/render/utils/runs.js

@@ -1,50 +1,18 @@
 import { getRunStatusStyle } from "../../status/colors.js";
-import { colorize } from "../../utils/colors.js";
-import { formatRunBadge } from "./badges.js";
-import { renderTable } from "./table.js";
-export function getRunMetadata(info) {
-    const detailRows = [
-        { label: "Created", value: info.createdAt },
-        { label: "Spec", value: info.specPath },
-        { label: "Workspace", value: info.workspacePath },
-        {
-            label: "Base Revision",
-            value: info.baseRevisionSha
-                ? info.baseRevisionSha.slice(0, 8)
-                : undefined,
-        },
-    ];
-    return detailRows.filter((row) => typeof row.value === "string" && row.value.length > 0);
-}
-export function buildRunMetadataSection(info) {
-    const lines = [];
-    const badge = formatRunBadge(info.runId);
-    if (info.status) {
-        const statusStyle = getRunStatusStyle(info.status);
-        lines.push(`${badge} ${colorize(info.status.toUpperCase(), statusStyle.cli)}`);
-    }
-    else {
-        lines.push(badge);
-    }
-    const detailRows = getRunMetadata(info);
-    if (detailRows.length > 0) {
-        const tableLines = renderTable({
-            columns: [
-                {
-                    header: "FIELD",
-                    accessor: (row) => row.label,
-                },
-                {
-                    header: "VALUE",
-                    accessor: (row) => row.value ?? "—",
-                },
-            ],
-            rows: detailRows,
-        });
-        const [, ...bodyLines] = tableLines;
-        if (bodyLines.length > 0) {
-            lines.push("", ...bodyLines);
-        }
-    }
-    return lines;
+import { buildStandardSessionShellSection } from "./transcript-shell.js";
+export function buildRunMetadataSectionWithStyle(info, style = {}) {
+    return buildStandardSessionShellSection({
+        badgeText: info.runId,
+        badgeVariant: "run",
+        status: info.status
+            ? {
+                value: info.status,
+                color: getRunStatusStyle(info.status).cli,
+            }
+            : undefined,
+        elapsed: info.elapsed,
+        createdAt: info.createdAt,
+        workspacePath: info.workspacePath,
+        style,
+    });
 }

package/dist/render/utils/stage-output.d.ts

@@ -0,0 +1,20 @@
+import type { TranscriptHintOptions } from "./transcript.js";
+export interface StageFrameShell {
+    metadataLines: readonly string[];
+    statusTableLines?: readonly string[];
+    footerLines?: readonly string[];
+}
+export declare function buildStageFrameSections(options: StageFrameShell): string[][];
+export interface StageFrameLinesOptions extends StageFrameShell {
+    leadingBlankLine?: boolean;
+    trailingBlankLine?: boolean;
+}
+export declare function buildStageFrameLines(options: StageFrameLinesOptions): string[];
+export interface StageFinalFrameOptions extends StageFrameShell {
+    hint?: TranscriptHintOptions;
+}
+export declare function renderStageFinalFrame(options: StageFinalFrameOptions): string;
+export interface StageStartLineEmitter {
+    emit(copy: string): void;
+}
+export declare function createStageStartLineEmitter(writeLine: (copy: string) => void): StageStartLineEmitter;

package/dist/render/utils/stage-output.js

@@ -0,0 +1,44 @@
+import { renderBlocks, renderTranscript } from "./transcript.js";
+export function buildStageFrameSections(options) {
+    const sections = [];
+    if (options.metadataLines.length > 0) {
+        sections.push([...options.metadataLines]);
+    }
+    if (options.statusTableLines && options.statusTableLines.length > 0) {
+        sections.push([...options.statusTableLines]);
+    }
+    if (options.footerLines && options.footerLines.length > 0) {
+        sections.push([...options.footerLines]);
+    }
+    return sections;
+}
+export function buildStageFrameLines(options) {
+    const sections = buildStageFrameSections(options);
+    return renderBlocks({
+        sections,
+        leadingBlankLine: options.leadingBlankLine,
+        trailingBlankLine: options.trailingBlankLine,
+        trimTrailingBlankLines: false,
+    });
+}
+export function renderStageFinalFrame(options) {
+    return renderTranscript({
+        sections: buildStageFrameSections(options),
+        hint: options.hint,
+    });
+}
+export function createStageStartLineEmitter(writeLine) {
+    let emitted = false;
+    return {
+        emit(copy) {
+            if (emitted) {
+                return;
+            }
+            if (copy.trim().length === 0) {
+                return;
+            }
+            emitted = true;
+            writeLine(copy);
+        },
+    };
+}

package/dist/render/utils/timezone.d.ts

@@ -0,0 +1,2 @@
+export declare function createLocalDateTimeFormatter(options: Intl.DateTimeFormatOptions, locales?: Intl.LocalesArgument): Intl.DateTimeFormat;
+export declare function formatLocalTimeZoneLabel(date: Date): string;

package/dist/render/utils/timezone.js

@@ -0,0 +1,42 @@
+const resolvedTimeZone = (() => {
+    try {
+        const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        return typeof timeZone === "string" && timeZone.length > 0
+            ? timeZone
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+})();
+export function createLocalDateTimeFormatter(options, locales = "en-CA") {
+    if (resolvedTimeZone) {
+        return new Intl.DateTimeFormat(locales, {
+            timeZone: resolvedTimeZone,
+            ...options,
+        });
+    }
+    return new Intl.DateTimeFormat(locales, options);
+}
+export function formatLocalTimeZoneLabel(date) {
+    try {
+        const parts = createLocalDateTimeFormatter({
+            timeZoneName: "short",
+        }).formatToParts(date);
+        const label = parts.find((part) => part.type === "timeZoneName")?.value;
+        if (label && label.length > 0) {
+            return label;
+        }
+    }
+    catch {
+        // Fall through to offset-based formatting.
+    }
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    const absoluteMinutes = Math.abs(offsetMinutes);
+    const hours = String(Math.floor(absoluteMinutes / 60)).padStart(2, "0");
+    const minutes = String(absoluteMinutes % 60).padStart(2, "0");
+    return minutes === "00"
+        ? `GMT${sign}${hours}`
+        : `GMT${sign}${hours}:${minutes}`;
+}

package/dist/render/utils/transcript-shell.d.ts

@@ -0,0 +1,66 @@
+import type { TerminalColor } from "../../utils/colors.js";
+export interface TranscriptShellStyleOptions {
+    isTty?: boolean;
+    columns?: number;
+}
+export interface TranscriptShellStyle {
+    isTty: boolean;
+    columns?: number;
+}
+type TerminalLikeWriter = {
+    isTTY?: boolean;
+    columns?: number;
+};
+export declare function resolveTranscriptShellStyle(options?: TranscriptShellStyleOptions): TranscriptShellStyle;
+export declare function resolveTranscriptShellStyleFromWriter(writer: TerminalLikeWriter, options?: {
+    forceTty?: boolean;
+}): TranscriptShellStyleOptions;
+export type TranscriptBadgeVariant = "run" | "verify" | "reduce" | "spec" | "message" | "agent";
+export declare function formatTranscriptBadge(text: string, variant: TranscriptBadgeVariant, style: TranscriptShellStyle): string;
+export declare function formatTranscriptStatusLabel(status: string, color: TerminalColor, style: TranscriptShellStyle): string;
+export declare function formatTranscriptErrorLine(message: string, style: TranscriptShellStyle): string;
+export type TranscriptDetailRow = {
+    label: string;
+    value: string;
+};
+export declare function buildStandardSessionDetailRows(options: {
+    elapsed?: string;
+    createdAt?: string;
+    workspacePath?: string;
+}): TranscriptDetailRow[];
+export declare function buildTranscriptDetailBodyRows(rows: readonly TranscriptDetailRow[]): string[];
+export declare function buildTranscriptShellSection(options: {
+    badgeText: string;
+    badgeVariant: TranscriptBadgeVariant;
+    status?: {
+        value: string;
+        color: TerminalColor;
+    };
+    detailRows?: readonly TranscriptDetailRow[];
+    style?: TranscriptShellStyleOptions;
+}): string[];
+export declare function buildStandardSessionShellSection(options: {
+    badgeText: string;
+    badgeVariant: TranscriptBadgeVariant;
+    status?: {
+        value: string;
+        color: TerminalColor;
+    };
+    elapsed?: string;
+    createdAt?: string;
+    workspacePath?: string;
+    style?: TranscriptShellStyleOptions;
+}): string[];
+export interface TranscriptStatusTableColumn<Row> {
+    header: string;
+    accessor: (row: Row) => string;
+    align?: "left" | "right";
+}
+export declare function renderTranscriptStatusTable<Row>(options: {
+    rows: readonly Row[];
+    agent: (row: Row) => string;
+    status: (row: Row) => string;
+    duration: (row: Row) => string;
+    extras?: readonly TranscriptStatusTableColumn<Row>[];
+}): string[];
+export {};

package/dist/render/utils/transcript-shell.js

@@ -0,0 +1,155 @@
+import { colorize } from "../../utils/colors.js";
+import { formatAlertMessage } from "../../utils/output.js";
+import { formatRunTimestamp } from "./records.js";
+import { renderTable } from "./table.js";
+export function resolveTranscriptShellStyle(options = {}) {
+    return {
+        isTty: options.isTty ?? Boolean(process.stdout.isTTY),
+        columns: options.columns,
+    };
+}
+export function resolveTranscriptShellStyleFromWriter(writer, options = {}) {
+    return {
+        isTty: options.forceTty === true ? true : Boolean(writer.isTTY),
+        columns: writer.columns,
+    };
+}
+const ANSI_RESET = "\u001B[0m";
+const ANSI_BOLD = "\u001B[1m";
+const ESC = "\u001B[";
+const BRAND_COLOR = "164;203;153";
+const VERIFY_COLOR = "255;238;140";
+const REDUCE_COLOR = "226;159;115";
+const SPEC_COLOR = "144;190;228";
+const MESSAGE_COLOR = "245;242;235";
+const BADGE_STYLES = {
+    run: {
+        foreground: `${ESC}38;2;0;0;0m`,
+        background: `${ESC}48;2;${BRAND_COLOR}m`,
+        bold: true,
+    },
+    verify: {
+        foreground: `${ESC}38;2;0;0;0m`,
+        background: `${ESC}48;2;${VERIFY_COLOR}m`,
+        bold: true,
+    },
+    reduce: {
+        foreground: `${ESC}38;2;0;0;0m`,
+        background: `${ESC}48;2;${REDUCE_COLOR}m`,
+        bold: true,
+    },
+    spec: {
+        foreground: `${ESC}38;2;0;0;0m`,
+        background: `${ESC}48;2;${SPEC_COLOR}m`,
+        bold: true,
+    },
+    message: {
+        foreground: `${ESC}38;2;0;0;0m`,
+        background: `${ESC}48;2;${MESSAGE_COLOR}m`,
+        bold: true,
+    },
+    agent: {
+        bold: true,
+    },
+};
+function applyBadgeStyle(text, style) {
+    const padding = Math.max(0, style.padding ?? 0);
+    const pad = padding === 0 ? "" : " ".repeat(padding);
+    const padded = `${pad}${text}${pad}`;
+    const parts = [];
+    if (typeof style.background === "string" && style.background.length > 0) {
+        parts.push(style.background);
+    }
+    if (typeof style.foreground === "string" && style.foreground.length > 0) {
+        parts.push(style.foreground);
+    }
+    if (style.bold === true) {
+        parts.push(ANSI_BOLD);
+    }
+    parts.push(padded, ANSI_RESET);
+    return parts.join("");
+}
+export function formatTranscriptBadge(text, variant, style) {
+    if (!style.isTty) {
+        return text;
+    }
+    return applyBadgeStyle(text, BADGE_STYLES[variant]);
+}
+export function formatTranscriptStatusLabel(status, color, style) {
+    const label = status.toUpperCase();
+    return style.isTty ? colorize(label, color) : label;
+}
+export function formatTranscriptErrorLine(message, style) {
+    if (!style.isTty) {
+        return `Error: ${message}`;
+    }
+    return formatAlertMessage("Error", "red", message);
+}
+export function buildStandardSessionDetailRows(options) {
+    const rows = [
+        { label: "Elapsed", value: options.elapsed },
+        {
+            label: "Created",
+            value: options.createdAt
+                ? formatRunTimestamp(options.createdAt)
+                : undefined,
+        },
+        { label: "Workspace", value: options.workspacePath },
+    ];
+    return rows.filter((row) => typeof row.value === "string" && row.value.length > 0);
+}
+export function buildTranscriptDetailBodyRows(rows) {
+    if (rows.length === 0) {
+        return [];
+    }
+    const labelWidth = rows.reduce((max, row) => Math.max(max, row.label.length), 0);
+    const bodyLines = [];
+    for (const row of rows) {
+        const value = row.value ?? "—";
+        const prefix = `${row.label.padEnd(labelWidth)}  `;
+        bodyLines.push(`${prefix}${value}`.trimEnd());
+    }
+    return bodyLines;
+}
+export function buildTranscriptShellSection(options) {
+    const style = resolveTranscriptShellStyle(options.style);
+    const lines = [];
+    const badge = formatTranscriptBadge(options.badgeText, options.badgeVariant, style);
+    if (options.status) {
+        const statusLabel = formatTranscriptStatusLabel(options.status.value, options.status.color, style);
+        lines.push(`${badge} ${statusLabel}`);
+    }
+    else {
+        lines.push(badge);
+    }
+    const detailBody = buildTranscriptDetailBodyRows(options.detailRows ?? []);
+    if (detailBody.length > 0) {
+        lines.push("", ...detailBody);
+    }
+    return lines;
+}
+export function buildStandardSessionShellSection(options) {
+    return buildTranscriptShellSection({
+        badgeText: options.badgeText,
+        badgeVariant: options.badgeVariant,
+        status: options.status,
+        detailRows: buildStandardSessionDetailRows({
+            elapsed: options.elapsed,
+            createdAt: options.createdAt,
+            workspacePath: options.workspacePath,
+        }),
+        style: options.style,
+    });
+}
+export function renderTranscriptStatusTable(options) {
+    const extras = options.extras ?? [];
+    return renderTable({
+        columns: [
+            { header: "AGENT", accessor: options.agent },
+            { header: "STATUS", accessor: options.status },
+            { header: "DURATION", accessor: options.duration },
+            ...extras,
+        ],
+        rows: options.rows,
+    });
+}

package/dist/render/utils/transcript.d.ts

@@ -11,4 +11,10 @@ export interface TranscriptOptions {
     sections?: string[][];
     hint?: TranscriptHintOptions;
 }
-export declare function renderTranscript({ metadata, sections, hint, }: TranscriptOptions): string;
+export interface RenderBlocksOptions extends TranscriptOptions {
+    leadingBlankLine?: boolean;
+    trailingBlankLine?: boolean;
+    trimTrailingBlankLines?: boolean;
+}
+export declare function renderBlocks({ metadata, sections, hint, leadingBlankLine, trailingBlankLine, trimTrailingBlankLines: shouldTrim, }: RenderBlocksOptions): string[];
+export declare function renderTranscript(options: TranscriptOptions): string;

package/dist/render/utils/transcript.js

@@ -1,10 +1,13 @@
-export function renderTranscript({ metadata = [], sections = [], hint, }) {
+export function renderBlocks({ metadata = [], sections = [], hint, leadingBlankLine = false, trailingBlankLine = false, trimTrailingBlankLines: shouldTrim = true, }) {
     const lines = [];
     const metadataLines = metadata
         .filter((entry) => {
         return typeof entry.value === "string" && entry.value.length > 0;
     })
         .map((entry) => `${entry.label}: ${entry.value}`);
+    if (leadingBlankLine) {
+        lines.push("");
+    }
     if (metadataLines.length > 0) {
         lines.push(...metadataLines, "");
     }
@@ -24,7 +27,14 @@ export function renderTranscript({ metadata = [], sections = [], hint, }) {
         }
         lines.push(resolvedHint);
     }
-    return trimTrailingBlankLines(lines).join("\n");
+    const trimmed = shouldTrim ? trimTrailingBlankLines(lines) : lines;
+    if (trailingBlankLine) {
+        trimmed.push("");
+    }
+    return trimmed;
+}
+export function renderTranscript(options) {
+    return renderBlocks(options).join("\n");
 }
 function withRerunHint(message) {
     return message.endsWith(" and rerun.") ? message : `${message} and rerun.`;

package/dist/render/utils/wrap.d.ts

@@ -0,0 +1 @@
+export declare function wrapWords(text: string, maxWidth: number): string[];

package/dist/render/utils/wrap.js

@@ -0,0 +1,20 @@
+export function wrapWords(text, maxWidth) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    const words = trimmed.split(/\s+/);
+    const lines = [];
+    let current = words[0] ?? "";
+    for (const word of words.slice(1)) {
+        const candidate = `${current} ${word}`;
+        if (candidate.length <= maxWidth) {
+            current = candidate;
+            continue;
+        }
+        lines.push(current);
+        current = word;
+    }
+    lines.push(current);
+    return lines;
+}

package/dist/status/colors.d.ts

@@ -1,10 +1,9 @@
-import type { EvalStatus } from "../configs/evals/types.js";
 import type { TerminalColor } from "../utils/colors.js";
-import type { AgentStatus, RunStatus } from "./index.js";
+import type { AgentStatus, CheckStatus, RunStatus } from "./index.js";
 interface StatusStyle {
     cli: TerminalColor;
 }
 export declare function getAgentStatusStyle(status: AgentStatus): StatusStyle;
-export declare function getEvalStatusStyle(status: EvalStatus): StatusStyle;
+export declare function getCheckStatusStyle(status: CheckStatus): StatusStyle;
 export declare function getRunStatusStyle(status: RunStatus): StatusStyle;
 export {};

package/dist/status/colors.js

@@ -7,7 +7,7 @@ const agentStatusStyles = {
     running: { cli: "cyan" },
     queued: { cli: "gray" },
 };
-const evalStatusStyles = {
+const checkStatusStyles = {
     succeeded: { cli: "green" },
     failed: { cli: "red" },
     errored: { cli: "red" },
@@ -25,8 +25,8 @@ const runStatusStyles = {
 export function getAgentStatusStyle(status) {
     return agentStatusStyles[status];
 }
-export function getEvalStatusStyle(status) {
-    return evalStatusStyles[status];
+export function getCheckStatusStyle(status) {
+    return checkStatusStyles[status];
 }
 export function getRunStatusStyle(status) {
     return runStatusStyles[status];