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

package/dist/render/transcripts/reduce.js

@@ -0,0 +1,395 @@
+import { getAgentStatusStyle, getRunStatusStyle } from "../../status/colors.js";
+import { TERMINAL_REDUCTION_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 buildReduceStageShell(options) {
+    return {
+        metadataLines: buildStandardSessionShellSection({
+            badgeText: options.reductionId,
+            badgeVariant: "reduce",
+            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 createReduceRenderer(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 reducerOrder = [];
+    const reducerRecords = new Map();
+    function stopRefreshLoop() {
+        if (!refreshInterval) {
+            return;
+        }
+        clearInterval(refreshInterval);
+        refreshInterval = undefined;
+    }
+    function hasRunningReducers() {
+        for (const reducer of reducerRecords.values()) {
+            if (reducer.status === "running") {
+                return true;
+            }
+        }
+        return false;
+    }
+    function syncRefreshLoop() {
+        if (!stdout.isTTY || disabled || !context || !hasRunningReducers()) {
+            stopRefreshLoop();
+            return;
+        }
+        if (refreshInterval) {
+            return;
+        }
+        refreshInterval = setInterval(() => {
+            guard(() => {
+                if (!stdout.isTTY || disabled || !context || !hasRunningReducers()) {
+                    stopRefreshLoop();
+                    return;
+                }
+                const nextElapsed = formatReduceProgressElapsed(context);
+                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 reduce output disabled: ${formatErrorDetail(error)}\n`);
+            }
+        }
+    }
+    function formatReduceProgressElapsed(source) {
+        return formatRenderLifecycleDuration({
+            lifecycle: {
+                status: source.status,
+                startedAt: source.startedAt,
+                completedAt: source.completedAt,
+            },
+            terminalStatuses: TERMINAL_REDUCTION_STATUSES,
+            now: now(),
+        });
+    }
+    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_REDUCTION_STATUSES,
+            now: now(),
+        }) ?? DASH);
+    }
+    function syncContextLifecycleFromReducerRecords() {
+        if (!context) {
+            return;
+        }
+        let earliestStartedAt = safeParse(context.startedAt);
+        let latestCompletedAt = safeParse(context.completedAt);
+        for (const reducer of reducerRecords.values()) {
+            const startedAt = safeParse(reducer.startedAt);
+            if (startedAt !== undefined &&
+                (earliestStartedAt === undefined || startedAt < earliestStartedAt)) {
+                earliestStartedAt = startedAt;
+            }
+            const completedAt = safeParse(reducer.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 buildReducerTable(style) {
+        if (reducerRecords.size === 0) {
+            return [];
+        }
+        const resolvedStyle = resolveTranscriptShellStyle(style);
+        const rows = reducerOrder
+            .filter((reducerId) => reducerRecords.has(reducerId))
+            .map((reducerId) => {
+            const reducer = reducerRecords.get(reducerId);
+            return {
+                reducerAgentId: reducer.reducerAgentId,
+                status: formatTranscriptStatusLabel(reducer.status, getAgentStatusStyle(reducer.status).cli, resolvedStyle),
+                duration: formatDuration(reducer),
+            };
+        });
+        return renderTranscriptStatusTable({
+            rows,
+            agent: (row) => row.reducerAgentId,
+            status: (row) => row.status,
+            duration: (row) => row.duration,
+        });
+    }
+    function render() {
+        if (!context || disabled || !stdout.isTTY) {
+            return;
+        }
+        syncContextLifecycleFromReducerRecords();
+        const style = resolveTranscriptShellStyleFromWriter(stdout, { forceTty: true });
+        const elapsed = formatReduceProgressElapsed(context);
+        lastElapsedLabel = elapsed ?? null;
+        const shell = buildReduceStageShell({
+            reductionId: context.reductionId,
+            createdAt: context.createdAt,
+            elapsed: elapsed ?? DASH,
+            workspacePath: context.workspacePath,
+            status: context.status,
+            tableLines: buildReducerTable(style),
+            style,
+        });
+        const interactiveLines = buildStageFrameLines({
+            metadataLines: shell.metadataLines,
+            statusTableLines: shell.statusTableLines,
+            leadingBlankLine: !suppressLeadingBlankLine,
+            trailingBlankLine: !suppressTrailingBlankLine,
+        });
+        if (interactiveLines.length === 0) {
+            return;
+        }
+        interactiveFrameRenderer.render(interactiveLines);
+    }
+    function upsertReducer(record) {
+        if (!reducerOrder.includes(record.reducerAgentId)) {
+            reducerOrder.push(record.reducerAgentId);
+        }
+        const existing = reducerRecords.get(record.reducerAgentId);
+        reducerRecords.set(record.reducerAgentId, {
+            ...existing,
+            ...record,
+            startedAt: record.startedAt ?? existing?.startedAt,
+            completedAt: record.completedAt ?? existing?.completedAt,
+        });
+    }
+    return {
+        onProgressEvent(event) {
+            guard(() => {
+                if (event.stage !== "reduce") {
+                    return;
+                }
+                if (event.type === "stage.begin") {
+                    context = { ...event.context };
+                    render();
+                    syncRefreshLoop();
+                    return;
+                }
+                if (event.type === "stage.candidate") {
+                    upsertReducer(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: "reduce",
+                    context: nextContext,
+                });
+            });
+        },
+        update(record) {
+            this.onProgressEvent({
+                type: "stage.candidate",
+                stage: "reduce",
+                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: "reduce",
+                        status,
+                    });
+                }
+                else {
+                    render();
+                }
+                disabled = true;
+            });
+        },
+    };
+}
+export function renderReduceTranscript(options) {
+    const { reductionId, createdAt, elapsed, workspacePath, status, reducers, nextCommandLines, suppressHint, isTty, includeSummarySection = true, } = options;
+    const style = { isTty };
+    const resolvedStyle = resolveTranscriptShellStyle(style);
+    const sections = [];
+    if (includeSummarySection) {
+        const summaryShell = buildReduceStageShell({
+            reductionId,
+            createdAt,
+            elapsed,
+            workspacePath,
+            status,
+            tableLines: reducers.length > 0
+                ? renderTranscriptStatusTable({
+                    rows: reducers,
+                    agent: (row) => row.reducerAgentId,
+                    status: (row) => formatTranscriptStatusLabel(row.status, getAgentStatusStyle(row.status === "running" ? "running" : row.status).cli, resolvedStyle),
+                    duration: (row) => row.duration,
+                })
+                : [],
+            style,
+        });
+        sections.push(...buildStageFrameSections(summaryShell));
+    }
+    if (reducers.length > 0) {
+        sections.push(["---"]);
+    }
+    reducers.forEach((reducer, index) => {
+        const block = [`Agent: ${reducer.reducerAgentId}`];
+        if (reducer.previewLines && reducer.previewLines.length > 0) {
+            block.push("", ...reducer.previewLines);
+        }
+        if (reducer.errorLine) {
+            const inlineError = reducer.errorLine.replace(/\s+/gu, " ").trim();
+            block.push("", formatAgentErrorLine(inlineError, style));
+        }
+        block.push("", `Output: ${reducer.outputPath ?? DASH}`);
+        if (index < reducers.length - 1) {
+            block.push("", "---");
+        }
+        sections.push(block);
+    });
+    const hint = suppressHint || !nextCommandLines || nextCommandLines.length === 0
+        ? undefined
+        : {
+            message: `---\n\nNext:\n${nextCommandLines
+                .map((line) => `  ${line}`)
+                .join("\n")}`,
+        };
+    return renderTranscript({ sections, hint });
+}
+export function formatReducerDuration(options) {
+    return (formatRenderLifecycleDuration({
+        lifecycle: {
+            status: options.status,
+            startedAt: options.startedAt,
+            completedAt: options.completedAt,
+        },
+        terminalStatuses: TERMINAL_REDUCTION_STATUSES,
+        now: options.now,
+    }) ?? "—");
+}
+export function formatReduceElapsed(options) {
+    return formatRenderLifecycleDuration({
+        lifecycle: {
+            status: options.status,
+            startedAt: options.startedAt,
+            completedAt: options.completedAt,
+        },
+        terminalStatuses: TERMINAL_REDUCTION_STATUSES,
+        now: options.now,
+    });
+}

package/dist/render/transcripts/root-launcher.d.ts

@@ -0,0 +1,19 @@
+export interface RootLauncherAvailableAgentLine {
+    label: string;
+}
+export interface RootLauncherUnavailableAgentLine {
+    label: string;
+    reasons: readonly string[];
+}
+export declare function renderRootLauncherSelectionScreen(options: {
+    launchable: readonly RootLauncherAvailableAgentLine[];
+    unavailable: readonly RootLauncherUnavailableAgentLine[];
+}): string;
+export declare function renderRootLauncherSingleAgentScreen(options: {
+    selected: string;
+    unavailable: readonly RootLauncherUnavailableAgentLine[];
+}): string;
+export declare function renderRootLauncherInvalidSelection(max: number): string;
+export declare function renderRootLauncherMcpInstallSuccess(): string;
+export declare function renderRootLauncherMcpInstallStart(): string;
+export declare function renderRootLauncherLaunchStart(label: string): string;

package/dist/render/transcripts/root-launcher.js

@@ -0,0 +1,40 @@
+import { colorize } from "../../utils/colors.js";
+export function renderRootLauncherSelectionScreen(options) {
+    const lines = [
+        "Start a native agent session from this repository.",
+        "",
+        "Enabled agents:",
+        ...options.launchable.map((agent, index) => `  ${index + 1}. ${agent.label}`),
+    ];
+    if (options.unavailable.length > 0) {
+        lines.push("", "Unavailable enabled agents:");
+        for (const agent of options.unavailable) {
+            lines.push(`  - ${agent.label}: ${agent.reasons.join("; ")}`);
+        }
+    }
+    lines.push("", "Choose one agent to launch.");
+    return lines.join("\n");
+}
+export function renderRootLauncherSingleAgentScreen(options) {
+    const lines = ["Start a native agent session from this repository.", ""];
+    if (options.unavailable.length > 0) {
+        lines.push("", "Unavailable enabled agents:");
+        for (const agent of options.unavailable) {
+            lines.push(`  - ${agent.label}: ${agent.reasons.join("; ")}`);
+        }
+    }
+    lines.push(`Using agent: ${options.selected}`);
+    return lines.join("\n");
+}
+export function renderRootLauncherInvalidSelection(max) {
+    return `Choose a number from 1 to ${max}.`;
+}
+export function renderRootLauncherMcpInstallSuccess() {
+    return colorize("Success!", "green");
+}
+export function renderRootLauncherMcpInstallStart() {
+    return "Installing Voratiq MCP...";
+}
+export function renderRootLauncherLaunchStart(label) {
+    return `Launching ${label}...`;
+}

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

@@ -1,25 +1,54 @@
-import type { AgentInvocationRecord, RunReport } from "../../records/types.js";
+import type { AgentInvocationRecord, RunReport } from "../../domain/run/model/types.js";
+import type { StageProgressEventConsumer } from "./stage-progress.js";
 type CliWriter = Pick<NodeJS.WriteStream, "write"> & {
     isTTY?: boolean;
+    columns?: number;
 };
 interface RunProgressContext {
     runId: string;
     status: RunReport["status"];
-    specPath: string;
     workspacePath: string;
     createdAt: string;
-    baseRevisionSha: string;
+    startedAt?: string;
+    completedAt?: string;
 }
 interface RunRendererOptions {
     stdout?: CliWriter;
     stderr?: CliWriter;
     now?: () => number;
+    suppressLeadingBlankLine?: boolean;
+    suppressTrailingBlankLine?: boolean;
 }
-interface RunProgressRenderer {
+interface RunProgressRenderer extends StageProgressEventConsumer<RunProgressContext, AgentInvocationRecord> {
     begin(context?: RunProgressContext): void;
     update(record: AgentInvocationRecord): void;
-    complete(report: RunReport): string;
+    complete(report: RunReport, options?: {
+        suppressHint?: boolean;
+    }): string;
 }
+export interface RunTranscriptAgentRecord {
+    agentId: string;
+    status: AgentInvocationRecord["status"];
+    startedAt?: string;
+    completedAt?: string;
+    diffStatistics?: string;
+}
+export interface RunTranscriptOptions {
+    runId: string;
+    status: RunReport["status"];
+    workspacePath: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    agents: readonly RunTranscriptAgentRecord[];
+    isTty?: boolean;
+    now?: number;
+}
+export declare function formatRunElapsed(source: {
+    status: RunReport["status"];
+    startedAt?: string;
+    completedAt?: string;
+}, now?: number): string | undefined;
+export declare function renderRunTranscript(options: RunTranscriptOptions): string;
 export declare function createRunRenderer(options?: RunRendererOptions): RunProgressRenderer;
-export declare function buildRunTranscriptSections(report: RunReport): string[][];
 export type { RunProgressContext, RunProgressRenderer };