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

package/dist/render/transcripts/run.js

@@ -1,23 +1,63 @@
-import { getEvalStatusStyle } from "../../status/colors.js";
-import { colorize } from "../../utils/colors.js";
+import { TERMINAL_RUN_STATUSES } from "../../status/index.js";
 import { formatCompactDiffStatistics } from "../../utils/diff.js";
-import { formatAgentDuration, formatAgentStatusLabel, formatDurationLabel, } from "../utils/agents.js";
+import { formatAgentDuration, formatAgentStatusLabelWithStyle, } from "../utils/agents.js";
 import { formatAgentBadge } from "../utils/badges.js";
+import { formatRenderLifecycleDuration } from "../utils/duration.js";
+import { createInteractiveFrameRenderer } from "../utils/interactive-frame.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";
+import { buildRunMetadataSectionWithStyle } from "../utils/runs.js";
+import { buildStageFrameLines, renderStageFinalFrame, } from "../utils/stage-output.js";
+import { renderTranscriptStatusTable, resolveTranscriptShellStyle, resolveTranscriptShellStyleFromWriter, } from "../utils/transcript-shell.js";
+const DASH = "—";
+export function formatRunElapsed(source, now) {
+    return formatRenderLifecycleDuration({
+        lifecycle: {
+            status: source.status,
+            startedAt: source.startedAt,
+            completedAt: source.completedAt,
+        },
+        terminalStatuses: TERMINAL_RUN_STATUSES,
+        now,
+    });
 }
