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

package/dist/commands/run/agents/eval-runner.d.ts

@@ -1,19 +0,0 @@
-import type { EnvironmentConfig } from "../../../configs/environment/types.js";
-import type { AgentEvalResult, EvalDefinition } from "../../../configs/evals/types.js";
-import { type ArtifactCollectionResult, type SandboxPersona } from "../../../workspace/agents.js";
-import type { AgentWorkspacePaths } from "../../../workspace/layout.js";
-export interface EvalRunInput {
-    evalPlan: readonly EvalDefinition[];
-    workspacePaths: AgentWorkspacePaths;
-    baseRevisionSha: string;
-    root: string;
-    manifestEnv: Record<string, string>;
-    environment: EnvironmentConfig;
-    persona: SandboxPersona;
-}
-export interface EvalRunResult {
-    artifacts: ArtifactCollectionResult;
-    evaluations: AgentEvalResult[];
-    warnings: string[];
-}
-export declare function runPostProcessingAndEvaluations(input: EvalRunInput): Promise<EvalRunResult>;

package/dist/commands/run/agents/eval-runner.js

@@ -1,27 +0,0 @@
-import { executeEvaluations } from "../../../evals/runner.js";
-import { collectAgentArtifacts, } from "../../../workspace/agents.js";
-export async function runPostProcessingAndEvaluations(input) {
-    const { evalPlan, workspacePaths, baseRevisionSha, root, manifestEnv, environment, persona, } = input;
-    const artifacts = await collectAgentArtifacts({
-        baseRevisionSha,
-        workspacePath: workspacePaths.workspacePath,
-        summaryPath: workspacePaths.summaryPath,
-        diffPath: workspacePaths.diffPath,
-        root,
-        environment,
-        persona,
-    });
-    const evalOutcome = await executeEvaluations({
-        evaluations: evalPlan,
-        cwd: workspacePaths.workspacePath,
-        root,
-        logsDirectory: workspacePaths.evalsDirPath,
-        env: manifestEnv,
-        environment,
-    });
-    return {
-        artifacts,
-        evaluations: evalOutcome.results,
-        warnings: evalOutcome.warnings,
-    };
-}

package/dist/commands/run/agents/failures.js

@@ -1,32 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { CLAUDE_OAUTH_RELOGIN_HINT, CLAUDE_PROVIDER_ID, } from "../../../auth/providers/claude/constants.js";
-const CLAUDE_FAILURE_PATTERNS = [
-    /Please run \/login/i,
-    /OAuth token has expired/i,
-];
-export async function detectAgentProcessFailureDetail(input) {
-    if (input.provider !== CLAUDE_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;
-    }
-    return undefined;
-}
-async function readCombinedLogs(stdoutPath, stderrPath) {
-    const [stdout, stderr] = await Promise.all([
-        safeRead(stdoutPath),
-        safeRead(stderrPath),
-    ]);
-    return `${stdout}\n${stderr}`;
-}
-async function safeRead(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch {
-        return "";
-    }
-}

package/dist/commands/run/agents/preparation.js

