voratiq 0.1.0-beta.0

package/dist/render/transcripts/run.js

@@ -0,0 +1,295 @@
+import { getEvalStatusStyle } from "../../status/colors.js";
+import { colorize } from "../../utils/colors.js";
+import { formatCompactDiffStatistics } from "../../utils/diff.js";
+import { formatAgentDuration, formatAgentStatusLabel, formatDurationLabel, } from "../utils/agents.js";
+import { formatAgentBadge } from "../utils/badges.js";
+import { formatRunTimestamp } from "../utils/records.js";
+import { buildRunMetadataSection } from "../utils/runs.js";
+import { renderTable } from "../utils/table.js";
+import { renderTranscript } from "../utils/transcript.js";
+const SUPPRESS_RUN_STATUS_TABLE_ENV = "VORATIQ_SUPPRESS_RUN_STATUS_TABLE";
+function shouldSuppressRunStatusTable() {
+    const flag = process.env[SUPPRESS_RUN_STATUS_TABLE_ENV];
+    return flag === "1" || flag?.toLowerCase() === "true";
+}
+const ERASE_LINE = "\u001b[2K";
+const CURSOR_COLUMN_START = "\u001b[0G";
+function cursorUp(lines) {
+    return `\u001b[${lines}F`;
+}
+const DASH = "—";
+function formatErrorDetail(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (error === null || error === undefined) {
+        return "unknown error";
+    }
+    if (typeof error === "number" ||
+        typeof error === "boolean" ||
+        typeof error === "bigint") {
+        return `${error}`;
+    }
+    if (typeof error === "symbol") {
+        return error.description ?? error.toString();
+    }
+    if (typeof error === "object") {
+        try {
+            const serialized = JSON.stringify(error);
+            if (serialized) {
+                return serialized;
+            }
+        }
+        catch {
+            // ignore JSON serialization failures; fall through to default message.
+        }
+    }
+    return "unknown error";
+}
+export function createRunRenderer(options = {}) {
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const now = options.now ?? Date.now.bind(Date);
+    let context;
+    let disabled = shouldSuppressRunStatusTable();
+    let warningLogged = false;
+    let lastRenderedLines = 0;
+    let blockInitialized = false;
+    let metadataPrinted = false;
+    const agentOrder = [];
+    const agentRecords = new Map();
+    function guard(action) {
+        if (disabled) {
+            return;
+        }
+        try {
+            action();
+        }
+        catch (error) {
+            disabled = true;
+            if (!warningLogged) {
+                warningLogged = true;
+                const detail = formatErrorDetail(error);
+                stderr.write(`[voratiq] Progressive run output disabled: ${detail}\n`);
+            }
+        }
+    }
+    function buildInteractiveLines(metadataLines, tableLines) {
+        if (metadataLines.length === 0) {
+            return [];
+        }
+        const lines = [""];
+        lines.push(...metadataLines);
+        if (tableLines.length > 0) {
+            lines.push("");
+            lines.push(...tableLines);
+        }
+        lines.push("");
+        return lines;
+    }
+    function buildTableRefreshLines(tableLines) {
+        if (tableLines.length === 0) {
+            return [];
+        }
+        return ["", ...tableLines, ""];
+    }
+    function render() {
+        if (!context || disabled) {
+            return;
+        }
+        const metadataLines = buildRunMetadataSection({
+            runId: context.runId,
+            status: context.status,
+            specPath: context.specPath,
+            workspacePath: context.workspacePath,
+            createdAt: formatRunTimestamp(context.createdAt),
+            baseRevisionSha: context.baseRevisionSha,
+        });
+        const tableLines = buildAgentTable();
+        const shouldIncludeTable = tableLines.length > 0;
+        const interactiveLines = buildInteractiveLines(metadataLines, tableLines);
+        if (stdout.isTTY) {
+            if (interactiveLines.length === 0) {
+                return;
+            }
+            if (!blockInitialized) {
+                stdout.write(interactiveLines.join("\n"));
+                lastRenderedLines = interactiveLines.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, interactiveLines.length);
+            const rewrittenLines = [];
+            for (let index = 0; index < totalLines; index += 1) {
+                const line = interactiveLines[index] ?? "";
+                rewrittenLines.push(CURSOR_COLUMN_START, ERASE_LINE, line);
+                if (index < totalLines - 1) {
+                    rewrittenLines.push("\n");
+                }
+            }
+            stdout.write(rewrittenLines.join(""));
+            lastRenderedLines = totalLines;
+            return;
+        }
+        if (!metadataPrinted) {
+            if (interactiveLines.length > 0) {
+                stdout.write(interactiveLines.join("\n"));
+            }
+            metadataPrinted = true;
+            return;
+        }
+        if (!shouldIncludeTable) {
+            return;
+        }
+        const refreshLines = buildTableRefreshLines(tableLines);
+        if (refreshLines.length > 0) {
+            stdout.write(refreshLines.join("\n"));
+        }
+    }
+    function buildAgentTable() {
+        if (agentRecords.size === 0) {
+            return [];
+        }
+        const rows = agentOrder
+            .filter((agentId) => agentRecords.has(agentId))
+            .map((agentId) => {
+            const record = agentRecords.get(agentId);
+            return {
+                agentId: formatAgentBadge(agentId),
+                status: formatAgentStatusLabel(record.status),
+                elapsed: formatElapsed(record),
+                diff: formatDiffCell(record.diffStatistics),
+                evals: formatEvals(record),
+            };
+        });
+        return renderTable({
+            columns: [
+                { header: "AGENT", accessor: (row) => row.agentId },
+                { header: "STATUS", accessor: (row) => row.status },
+                { header: "ELAPSED", accessor: (row) => row.elapsed },
+                { header: "CHANGES", accessor: (row) => row.diff },
+                { header: "EVALS", accessor: (row) => row.evals },
+            ],
+            rows,
+        });
+    }
+    function formatDiffCell(value) {
+        const compact = formatCompactDiffStatistics(value);
+        if (compact) {
+            return compact;
+        }
+        return value ?? DASH;
+    }
+    function formatElapsed(record) {
+        if (!record.startedAt) {
+            return DASH;
+        }
+        const started = Date.parse(record.startedAt);
+        if (Number.isNaN(started)) {
+            return DASH;
+        }
+        if (!record.completedAt && record.status === "running") {
+            const elapsedMs = Math.max(0, now() - started);
+            const formattedElapsed = formatDurationLabel(elapsedMs);
+            return formattedElapsed ?? DASH;
+        }
+        if (!record.completedAt) {
+            return DASH;
+        }
+        const formatted = formatAgentDuration({
+            agentId: record.agentId,
+            status: record.status,
+            startedAt: record.startedAt,
+            completedAt: record.completedAt,
+        });
+        if (formatted) {
+            return formatted;
+        }
+        const completed = Date.parse(record.completedAt);
+        if (Number.isNaN(completed)) {
+            return DASH;
+        }
+        const elapsed = formatDurationLabel(Math.max(0, completed - started));
+        return elapsed ?? DASH;
+    }
+    function formatEvals(record) {
+        if (!record.evals || record.evals.length === 0) {
+            return DASH;
+        }
+        return record.evals
+            .map((evaluation) => colorize(evaluation.slug, getEvalStatusStyle(evaluation.status).cli))
+            .join(" ");
+    }
+    function upsertRecord(record) {
+        if (!agentOrder.includes(record.agentId)) {
+            agentOrder.push(record.agentId);
+        }
+        agentRecords.set(record.agentId, record);
+    }
+    function ensureFinalRender(report) {
+        if (!context) {
+            return;
+        }
+        context = {
+            ...context,
+            status: report.status,
+        };
+        render();
+    }
+    return {
+        begin(beginContext) {
+            guard(() => {
+                if (!beginContext) {
+                    render();
+                    return;
+                }
+                context = { ...beginContext };
+                render();
+            });
+        },
+        update(record) {
+            guard(() => {
+                upsertRecord(record);
+                render();
+            });
+        },
+        complete(report) {
+            let transcript = "";
+            guard(() => {
+                ensureFinalRender(report);
+                disabled = true;
+            });
+            const hint = {
+                message: `To review results:\n  voratiq review --run ${report.runId}`,
+            };
+            const sections = stdout.isTTY
+                ? undefined
+                : buildRunTranscriptSections(report);
+            transcript = renderTranscript({ sections, hint });
+            return transcript;
+        },
+    };
+}
+export function buildRunTranscriptSections(report) {
+    const sections = [];
+    const headerLines = [];
+    headerLines.push(`${report.runId} ${report.status.toUpperCase()}`);
+    sections.push(headerLines);
+    const agentLines = [];
+    const sortedAgents = [...report.agents].sort((a, b) => a.agentId.localeCompare(b.agentId));
+    for (const agent of sortedAgents) {
+        agentLines.push(`  ${agent.agentId} ${agent.status.toUpperCase()}`);
+    }
+    if (agentLines.length > 0) {
+        sections.push(agentLines);
+    }
+    return sections;
+}

