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

package/dist/cli/list.js

@@ -2,44 +2,67 @@ import { Command } from "commander";
 import { executeListCommand } from "../commands/list/command.js";
 import { resolveCliContext } from "../preflight/index.js";
 import { parsePositiveInteger } from "../utils/validators.js";
+import { resolveWorkspacePath, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_FILE, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
+import { parseListInspectionCommandOptions } from "./contract.js";
 import { writeCommandOutput } from "./output.js";
-export async function runListCommand(options = {}) {
+export async function runListCommand(options) {
     const { root, workspacePaths } = await resolveCliContext({
         requireWorkspace: false,
     });
     const execution = await executeListCommand({
         root,
+        specsFilePath: workspacePaths.specsFile,
         runsFilePath: workspacePaths.runsFile,
+        reductionsFilePath: workspacePaths.reductionsFile ??
+            resolveWorkspacePath(root, VORATIQ_REDUCTION_FILE),
+        messagesFilePath: workspacePaths.messagesFile ??
+            resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
+        verificationsFilePath: workspacePaths.verificationsFile ??
+            resolveWorkspacePath(root, VORATIQ_VERIFICATION_FILE),
+        operator: options.operator,
+        sessionId: options.sessionId,
         limit: options.limit,
-        specPath: options.spec,
-        runId: options.run,
-        includePruned: options.includePruned,
+        verbose: options.verbose,
     });
-    const body = execution.output ?? "No runs recorded.";
+    const body = execution.output ??
+        (execution.mode === "table"
+            ? `No ${options.operator} sessions recorded.`
+            : `${options.operator} session \`${options.sessionId}\` not found.`);
     const alerts = execution.warnings.map((warning) => ({
         severity: "warn",
         message: warning,
     }));
-    return { alerts, body };
+    return { alerts, body, json: execution.json };
 }
 function parseLimitOption(value) {
     return parsePositiveInteger(value, "Expected positive integer after --limit", "--limit must be greater than 0");
 }
 export function createListCommand() {
     return new Command("list")
-        .description("List recorded runs")
-        .option("--limit <count>", "Maximum number of runs to display", parseLimitOption)
-        .option("--spec <path>", "Filter runs by spec path")
-        .option("--run <id>", "Filter runs by run identifier")
-        .option("--include-pruned", "Include pruned runs in the listing")
+        .description("List recorded sessions for an operator")
+        .option("--spec [session-id]", "List spec sessions or show one spec session")
+        .option("--run [session-id]", "List run sessions or show one run session")
+        .option("--reduce [session-id]", "List reduction sessions or show one reduction session")
+        .option("--verify [session-id]", "List verification sessions or show one verification session")
+        .option("--message [session-id]", "List message sessions or show one message session")
+        .option("--limit <count>", "Show only the N most recent sessions (default: 10)", parseLimitOption)
+        .option("--verbose", "Show all statuses for the selected operator in table mode")
+        .option("--json", "Emit machine-readable list output")
         .allowExcessArguments(false)
-        .action(async (options) => {
+        .action(async (options, command) => {
+        const selection = parseListInspectionCommandOptions(options, command);
         const result = await runListCommand({
-            limit: options.limit,
-            spec: options.spec,
-            run: options.run,
-            includePruned: options.includePruned,
+            operator: selection.operator,
+            sessionId: selection.mode === "detail" ? selection.sessionId : undefined,
+            limit: selection.limit,
+            verbose: selection.verbose ?? false,
         });
+        if (options.json) {
+            writeCommandOutput({
+                body: JSON.stringify(result.json),
+            });
+            return;
+        }
         writeCommandOutput({
             body: result.body,
             alerts: result.alerts,

package/dist/cli/mcp.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createMcpCommand(): Command;

package/dist/cli/mcp.js

@@ -0,0 +1,16 @@
+import process from "node:process";
+import { Command } from "commander";
+import { createEntrypointCliTarget, runVoratiqMcpStdioServer, } from "../mcp/server.js";
+export function createMcpCommand() {
+    return new Command("mcp")
+        .description("Run the bundled Voratiq MCP server")
+        .requiredOption("--stdio", "Serve MCP over stdio")
+        .allowExcessArguments(false)
+        .action(async () => {
+        await runVoratiqMcpStdioServer({
+            selfCliTarget: createEntrypointCliTarget({
+                cliEntrypoint: process.argv[1],
+            }),
+        });
+    });
+}

package/dist/cli/message.d.ts

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { type CommandOutputWriter } from "./output.js";
+export interface MessageCommandOptions {
+    prompt: string;
+    agentIds?: string[];
+    profile?: string;
+    maxParallel?: number;
+    extraContext?: string[];
+    json?: boolean;
+    stdout?: Pick<NodeJS.WriteStream, "write"> & {
+        isTTY?: boolean;
+    };
+    stderr?: Pick<NodeJS.WriteStream, "write"> & {
+        isTTY?: boolean;
+    };
+    writeOutput?: CommandOutputWriter;
+}
+export interface MessageCommandResult {
+    body: string;
+    sessionId: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    outputArtifacts: ReadonlyArray<{
+        agentId: string;
+        outputPath?: string;
+    }>;
+}
+export declare function runMessageCommand(options: MessageCommandOptions): Promise<MessageCommandResult>;
+export declare function createMessageCommand(): Command;

package/dist/cli/message.js

@@ -0,0 +1,147 @@
+import { readFile } from "node:fs/promises";
+import { Command, Option } from "commander";
+import { checkPlatformSupport } from "../agents/runtime/sandbox.js";
+import { executeMessageCommand } from "../commands/message/command.js";
+import { buildMarkdownPreviewLines } from "../commands/shared/preview.js";
+import { resolveExtraContextFiles } from "../competition/shared/extra-context.js";
+import { ensureSandboxDependencies, resolveCliContext, } from "../preflight/index.js";
+import { createMessageRenderer, formatMessageElapsed, formatMessageRecipientDuration, renderMessageTranscript, } from "../render/transcripts/message.js";
+import { renderWorkspaceAutoInitializedNotice } from "../render/transcripts/shared.js";
+import { createStageStartLineEmitter } from "../render/utils/stage-output.js";
+import { resolvePath } from "../utils/path.js";
+import { parsePositiveInteger } from "../utils/validators.js";
+import { resolveWorkspacePath, VORATIQ_MESSAGE_FILE, } from "../workspace/structure.js";
+import { parseMessageExecutionCommandOptions } from "./contract.js";
+import { buildMessageOperatorEnvelope, createSilentCliWriter, writeOperatorResultEnvelope, } from "./operator-envelope.js";
+import { writeCommandOutput } from "./output.js";
+export async function runMessageCommand(options) {
+    const { prompt, agentIds, profile, maxParallel, extraContext, json = false, stdout, stderr, writeOutput, } = options;
+    const effectiveWriteOutput = json
+        ? undefined
+        : (writeOutput ?? writeCommandOutput);
+    const rendererStdout = json ? createSilentCliWriter() : stdout;
+    const rendererStderr = json ? createSilentCliWriter() : stderr;
+    const isTty = json ? false : (stdout?.isTTY ?? process.stdout.isTTY);
+    const { root, workspacePaths, workspaceAutoInitialized } = await resolveCliContext({
+        workspaceAutoInitMode: "when-missing",
+    });
+    const workspaceNotice = workspaceAutoInitialized
+        ? renderWorkspaceAutoInitializedNotice()
+        : undefined;
+    if (workspaceNotice && effectiveWriteOutput) {
+        effectiveWriteOutput({
+            alerts: [{ severity: "info", message: workspaceNotice }],
+            leadingNewline: false,
+        });
+    }
+    checkPlatformSupport();
+    ensureSandboxDependencies();
+    const extraContextFiles = await resolveExtraContextFiles({
+        root,
+        paths: extraContext,
+    });
+    const startLine = createStageStartLineEmitter((message) => {
+        effectiveWriteOutput?.({
+            alerts: [{ severity: "info", message }],
+        });
+    });
+    if (effectiveWriteOutput) {
+        startLine.emit("Messaging…");
+    }
+    const renderer = createMessageRenderer({
+        stdout: rendererStdout,
+        stderr: rendererStderr,
+    });
+    const execution = await executeMessageCommand({
+        root,
+        messagesFilePath: workspacePaths.messagesFile ??
+            resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
+        prompt,
+        agentIds,
+        profileName: profile,
+        maxParallel,
+        extraContextFiles,
+        sourceInteractiveSessionId: process.env.VORATIQ_INTERACTIVE_SESSION_ID?.trim() || undefined,
+        renderer,
+    });
+    const body = renderMessageTranscript({
+        messageId: execution.messageId,
+        createdAt: execution.record.createdAt,
+        elapsed: formatMessageElapsed({
+            status: execution.record.status,
+            startedAt: execution.record.startedAt,
+            completedAt: execution.record.completedAt,
+        }) ?? "—",
+        workspacePath: `.voratiq/message/sessions/${execution.messageId}`,
+        status: execution.record.status,
+        recipients: await Promise.all(execution.recipients.map(async (recipient) => ({
+            agentId: recipient.agentId,
+            status: recipient.status,
+            duration: formatMessageRecipientDuration({
+                status: recipient.status,
+                startedAt: recipient.startedAt,
+                completedAt: recipient.completedAt,
+            }) ?? "—",
+            outputPath: recipient.outputPath,
+            previewLines: recipient.status === "succeeded" && recipient.outputPath
+                ? buildMarkdownPreviewLines(await readFile(resolvePath(root, recipient.outputPath), "utf8"))
+                : undefined,
+            errorLine: recipient.error ?? undefined,
+        }))),
+        isTty,
+        includeSummarySection: !isTty,
+    });
+    return {
+        body,
+        sessionId: execution.messageId,
+        status: execution.record.status,
+        outputArtifacts: execution.recipients.map((recipient) => ({
+            agentId: recipient.agentId,
+            outputPath: recipient.outputPath,
+        })),
+    };
+}
+function collectStringOption(value, previous) {
+    return [...previous, value];
+}
+function parseMaxParallelOption(value) {
+    return parsePositiveInteger(value, "Expected positive integer after --max-parallel", "--max-parallel must be greater than 0");
+}
+export function createMessageCommand() {
+    return new Command("message")
+        .description("Send an isolated prompt to one or more agents")
+        .requiredOption("--prompt <text>", "Prompt to send")
+        .addOption(new Option("--agent <agent-id>", "Set recipient agents directly (repeatable; order preserved)")
+        .default([], "")
+        .argParser(collectStringOption))
+        .option("--profile <name>", 'Orchestration profile (default: "default")')
+        .option("--max-parallel <count>", "Max concurrent recipients (default: all)", parseMaxParallelOption)
+        .addOption(new Option("--extra-context <path>", "Stage an extra context file into each recipient workspace (repeatable)")
+        .default([], "")
+        .argParser(collectStringOption))
+        .option("--json", "Emit a machine-readable result envelope")
+        .allowExcessArguments(false)
+        .action(async (options, command) => {
+        const input = parseMessageExecutionCommandOptions(options, command);
+        const result = await runMessageCommand({
+            prompt: input.prompt,
+            agentIds: input.agentIds,
+            profile: input.profile,
+            maxParallel: input.maxParallel,
+            extraContext: input.extraContext,
+            json: Boolean(options.json),
+        });
+        if (options.json) {
+            writeOperatorResultEnvelope(buildMessageOperatorEnvelope({
+                sessionId: result.sessionId,
+                status: result.status,
+                outputArtifacts: result.outputArtifacts,
+            }), result.status === "succeeded" ? 0 : 1);
+            return;
+        }
+        writeCommandOutput({
+            body: result.body,
+            exitCode: result.status === "succeeded" ? 0 : 1,
+        });
+    });
+}

package/dist/cli/operator-envelope.d.ts

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import type { ReductionTarget } from "../domain/reduce/model/types.js";
+import type { SelectionDecision } from "../policy/index.js";
+import type { ReductionStatus, RunStatus, VerificationStatus } from "../status/index.js";
+import { externalExecutionOperators } from "./contract.js";
+export type EnvelopeOperator = (typeof externalExecutionOperators)[number];
+export type EnvelopeStatus = "succeeded" | "failed" | "unresolved";
+export interface EnvelopeArtifactRef {
+    kind: string;
+    path: string;
+    role?: string;
+    agentId?: string;
+}
+export interface OperatorResultEnvelope {
+    version: 1;
+    operator: EnvelopeOperator;
+    status: EnvelopeStatus;
+    timestamp: string;
+    ids?: {
+        sessionId?: string;
+        runId?: string;
+        verificationId?: string;
+        reductionId?: string;
+        messageId?: string;
+        agentId?: string;
+    };
+    target?: {
+        kind: string;
+        sessionId: string;
+    };
+    artifacts: EnvelopeArtifactRef[];
+    selection?: {
+        state: "resolvable" | "unresolved";
+        selectedCanonicalAgentId?: string;
+        selectedSpecPath?: string;
+    };
+    unresolvedReasons?: Array<{
+        code: string;
+        detail?: string;
+    }>;
+    alerts?: Array<{
+        level: "info" | "warn" | "error";
+        message: string;
+    }>;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export declare const operatorResultEnvelopeSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    operator: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        apply: "apply";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+        prune: "prune";
+    }>;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+        unresolved: "unresolved";
+    }>;
+    timestamp: z.ZodString;
+    ids: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        verificationId: z.ZodOptional<z.ZodString>;
+        reductionId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    target: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$loose>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        path: z.ZodString;
+        role: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    selection: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            resolvable: "resolvable";
+            unresolved: "unresolved";
+        }>;
+        selectedCanonicalAgentId: z.ZodOptional<z.ZodString>;
+        selectedSpecPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    unresolvedReasons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    alerts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+        }>;
+        message: z.ZodString;
+    }, z.core.$loose>>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export interface VerifyEnvelopeInput {
+    verificationId: string;
+    target: {
+        kind: "spec" | "run" | "reduce" | "message";
+        sessionId: string;
+    };
+    outputPath: string;
+    status: VerificationStatus;
+    selection?: SelectionDecision;
+    selectedSpecPath?: string;
+    warningMessage?: string;
+}
+export interface ReduceEnvelopeInput {
+    reductionId: string;
+    target: ReductionTarget;
+    status: ReductionStatus;
+}
+export interface MessageEnvelopeInput {
+    sessionId: string;
+    status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    outputArtifacts?: ReadonlyArray<{
+        agentId: string;
+        outputPath?: string;
+    }>;
+}
+export interface ApplyEnvelopeInput {
+    runId: string;
+    agentId: string;
+    diffPath: string;
+    ignoredBaseMismatch: boolean;
+}
+export interface PruneEnvelopeInput {
+    status: "pruned" | "noop" | "aborted";
+    runId?: string;
+    runPath?: string;
+}
+export declare function buildOperatorEnvelope(options: {
+    operator: EnvelopeOperator;
+    status: EnvelopeStatus;
+    ids?: OperatorResultEnvelope["ids"];
+    artifacts?: EnvelopeArtifactRef[];
+    selection?: OperatorResultEnvelope["selection"];
+    unresolvedReasons?: OperatorResultEnvelope["unresolvedReasons"];
+    alerts?: OperatorResultEnvelope["alerts"];
+    error?: OperatorResultEnvelope["error"];
+    target?: OperatorResultEnvelope["target"];
+    timestamp?: string;
+}): OperatorResultEnvelope;
+export declare function buildFailedOperatorEnvelope(options: {
+    operator: EnvelopeOperator;
+    error: unknown;
+}): OperatorResultEnvelope;
+export declare function buildSpecOperatorEnvelope(options: {
+    sessionId?: string;
+    generatedSpecPaths: readonly string[];
+}): OperatorResultEnvelope;
+export declare function buildRunOperatorEnvelope(options: {
+    runId: string;
+    specPath: string;
+    status: RunStatus;
+}): OperatorResultEnvelope;
+export declare function buildVerifyOperatorEnvelope(options: VerifyEnvelopeInput): OperatorResultEnvelope;
+export declare function buildReduceOperatorEnvelope(options: ReduceEnvelopeInput): OperatorResultEnvelope;
+export declare function buildMessageOperatorEnvelope(options: MessageEnvelopeInput): OperatorResultEnvelope;
+export declare function buildApplyOperatorEnvelope(options: ApplyEnvelopeInput): OperatorResultEnvelope;
+export declare function buildPruneOperatorEnvelope(options: PruneEnvelopeInput): OperatorResultEnvelope;
+export declare function writeOperatorResultEnvelope(envelope: OperatorResultEnvelope, exitCode?: number): void;
+export declare function createSilentCliWriter(): Pick<NodeJS.WriteStream, "write"> & {
+    isTTY?: boolean;
+};
+export declare function resolveJsonEnvelopeOperator(argv: readonly string[]): EnvelopeOperator | undefined;