@@ -1,123 +0,0 @@
-import { ensureWorkspaceError, prepareAgentWorkspace, } from "../../../workspace/agents.js";
-import { buildAgentWorkspacePaths } from "../../../workspace/layout.js";
-import { MissingAgentProviderError, RunCommandError } from "../errors.js";
-import { registerStagedSandboxContext, teardownRegisteredSandboxContext, } from "../sandbox-registry.js";
-import { stageAgentAuth } from "./auth-stage.js";
-import { captureAgentChatTranscripts } from "./chat-preserver.js";
-import { AgentRunContext } from "./run-context.js";
-import { configureSandboxSettings } from "./sandbox-launcher.js";
-import { writeAgentManifest } from "./workspace-prep.js";
-export async function prepareAgentForExecution(context) {
-    const { agent, baseRevisionSha, runId, root, evalPlan, environment } = context;
-    const workspacePaths = buildAgentWorkspacePaths({
-        root,
-        runId,
-        agentId: agent.id,
-    });
-    const startedAt = new Date().toISOString();
-    const agentContext = new AgentRunContext({
-        agent,
-        runId,
-        startedAt,
-        evalPlan,
-    });
-    try {
-        await prepareAgentWorkspace({
-            paths: workspacePaths,
-            baseRevisionSha,
-            root,
-            agentId: agent.id,
-            runId,
-            environment,
-        });
-    }
-    catch (error) {
-        return {
-            status: "failed",
-            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
-        };
-    }
-    let authContext;
-    let manifestEnv = {};
-    try {
-        const staged = await stageAgentAuth({
-            agent,
-            agentRoot: workspacePaths.agentRoot,
-            runId,
-            root,
-        });
-        authContext = staged.context;
-        registerStagedSandboxContext(authContext);
-        manifestEnv = staged.env;
-    }
-    catch (error) {
-        return {
-            status: "failed",
-            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
-        };
-    }
-    try {
-        manifestEnv = await writeAgentManifest({
-            agent,
-            workspacePaths,
-            env: manifestEnv,
-            environment,
-        });
-    }
-    catch (error) {
-        await captureAgentChatTranscripts({
-            agent,
-            agentContext,
-            agentRoot: workspacePaths.agentRoot,
-            reason: "pre-run",
-        });
-        await teardownRegisteredSandboxContext(authContext);
-        return {
-            status: "failed",
-            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
-        };
-    }
-    try {
-        const providerId = agent.provider;
-        if (!providerId) {
-            throw new MissingAgentProviderError(agent.id);
-        }
-        await configureSandboxSettings({
-            workspacePaths,
-            providerId,
-            root,
-        });
-    }
-    catch (error) {
-        await captureAgentChatTranscripts({
-            agent,
-            agentContext,
-            agentRoot: workspacePaths.agentRoot,
-            reason: "pre-run",
-        });
-        await teardownRegisteredSandboxContext(authContext);
-        return {
-            status: "failed",
-            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
-        };
-    }
-    return {
-        status: "ready",
-        prepared: {
-            agent,
-            agentContext,
-            workspacePaths,
-            runtimeManifestPath: workspacePaths.runtimeManifestPath,
-            baseRevisionSha,
-            root,
-            runId,
-            evalPlan,
-            environment,
-            manifestEnv,
-            authContext,
-        },
-    };
-}
-function ensureWorkspaceFailure(error) {
-    return error instanceof RunCommandError ? error : ensureWorkspaceError(error);
-}

package/dist/commands/run/agents.d.ts

@@ -1,14 +0,0 @@
-import type { AgentDefinition } from "../../configs/agents/types.js";
-import type { EnvironmentConfig } from "../../configs/environment/types.js";
-import type { EvalDefinition } from "../../configs/evals/types.js";
-import type { AgentPreparationResult, PreparedAgentExecution } from "./agents/types.js";
-import type { AgentExecutionResult } from "./reports.js";
-export declare function prepareAgents(options: {
-    agents: readonly AgentDefinition[];
-    baseRevisionSha: string;
-    runId: string;
-    root: string;
-    evalPlan: readonly EvalDefinition[];
-    environment: EnvironmentConfig;
-}): Promise<AgentPreparationResult>;
-export declare function runAgentsWithLimit(agents: PreparedAgentExecution[], limit: number): Promise<AgentExecutionResult[]>;

package/dist/commands/run/agents.js