package/dist/render/transcripts/shared.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSectionInput } from "../utils/agents.js";
+import type { RunDisplayInfo } from "../utils/runs.js";
+import type { TranscriptHintOptions } from "../utils/transcript.js";
+export interface TranscriptScaffoldOptions {
+    metadata: RunDisplayInfo;
+    agents: readonly AgentSectionInput[];
+    beforeAgents?: readonly string[][];
+    afterAgents?: readonly string[][];
+    warnings?: readonly string[];
+    hint?: TranscriptHintOptions;
+}
+export declare function renderTranscriptWithMetadata(options: TranscriptScaffoldOptions): string;

package/dist/render/transcripts/shared.js

@@ -0,0 +1,41 @@
+import { buildAgentSection } from "../utils/agents.js";
+import { buildRunMetadataSection } from "../utils/runs.js";
+import { renderTranscript } from "../utils/transcript.js";
+export function renderTranscriptWithMetadata(options) {
+    const sections = buildTranscriptSections(options);
+    return renderTranscript({ sections, hint: options.hint });
+}
+function buildTranscriptSections(options) {
+    const sections = [];
+    const metadataSection = buildRunMetadataSection(options.metadata);
+    if (metadataSection.length > 0) {
+        sections.push(metadataSection);
+    }
+    appendSections(sections, options.beforeAgents);
+    options.agents.forEach((agent) => {
+        const agentSection = buildAgentSection(agent);
+        if (agentSection.length > 0) {
+            sections.push(agentSection);
+        }
+    });
+    appendSections(sections, buildWarningSections(options.warnings));
+    appendSections(sections, options.afterAgents);
+    return sections;
+}
+function buildWarningSections(warnings) {
+    if (!warnings || warnings.length === 0) {
+        return undefined;
+    }
+    return warnings.map((warning) => [warning]);
+}
+function appendSections(sections, blocks) {
+    if (!blocks) {
+        return;
+    }
+    blocks.forEach((block) => {
+        if (block.length === 0) {
+            return;
+        }
+        sections.push(block);
+    });
+}

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