-const ERASE_LINE = "\u001b[2K";
-const CURSOR_COLUMN_START = "\u001b[0G";
-function cursorUp(lines) {
-    return `\u001b[${lines}F`;
+export function renderRunTranscript(options) {
+    const style = resolveTranscriptShellStyle({ isTty: options.isTty });
+    const shell = {
+        metadataLines: buildRunMetadataSectionWithStyle({
+            runId: options.runId,
+            status: options.status,
+            workspacePath: options.workspacePath,
+            elapsed: formatRunElapsed({
+                status: options.status,
+                startedAt: options.startedAt,
+                completedAt: options.completedAt,
+            }, options.now) ?? DASH,
+            createdAt: formatRunTimestamp(options.createdAt),
+        }, style),
+        statusTableLines: options.agents.length === 0
+            ? []
+            : renderTranscriptStatusTable({
+                rows: options.agents.map((agent) => ({
+                    agentId: formatAgentBadge(agent.agentId, style),
+                    status: formatAgentStatusLabelWithStyle(agent.status, style),
+                    duration: agent.status === "running"
+                        ? DASH
+                        : (formatAgentDuration(agent, {
+                            now: options.now ?? Date.now(),
+                        }) ?? DASH),
+                    diff: formatCompactDiffStatistics(agent.diffStatistics) ?? DASH,
+                })),
+                agent: (row) => row.agentId,
+                status: (row) => row.status,
+                duration: (row) => row.duration,
+                extras: [{ header: "CHANGES", accessor: (row) => row.diff }],
+            }),
+    };
+    return renderStageFinalFrame({
+        metadataLines: shell.metadataLines,
+        statusTableLines: shell.statusTableLines,
+    });
 }
-const DASH = "—";
 function formatErrorDetail(error) {
     if (error instanceof Error) {
         return error.message;
@@ -53,14 +93,62 @@ export function createRunRenderer(options = {}) {
     const stdout = options.stdout ?? process.stdout;
     const stderr = options.stderr ?? process.stderr;
     const now = options.now ?? Date.now.bind(Date);
+    const suppressLeadingBlankLine = options.suppressLeadingBlankLine === true;
+    const suppressTrailingBlankLine = options.suppressTrailingBlankLine === true;
     let context;
-    let disabled = shouldSuppressRunStatusTable();
+    let disabled = false;
     let warningLogged = false;
-    let lastRenderedLines = 0;
-    let blockInitialized = false;
-    let metadataPrinted = false;
+    let refreshInterval;
+    let lastElapsedLabel = null;
+    const interactiveFrameRenderer = createInteractiveFrameRenderer(stdout);
     const agentOrder = [];
     const agentRecords = new Map();
+    function stopRefreshLoop() {
+        if (!refreshInterval) {
+            return;
+        }
+        clearInterval(refreshInterval);
+        refreshInterval = undefined;
+    }
+    function hasRunningAgents() {
+        for (const record of agentRecords.values()) {
+            if (record.status === "running") {
+                return true;
+            }
+        }
+        return false;
+    }
+    function syncRefreshLoop() {
+        if (!stdout.isTTY || disabled) {
+            stopRefreshLoop();
+            return;
+        }
+        if (!hasRunningAgents()) {
+            stopRefreshLoop();
+            return;
+        }
+        if (refreshInterval) {
+            return;
+        }
+        refreshInterval = setInterval(() => {
+            guard(() => {
+                if (!stdout.isTTY || disabled || !context) {
+                    stopRefreshLoop();
+                    return;
+                }
+                if (!hasRunningAgents()) {
+                    stopRefreshLoop();
+                    return;
+                }
+                const nextElapsed = formatRunElapsed(context);
+                if (nextElapsed === lastElapsedLabel) {
+                    return;
+                }
+                render();
+            });
+        }, 1000);
+        refreshInterval.unref?.();
+    }
     function guard(action) {
         if (disabled) {
             return;
@@ -70,6 +158,7 @@ export function createRunRenderer(options = {}) {
         }
         catch (error) {
             disabled = true;
+            stopRefreshLoop();
             if (!warningLogged) {
                 warningLogged = true;
                 const detail = formatErrorDetail(error);
@@ -77,84 +166,48 @@ export function createRunRenderer(options = {}) {
             }
         }
     }
-    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 resolveFinalContext(report) {
+        return {
+            runId: context?.runId ?? report.runId,
+            status: report.status,
+            workspacePath: context?.workspacePath ?? "",
+            createdAt: context?.createdAt ?? report.createdAt,
+            startedAt: context?.startedAt ?? report.startedAt,
+            completedAt: context?.completedAt ?? report.completedAt,
+        };
     }
-    function buildTableRefreshLines(tableLines) {
-        if (tableLines.length === 0) {
-            return [];
-        }
-        return ["", ...tableLines, ""];
+    function buildRunStageShell(source, style) {
+        const elapsedLabel = formatRunElapsed(source);
+        lastElapsedLabel = elapsedLabel ?? null;
+        return {
+            metadataLines: buildRunMetadataSectionWithStyle({
+                runId: source.runId,
+                status: source.status,
+                workspacePath: source.workspacePath,
+                elapsed: elapsedLabel,
+                createdAt: formatRunTimestamp(source.createdAt),
+            }, style),
+            statusTableLines: buildAgentTable(style),
+        };
     }
     function render() {
-        if (!context || disabled) {
+        if (!context || disabled || !stdout.isTTY) {
             return;
         }
-        const metadataLines = buildRunMetadataSection({
-            runId: context.runId,
-            status: context.status,
-            specPath: context.specPath,
-            workspacePath: context.workspacePath,
-            createdAt: formatRunTimestamp(context.createdAt),
-            baseRevisionSha: context.baseRevisionSha,
+        const style = resolveTranscriptShellStyleFromWriter(stdout, { forceTty: true });
+        const shell = buildRunStageShell(context, style);
+        const interactiveLines = buildStageFrameLines({
+            metadataLines: shell.metadataLines,
+            statusTableLines: shell.statusTableLines,
+            leadingBlankLine: !suppressLeadingBlankLine,
+            trailingBlankLine: !suppressTrailingBlankLine,
         });
-        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;
+        if (interactiveLines.length === 0) {
             return;
         }
-        if (!shouldIncludeTable) {
-            return;
-        }
-        const refreshLines = buildTableRefreshLines(tableLines);
-        if (refreshLines.length > 0) {
-            stdout.write(refreshLines.join("\n"));
-        }
+        interactiveFrameRenderer.render(interactiveLines);
     }
-    function buildAgentTable() {
+    function buildAgentTable(style) {
         if (agentRecords.size === 0) {
             return [];
         }
@@ -163,22 +216,18 @@ export function createRunRenderer(options = {}) {
             .map((agentId) => {
             const record = agentRecords.get(agentId);
             return {
-                agentId: formatAgentBadge(agentId),
-                status: formatAgentStatusLabel(record.status),
-                elapsed: formatElapsed(record),
+                agentId: formatAgentBadge(agentId, style),
+                status: formatAgentStatusLabelWithStyle(record.status, style),
+                duration: formatDuration(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 },
-            ],
+        return renderTranscriptStatusTable({
             rows,
+            agent: (row) => row.agentId,
+            status: (row) => row.status,
+            duration: (row) => row.duration,
+            extras: [{ header: "CHANGES", accessor: (row) => row.diff }],
         });
     }
     function formatDiffCell(value) {
@@ -188,45 +237,23 @@ export function createRunRenderer(options = {}) {
         }
         return value ?? DASH;
     }
-    function formatElapsed(record) {
-        if (!record.startedAt) {
+    function formatDuration(record) {
+        if (record.status === "running") {
             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;
+        const duration = formatAgentDuration(record, { now: now() });
+        return duration ?? 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 formatRunElapsed(source) {
+        return formatRenderLifecycleDuration({
+            lifecycle: {
+                status: source.status,
+                startedAt: source.startedAt,
+                completedAt: source.completedAt,
+            },
+            terminalStatuses: TERMINAL_RUN_STATUSES,
+            now: now(),
+        });
     }
     function upsertRecord(record) {
         if (!agentOrder.includes(record.agentId)) {
@@ -234,6 +261,22 @@ export function createRunRenderer(options = {}) {
         }
         agentRecords.set(record.agentId, record);
     }
+    function syncRecordsFromReport(report) {
+        const sortedAgents = [...report.agents].sort((a, b) => a.agentId.localeCompare(b.agentId));
+        for (const agent of sortedAgents) {
+            const existing = agentRecords.get(agent.agentId);
+            upsertRecord({
+                agentId: agent.agentId,
+                model: existing?.model ?? "unknown",
+                status: agent.status,
+                startedAt: agent.startedAt,
+                completedAt: agent.completedAt,
+                diffStatistics: agent.diffStatistics,
+                error: agent.error,
+                warnings: agent.warnings,
+            });
+        }
+    }
     function ensureFinalRender(report) {
         if (!context) {
             return;
@@ -241,55 +284,88 @@ export function createRunRenderer(options = {}) {
         context = {
             ...context,
             status: report.status,
+            startedAt: report.startedAt ?? context.startedAt,
+            completedAt: report.completedAt ?? context.completedAt,
         };
         render();
     }
     return {
+        onProgressEvent(event) {
+            guard(() => {
+                if (event.stage !== "run") {
+                    return;
+                }
+                if (event.type === "stage.begin") {
+                    context = { ...event.context };
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                if (event.type === "stage.candidate") {
+                    upsertRecord(event.candidate);
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                if (!context) {
+                    return;
+                }
+                context = {
+                    ...context,
+                    status: event.status,
+                };
+                render();
+                syncRefreshLoop();
+            });
+        },
         begin(beginContext) {
             guard(() => {
                 if (!beginContext) {
                     render();
+                    syncRefreshLoop();
                     return;
                 }
-                context = { ...beginContext };
-                render();
+                this.onProgressEvent({
+                    type: "stage.begin",
+                    stage: "run",
+                    context: beginContext,
+                });
             });
         },
         update(record) {
-            guard(() => {
-                upsertRecord(record);
-                render();
+            this.onProgressEvent({
+                type: "stage.candidate",
+                stage: "run",
+                candidate: record,
             });
         },
-        complete(report) {
-            let transcript = "";
+        complete(report, options) {
+            stopRefreshLoop();
+            syncRecordsFromReport(report);
             guard(() => {
+                this.onProgressEvent({
+                    type: "stage.status",
+                    stage: "run",
+                    status: report.status,
+                });
                 ensureFinalRender(report);
                 disabled = true;
             });
-            const hint = {
-                message: `To review results:\n  voratiq review --run ${report.runId}`,
-            };
-            const sections = stdout.isTTY
+            const hint = options?.suppressHint
                 ? undefined
-                : buildRunTranscriptSections(report);
-            transcript = renderTranscript({ sections, hint });
-            return transcript;
+                : {
+                    message: `To verify results:\n  voratiq verify --run ${report.runId}`,
+                };
+            if (stdout.isTTY) {
+                return hint?.message ?? "";
+            }
+            const finalContext = resolveFinalContext(report);
+            const finalShell = buildRunStageShell(finalContext, { isTty: false });
+            return renderStageFinalFrame({
+                metadataLines: finalShell.metadataLines,
+                statusTableLines: finalShell.statusTableLines,
+                hint,
+            });
         },
     };
 }
-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

@@ -8,5 +8,7 @@ export interface TranscriptScaffoldOptions {
     afterAgents?: readonly string[][];
     warnings?: readonly string[];
     hint?: TranscriptHintOptions;
+    isTty?: boolean;
 }
+export declare function renderWorkspaceAutoInitializedNotice(): string;
 export declare function renderTranscriptWithMetadata(options: TranscriptScaffoldOptions): string;

package/dist/render/transcripts/shared.js

@@ -1,19 +1,26 @@
-import { buildAgentSection } from "../utils/agents.js";
-import { buildRunMetadataSection } from "../utils/runs.js";
+import { buildAgentSectionWithStyle } from "../utils/agents.js";
+import { buildRunMetadataSectionWithStyle } from "../utils/runs.js";
 import { renderTranscript } from "../utils/transcript.js";
+export function renderWorkspaceAutoInitializedNotice() {
+    return "Voratiq initialized (.voratiq/).";
+}
 export function renderTranscriptWithMetadata(options) {
     const sections = buildTranscriptSections(options);
     return renderTranscript({ sections, hint: options.hint });
 }
 function buildTranscriptSections(options) {
     const sections = [];
-    const metadataSection = buildRunMetadataSection(options.metadata);
+    const metadataSection = buildRunMetadataSectionWithStyle(options.metadata, {
+        isTty: options.isTty,
+    });
     if (metadataSection.length > 0) {
         sections.push(metadataSection);
     }
     appendSections(sections, options.beforeAgents);
     options.agents.forEach((agent) => {
-        const agentSection = buildAgentSection(agent);
+        const agentSection = buildAgentSectionWithStyle(agent, {
+            isTty: options.isTty,
+        });
         if (agentSection.length > 0) {
             sections.push(agentSection);
         }

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

@@ -0,0 +1,74 @@
+import type { ExtractedTokenUsage } from "../../domain/run/model/types.js";
+import type { TokenUsageResult } from "../../workspace/chat/token-usage-result.js";
+import type { StageProgressEventConsumer } from "./stage-progress.js";
+type CliWriter = Pick<NodeJS.WriteStream, "write"> & {
+    isTTY?: boolean;
+    columns?: number;
+};
+export interface SpecProgressContext {
+    sessionId: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    workspacePath: string;
+    status: "running" | "succeeded" | "failed" | "aborted";
+}
+export interface SpecProgressAgentRecord {
+    agentId: string;
+    status: "queued" | "running" | "succeeded" | "failed";
+    startedAt?: string;
+    completedAt?: string;
+    tokenUsage?: ExtractedTokenUsage;
+    tokenUsageResult?: TokenUsageResult;
+}
+interface SpecRendererOptions {
+    stdout?: CliWriter;
+    stderr?: CliWriter;
+    now?: () => number;
+    suppressLeadingBlankLine?: boolean;
+    suppressTrailingBlankLine?: boolean;
+}
+export interface SpecProgressRenderer extends StageProgressEventConsumer<SpecProgressContext, SpecProgressAgentRecord> {
+    begin(context?: SpecProgressContext): void;
+    update(record: SpecProgressAgentRecord): void;
+    complete(status?: SpecProgressContext["status"], lifecycle?: {
+        startedAt?: string;
+        completedAt?: string;
+    }): void;
+}
+export interface SpecTranscriptAgentBlock {
+    agentId: string;
+    status: "queued" | "running" | "succeeded" | "failed";
+    duration: string;
+    outputPath?: string;
+    dataPath?: string;
+    previewLines?: readonly string[];
+    errorLine?: string;
+}
+export interface SpecTranscriptOptions {
+    sessionId: string;
+    createdAt: string;
+    elapsed: string;
+    workspacePath: string;
+    status: "running" | "succeeded" | "failed" | "aborted";
+    agents: readonly SpecTranscriptAgentBlock[];
+    nextCommandLines?: readonly string[];
+    isTty?: boolean;
+    includeSummarySection?: boolean;
+}
+export declare function createSpecRenderer(options?: SpecRendererOptions): SpecProgressRenderer;
+export declare function formatSpecElapsed(options: {
+    status: SpecProgressContext["status"];
+    startedAt?: string;
+    completedAt?: string;
+}, now?: number): string | undefined;
+export declare function formatSpecAgentDuration(options: {
+    status: SpecTranscriptAgentBlock["status"];
+    startedAt?: string;
+    completedAt?: string;
+    now?: number;
+}): string;
+export declare function renderSpecTranscript(input: SpecTranscriptOptions | string, options?: {
+    suppressHint?: boolean;
+}): string;
+export {};