@@ -1,47 +0,0 @@
-import { runPreparedAgent } from "./agents/lifecycle.js";
-import { prepareAgentForExecution } from "./agents/preparation.js";
-export async function prepareAgents(options) {
-    const { agents, baseRevisionSha, runId, root, evalPlan, environment } = options;
-    const ready = [];
-    const failures = [];
-    for (const agent of agents) {
-        const preparation = await prepareAgentForExecution({
-            agent,
-            baseRevisionSha,
-            runId,
-            root,
-            evalPlan,
-            environment,
-        });
-        if (preparation.status === "ready") {
-            ready.push(preparation.prepared);
-        }
-        else {
-            failures.push(preparation.result);
-        }
-    }
-    return { ready, failures };
-}
-export async function runAgentsWithLimit(agents, limit) {
-    if (agents.length === 0) {
-        return [];
-    }
-    const workerCount = Math.max(1, Math.min(limit, agents.length));
-    const results = new Array(agents.length);
-    let nextIndex = 0;
-    async function worker() {
-        while (true) {
-            const current = nextIndex++;
-            if (current >= agents.length) {
-                return;
-            }
-            results[current] = await runPreparedAgent(agents[current]);
-        }
-    }
-    const workers = [];
-    for (let index = 0; index < workerCount; index += 1) {
-        workers.push(worker());
-    }
-    await Promise.all(workers);
-    return results;
-}

package/dist/commands/run/prompts.d.ts

@@ -1,4 +0,0 @@
-export interface BuildAgentPromptOptions {
-    specContent: string;
-}
-export declare function buildAgentPrompt(options: BuildAgentPromptOptions): string;

package/dist/commands/run/prompts.js

@@ -1,16 +0,0 @@
-export function buildAgentPrompt(options) {
-    const { specContent } = options;
-    const lines = [
-        "Implement the following task:",
-        "",
-        "```",
-        specContent.trimEnd(),
-        "```",
-        "",
-        "Constraints:",
-        "- You are running headlessly. Never pause for user interaction.",
-        "- You are sandboxed. If an operation is blocked, skip it and continue.",
-        "- When finished, write a 1-2 sentence summary to `.summary.txt` (in the workspace root).",
-    ];
-    return `${lines.join("\n")}\n`;
-}

package/dist/commands/run/sandbox-registry.d.ts

@@ -1,4 +0,0 @@
-import type { StagedAuthContext } from "./agents/auth-stage.js";
-export declare function registerStagedSandboxContext(context: StagedAuthContext): void;
-export declare function teardownRegisteredSandboxContext(context: StagedAuthContext | undefined): Promise<void>;
-export declare function teardownRunSandboxes(runId: string | undefined): Promise<void>;

package/dist/commands/run/sandbox-registry.js

@@ -1,54 +0,0 @@
-import { teardownAuthContext } from "./agents/auth-stage.js";
-const sandboxRegistry = new Map();
-export function registerStagedSandboxContext(context) {
-    const contexts = sandboxRegistry.get(context.runId);
-    if (contexts) {
-        contexts.add(context);
-        return;
-    }
-    sandboxRegistry.set(context.runId, new Set([context]));
-}
-export async function teardownRegisteredSandboxContext(context) {
-    if (!context) {
-        return;
-    }
-    await teardownAuthContext(context);
-    removeContextFromRegistry(context);
-}
-export async function teardownRunSandboxes(runId) {
-    if (!runId) {
-        return;
-    }
-    const contexts = sandboxRegistry.get(runId);
-    if (!contexts || contexts.size === 0) {
-        sandboxRegistry.delete(runId);
-        return;
-    }
-    const failures = [];
-    const stagedContexts = Array.from(contexts);
-    for (const context of stagedContexts) {
-        try {
-            await teardownAuthContext(context);
-            removeContextFromRegistry(context);
-        }
-        catch (error) {
-            failures.push(error);
-        }
-    }
-    if (failures.length === 1) {
-        throw failures[0];
-    }
-    if (failures.length > 1) {
-        throw new AggregateError(failures, `Failed to teardown ${failures.length} sandbox contexts for run ${runId}`);
-    }
-}
-function removeContextFromRegistry(context) {
-    const contexts = sandboxRegistry.get(context.runId);
-    if (!contexts) {
-        return;
-    }
-    contexts.delete(context);
-    if (contexts.size === 0) {
-        sandboxRegistry.delete(context.runId);
-    }
-}

