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

package/dist/cli/operator-envelope.js

@@ -0,0 +1,425 @@
+import { z } from "zod";
+import { getMessageSessionDirectoryPath, getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, } from "../workspace/structure.js";
+import { externalExecutionOperators } from "./contract.js";
+import { toCliError } from "./errors.js";
+export const operatorResultEnvelopeSchema = z
+    .object({
+    version: z.literal(1),
+    operator: z.enum(externalExecutionOperators),
+    status: z.enum(["succeeded", "failed", "unresolved"]),
+    timestamp: z.string(),
+    ids: z
+        .object({
+        sessionId: z.string().optional(),
+        runId: z.string().optional(),
+        verificationId: z.string().optional(),
+        reductionId: z.string().optional(),
+        messageId: z.string().optional(),
+        agentId: z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+    target: z
+        .object({
+        kind: z.string(),
+        sessionId: z.string(),
+    })
+        .passthrough()
+        .optional(),
+    artifacts: z.array(z
+        .object({
+        kind: z.string(),
+        path: z.string(),
+        role: z.string().optional(),
+        agentId: z.string().optional(),
+    })
+        .passthrough()),
+    selection: z
+        .object({
+        state: z.enum(["resolvable", "unresolved"]),
+        selectedCanonicalAgentId: z.string().optional(),
+        selectedSpecPath: z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+    unresolvedReasons: z
+        .array(z
+        .object({
+        code: z.string(),
+        detail: z.string().optional(),
+    })
+        .passthrough())
+        .optional(),
+    alerts: z
+        .array(z
+        .object({
+        level: z.enum(["info", "warn", "error"]),
+        message: z.string(),
+    })
+        .passthrough())
+        .optional(),
+    error: z
+        .object({
+        code: z.string(),
+        message: z.string(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+export function buildOperatorEnvelope(options) {
+    const envelope = {
+        version: 1,
+        operator: options.operator,
+        status: options.status,
+        timestamp: options.timestamp ?? new Date().toISOString(),
+        artifacts: options.artifacts ?? [],
+    };
+    if (options.ids && Object.keys(options.ids).length > 0) {
+        envelope.ids = options.ids;
+    }
+    if (options.selection) {
+        envelope.selection = options.selection;
+    }
+    if (options.target) {
+        envelope.target = options.target;
+    }
+    if (options.status === "unresolved" &&
+        options.unresolvedReasons &&
+        options.unresolvedReasons.length > 0) {
+        envelope.unresolvedReasons = options.unresolvedReasons;
+    }
+    if (options.alerts && options.alerts.length > 0) {
+        envelope.alerts = options.alerts;
+    }
+    if (options.error) {
+        envelope.error = options.error;
+    }
+    return envelope;
+}
+export function buildFailedOperatorEnvelope(options) {
+    return buildOperatorEnvelope({
+        operator: options.operator,
+        status: "failed",
+        error: toEnvelopeError(options.error),
+    });
+}
+export function buildSpecOperatorEnvelope(options) {
+    const artifacts = [];
+    if (options.sessionId) {
+        artifacts.push({
+            kind: "session",
+            role: "session",
+            path: getSpecSessionDirectoryPath(options.sessionId),
+        });
+    }
+    for (const path of options.generatedSpecPaths) {
+        artifacts.push({
+            kind: "spec",
+            role: "candidate",
+            path,
+            ...withAgentId(options.sessionId
+                ? getAgentIdFromSessionArtifactPath(path, options.sessionId)
+                : undefined),
+        });
+    }
+    return buildOperatorEnvelope({
+        operator: "spec",
+        status: "succeeded",
+        ids: options.sessionId ? { sessionId: options.sessionId } : undefined,
+        artifacts,
+    });
+}
+export function buildRunOperatorEnvelope(options) {
+    return buildOperatorEnvelope({
+        operator: "run",
+        status: normalizeTerminalStatus(options.status),
+        ids: {
+            runId: options.runId,
+        },
+        artifacts: [
+            {
+                kind: "session",
+                role: "session",
+                path: getRunDirectoryPath(options.runId),
+            },
+            {
+                kind: "spec",
+                role: "input",
+                path: options.specPath,
+            },
+        ],
+    });
+}
+export function buildVerifyOperatorEnvelope(options) {
+    const status = options.selection?.state === "unresolved"
+        ? "unresolved"
+        : normalizeTerminalStatus(options.status);
+    const ids = {
+        sessionId: options.verificationId,
+    };
+    if (options.target.kind === "run") {
+        ids.runId = options.target.sessionId;
+    }
+    if (options.target.kind === "reduce") {
+        ids.reductionId = options.target.sessionId;
+    }
+    if (options.target.kind === "message") {
+        ids.messageId = options.target.sessionId;
+    }
+    const alerts = [];
+    if (options.warningMessage) {
+        alerts.push({ level: "warn", message: options.warningMessage });
+    }
+    if (status === "unresolved") {
+        alerts.push({
+            level: "warn",
+            message: "Verification could not resolve a canonical candidate.",
+        });
+    }
+    return buildOperatorEnvelope({
+        operator: "verify",
+        status,
+        ids,
+        target: options.target,
+        artifacts: [
+            {
+                kind: "session",
+                role: "session",
+                path: options.outputPath,
+            },
+            ...(options.selectedSpecPath
+                ? [
+                    {
+                        kind: "spec",
+                        role: "selected",
+                        path: options.selectedSpecPath,
+                    },
+                ]
+                : []),
+        ],
+        selection: options.selection
+            ? {
+                state: options.selection.state,
+                ...(options.selection.state === "resolvable"
+                    ? {
+                        selectedCanonicalAgentId: options.selection.selectedCanonicalAgentId,
+                    }
+                    : {}),
+                ...(options.selectedSpecPath
+                    ? { selectedSpecPath: options.selectedSpecPath }
+                    : {}),
+            }
+            : undefined,
+        unresolvedReasons: options.selection?.state === "unresolved"
+            ? options.selection.unresolvedReasons.map((reason) => ({
+                code: reason.code,
+            }))
+            : undefined,
+        alerts,
+    });
+}
+export function buildReduceOperatorEnvelope(options) {
+    const ids = {
+        sessionId: options.reductionId,
+    };
+    if (options.target.type === "run") {
+        ids.runId = options.target.id;
+    }
+    if (options.target.type === "verify") {
+        ids.verificationId = options.target.id;
+    }
+    if (options.target.type === "reduce") {
+        ids.reductionId = options.target.id;
+    }
+    return buildOperatorEnvelope({
+        operator: "reduce",
+        status: normalizeTerminalStatus(options.status),
+        ids,
+        artifacts: [
+            {
+                kind: "session",
+                role: "session",
+                path: getReductionSessionDirectoryPath(options.reductionId),
+            },
+            {
+                kind: options.target.type,
+                role: "input",
+                path: getReductionSourcePath(options.target),
+            },
+        ],
+    });
+}
+export function buildMessageOperatorEnvelope(options) {
+    return buildOperatorEnvelope({
+        operator: "message",
+        status: normalizeTerminalStatus(options.status),
+        ids: {
+            sessionId: options.sessionId,
+        },
+        artifacts: [
+            {
+                kind: "session",
+                role: "session",
+                path: getMessageSessionDirectoryPath(options.sessionId),
+            },
+            ...(options.outputArtifacts ?? []).flatMap((artifact) => [
+                ...(artifact.outputPath
+                    ? [
+                        {
+                            kind: "output",
+                            role: "output",
+                            agentId: artifact.agentId,
+                            path: artifact.outputPath,
+                        },
+                    ]
+                    : []),
+            ]),
+        ],
+    });
+}
+export function buildApplyOperatorEnvelope(options) {
+    return buildOperatorEnvelope({
+        operator: "apply",
+        status: "succeeded",
+        ids: {
+            runId: options.runId,
+            agentId: options.agentId,
+        },
+        artifacts: [
+            {
+                kind: "run",
+                role: "target",
+                path: getRunDirectoryPath(options.runId),
+            },
+            {
+                kind: "diff",
+                role: "output",
+                path: options.diffPath,
+                agentId: options.agentId,
+            },
+        ],
+        alerts: options.ignoredBaseMismatch
+            ? [
+                {
+                    level: "warn",
+                    message: "Apply proceeded despite a base mismatch.",
+                },
+            ]
+            : undefined,
+    });
+}
+export function buildPruneOperatorEnvelope(options) {
+    return buildOperatorEnvelope({
+        operator: "prune",
+        status: options.status === "aborted"
+            ? "failed"
+            : "succeeded",
+        ids: options.runId
+            ? {
+                runId: options.runId,
+            }
+            : undefined,
+        artifacts: options.runPath
+            ? [
+                {
+                    kind: "run",
+                    role: "target",
+                    path: options.runPath,
+                },
+            ]
+            : [],
+    });
+}
+export function writeOperatorResultEnvelope(envelope, exitCode) {
+    process.stdout.write(`${JSON.stringify(envelope)}\n`);
+    if (typeof exitCode === "number") {
+        process.exitCode = exitCode;
+    }
+}
+export function createSilentCliWriter() {
+    return {
+        isTTY: false,
+        write() {
+            return true;
+        },
+    };
+}
+export function resolveJsonEnvelopeOperator(argv) {
+    if (!argv.includes("--json")) {
+        return undefined;
+    }
+    if (argv.includes("--help") || argv.includes("-h")) {
+        return undefined;
+    }
+    if (argv.includes("--version") || argv.includes("-v")) {
+        return undefined;
+    }
+    for (let index = 2; index < argv.length; index += 1) {
+        const entry = argv[index];
+        if (!entry || entry === "--") {
+            continue;
+        }
+        if (entry.startsWith("-")) {
+            continue;
+        }
+        if (isEnvelopeOperator(entry)) {
+            return entry;
+        }
+        return undefined;
+    }
+    return undefined;
+}
+function isEnvelopeOperator(value) {
+    return externalExecutionOperators.includes(value);
+}
+function normalizeTerminalStatus(status) {
+    return status === "succeeded" ? "succeeded" : "failed";
+}
+function toEnvelopeError(error) {
+    const cliError = toCliError(error);
+    let code = "command_failed";
+    if (error && typeof error === "object") {
+        if ("code" in error && typeof error.code === "string") {
+            code = normalizeErrorCode(error.code);
+        }
+        else if ("name" in error && typeof error.name === "string") {
+            code = normalizeErrorCode(error.name);
+        }
+    }
+    return {
+        code,
+        message: cliError.headline,
+    };
+}
+function normalizeErrorCode(value) {
+    const snake = value
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^a-zA-Z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toLowerCase();
+    return snake.length > 0 ? snake : "command_failed";
+}
+function getReductionSourcePath(target) {
+    switch (target.type) {
+        case "spec":
+            return `.voratiq/spec/sessions/${target.id}`;
+        case "run":
+            return `.voratiq/run/sessions/${target.id}`;
+        case "reduce":
+            return `.voratiq/reduce/sessions/${target.id}`;
+        case "verify":
+            return `.voratiq/verify/sessions/${target.id}`;
+        case "message":
+            return `.voratiq/message/sessions/${target.id}`;
+    }
+}
+function getAgentIdFromSessionArtifactPath(path, sessionId) {
+    const parts = path.split("/");
+    const sessionIndex = parts.lastIndexOf(sessionId);
+    const candidate = sessionIndex >= 0 ? parts[sessionIndex + 1] : undefined;
+    return candidate && candidate.length > 0 ? candidate : undefined;
+}
+function withAgentId(agentId) {
+    return agentId ? { agentId } : {};
+}

package/dist/cli/output.d.ts

@@ -1,4 +1,8 @@
-export declare function writeCommandPreface(preface: string): void;
+import { type FormatCliOutputOptions } from "../utils/output.js";
+type CliWriter = Pick<NodeJS.WriteStream, "write"> & {
+    isTTY?: boolean;
+    columns?: number;
+};
 export type AlertSeverity = "info" | "warn" | "error";
 export interface Alert {
     readonly severity: AlertSeverity;
@@ -9,6 +13,16 @@ export interface CommandOutputPayload {
     readonly alerts?: readonly Alert[];
     readonly stderr?: string | readonly string[];
     readonly exitCode?: number;
+    readonly formatBody?: FormatCliOutputOptions;
+    readonly leadingNewline?: boolean;
 }
+export type CommandOutputWriter = (payload: CommandOutputPayload) => void;
+export interface ChainedCommandOutput {
+    stdout: CliWriter;
+    stderr: CliWriter;
+    end(): void;
+}
+export declare function beginChainedCommandOutput(): ChainedCommandOutput;
 export declare function writeCommandOutput(payload: CommandOutputPayload): void;
 export declare function renderCommandOutput(payload: CommandOutputPayload): void;
+export {};

package/dist/cli/output.js

@@ -1,10 +1,29 @@
 import { formatAlertMessage, formatCliOutput, formatErrorMessage, } from "../utils/output.js";
-export function writeCommandPreface(preface) {
-    process.stdout.write(`\n${preface}\n`);
+let chainedOutputState = null;
+export function beginChainedCommandOutput() {
+    const state = {
+        stdoutTrailingNewlines: 0,
+        stdoutHasOutput: false,
+    };
+    chainedOutputState = state;
+    return {
+        stdout: createTrackingWriter(process.stdout, state),
+        stderr: process.stderr,
+        end: () => {
+            if (chainedOutputState === state) {
+                chainedOutputState = null;
+            }
+        },
+    };
 }
 export function writeCommandOutput(payload) {
+    if (chainedOutputState) {
+        writeChainedCommandOutput(payload, chainedOutputState);
+        return;
+    }
     const hasAlerts = (payload.alerts ?? []).length > 0;
-    if (hasAlerts) {
+    const shouldInsertLeadingNewline = payload.leadingNewline ?? hasAlerts;
+    if (shouldInsertLeadingNewline) {
         process.stdout.write("\n");
     }
     renderCommandOutput(payload);
@@ -28,7 +47,7 @@ export function renderCommandOutput(payload) {
     if (body !== undefined) {
         const normalizedBody = typeof body === "string" ? body : body.join("\n");
         if (normalizedBody.trim().length > 0) {
-            const formattedBody = formatCliOutput(normalizedBody);
+            const formattedBody = formatCliOutput(normalizedBody, payload.formatBody);
             process.stdout.write(formattedBody);
         }
     }
@@ -46,11 +65,140 @@ function formatAlert(alert) {
             formatted = formatAlertMessage("Warning", "yellow", alert.message);
             break;
         case "info":
-            formatted = formatAlertMessage("Info", "cyan", alert.message);
+            formatted = alert.message;
             break;
     }
     return `${formatted}\n`;
 }
+function writeChainedCommandOutput(payload, state) {
+    const alerts = payload.alerts ?? [];
+    const stdoutParts = [];
+    let hasStdoutAlert = false;
+    for (const alert of alerts) {
+        const formattedAlert = formatAlert(alert);
+        if (alert.severity === "info") {
+            stdoutParts.push(formattedAlert);
+            hasStdoutAlert = true;
+        }
+        else {
+            process.stderr.write(formattedAlert);
+        }
+    }
+    const stderr = normalizeToArray(payload.stderr);
+    for (const entry of stderr) {
+        process.stderr.write(entry);
+    }
+    const body = payload.body;
+    if (body !== undefined) {
+        const normalizedBody = typeof body === "string" ? body : body.join("\n");
+        if (normalizedBody.trim().length > 0) {
+            if (hasStdoutAlert) {
+                stdoutParts.push("\n");
+            }
+            const formattedBody = formatCliOutput(normalizedBody, {
+                leadingNewline: false,
+                trailingNewline: typeof payload.exitCode === "number",
+            });
+            stdoutParts.push(formattedBody);
+        }
+    }
+    let stdoutChunk = normalizeChainedChunk(stdoutParts.join(""));
+    if (stdoutChunk.length > 0 && typeof payload.exitCode === "number") {
+        stdoutChunk = `${stdoutChunk}\n`;
+    }
+    if (stdoutChunk.length > 0) {
+        writeChainedStdout(stdoutChunk, state);
+    }
+    if (typeof payload.exitCode === "number") {
+        process.exitCode = payload.exitCode;
+    }
+}
+function normalizeChainedChunk(value) {
+    if (value.length === 0) {
+        return "";
+    }
+    const trimmedLeading = value.replace(/^\n+/, "");
+    const trimmed = trimmedLeading.replace(/\n+$/, "");
+    if (trimmed.length === 0) {
+        return "";
+    }
+    return `${trimmed}\n`;
+}
+function writeChainedStdout(value, state) {
+    const prefix = getChainedPrefix(state);
+    if (prefix) {
+        process.stdout.write(prefix);
+        updateTrailingNewlines(state, prefix);
+        state.stdoutHasOutput = true;
+    }
+    process.stdout.write(value);
+    updateTrailingNewlines(state, value);
+    state.stdoutHasOutput = true;
+}
+function getChainedPrefix(state) {
+    if (!state.stdoutHasOutput) {
+        return "\n";
+    }
+    if (state.stdoutTrailingNewlines >= 2) {
+        return "";
+    }
+    if (state.stdoutTrailingNewlines === 1) {
+        return "\n";
+    }
+    return "\n\n";
+}
+function updateTrailingNewlines(state, value) {
+    if (value.length === 0) {
+        return;
+    }
+    let index = value.length - 1;
+    let count = 0;
+    while (index >= 0 && value[index] === "\n") {
+        count += 1;
+        index -= 1;
+    }
+    if (count === value.length) {
+        state.stdoutTrailingNewlines = Math.min(2, state.stdoutTrailingNewlines + count);
+        return;
+    }
+    if (count > 0) {
+        state.stdoutTrailingNewlines = Math.min(2, count);
+        return;
+    }
+    state.stdoutTrailingNewlines = 0;
+}
+function createTrackingWriter(target, state) {
+    let hasWritten = false;
+    return {
+        isTTY: target.isTTY,
+        get columns() {
+            return target.columns;
+        },
+        write(chunk) {
+            const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+            // Skip prefix insertion for TTY outputs - the run renderer uses cursor
+            // control sequences that assume precise line counts, and adding a prefix
+            // here would throw off those calculations.
+            if (!hasWritten && text.length > 0) {
+                hasWritten = true;
+                if (!target.isTTY) {
+                    const prefix = getChainedPrefix(state);
+                    if (prefix) {
+                        target.write(prefix);
+                        updateTrailingNewlines(state, prefix);
+                        state.stdoutHasOutput = true;
+                    }
+                }
+            }
+            const result = target.write(chunk);
+            updateTrailingNewlines(state, text);
+            if (text.length > 0) {
+                state.stdoutHasOutput = true;
+            }
+            return result;
+        },
+    };
+}
 function normalizeToArray(value) {
     if (value === undefined) {
         return [];

package/dist/cli/prune.d.ts

@@ -1,12 +1,16 @@
 import { Command } from "commander";
-import type { PruneResult } from "../commands/prune/types.js";
+import type { PruneAllResult, PruneResult } from "../commands/prune/types.js";
+import { type CommandOutputWriter } from "./output.js";
 export interface PruneCommandOptions {
-    runId: string;
+    runId?: string;
+    all?: boolean;
     purge?: boolean;
     yes?: boolean;
+    json?: boolean;
+    writeOutput?: CommandOutputWriter;
 }
 export interface PruneCommandResult {
-    result: PruneResult;
+    result: PruneResult | PruneAllResult;
     body: string;
     exitCode?: number;
 }