@@ -0,0 +1,28 @@
+import type { AgentEvalEnhanced, AgentInvocationEnhanced } from "../../records/enhanced.js";
+import type { AgentEvalView, AgentReport, AgentStatus } from "../../records/types.js";
+type AgentHeaderSource = Pick<AgentInvocationEnhanced, "agentId" | "status" | "startedAt" | "completedAt"> | Pick<AgentReport, "agentId" | "status" | "startedAt" | "completedAt">;
+type AgentSectionSource = AgentHeaderSource & {
+    diffStatistics?: string;
+    error?: string;
+    warnings?: string[];
+    baseDirectory?: string;
+    runtimeManifestPath?: string;
+    assets?: AgentInvocationEnhanced["assets"];
+    evals?: (AgentEvalEnhanced | AgentEvalView)[];
+};
+export type AgentSectionInput = AgentSectionSource;
+type AgentMetadataRow = {
+    label: string;
+    value: string;
+};
+export declare function formatAgentStatusLabel(status: AgentStatus): string;
+export declare function buildAgentSectionHeader(agent: AgentHeaderSource): string;
+export declare function getAgentMetadata(agent: AgentSectionSource): AgentMetadataRow[];
+export declare function buildAgentMetadataSection(agent: AgentSectionSource): string[];
+export declare function buildAgentSection(agent: AgentSectionSource): string[];
+export declare function buildAgentSectionArtifacts(agent: AgentSectionSource, agentRoot?: string): string[];
+export declare function buildAgentSectionEvals(agent: AgentSectionSource, agentRoot?: string): string[];
+export declare function buildAgentSectionRuntime(agent: AgentSectionSource, agentRoot?: string): string[];
+export declare function formatAgentDuration(agent: AgentHeaderSource): string | undefined;
+export declare function formatDurationLabel(durationMs: number): string | undefined;
+export {};

package/dist/render/utils/agents.js