package/dist/configs/evals/defaults.d.ts

@@ -1,8 +0,0 @@
-export interface EvalDefault {
-    readonly slug: string;
-    readonly command?: string;
-}
-export declare const DEFAULT_EVAL_TEMPLATE_HEADER: readonly string[];
-export declare const DEFAULT_EVAL_DEFAULTS: readonly EvalDefault[];
-export declare function serializeEvalDefaults(defaults: readonly EvalDefault[]): string[];
-export declare function listEvalDefaults(): EvalDefault[];

package/dist/configs/evals/defaults.js

@@ -1,28 +0,0 @@
-export const DEFAULT_EVAL_TEMPLATE_HEADER = [
-    "# Eval commands run after each agent finishes its run.",
-    "# For each slug, provide the command that runs that eval.",
-    "# Leave any entry blank (or delete it entirely) to skip that eval.",
-    '# Example: format: "npm run format:check"',
-    "",
-];
-export const DEFAULT_EVAL_DEFAULTS = [
-    { slug: "format" },
-    { slug: "lint" },
-    { slug: "typecheck" },
-    { slug: "tests" },
-];
-export function serializeEvalDefaults(defaults) {
-    const lines = [...DEFAULT_EVAL_TEMPLATE_HEADER];
-    for (const { slug, command } of defaults) {
-        if (command && command.length > 0) {
-            lines.push(`${slug}: ${JSON.stringify(command)}`);
-        }
-        else {
-            lines.push(`${slug}:`);
-        }
-    }
-    return lines;
-}
-export function listEvalDefaults() {
-    return DEFAULT_EVAL_DEFAULTS.map((definition) => ({ ...definition }));
-}

package/dist/configs/evals/detect.d.ts

@@ -1,10 +0,0 @@
-import { type EnvironmentConfig } from "../environment/types.js";
-import type { EvalSlug } from "./types.js";
-export declare const CANONICAL_EVAL_SLUGS: EvalSlug[];
-export interface EvalSuggestion {
-    source: "node" | "python";
-    commands: Map<EvalSlug, string>;
-    notes: string[];
-    warnings: string[];
-}
-export declare function detectEvalSuggestions(root: string, environment: EnvironmentConfig): Promise<EvalSuggestion[]>;

package/dist/configs/evals/errors.d.ts

@@ -1,16 +0,0 @@
-import { WorkspaceSetupError } from "../../workspace/errors.js";
-declare const DEFAULT_EVALS_ERROR_CONTEXT: "Invalid evals.yaml";
-export { DEFAULT_EVALS_ERROR_CONTEXT };
-export declare class EvalsError extends WorkspaceSetupError {
-    constructor(message: string);
-}
-export declare class EvalsConfigError extends EvalsError {
-    constructor(message: string);
-}
-export declare class MissingEvalsConfigError extends EvalsConfigError {
-    readonly filePath: string;
-    constructor(filePath: string);
-}
-export declare class EvalsYamlParseError extends EvalsConfigError {
-    constructor(message: string);
-}

package/dist/configs/evals/errors.js

@@ -1,29 +0,0 @@
-import { WorkspaceSetupError } from "../../workspace/errors.js";
-const DEFAULT_EVALS_ERROR_CONTEXT = "Invalid evals.yaml";
-export { DEFAULT_EVALS_ERROR_CONTEXT };
-export class EvalsError extends WorkspaceSetupError {
-    constructor(message) {
-        super(message);
-        this.name = "EvalsError";
-    }
-}
-export class EvalsConfigError extends EvalsError {
-    constructor(message) {
-        super(message);
-        this.name = "EvalsConfigError";
-    }
-}
-export class MissingEvalsConfigError extends EvalsConfigError {
-    filePath;
-    constructor(filePath) {
-        super(`Missing eval configuration file at ${filePath}.`);
-        this.filePath = filePath;
-        this.name = "MissingEvalsConfigError";
-    }
-}
-export class EvalsYamlParseError extends EvalsConfigError {
-    constructor(message) {
-        super(message);
-        this.name = "EvalsYamlParseError";
-    }
-}

