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

package/dist/render/transcripts/message.js

@@ -0,0 +1,362 @@
+import { getAgentStatusStyle, getRunStatusStyle } from "../../status/colors.js";
+import { TERMINAL_MESSAGE_STATUSES } from "../../status/index.js";
+import { formatAgentErrorLine } from "../utils/agents.js";
+import { formatRenderLifecycleDuration } from "../utils/duration.js";
+import { createInteractiveFrameRenderer } from "../utils/interactive-frame.js";
+import { buildStageFrameLines, buildStageFrameSections, } 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 buildMessageStageShell(options) {
+    return {
+        metadataLines: buildStandardSessionShellSection({
+            badgeText: options.messageId,
+            badgeVariant: "message",
+            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 createMessageRenderer(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 recipientOrder = [];
+    const recipientRecords = new Map();
+    function stopRefreshLoop() {
+        if (!refreshInterval) {
+            return;
+        }
+        clearInterval(refreshInterval);
+        refreshInterval = undefined;
+    }
+    function hasRunningRecipients() {
+        for (const recipient of recipientRecords.values()) {
+            if (recipient.status === "running") {
+                return true;
+            }
+        }
+        return false;
+    }
+    function syncRefreshLoop() {
+        if (!stdout.isTTY || disabled || !context || !hasRunningRecipients()) {
+            stopRefreshLoop();
+            return;
+        }
+        if (refreshInterval) {
+            return;
+        }
+        refreshInterval = setInterval(() => {
+            guard(() => {
+                if (!stdout.isTTY || disabled || !context || !hasRunningRecipients()) {
+                    stopRefreshLoop();
+                    return;
+                }
+                const nextElapsed = formatMessageProgressElapsed(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 message 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: TERMINAL_MESSAGE_STATUSES,
+            now: now(),
+        }) ?? DASH);
+    }
+    function syncContextLifecycleFromRecipientRecords() {
+        if (!context) {
+            return;
+        }
+        let earliestStartedAt = safeParse(context.startedAt);
+        let latestCompletedAt = safeParse(context.completedAt);
+        for (const recipient of recipientRecords.values()) {
+            const startedAt = safeParse(recipient.startedAt);
+            if (startedAt !== undefined &&
+                (earliestStartedAt === undefined || startedAt < earliestStartedAt)) {
+                earliestStartedAt = startedAt;
+            }
+            const completedAt = safeParse(recipient.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 buildRecipientTable(style) {
+        if (recipientRecords.size === 0) {
+            return [];
+        }
+        const resolvedStyle = resolveTranscriptShellStyle(style);
+        const rows = recipientOrder
+            .filter((agentId) => recipientRecords.has(agentId))
+            .map((agentId) => {
+            const recipient = recipientRecords.get(agentId);
+            return {
+                agentId: recipient.agentId,
+                status: formatTranscriptStatusLabel(recipient.status, getAgentStatusStyle(recipient.status).cli, resolvedStyle),
+                duration: formatDuration(recipient),
+            };
+        });
+        return renderTranscriptStatusTable({
+            rows,
+            agent: (row) => row.agentId,
+            status: (row) => row.status,
+            duration: (row) => row.duration,
+        });
+    }
+    function render() {
+        if (!context || disabled || !stdout.isTTY) {
+            return;
+        }
+        syncContextLifecycleFromRecipientRecords();
+        const style = resolveTranscriptShellStyleFromWriter(stdout, { forceTty: true });
+        const elapsed = formatMessageProgressElapsed(context, now());
+        lastElapsedLabel = elapsed ?? null;
+        const shell = buildMessageStageShell({
+            messageId: context.messageId,
+            createdAt: context.createdAt,
+            elapsed: elapsed ?? DASH,
+            workspacePath: context.workspacePath,
+            status: context.status,
+            tableLines: buildRecipientTable(style),
+            style,
+        });
+        const interactiveLines = buildStageFrameLines({
+            metadataLines: shell.metadataLines,
+            statusTableLines: shell.statusTableLines,
+            leadingBlankLine: !suppressLeadingBlankLine,
+            trailingBlankLine: !suppressTrailingBlankLine,
+        });
+        if (interactiveLines.length === 0) {
+            return;
+        }
+        interactiveFrameRenderer.render(interactiveLines);
+    }
+    function upsertRecipient(record) {
+        if (!recipientOrder.includes(record.agentId)) {
+            recipientOrder.push(record.agentId);
+        }
+        const existing = recipientRecords.get(record.agentId);
+        recipientRecords.set(record.agentId, {
+            ...existing,
+            ...record,
+            startedAt: record.startedAt ?? existing?.startedAt,
+            completedAt: record.completedAt ?? existing?.completedAt,
+            outputPath: record.outputPath ?? existing?.outputPath,
+            tokenUsage: record.tokenUsage ?? existing?.tokenUsage,
+            tokenUsageResult: record.tokenUsageResult ?? existing?.tokenUsageResult,
+            error: record.error ?? existing?.error,
+        });
+    }
+    return {
+        begin(nextContext) {
+            guard(() => {
+                if (!nextContext) {
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                context = { ...nextContext };
+                render();
+                syncRefreshLoop();
+            });
+        },
+        update(record) {
+            guard(() => {
+                upsertRecipient(record);
+                render();
+                syncRefreshLoop();
+            });
+        },
+        complete(status, lifecycle) {
+            stopRefreshLoop();
+            guard(() => {
+                if (context && lifecycle) {
+                    context = {
+                        ...context,
+                        startedAt: lifecycle.startedAt ?? context.startedAt,
+                        completedAt: lifecycle.completedAt ?? context.completedAt,
+                    };
+                }
+                if (context && status) {
+                    context = {
+                        ...context,
+                        status,
+                    };
+                }
+                render();
+                disabled = true;
+            });
+        },
+    };
+}
+export function renderMessageTranscript(options) {
+    const { recipients, isTty, includeSummarySection = true } = options;
+    const style = { isTty };
+    const resolvedStyle = resolveTranscriptShellStyle(style);
+    const sections = [];
+    if (includeSummarySection) {
+        const shell = {
+            metadataLines: buildStandardSessionShellSection({
+                badgeText: options.messageId,
+                badgeVariant: "message",
+                status: {
+                    value: options.status,
+                    color: getRunStatusStyle(options.status).cli,
+                },
+                elapsed: options.elapsed,
+                createdAt: options.createdAt,
+                workspacePath: options.workspacePath,
+                style,
+            }),
+            statusTableLines: recipients.length > 0
+                ? renderTranscriptStatusTable({
+                    rows: recipients,
+                    agent: (row) => row.agentId,
+                    status: (row) => formatTranscriptStatusLabel(row.status, getAgentStatusStyle(row.status).cli, resolvedStyle),
+                    duration: (row) => row.duration,
+                })
+                : [],
+        };
+        sections.push(...buildStageFrameSections(shell));
+    }
+    if (recipients.length > 0) {
+        sections.push(["---"]);
+    }
+    recipients.forEach((recipient, index) => {
+        const block = [`Agent: ${recipient.agentId}`];
+        if (recipient.previewLines && recipient.previewLines.length > 0) {
+            block.push("", ...recipient.previewLines);
+        }
+        if (recipient.errorLine) {
+            const inlineError = recipient.errorLine.replace(/\s+/gu, " ").trim();
+            block.push("", formatAgentErrorLine(inlineError, style));
+        }
+        block.push("", `Output: ${recipient.outputPath ?? DASH}`);
+        if (index < recipients.length - 1) {
+            block.push("", "---");
+        }
+        sections.push(block);
+    });
+    return renderTranscript({ sections });
+}
+export function formatMessageElapsed(input) {
+    return formatRenderLifecycleDuration({
+        lifecycle: {
+            status: input.status,
+            startedAt: input.startedAt,
+            completedAt: input.completedAt,
+        },
+        terminalStatuses: TERMINAL_MESSAGE_STATUSES,
+        now: input.now,
+    });
+}
+export function formatMessageRecipientDuration(input) {
+    return formatRenderLifecycleDuration({
+        lifecycle: {
+            status: input.status,
+            startedAt: input.startedAt,
+            completedAt: input.completedAt,
+        },
+        terminalStatuses: ["succeeded", "failed", "aborted"],
+        now: input.now,
+    });
+}
+function formatMessageProgressElapsed(source, now) {
+    return formatMessageElapsed({
+        status: source.status,
+        startedAt: source.startedAt,
+        completedAt: source.completedAt,
+        now,
+    });
+}

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

@@ -1,8 +1,8 @@
-import type { PruneResult } from "../../commands/prune/types.js";
+import type { PruneAllResult, PruneResult } from "../../commands/prune/types.js";
+import type { RunRecord } from "../../domain/run/model/types.js";
 import type { RunStatus } from "../../status/index.js";
 export interface PruneConfirmationPrefaceOptions {
     runId: string;
-    specPath: string;
     runStatus: RunStatus;
     createdAt: string;
     runPath?: string;
@@ -13,4 +13,9 @@ export interface PruneConfirmationPrefaceOptions {
     previouslyDeletedAt?: string;
 }
 export declare function buildPruneConfirmationPreface(options: PruneConfirmationPrefaceOptions): string[];
+export interface PruneAllConfirmationPrefaceOptions {
+    records: readonly RunRecord[];
+}
+export declare function buildPruneAllConfirmationPreface(options: PruneAllConfirmationPrefaceOptions): string[];
 export declare function renderPruneTranscript(result: PruneResult): string;
+export declare function renderPruneAllTranscript(result: PruneAllResult): string;

package/dist/render/transcripts/prune.js

@@ -1,36 +1,65 @@
 import { colorize } from "../../utils/colors.js";
 import { formatRunTimestamp } from "../utils/records.js";
-import { buildRunMetadataSection } from "../utils/runs.js";
-import { renderTranscript } from "../utils/transcript.js";
+import { buildRunMetadataSectionWithStyle } from "../utils/runs.js";
+import { renderBlocks, renderTranscript } from "../utils/transcript.js";
+import { resolveTranscriptShellStyleFromWriter } from "../utils/transcript-shell.js";
+import { renderRunList } from "./list.js";
 export function buildPruneConfirmationPreface(options) {
-    const { runId, specPath, runStatus, createdAt, runPath, workspaces, directories, branches, purge, previouslyDeletedAt, } = options;
-    const introLines = buildRunMetadataSection({
+    const { runId, runStatus, createdAt, runPath, workspaces, directories, branches, purge, previouslyDeletedAt, } = options;
+    const introLines = buildRunMetadataSectionWithStyle({
         runId,
-        specPath,
         status: runStatus,
         workspacePath: runPath,
         createdAt: formatRunTimestamp(createdAt),
-    });
-    const lines = ["", ...introLines];
+    }, resolveTranscriptShellStyleFromWriter(process.stdout));
+    const sections = [];
+    const summaryLines = [...introLines];
     if (previouslyDeletedAt) {
-        lines.push(`Marked deleted: ${previouslyDeletedAt}`, "Proceeding will update the deletion timestamp.");
+        summaryLines.push(`Marked deleted: ${previouslyDeletedAt}`, "Proceeding will update the deletion timestamp.");
+    }
+    if (summaryLines.length > 0) {
+        sections.push(summaryLines);
     }
     if (purge) {
         if (directories.length > 0) {
-            lines.push("", "Directories to be deleted:");
-            directories.forEach((directory) => lines.push(`  - ${directory}`));
+            sections.push([
+                "Directories to be deleted:",
+                ...directories.map((directory) => `  - ${directory}`),
+            ]);
         }
     }
     else if (workspaces.length > 0) {
-        lines.push("", "Workspaces to be removed:");
-        workspaces.forEach((workspace) => lines.push(`  - ${workspace}`));
+        sections.push([
+            "Workspaces to be removed:",
+            ...workspaces.map((workspace) => `  - ${workspace}`),
+        ]);
     }
     if (branches.length > 0) {
-        lines.push("", "Branches to be deleted:");
-        branches.forEach((branch) => lines.push(`  - ${branch}`));
+        sections.push([
+            "Branches to be deleted:",
+            ...branches.map((branch) => `  - ${branch}`),
+        ]);
     }
-    lines.push("");
-    return lines;
+    return renderBlocks({
+        sections,
+        leadingBlankLine: true,
+        trailingBlankLine: true,
+    });
+}
+export function buildPruneAllConfirmationPreface(options) {
+    const { records } = options;
+    const tableOutput = renderRunList(records);
+    const sections = [];
+    if (tableOutput.trim().length > 0) {
+        sections.push(tableOutput.split("\n"));
+    }
+    const runLabel = records.length === 1 ? "run" : "runs";
+    sections.push([`${records.length} ${runLabel} to prune.`]);
+    return renderBlocks({
+        sections,
+        leadingBlankLine: true,
+        trailingBlankLine: true,
+    });
 }
 export function renderPruneTranscript(result) {
     if (result.status === "aborted") {
@@ -40,7 +69,7 @@ export function renderPruneTranscript(result) {
         return renderTranscript({
             sections,
             hint: {
-                message: `Re-run \`voratiq prune --run ${result.runId}\` when you are ready.`,
+                message: `Run \`voratiq prune --run ${result.runId}\` when ready.`,
             },
         });
     }
@@ -48,3 +77,21 @@ export function renderPruneTranscript(result) {
         sections: [[colorize("Run pruned successfully.", "green")]],
     });
 }
+export function renderPruneAllTranscript(result) {
+    if (result.status === "noop") {
+        return renderTranscript({
+            sections: [["No runs to prune."]],
+        });
+    }
+    if (result.status === "aborted") {
+        return renderTranscript({
+            sections: [[colorize("Prune aborted; no changes were made.", "yellow")]],
+            hint: {
+                message: "Run `voratiq prune --all` when ready.",
+            },
+        });
+    }
+    return renderTranscript({
+        sections: [[colorize("Runs pruned successfully.", "green")]],
+    });
+}

package/dist/render/transcripts/reduce.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 ReduceProgressContext {
+    reductionId: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    workspacePath: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+}
+export interface ReduceProgressReducerRecord {
+    reducerAgentId: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    startedAt?: string;
+    completedAt?: string;
+    tokenUsage?: ExtractedTokenUsage;
+    tokenUsageResult?: TokenUsageResult;
+}
+interface ReduceRendererOptions {
+    stdout?: CliWriter;
+    stderr?: CliWriter;
+    now?: () => number;
+    suppressLeadingBlankLine?: boolean;
+    suppressTrailingBlankLine?: boolean;
+}
+export interface ReduceProgressRenderer extends StageProgressEventConsumer<ReduceProgressContext, ReduceProgressReducerRecord> {
+    begin(context?: ReduceProgressContext): void;
+    update(record: ReduceProgressReducerRecord): void;
+    complete(status?: ReduceProgressContext["status"], lifecycle?: {
+        startedAt?: string;
+        completedAt?: string;
+    }): void;
+}
+export interface ReduceTranscriptReducerBlock {
+    reducerAgentId: string;
+    status: "queued" | "succeeded" | "failed" | "aborted" | "running";
+    duration: string;
+    outputPath?: string;
+    dataPath?: string;
+    previewLines?: string[];
+    errorLine?: string;
+}
+export interface ReduceTranscriptOptions {
+    reductionId: string;
+    createdAt: string;
+    elapsed: string;
+    workspacePath: string;
+    status: "queued" | "succeeded" | "failed" | "aborted" | "running";
+    reducers: readonly ReduceTranscriptReducerBlock[];
+    nextCommandLines?: readonly string[];
+    suppressHint?: boolean;
+    isTty?: boolean;
+    includeSummarySection?: boolean;
+}
+export declare function createReduceRenderer(options?: ReduceRendererOptions): ReduceProgressRenderer;
+export declare function renderReduceTranscript(options: ReduceTranscriptOptions): string;
+export declare function formatReducerDuration(options: {
+    status: ReduceProgressReducerRecord["status"];
+    startedAt?: string;
+    completedAt?: string;
+    now?: number;
+}): string;
+export declare function formatReduceElapsed(options: {
+    status: ReduceProgressContext["status"];
+    startedAt?: string;
+    completedAt?: string;
+    now?: number;
+}): string | undefined;
+export {};