voratiq 0.1.0-beta.6 → 0.1.0-beta.8

package/README.md

@@ -1,6 +1,6 @@
 # Voratiq
 
-Run agents in parallel, compare results, and apply the best solution.
+Run coding agents against each other. Merge the winner.
 
 ![`voratiq run --spec .voratiq/specs/apply-commit-flag.md`](https://raw.githubusercontent.com/voratiq/voratiq/main/assets/run-demo.png)
 
@@ -9,7 +9,7 @@ Run agents in parallel, compare results, and apply the best solution.
 Voratiq is in public beta. Install via npm:
 
 ```bash
-npm install -g voratiq@beta
+npm install -g voratiq
 ```
 
 ### Requirements
@@ -55,6 +55,31 @@ For a full walkthrough, see the [CLI tutorial](https://github.com/voratiq/vorati
 
 See the [docs](https://github.com/voratiq/voratiq/blob/main/docs/index.md) for core concepts, CLI reference, and configuration guides.
 
+## How It Works
+
+Voratiq takes your task spec, fans it out to multiple [sandboxed](https://github.com/voratiq/voratiq/blob/main/docs/configs/sandbox.md) [agents](https://github.com/voratiq/voratiq/blob/main/docs/configs/agents.md), and runs automatic [evals](https://github.com/voratiq/voratiq/blob/main/docs/configs/evals.md) (tests, lint, custom checks) on each result. You pick the best solution and merge it into your codebase.
+
+```mermaid
+flowchart TD
+    Spec["Same spec goes to all agents"]
+
+    subgraph Run[" "]
+        direction LR
+        A["Agent 1"]
+        B["..."]
+        C["Agent N"]
+    end
+
+    Evals["Evals run automatically"]
+    Pick["User picks the best implementation"]
+    Apply["Winning diff merged to codebase"]
+
+    Spec --> A & B & C
+    A & B & C --> Evals
+    Evals --> Pick
+    Pick --> Apply
+```
+
 ## License
 
 Voratiq is available under the [MIT License](https://github.com/voratiq/voratiq/blob/main/LICENSE).

package/dist/agents/runtime/auth.d.ts

@@ -17,6 +17,10 @@ export interface StageAuthResult {
     env: Record<string, string>;
     context: StagedAuthContext;
 }
-export declare function verifyAgentProviders(agents: readonly AgentDefinition[]): Promise<void>;
+export interface AgentProviderPreflightIssue {
+    readonly agentId: string;
+    readonly message: string;
+}
+export declare function verifyAgentProviders(agents: readonly Pick<AgentDefinition, "id" | "provider">[]): Promise<readonly AgentProviderPreflightIssue[]>;
 export declare function stageAgentAuth(options: StageAuthOptions): Promise<StageAuthResult>;
 export declare function teardownAuthContext(context: StagedAuthContext | undefined): Promise<void>;

package/dist/agents/runtime/auth.js

@@ -3,29 +3,40 @@ import { resolveAuthProvider } from "../../auth/providers/index.js";
 import { buildAuthRuntimeContext } from "../../auth/runtime.js";
 import { toErrorMessage } from "../../utils/errors.js";
 import { isFileSystemError } from "../../utils/fs.js";
-import { AuthProviderStageError, AuthProviderVerificationError, MissingAgentProviderError, UnknownAuthProviderError, } from "./errors.js";
+import { AuthProviderStageError, MissingAgentProviderError, UnknownAuthProviderError, } from "./errors.js";
 import { getRunCommand } from "./launcher.js";
 import { checkPlatformSupport } from "./sandbox.js";
 export async function verifyAgentProviders(agents) {
     if (agents.length === 0) {
-        return;
+        return [];
     }
     // Ensure platform and runtime dependencies are present.
     checkPlatformSupport();
     await getRunCommand();
     const runtime = buildAuthRuntimeContext();
+    const issues = [];
     for (const agent of agents) {
-        const provider = resolveAgentProvider(agent);
-        try {
-            await provider.verify({
+        const providerId = agent.provider?.trim();
+        if (!providerId) {
+            issues.push({ agentId: agent.id, message: "missing provider" });
+            continue;
+        }
+        const provider = resolveAuthProvider(providerId);
+        if (!provider) {
+            issues.push({
                 agentId: agent.id,
-                runtime,
+                message: `unknown auth provider "${providerId}"`,
             });
+            continue;
+        }
+        try {
+            await provider.verify({ agentId: agent.id, runtime });
         }
         catch (error) {
-            throw new AuthProviderVerificationError(extractAuthProviderMessage(error));
+            pushIssueLines(issues, agent.id, extractAuthProviderMessage(error));
         }
     }
+    return issues;
 }
 export async function stageAgentAuth(options) {
     const { agent, agentRoot, runId, root } = options;
@@ -105,3 +116,16 @@ function extractAuthProviderMessage(error) {
     }
     return toErrorMessage(error);
 }
+function pushIssueLines(issues, agentId, message) {
+    const lines = message
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0) {
+        issues.push({ agentId, message: "unknown error" });
+        return;
+    }
+    for (const line of lines) {
+        issues.push({ agentId, message: line });
+    }
+}

package/dist/agents/runtime/failures.js

@@ -1,20 +1,94 @@
 import { readFile } from "node:fs/promises";
 import { CLAUDE_OAUTH_RELOGIN_HINT, CLAUDE_PROVIDER_ID, } from "../../auth/providers/claude/constants.js";
+const GEMINI_PROVIDER_ID = "gemini";
+const CODEX_PROVIDER_ID = "codex";
 const CLAUDE_FAILURE_PATTERNS = [
     /Please run \/login/i,
     /OAuth token has expired/i,
 ];
+const JSON_MESSAGE_PATTERN = /"message"\s*:\s*"((?:\\.|[^"\\])*)"/;
 export async function detectAgentProcessFailureDetail(input) {
-    if (input.provider !== CLAUDE_PROVIDER_ID) {
+    if (input.provider !== CLAUDE_PROVIDER_ID &&
+        input.provider !== GEMINI_PROVIDER_ID &&
+        input.provider !== CODEX_PROVIDER_ID) {
         return undefined;
     }
     const combinedLogs = await readCombinedLogs(input.stdoutPath, input.stderrPath);
-    if (combinedLogs &&
-        CLAUDE_FAILURE_PATTERNS.some((pattern) => pattern.test(combinedLogs))) {
-        return CLAUDE_OAUTH_RELOGIN_HINT;
+    if (!combinedLogs) {
+        return undefined;
+    }
+    if (input.provider === CLAUDE_PROVIDER_ID) {
+        if (CLAUDE_FAILURE_PATTERNS.some((pattern) => pattern.test(combinedLogs))) {
+            return CLAUDE_OAUTH_RELOGIN_HINT;
+        }
+        return undefined;
+    }
+    if (input.provider === GEMINI_PROVIDER_ID) {
+        return (extractFirstJsonMessage(combinedLogs) ??
+            extractGeminiFallbackLine(combinedLogs));
+    }
+    if (input.provider === CODEX_PROVIDER_ID) {
+        return (extractFirstJsonMessage(combinedLogs) ??
+            findFirstMatchingLine(combinedLogs, [
+                /invalid_request_error/,
+                /unsupported_value/,
+                /thread .* panicked/i,
+            ]));
+    }
+    return undefined;
+}
+function extractFirstJsonMessage(text) {
+    const match = JSON_MESSAGE_PATTERN.exec(text);
+    if (!match) {
+        return undefined;
+    }
+    const raw = match[1]?.trim();
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(`"${raw}"`);
+        return isMeaningfulMessage(parsed) ? parsed : undefined;
+    }
+    catch {
+        return isMeaningfulMessage(raw) ? raw : undefined;
+    }
+}
+function isMeaningfulMessage(message) {
+    const normalized = message.trim();
+    if (!normalized) {
+        return false;
+    }
+    if (normalized === "[object Object]") {
+        return false;
+    }
+    return true;
+}
+function findFirstMatchingLine(text, matchers) {
+    const lines = text.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        for (const matcher of matchers) {
+            const match = matcher.exec(trimmed);
+            if (match) {
+                return trimmed.slice(match.index).trim();
+            }
+        }
     }
     return undefined;
 }
+function extractGeminiFallbackLine(text) {
+    return findFirstMatchingLine(text, [
+        /TerminalQuotaError:/,
+        /PERMISSION_DENIED/,
+        /RESOURCE_EXHAUSTED/,
+        /No capacity available/i,
+        /You have exhausted your capacity/i,
+        /exhausted your capacity/i,
+    ]);
+}
 async function readCombinedLogs(stdoutPath, stderrPath) {
     const [stdout, stderr] = await Promise.all([
         safeRead(stdoutPath),

package/dist/agents/runtime/launcher.js

@@ -7,7 +7,6 @@ import { spawnStreamingProcess } from "../../utils/process.js";
 import { AgentRuntimeProcessError } from "./errors.js";
 import { generateSandboxSettings, resolveSrtBinary, writeSandboxSettings, } from "./sandbox.js";
 import { createWatchdog, WATCHDOG_DEFAULTS, } from "./watchdog.js";
-const DEFAULT_SRT_ARGUMENTS = ["--debug"];
 const SRT_BINARY_ENV = "VORATIQ_SRT_BINARY";
 let cachedSrtBinaryPath;
 export async function configureSandboxSettings(input) {
@@ -32,7 +31,6 @@ export async function getRunCommand() {
 function getRunArgs(options) {
     const { settingsArg, configArg, shimEntryPath } = options;
     return [
-        ...DEFAULT_SRT_ARGUMENTS,
         "--settings",
         settingsArg,
         "--",
@@ -84,6 +82,7 @@ export async function runAgentProcess(options) {
             command,
             args,
             cwd: agentRoot,
+            env: { SRT_DEBUG: process.env.SRT_DEBUG ?? "1" },
             stdout: { writable: stdoutStream },
             stderr: { writable: stderrStream },
             detached: true,

package/dist/agents/runtime/watchdog.js

@@ -8,8 +8,29 @@ export const WATCHDOG_DEFAULTS = {
     hardAbortMs: 10 * 1000,
 };
 export const FATAL_PATTERNS = new Map([
-    ["gemini", [/You have exhausted your capacity on this model\./i]],
-    ["codex", [/Connection failed: error sending request for url\./i]],
+    [
+        "gemini",
+        [
+            /PERMISSION_DENIED/i,
+            /RESOURCE_EXHAUSTED/i,
+            /MODEL_CAPACITY_EXHAUSTED/i,
+            /No capacity available for model/i,
+        ],
+    ],
+    [
+        "codex",
+        [/invalid_request_error/i, /unsupported_value/i, /thread .* panicked/i],
+    ],
+    [
+        "claude",
+        [
+            /OAuth token revoked/i,
+            /OAuth token has expired/i,
+            /Please run \/login/i,
+            /invalid.*api.*key/i,
+            /insufficient_quota/i,
+        ],
+    ],
 ]);
 export function createWatchdog(child, stderrStream, options) {
     const { silenceTimeoutMs, wallClockCapMs, killGraceMs, hardAbortMs } = WATCHDOG_DEFAULTS;

package/dist/auth/providers/codex.js

@@ -51,7 +51,6 @@ export const codexAuthProvider = {
         registerSandboxSecrets(sandboxPaths.home, secretHandles);
         const envResult = composeSandboxEnvResult(sandboxPaths.home, {
             CODEX_HOME: sandboxPaths.codex,
-            RUST_BACKTRACE: "1",
         });
         return envResult;
     },

package/dist/bin.js

@@ -5,6 +5,7 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { Command, CommanderError } from "commander";
 import { createApplyCommand } from "./cli/apply.js";
+import { createAutoCommand } from "./cli/auto.js";
 import { commanderAlreadyRendered } from "./cli/commander-utils.js";
 import { CliError, toCliError } from "./cli/errors.js";
 import { createInitCommand } from "./cli/init.js";
@@ -104,6 +105,7 @@ export async function runCli(argv = process.argv) {
     program.addCommand(createSpecCommand());
     program.addCommand(createRunCommand());
     program.addCommand(createReviewCommand());
+    program.addCommand(createAutoCommand());
     program.addCommand(createApplyCommand());
     program.addCommand(createPruneCommand());
     if (argv.length <= 2) {

package/dist/cli/auto.d.ts

@@ -0,0 +1,23 @@
+import { Command } from "commander";
+export interface AutoCommandOptions {
+    description?: string;
+    specPath?: string;
+    specAgent?: string;
+    title?: string;
+    output?: string;
+    reviewerAgent: string;
+    maxParallel?: number;
+    branch?: boolean;
+}
+export interface AutoCommandResult {
+    exitCode: number;
+    specOutputPath?: string;
+    runId?: string;
+    reviewOutputPath?: string;
+}
+interface AutoRuntimeOptions {
+    now?: () => number;
+}
+export declare function runAutoCommand(options: AutoCommandOptions, runtime?: AutoRuntimeOptions): Promise<AutoCommandResult>;
+export declare function createAutoCommand(): Command;
+export {};

package/dist/cli/auto.js

@@ -0,0 +1,225 @@
+import { Command, Option } from "commander";
+import { renderAutoSummaryTranscript } from "../render/transcripts/auto.js";
+import { renderCliError } from "../render/utils/errors.js";
+import { parsePositiveInteger } from "../utils/validators.js";
+import { toCliError } from "./errors.js";
+import { beginChainedCommandOutput, writeCommandOutput } from "./output.js";
+import { runReviewCommand } from "./review.js";
+import { runRunCommand } from "./run.js";
+import { runSpecCommand } from "./spec.js";
+function parseMaxParallelOption(value) {
+    return parsePositiveInteger(value, "Expected positive integer after --max-parallel", "--max-parallel must be greater than 0");
+}
+export async function runAutoCommand(options, runtime = {}) {
+    const now = runtime.now ?? Date.now.bind(Date);
+    const overallStart = now();
+    const chainedOutput = beginChainedCommandOutput();
+    try {
+        let exitCode = 0;
+        let specStartedAt;
+        let specStatus = "skipped";
+        let specOutputPath;
+        let specDetail;
+        let runStartedAt;
+        let runStatus = "skipped";
+        let runId;
+        let runDetail;
+        let runRecordStatus;
+        let runCreatedAt;
+        let runSpecPath;
+        let runBaseRevisionSha;
+        let reviewStartedAt;
+        let reviewStatus = "skipped";
+        let reviewOutputPath;
+        let reviewDetail;
+        if (options.description) {
+            specStartedAt = now();
+            try {
+                if (!options.specAgent) {
+                    throw new Error("Expected --spec-agent when --description is provided.");
+                }
+                const specResult = await runSpecCommand({
+                    description: options.description,
+                    agent: options.specAgent,
+                    title: options.title,
+                    output: options.output,
+                    yes: true,
+                    suppressHint: true,
+                });
+                specStatus = "succeeded";
+                specOutputPath = specResult.outputPath;
+                writeCommandOutput({ body: specResult.body });
+            }
+            catch (error) {
+                specStatus = "failed";
+                specDetail = toCliError(error).headline;
+                exitCode = 1;
+                writeCommandOutput({ body: renderCliError(toCliError(error)) });
+            }
+        }
+        else if (options.specPath) {
+            specStatus = "skipped";
+            specOutputPath = options.specPath;
+        }
+        else {
+            specStatus = "failed";
+            specDetail = "Either --description or --spec must be provided.";
+            exitCode = 1;
+            writeCommandOutput({
+                body: renderCliError(toCliError(new Error(specDetail))),
+            });
+        }
+        if (exitCode === 0 && specOutputPath) {
+            runStartedAt = now();
+            try {
+                // For non-TTY, suppress run renderer blank lines and let the chained
+                // output system handle spacing. For TTY, let the run renderer handle
+                // its own spacing since cursor control requires precise line counts.
+                const suppressBlankLines = !process.stdout.isTTY;
+                const runResult = await runRunCommand({
+                    specPath: specOutputPath,
+                    maxParallel: options.maxParallel,
+                    branch: options.branch,
+                    suppressHint: true,
+                    suppressLeadingBlankLine: suppressBlankLines,
+                    suppressTrailingBlankLine: suppressBlankLines,
+                    stdout: chainedOutput.stdout,
+                    stderr: chainedOutput.stderr,
+                });
+                runStatus = "succeeded";
+                runId = runResult.report.runId;
+                runRecordStatus = runResult.report.status;
+                runCreatedAt = runResult.report.createdAt;
+                runSpecPath = runResult.report.spec?.path;
+                runBaseRevisionSha = runResult.report.baseRevisionSha;
+                if (runResult.exitCode === 1) {
+                    exitCode = 1;
+                }
+                writeCommandOutput({ body: runResult.body });
+            }
+            catch (error) {
+                runStatus = "failed";
+                runDetail = toCliError(error).headline;
+                exitCode = 1;
+                writeCommandOutput({ body: renderCliError(toCliError(error)) });
+            }
+        }
+        if (exitCode === 0 || runId) {
+            if (!runId) {
+                reviewStatus = "skipped";
+            }
+            else {
+                reviewStartedAt = now();
+                try {
+                    const reviewResult = await runReviewCommand({
+                        runId,
+                        agentId: options.reviewerAgent,
+                        suppressHint: true,
+                    });
+                    reviewStatus = "succeeded";
+                    reviewOutputPath = reviewResult.outputPath;
+                    writeCommandOutput({
+                        body: reviewResult.body,
+                        stderr: reviewResult.stderr,
+                    });
+                }
+                catch (error) {
+                    reviewStatus = "failed";
+                    reviewDetail = toCliError(error).headline;
+                    exitCode = 1;
+                    writeCommandOutput({ body: renderCliError(toCliError(error)) });
+                }
+            }
+        }
+        const overallDurationMs = now() - overallStart;
+        const specDurationMs = specStartedAt !== undefined ? now() - specStartedAt : undefined;
+        const runDurationMs = runStartedAt !== undefined ? now() - runStartedAt : undefined;
+        const reviewDurationMs = reviewStartedAt !== undefined ? now() - reviewStartedAt : undefined;
+        const summaryBody = renderAutoSummaryTranscript({
+            totalDurationMs: overallDurationMs,
+            spec: {
+                status: specStatus,
+                ...(typeof specDurationMs === "number"
+                    ? { durationMs: specDurationMs }
+                    : {}),
+                outputPath: specOutputPath,
+                ...(specDetail ? { detail: specDetail } : {}),
+            },
+            run: {
+                status: runStatus,
+                ...(typeof runDurationMs === "number"
+                    ? { durationMs: runDurationMs }
+                    : {}),
+                ...(runId ? { runId } : {}),
+                ...(runRecordStatus ? { runStatus: runRecordStatus } : {}),
+                ...(runCreatedAt ? { createdAt: runCreatedAt } : {}),
+                ...(runSpecPath ? { specPath: runSpecPath } : {}),
+                ...(runBaseRevisionSha ? { baseRevisionSha: runBaseRevisionSha } : {}),
+                ...(runDetail ? { detail: runDetail } : {}),
+            },
+            review: {
+                status: reviewStatus,
+                ...(typeof reviewDurationMs === "number"
+                    ? { durationMs: reviewDurationMs }
+                    : {}),
+                ...(reviewOutputPath ? { outputPath: reviewOutputPath } : {}),
+                ...(reviewDetail ? { detail: reviewDetail } : {}),
+            },
+        });
+        writeCommandOutput({
+            body: summaryBody,
+            exitCode,
+        });
+        return {
+            exitCode,
+            specOutputPath,
+            runId,
+            reviewOutputPath,
+        };
+    }
+    finally {
+        chainedOutput.end();
+    }
+}
+export function createAutoCommand() {
+    return new Command("auto")
+        .description("Generate a spec, run agents, and review results in one command")
+        .addOption(new Option("--description <text>", "Generate a spec from a description, then run and review").conflicts("spec"))
+        .addOption(new Option("--spec <path>", "Use an existing spec path, then run and review").conflicts("description"))
+        .requiredOption("--review-agent <agent-id>", "Reviewer agent identifier")
+        .option("--spec-agent <agent-id>", "Spec generator agent identifier")
+        .option("--title <text>", "Optional spec title (description mode only)")
+        .option("--output <path>", "Optional spec output path within .voratiq/specs/ (description mode only)")
+        .option("--max-parallel <count>", "Maximum number of agents to run concurrently", parseMaxParallelOption)
+        .option("--branch", "Checkout or create a branch named after the spec file")
+        .allowExcessArguments(false)
+        .action(async (options, command) => {
+        const hasDescription = typeof options.description === "string" &&
+            options.description.length > 0;
+        const hasSpec = typeof options.spec === "string" && options.spec.length > 0;
+        if (!hasDescription && !hasSpec) {
+            command.error("error: either --description <text> or --spec <path> must be provided", {
+                exitCode: 1,
+            });
+        }
+        if (hasDescription &&
+            (!options.specAgent || options.specAgent.length === 0)) {
+            command.error("error: --spec-agent <agent-id> is required with --description", {
+                exitCode: 1,
+            });
+        }
+        if (hasSpec && (options.specAgent || options.title || options.output)) {
+            command.error("error: --spec-agent/--title/--output are only valid with --description", { exitCode: 1 });
+        }
+        await runAutoCommand({
+            description: options.description,
+            specPath: options.spec,
+            specAgent: options.specAgent,
+            title: options.title,
+            output: options.output,
+            reviewerAgent: options.reviewAgent,
+            maxParallel: options.maxParallel,
+            branch: options.branch,
+        });
+    });
+}

package/dist/cli/output.d.ts

@@ -1,4 +1,8 @@
+import { type FormatCliOutputOptions } from "../utils/output.js";
 export declare function writeCommandPreface(preface: string): void;
+type CliWriter = Pick<NodeJS.WriteStream, "write"> & {
+    isTTY?: boolean;
+};
 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 {};