package/dist/configs/evals/loader.d.ts

@@ -1,9 +0,0 @@
-import { type EvalDefinition, type EvalsConfig } from "./types.js";
-export declare function readEvalsConfig(content: string): EvalsConfig;
-export interface LoadEvalConfigOptions {
-    root?: string;
-    filePath?: string;
-    readFile?: (path: string) => string;
-}
-export declare function loadEvalConfig(options?: LoadEvalConfigOptions): EvalsConfig;
-export declare function buildEvalDefinitions(config: EvalsConfig): EvalDefinition[];

package/dist/configs/evals/loader.js

@@ -1,46 +0,0 @@
-import { ZodError } from "zod";
-import { parseYamlDocument, } from "../../utils/yaml-reader.js";
-import { resolveWorkspacePath, VORATIQ_EVALS_FILE, } from "../../workspace/structure.js";
-import { createConfigLoader } from "../shared/loader-factory.js";
-import { formatYamlErrorMessage } from "../shared/yaml-error-formatter.js";
-import { DEFAULT_EVALS_ERROR_CONTEXT, EvalsConfigError, EvalsYamlParseError, MissingEvalsConfigError, } from "./errors.js";
-import { evalsConfigSchema, } from "./types.js";
-export function readEvalsConfig(content) {
-    const parsed = parseYamlDocument(content, {
-        formatError: formatEvalsYamlError,
-    });
-    try {
-        const config = evalsConfigSchema.parse(parsed);
-        return config;
-    }
-    catch (error) {
-        if (error instanceof ZodError) {
-            const detail = error.issues
-                .map((issue) => issue.message)
-                .join("; ")
-                .trim();
-            throw new EvalsConfigError(`${DEFAULT_EVALS_ERROR_CONTEXT}: ${detail || "invalid mapping"}`);
-        }
-        throw error;
-    }
-}
-function formatEvalsYamlError(detail) {
-    const message = formatYamlErrorMessage(detail, {
-        context: DEFAULT_EVALS_ERROR_CONTEXT,
-    });
-    return new EvalsYamlParseError(message);
-}
-const loadEvalConfigInternal = createConfigLoader({
-    resolveFilePath: (root, options) => options.filePath ?? resolveWorkspacePath(root, VORATIQ_EVALS_FILE),
-    selectReadFile: (options) => options.readFile,
-    handleMissing: ({ filePath }) => {
-        throw new MissingEvalsConfigError(filePath);
-    },
-    parse: (content) => readEvalsConfig(content),
-});
-export function loadEvalConfig(options = {}) {
-    return loadEvalConfigInternal(options);
-}
-export function buildEvalDefinitions(config) {
-    return config.map(({ slug, command }) => ({ slug, command }));
-}

package/dist/configs/evals/types.d.ts