@@ -0,0 +1,261 @@
+import { getAgentStatusStyle, getEvalStatusStyle, } from "../../status/colors.js";
+import { colorize } from "../../utils/colors.js";
+import { formatAgentBadge } from "./badges.js";
+import { renderTable } from "./table.js";
+export function formatAgentStatusLabel(status) {
+    const statusColor = getAgentStatusStyle(status).cli;
+    return colorize(status.toUpperCase(), statusColor);
+}
+export function buildAgentSectionHeader(agent) {
+    const agentLabel = formatAgentBadge(agent.agentId);
+    const status = agent.status;
+    const statusLabel = formatAgentStatusLabel(status);
+    return `  ${agentLabel} ${statusLabel}`;
+}
+export function getAgentMetadata(agent) {
+    const baseDir = agent.baseDirectory;
+    const candidates = [
+        { label: "Duration", value: formatAgentDuration(agent) },
+        { label: "Changes", value: agent.diffStatistics },
+        { label: "Root", value: baseDir },
+    ];
+    return candidates.filter((row) => typeof row.value === "string" && row.value.length > 0);
+}
+export function buildAgentMetadataSection(agent) {
+    const metadata = getAgentMetadata(agent);
+    if (metadata.length === 0) {
+        return [];
+    }
+    const tableLines = renderTable({
+        columns: [
+            {
+                header: "FIELD",
+                accessor: (row) => row.label,
+            },
+            {
+                header: "VALUE",
+                accessor: (row) => row.value,
+            },
+        ],
+        rows: metadata,
+    });
+    const [, ...bodyLines] = tableLines;
+    return bodyLines;
+}
+export function buildAgentSection(agent) {
+    const lines = [buildAgentSectionHeader(agent)];
+    const agentRoot = getAgentRootPath(agent);
+    const metadataLines = buildAgentMetadataSection(agent);
+    if (metadataLines.length > 0) {
+        lines.push("", ...indentLines(metadataLines));
+    }
+    const runtimeLines = buildAgentSectionRuntime(agent, agentRoot);
+    if (runtimeLines.length > 0) {
+        lines.push("", ...indentLines(runtimeLines));
+    }
+    if (agent.warnings && agent.warnings.length > 0) {
+        const warningLines = agent.warnings.map((warning) => colorize(`Warning: ${warning}`, "yellow"));
+        lines.push("", ...indentLines(warningLines));
+    }
+    if (agent.error) {
+        lines.push("", ...indentLines([colorize(`Error: ${agent.error}`, "red")]));
+    }
+    const evalLines = buildAgentSectionEvals(agent, agentRoot);
+    if (evalLines.length > 0) {
+        lines.push("", ...indentLines(evalLines));
+    }
+    const artifactLines = buildAgentSectionArtifacts(agent, agentRoot);
+    if (artifactLines.length > 0) {
+        lines.push("", ...indentLines(artifactLines));
+    }
+    return lines;
+}
+export function buildAgentSectionArtifacts(agent, agentRoot) {
+    const labelValuePairs = [
+        ["summary", agent.assets?.summaryPath],
+        ["diff", agent.assets?.diffPath],
+        ["chat", agent.assets?.chatPath],
+        ["stdout", agent.assets?.stdoutPath],
+        ["stderr", agent.assets?.stderrPath],
+    ];
+    const availablePairs = labelValuePairs.filter((pair) => typeof pair[1] === "string");
+    if (availablePairs.length === 0) {
+        return [];
+    }
+    const rows = availablePairs.map(([label, value]) => [
+        label,
+        relativizePath(value, agentRoot),
+    ]);
+    const tableLines = renderTable({
+        columns: [
+            {
+                header: "ARTIFACT",
+                accessor: (row) => row[0],
+            },
+            {
+                header: "PATH",
+                accessor: (row) => row[1],
+            },
+        ],
+        rows,
+    });
+    return tableLines;
+}
+export function buildAgentSectionEvals(agent, agentRoot) {
+    const evalResults = agent.evals ?? [];
+    const rows = evalResults.length === 0
+        ? [
+            {
+                slug: "none",
+                status: colorize("SKIPPED", getEvalStatusStyle("skipped").cli),
+                log: "—",
+            },
+        ]
+        : evalResults.map((evaluation) => ({
+            slug: evaluation.slug,
+            status: colorize(evaluation.status.toUpperCase(), getEvalStatusStyle(evaluation.status).cli),
+            log: evaluation.logPath !== undefined
+                ? relativizePath(evaluation.logPath, agentRoot)
+                : "—",
+        }));
+    const tableLines = renderTable({
+        columns: [
+            { header: "EVAL", accessor: (row) => row.slug },
+            { header: "STATUS", accessor: (row) => row.status },
+            { header: "LOG", accessor: (row) => row.log },
+        ],
+        rows,
+    });
+    return tableLines;
+}
+export function buildAgentSectionRuntime(agent, agentRoot) {
+    const rows = [];
+    if (typeof agent.runtimeManifestPath === "string" &&
+        agent.runtimeManifestPath.length > 0) {
+        rows.push([
+            "manifest",
+            relativizePath(agent.runtimeManifestPath, agentRoot),
+        ]);
+    }
+    const sandboxPath = deriveSandboxSettingsPath(agent);
+    if (sandboxPath) {
+        rows.push(["sandbox", relativizePath(sandboxPath, agentRoot)]);
+    }
+    if (rows.length === 0) {
+        return [];
+    }
+    const tableLines = renderTable({
+        columns: [
+            {
+                header: "RUNTIME",
+                accessor: (row) => row[0],
+            },
+            {
+                header: "PATH",
+                accessor: (row) => row[1],
+            },
+        ],
+        rows,
+    });
+    return tableLines;
+}
+export function formatAgentDuration(agent) {
+    const startedAt = safeParse(agent.startedAt);
+    const completedAt = safeParse(agent.completedAt);
+    if (startedAt === undefined ||
+        completedAt === undefined ||
+        completedAt < startedAt) {
+        return undefined;
+    }
+    const durationMs = completedAt - startedAt;
+    return formatDurationLabel(durationMs);
+}
+function safeParse(timestamp) {
+    if (!timestamp) {
+        return undefined;
+    }
+    const parsed = Date.parse(timestamp);
+    if (Number.isNaN(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+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(" ");
+}
+function getAgentRootPath(agent) {
+    if (typeof agent.baseDirectory === "string") {
+        return agent.baseDirectory;
+    }
+    const assets = agent.assets;
+    const candidates = [
+        assets?.summaryPath,
+        assets?.diffPath,
+        assets?.stdoutPath,
+        assets?.stderrPath,
+    ].filter((value) => typeof value === "string");
+    for (const candidate of candidates) {
+        const parent = parentDirectory(candidate);
+        if (parent) {
+            return stripWorkspaceSuffix(parent);
+        }
+    }
+    return undefined;
+}
+function parentDirectory(path) {
+    const segments = path.split("/").filter((segment) => segment.length > 0);
+    if (segments.length <= 1) {
+        return undefined;
+    }
+    return segments.slice(0, -1).join("/");
+}
+function stripWorkspaceSuffix(path) {
+    return path.endsWith("/workspace") ? path.slice(0, -10) : path;
+}
+function deriveSandboxSettingsPath(agent) {
+    if (typeof agent.baseDirectory === "string" &&
+        agent.baseDirectory.length > 0) {
+        return `${stripTrailingSlash(agent.baseDirectory)}/runtime/sandbox.json`;
+    }
+    if (typeof agent.runtimeManifestPath === "string" &&
+        agent.runtimeManifestPath.length > 0) {
+        const runtimeDir = parentDirectory(agent.runtimeManifestPath);
+        if (runtimeDir) {
+            return `${runtimeDir}/sandbox.json`;
+        }
+    }
+    return undefined;
+}
+function stripTrailingSlash(path) {
+    return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function relativizePath(path, root) {
+    if (!root) {
+        return path;
+    }
+    const normalizedRoot = root.endsWith("/") ? root : `${root}/`;
+    if (path.startsWith(normalizedRoot)) {
+        return path.slice(normalizedRoot.length);
+    }
+    return path;
+}
+function indentLines(lines) {
+    return lines.map((line) => (line.length > 0 ? `  ${line}` : line));
+}

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

@@ -0,0 +1,20 @@
+type AnsiCode = string;
+export interface BadgeStyle {
+    foreground?: AnsiCode;
+    background?: AnsiCode;
+    bold?: boolean;
+    padding?: number;
+}
+export declare const BADGE_STYLES: {
+    readonly run: {
+        readonly foreground: "\u001B[38;2;0;0;0m";
+        readonly background: "\u001B[48;2;164;203;153m";
+        readonly bold: true;
+    };
+    readonly agent: {
+        readonly bold: true;
+    };
+};
+export declare function formatRunBadge(text: string): string;
+export declare function formatAgentBadge(text: string): string;
+export {};

package/dist/render/utils/badges.js

@@ -0,0 +1,37 @@
+const ANSI_RESET = "\u001B[0m";
+const ANSI_BOLD = "\u001B[1m";
+const ESC = "\u001B[";
+const BRAND_COLOR = "164;203;153";
+export const BADGE_STYLES = {
+    run: {
+        foreground: `${ESC}38;2;0;0;0m`,
+        background: `${ESC}48;2;${BRAND_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 formatRunBadge(text) {
+    return applyBadgeStyle(text, BADGE_STYLES.run);
+}
+export function formatAgentBadge(text) {
+    return applyBadgeStyle(text, BADGE_STYLES.agent);
+}

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

@@ -0,0 +1,2 @@
+import { CliError } from "../../cli/errors.js";
+export declare function renderCliError(error: CliError): string;