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

package/dist/render/transcripts/spec.js

@@ -0,0 +1,394 @@
+import { getAgentStatusStyle, getRunStatusStyle } from "../../status/colors.js";
+import { TERMINAL_SPEC_STATUSES } from "../../status/index.js";
+import { formatAgentErrorLine } from "../utils/agents.js";
+import { formatAgentBadge } from "../utils/badges.js";
+import { formatRenderLifecycleDuration } from "../utils/duration.js";
+import { createInteractiveFrameRenderer } from "../utils/interactive-frame.js";
+import { buildStageFrameLines, buildStageFrameSections, renderStageFinalFrame, } from "../utils/stage-output.js";
+import { renderTranscript } from "../utils/transcript.js";
+import { buildStandardSessionShellSection, formatTranscriptStatusLabel, renderTranscriptStatusTable, resolveTranscriptShellStyle, resolveTranscriptShellStyleFromWriter, } from "../utils/transcript-shell.js";
+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 serialization errors and fall back.
+        }
+    }
+    return "unknown error";
+}
+function buildSpecStageShell(options) {
+    return {
+        metadataLines: buildStandardSessionShellSection({
+            badgeText: options.sessionId,
+            badgeVariant: "spec",
+            status: {
+                value: options.status,
+                color: getRunStatusStyle(options.status).cli,
+            },
+            elapsed: options.elapsed,
+            createdAt: options.createdAt,
+            workspacePath: options.workspacePath,
+            style: options.style,
+        }),
+        statusTableLines: options.tableLines ?? [],
+    };
+}
+export function createSpecRenderer(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 = false;
+    let warningLogged = 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 agent of agentRecords.values()) {
+            if (agent.status === "running") {
+                return true;
+            }
+        }
+        return false;
+    }
+    function syncRefreshLoop() {
+        if (!stdout.isTTY || disabled || !context || !hasRunningAgents()) {
+            stopRefreshLoop();
+            return;
+        }
+        if (refreshInterval) {
+            return;
+        }
+        refreshInterval = setInterval(() => {
+            guard(() => {
+                if (!stdout.isTTY || disabled || !context || !hasRunningAgents()) {
+                    stopRefreshLoop();
+                    return;
+                }
+                const nextElapsed = formatSpecElapsed(context, now());
+                if (nextElapsed === lastElapsedLabel) {
+                    return;
+                }
+                render();
+            });
+        }, 1000);
+        refreshInterval.unref?.();
+    }
+    function guard(action) {
+        if (disabled) {
+            return;
+        }
+        try {
+            action();
+        }
+        catch (error) {
+            disabled = true;
+            stopRefreshLoop();
+            if (!warningLogged) {
+                warningLogged = true;
+                stderr.write(`[voratiq] Progressive spec output disabled: ${formatErrorDetail(error)}\n`);
+            }
+        }
+    }
+    function safeParse(value) {
+        if (!value) {
+            return undefined;
+        }
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    function formatDuration(record) {
+        if (record.status === "running") {
+            return DASH;
+        }
+        return (formatRenderLifecycleDuration({
+            lifecycle: {
+                status: record.status,
+                startedAt: record.startedAt,
+                completedAt: record.completedAt,
+            },
+            terminalStatuses: ["succeeded", "failed"],
+            now: now(),
+        }) ?? DASH);
+    }
+    function syncContextLifecycleFromAgentRecords() {
+        if (!context) {
+            return;
+        }
+        let earliestStartedAt = safeParse(context.startedAt);
+        let latestCompletedAt = safeParse(context.completedAt);
+        for (const agent of agentRecords.values()) {
+            const startedAt = safeParse(agent.startedAt);
+            if (startedAt !== undefined &&
+                (earliestStartedAt === undefined || startedAt < earliestStartedAt)) {
+                earliestStartedAt = startedAt;
+            }
+            const completedAt = safeParse(agent.completedAt);
+            if (completedAt !== undefined &&
+                (latestCompletedAt === undefined || completedAt > latestCompletedAt)) {
+                latestCompletedAt = completedAt;
+            }
+        }
+        context = {
+            ...context,
+            startedAt: earliestStartedAt === undefined
+                ? undefined
+                : new Date(earliestStartedAt).toISOString(),
+            completedAt: latestCompletedAt === undefined
+                ? undefined
+                : new Date(latestCompletedAt).toISOString(),
+        };
+    }
+    function buildAgentTable(style) {
+        if (agentRecords.size === 0) {
+            return [];
+        }
+        const resolvedStyle = resolveTranscriptShellStyle(style);
+        const rows = agentOrder
+            .map((agentId) => {
+            const agent = agentRecords.get(agentId);
+            if (!agent) {
+                return undefined;
+            }
+            return {
+                agentId: formatAgentBadge(agent.agentId, style),
+                status: formatTranscriptStatusLabel(agent.status, getAgentStatusStyle(agent.status).cli, resolvedStyle),
+                duration: formatDuration(agent),
+            };
+        })
+            .filter((row) => row !== undefined);
+        return renderTranscriptStatusTable({
+            rows,
+            agent: (row) => row.agentId,
+            status: (row) => row.status,
+            duration: (row) => row.duration,
+        });
+    }
+    function render() {
+        if (!context || disabled || !stdout.isTTY) {
+            return;
+        }
+        syncContextLifecycleFromAgentRecords();
+        const style = resolveTranscriptShellStyleFromWriter(stdout, { forceTty: true });
+        const elapsed = formatSpecElapsed(context, now());
+        lastElapsedLabel = elapsed ?? null;
+        const shell = buildSpecStageShell({
+            sessionId: context.sessionId,
+            createdAt: context.createdAt,
+            elapsed: elapsed ?? DASH,
+            workspacePath: context.workspacePath,
+            status: context.status,
+            tableLines: buildAgentTable(style),
+            style,
+        });
+        const interactiveLines = buildStageFrameLines({
+            metadataLines: shell.metadataLines,
+            statusTableLines: shell.statusTableLines,
+            leadingBlankLine: !suppressLeadingBlankLine,
+            trailingBlankLine: !suppressTrailingBlankLine,
+        });
+        if (interactiveLines.length === 0) {
+            return;
+        }
+        interactiveFrameRenderer.render(interactiveLines);
+    }
+    function upsertAgent(record) {
+        if (!agentOrder.includes(record.agentId)) {
+            agentOrder.push(record.agentId);
+        }
+        const existing = agentRecords.get(record.agentId);
+        agentRecords.set(record.agentId, {
+            ...existing,
+            ...record,
+            startedAt: record.startedAt ?? existing?.startedAt,
+            completedAt: record.completedAt ?? existing?.completedAt,
+        });
+    }
+    return {
+        onProgressEvent(event) {
+            guard(() => {
+                if (event.stage !== "spec") {
+                    return;
+                }
+                if (event.type === "stage.begin") {
+                    context = { ...event.context };
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                if (event.type === "stage.candidate") {
+                    upsertAgent(event.candidate);
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                if (!context) {
+                    return;
+                }
+                context = {
+                    ...context,
+                    status: event.status,
+                };
+                render();
+                syncRefreshLoop();
+            });
+        },
+        begin(nextContext) {
+            guard(() => {
+                if (!nextContext) {
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                this.onProgressEvent({
+                    type: "stage.begin",
+                    stage: "spec",
+                    context: nextContext,
+                });
+            });
+        },
+        update(record) {
+            this.onProgressEvent({
+                type: "stage.candidate",
+                stage: "spec",
+                candidate: record,
+            });
+        },
+        complete(status, lifecycle) {
+            stopRefreshLoop();
+            guard(() => {
+                if (context && lifecycle) {
+                    context = {
+                        ...context,
+                        startedAt: lifecycle.startedAt ?? context.startedAt,
+                        completedAt: lifecycle.completedAt ?? context.completedAt,
+                    };
+                }
+                if (status) {
+                    this.onProgressEvent({
+                        type: "stage.status",
+                        stage: "spec",
+                        status,
+                    });
+                }
+                else {
+                    render();
+                }
+                disabled = true;
+            });
+        },
+    };
+}
+export function formatSpecElapsed(options, now) {
+    return formatRenderLifecycleDuration({
+        lifecycle: {
+            status: options.status,
+            startedAt: options.startedAt,
+            completedAt: options.completedAt,
+        },
+        terminalStatuses: TERMINAL_SPEC_STATUSES,
+        now,
+    });
+}
+export function formatSpecAgentDuration(options) {
+    return (formatRenderLifecycleDuration({
+        lifecycle: {
+            status: options.status,
+            startedAt: options.startedAt,
+            completedAt: options.completedAt,
+        },
+        terminalStatuses: ["succeeded", "failed"],
+        now: options.now,
+    }) ?? DASH);
+}
+export function renderSpecTranscript(input, options = {}) {
+    const { suppressHint } = options;
+    if (typeof input === "string") {
+        return renderStageFinalFrame({
+            metadataLines: [`Spec saved: ${input}`],
+        });
+    }
+    const { sessionId, createdAt, elapsed, workspacePath, status, agents, nextCommandLines, isTty, includeSummarySection = true, } = input;
+    const style = { isTty };
+    const resolvedStyle = resolveTranscriptShellStyle(style);
+    const sections = [];
+    if (includeSummarySection) {
+        const summaryShell = buildSpecStageShell({
+            sessionId,
+            createdAt,
+            elapsed,
+            workspacePath,
+            status,
+            tableLines: agents.length > 0
+                ? renderTranscriptStatusTable({
+                    rows: agents,
+                    agent: (row) => row.agentId,
+                    status: (row) => formatTranscriptStatusLabel(row.status, getAgentStatusStyle(row.status).cli, resolvedStyle),
+                    duration: (row) => row.duration,
+                })
+                : [],
+            style,
+        });
+        sections.push(...buildStageFrameSections(summaryShell));
+    }
+    if (agents.length > 0) {
+        sections.push(["---"]);
+    }
+    agents.forEach((agent, index) => {
+        const block = [`Agent: ${agent.agentId}`];
+        if (agent.previewLines && agent.previewLines.length > 0) {
+            block.push("", ...agent.previewLines);
+        }
+        if (agent.errorLine) {
+            const inlineError = agent.errorLine.replace(/\s+/gu, " ").trim();
+            block.push("", formatAgentErrorLine(inlineError, style));
+        }
+        block.push("", `Output: ${agent.outputPath ?? DASH}`);
+        if (index < agents.length - 1) {
+            block.push("", "---");
+        }
+        sections.push(block);
+    });
+    const hint = suppressHint || !nextCommandLines || nextCommandLines.length === 0
+        ? undefined
+        : {
+            message: `---\n\nTo run a spec:\n${nextCommandLines
+                .map((line) => `  ${line}`)
+                .join("\n")}`,
+        };
+    return renderTranscript({ sections, hint });
+}

package/dist/render/transcripts/stage-progress.d.ts

@@ -0,0 +1,22 @@
+export type StageRendererId = "spec" | "run" | "reduce" | "verify" | "message";
+export type StageProgressStatus = "queued" | "running" | "succeeded" | "failed" | "errored" | "aborted" | "skipped" | "pruned";
+export interface StageProgressBeginEvent<TContext extends object> {
+    type: "stage.begin";
+    stage: StageRendererId;
+    context: TContext;
+}
+export interface StageProgressCandidateEvent<TCandidate extends object> {
+    type: "stage.candidate";
+    stage: StageRendererId;
+    candidate: TCandidate;
+}
+export interface StageProgressStatusEvent {
+    type: "stage.status";
+    stage: StageRendererId;
+    status: StageProgressStatus;
+}
+export type StageProgressEvent<TContext extends object, TCandidate extends object> = StageProgressBeginEvent<TContext> | StageProgressCandidateEvent<TCandidate> | StageProgressStatusEvent;
+export interface StageProgressEventConsumer<TContext extends object, TCandidate extends object> {
+    onProgressEvent(event: StageProgressEvent<TContext, TCandidate>): void;
+}
+export declare function emitStageProgressEvent<TContext extends object, TCandidate extends object>(consumer: StageProgressEventConsumer<TContext, TCandidate> | undefined, event: StageProgressEvent<TContext, TCandidate>): void;

package/dist/render/transcripts/stage-progress.js

@@ -0,0 +1,6 @@
+export function emitStageProgressEvent(consumer, event) {
+    if (!consumer) {
+        return;
+    }
+    consumer.onProgressEvent(event);
+}

package/dist/render/transcripts/update-check.d.ts

@@ -0,0 +1,2 @@
+export declare function renderUpdatePromptPreface(notice: string, firstPrompt: boolean): string[];
+export declare function renderUpdateProgressLines(): string[];

package/dist/render/transcripts/update-check.js

@@ -0,0 +1,22 @@
+import { renderBlocks } from "../utils/transcript.js";
+const UPDATE_COMMAND_TEXT = "npm install -g voratiq@latest";
+export function renderUpdatePromptPreface(notice, firstPrompt) {
+    const sections = [
+        [notice],
+        [
+            "What would you like to do?",
+            `  [1] Update now (${UPDATE_COMMAND_TEXT})`,
+            "  [2] Skip",
+        ],
+    ];
+    return renderBlocks({
+        sections,
+        leadingBlankLine: firstPrompt,
+    });
+}
+export function renderUpdateProgressLines() {
+    return renderBlocks({
+        sections: [[`Updating Voratiq via \`${UPDATE_COMMAND_TEXT}\``]],
+        leadingBlankLine: true,
+    });
+}

package/dist/render/transcripts/verify.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 VerifyProgressContext {
+    verificationId: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    workspacePath: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+}
+export interface VerifyProgressMethodRecord {
+    methodKey: string;
+    verifierLabel: string;
+    agentLabel?: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    startedAt?: string;
+    completedAt?: string;
+    artifactPath?: string;
+    tokenUsage?: ExtractedTokenUsage;
+    tokenUsageResult?: TokenUsageResult;
+}
+interface VerifyRendererOptions {
+    stdout?: CliWriter;
+    stderr?: CliWriter;
+    now?: () => number;
+    suppressLeadingBlankLine?: boolean;
+    suppressTrailingBlankLine?: boolean;
+}
+export interface VerifyProgressRenderer extends StageProgressEventConsumer<VerifyProgressContext, VerifyProgressMethodRecord> {
+    begin(context?: VerifyProgressContext): void;
+    update(record: VerifyProgressMethodRecord): void;
+    complete(status?: VerifyProgressContext["status"], lifecycle?: {
+        startedAt?: string;
+        completedAt?: string;
+    }): void;
+}
+export interface VerifyTranscriptMethodBlock {
+    verifierLabel: string;
+    agentLabel?: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    duration: string;
+    artifactPath?: string;
+    bodyLines?: readonly string[];
+    errorLine?: string;
+}
+export declare function createVerifyRenderer(options?: VerifyRendererOptions): VerifyProgressRenderer;
+export declare function renderVerifyTranscript(options: {
+    verificationId: string;
+    createdAt: string;
+    elapsed: string;
+    workspacePath: string;
+    target?: {
+        kind: string;
+        sessionId: string;
+    };
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    methods: readonly VerifyTranscriptMethodBlock[];
+    suppressHint?: boolean;
+    warningMessage?: string;
+    hintMessage?: string;
+    isTty?: boolean;
+    includeSummarySection?: boolean;
+}): string;
+export declare function formatVerifyElapsed(source: {
+    status: VerifyProgressContext["status"];
+    startedAt?: string;
+    completedAt?: string;
+}, now?: number): string | undefined;
+export {};