@@ -1,42 +0,0 @@
-import { z } from "zod";
-import { EVAL_STATUS_VALUES } from "../../status/index.js";
-export declare const evalSlugSchema: z.ZodString;
-export type EvalSlug = z.infer<typeof evalSlugSchema>;
-export declare const evalStatusSchema: z.ZodEnum<{
-    succeeded: "succeeded";
-    failed: "failed";
-    errored: "errored";
-    skipped: "skipped";
-}>;
-export type EvalStatus = (typeof EVAL_STATUS_VALUES)[number];
-export declare const evalCommandSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>;
-export interface EvalCommandEntry {
-    slug: EvalSlug;
-    command?: string;
-}
-export type EvalsConfig = ReadonlyArray<EvalCommandEntry>;
-export declare const evalsConfigSchema: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<string | undefined, string | null | undefined>>>, z.ZodTransform<EvalCommandEntry[], Record<string, string | undefined>>>;
-export declare const agentEvalResultSchema: z.ZodObject<{
-    slug: z.ZodString;
-    status: z.ZodEnum<{
-        succeeded: "succeeded";
-        failed: "failed";
-        errored: "errored";
-        skipped: "skipped";
-    }>;
-    command: z.ZodOptional<z.ZodString>;
-    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    logPath: z.ZodOptional<z.ZodString>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type AgentEvalResult = z.infer<typeof agentEvalResultSchema>;
-export interface EvalDefinition {
-    slug: EvalSlug;
-    command?: string;
-}
-/**
- * Normalizes an eval command by trimming whitespace and converting empty strings to undefined.
- * Exported for reuse in init scaffolding and other contexts.
- */
-export declare function normalizeEvalCommand(command: string | undefined): string | undefined;
-export declare function sanitizeSlugForFilename(slug: string): string;

package/dist/configs/evals/types.js

@@ -1,74 +0,0 @@
-import { z } from "zod";
-import { evalStatusSchema as sharedEvalStatusSchema, } from "../../status/index.js";
-const EVAL_SLUG_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/u;
-export const evalSlugSchema = z
-    .string()
-    .min(1, "eval slug is required")
-    .regex(EVAL_SLUG_PATTERN, "eval slug must contain only lowercase letters, numbers, dots, or hyphens");
-export const evalStatusSchema = sharedEvalStatusSchema;
-export const evalCommandSchema = z
-    .union([z.string(), z.null(), z.undefined()])
-    .transform((value) => {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-});
-export const evalsConfigSchema = z
-    .record(z.string(), evalCommandSchema)
-    .superRefine((value, ctx) => {
-    const seen = new Set();
-    for (const rawSlug of Object.keys(value)) {
-        const trimmedSlug = rawSlug.trim();
-        const parsed = evalSlugSchema.safeParse(trimmedSlug);
-        if (!parsed.success) {
-            const message = parsed.error.issues[0]?.message ?? "invalid eval slug";
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: [rawSlug],
-                message,
-            });
-            continue;
-        }
-        if (seen.has(parsed.data)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                path: [rawSlug],
-                message: `Duplicate eval slug "${parsed.data}"`,
-            });
-        }
-        seen.add(parsed.data);
-    }
-})
-    .transform((value) => {
-    const entries = [];
-    for (const [rawSlug, rawCommand] of Object.entries(value)) {
-        const slug = evalSlugSchema.parse(rawSlug.trim());
-        const normalizedCommand = normalizeEvalCommand(rawCommand);
-        entries.push({ slug, command: normalizedCommand });
-    }
-    return entries;
-});
-export const agentEvalResultSchema = z.object({
-    slug: evalSlugSchema,
-    status: evalStatusSchema,
-    command: z.string().optional(),
-    exitCode: z.number().nullable().optional(),
-    logPath: z.string().optional(),
-    error: z.string().optional(),
-});
-/**
- * Normalizes an eval command by trimming whitespace and converting empty strings to undefined.
- * Exported for reuse in init scaffolding and other contexts.
- */
-export function normalizeEvalCommand(command) {
-    if (command === undefined) {
-        return undefined;
-    }
-    const trimmed = command.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-export function sanitizeSlugForFilename(slug) {
-    return slug.replace(/[^a-z0-9.-]/gu, "-");
-}

package/dist/evals/runner.d.ts

@@ -1,16 +0,0 @@
-import { type EnvironmentConfig } from "../configs/environment/types.js";
-import type { AgentEvalResult, EvalDefinition } from "../configs/evals/types.js";
-interface ExecuteEvaluationsOptions {
-    evaluations: readonly EvalDefinition[];
-    cwd: string;
-    root: string;
-    logsDirectory: string;
-    env?: NodeJS.ProcessEnv;
-    environment: EnvironmentConfig;
-}
-export interface ExecuteEvaluationsResult {
-    results: AgentEvalResult[];
-    warnings: string[];
-}
-export declare function executeEvaluations(options: ExecuteEvaluationsOptions): Promise<ExecuteEvaluationsResult>;
-export {};