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

package/dist/evals/runner.js

@@ -1,132 +0,0 @@
-import { createWriteStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { getNodeDependencyRoots, getPythonEnvironmentPath, } from "../configs/environment/types.js";
-import { sanitizeSlugForFilename } from "../configs/evals/types.js";
-import { toErrorMessage } from "../utils/errors.js";
-import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../utils/path.js";
-import { spawnStreamingProcess } from "../utils/process.js";
-export async function executeEvaluations(options) {
-    const { evaluations, cwd, root, logsDirectory, env, environment } = options;
-    const results = [];
-    const warnings = [];
-    await mkdir(logsDirectory, { recursive: true });
-    const evalEnvironment = composeEvalEnvironment(env);
-    for (const evaluation of evaluations) {
-        const { slug, command } = evaluation;
-        if (!command) {
-            results.push({
-                slug,
-                status: "skipped",
-            });
-            continue;
-        }
-        const logFileName = `${sanitizeSlugForFilename(slug)}.log`;
-        const logPath = resolvePath(logsDirectory, logFileName);
-        const logStream = createWriteStream(logPath, { flags: "w" });
-        let exitCode = null;
-        let status = "succeeded";
-        let errorMessage;
-        const missingStacks = detectMissingStacks(command, environment);
-        if (missingStacks.length > 0) {
-            const warningMessage = buildMissingStackWarning(slug, command, missingStacks);
-            logStream.write(`${warningMessage}\n`);
-            warnings.push(warningMessage);
-        }
-        try {
-            logStream.write("[voratiq] Injecting VORATIQ_WORKSPACE_TESTS=1 for workspace evals\n");
-            const { exitCode: code, signal } = await spawnStreamingProcess({
-                command,
-                cwd,
-                env: evalEnvironment,
-                shell: true,
-                stdout: { writable: logStream, endOnClose: false },
-                stderr: { writable: logStream, endOnClose: false },
-            });
-            if (signal) {
-                status = "errored";
-                exitCode = null;
-                errorMessage = `Process terminated by signal ${signal}`;
-            }
-            else {
-                exitCode = code;
-                status = code === 0 ? "succeeded" : "failed";
-            }
-        }
-        catch (error) {
-            status = "errored";
-            exitCode = null;
-            errorMessage = toErrorMessage(error);
-        }
-        finally {
-            logStream.end();
-        }
-        results.push({
-            slug,
-            status,
-            command,
-            exitCode,
-            logPath: normalizePathForDisplay(relativeToRoot(root, logPath)),
-            error: errorMessage,
-        });
-    }
-    return { results, warnings };
-}
-function composeEvalEnvironment(overrides) {
-    return {
-        ...overrides,
-        VORATIQ_WORKSPACE_TESTS: "1",
-    };
-}
-function detectMissingStacks(command, environment) {
-    const lower = command.toLowerCase();
-    const required = new Set();
-    if (requiresNodeStack(lower)) {
-        required.add("node");
-    }
-    if (requiresPythonStack(lower)) {
-        required.add("python");
-    }
-    const missing = [];
-    if (required.has("node") &&
-        getNodeDependencyRoots(environment).length === 0) {
-        missing.push("node");
-    }
-    if (required.has("python") && !getPythonEnvironmentPath(environment)) {
-        missing.push("python");
-    }
-    return missing;
-}
-function requiresNodeStack(source) {
-    const markers = [
-        "npm ",
-        "npm:",
-        "npx ",
-        "pnpm ",
-        "yarn ",
-        " node",
-        "node ",
-        "tsc",
-        "jest",
-    ];
-    return markers.some((marker) => source.includes(marker));
-}
-function requiresPythonStack(source) {
-    const markers = [
-        "python",
-        "pytest",
-        "ruff",
-        "uv ",
-        " uv",
-        "pipenv",
-        "pip ",
-        " pip",
-        "poetry",
-        "pyright",
-        "conda",
-    ];
-    return markers.some((marker) => source.includes(marker));
-}
-function buildMissingStackWarning(slug, command, stacks) {
-    const stackLabel = stacks.join(" and ");
-    return `[voratiq] Warning: "${slug}" command requires ${stackLabel} tooling, but .voratiq/environment.yaml is missing the corresponding configuration. Command: ${command}`;
-}

package/dist/records/persistence.js

@@ -1,469 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { assertTestHookRegistrationEnabled } from "../testing/test-hooks.js";
-import { isFileSystemError, pathExists } from "../utils/fs.js";
-import { relativeToRoot } from "../utils/path.js";
-import { RunOptionValidationError, RunRecordMutationError, RunRecordNotFoundError, RunRecordParseError, } from "./errors.js";
-import { acquireHistoryLock } from "./history-lock.js";
-import { runRecordSchema } from "./types.js";
-export { HISTORY_LOCK_STALE_GRACE_MS } from "./history-lock.js";
-const RUN_INDEX_VERSION = 2;
-export const RUN_RECORD_FILENAME = "record.json";
-const HISTORY_LOCK_FILENAME = "history.lock";
-const BUFFER_FLUSH_DELAY_MS = 250;
-const runRecordBuffers = new Map();
-const readRunRecordsInternal = async (options) => {
-    const { root, runsFilePath, limit, predicate, onWarning } = options;
-    if (limit !== undefined && (!Number.isInteger(limit) || limit <= 0)) {
-        throw new RunOptionValidationError("limit", "must be a positive integer");
-    }
-    const sessionsDir = getSessionsDirectory(runsFilePath);
-    let index;
-    try {
-        index = await readRunIndex(runsFilePath);
-    }
-    catch (error) {
-        if (error instanceof RunRecordParseError) {
-            const displayPath = relativeToRoot(root, runsFilePath);
-            throw new RunRecordParseError(displayPath, error.details);
-        }
-        throw error;
-    }
-    const matches = [];
-    for (let i = index.sessions.length - 1; i >= 0; i -= 1) {
-        const entry = index.sessions[i];
-        if (!entry) {
-            continue;
-        }
-        const recordPath = join(sessionsDir, entry.runId, RUN_RECORD_FILENAME);
-        try {
-            const record = await readRunRecordFromDisk(recordPath);
-            if (predicate && !predicate(record)) {
-                continue;
-            }
-            matches.push(record);
-            if (limit !== undefined && matches.length >= limit) {
-                break;
-            }
-        }
-        catch (error) {
-            if (error instanceof RunRecordParseError) {
-                const warning = {
-                    kind: "parse-error",
-                    runId: entry.runId,
-                    recordPath,
-                    displayPath: relativeToRoot(root, recordPath),
-                    details: error.details,
-                };
-                onWarning?.(warning);
-                continue;
-            }
-            if (error instanceof RunRecordNotFoundError) {
-                const warning = {
-                    kind: "missing-record",
-                    runId: entry.runId,
-                    recordPath,
-                    displayPath: relativeToRoot(root, recordPath),
-                };
-                onWarning?.(warning);
-                continue;
-            }
-            throw error;
-        }
-    }
-    return matches;
-};
-let readRunRecordsImpl = readRunRecordsInternal;
-function setReadRunRecordsImplementation(implementation) {
-    readRunRecordsImpl = implementation;
-}
-function resetReadRunRecordsImplementation() {
-    readRunRecordsImpl = readRunRecordsInternal;
-}
-export async function readRunRecords(options) {
-    return readRunRecordsImpl(options);
-}
-export async function appendRunRecord(options) {
-    const { root, runsFilePath, record } = options;
-    const runsRoot = getRunsDirectory(runsFilePath);
-    const sessionsDir = getSessionsDirectory(runsFilePath);
-    const recordDir = join(sessionsDir, record.runId);
-    const recordPath = join(recordDir, RUN_RECORD_FILENAME);
-    const displayPath = relativeToRoot(root, recordPath);
-    const lockPath = join(runsRoot, HISTORY_LOCK_FILENAME);
-    await mkdir(recordDir, { recursive: true });
-    const releaseLock = await acquireHistoryLock(lockPath);
-    try {
-        if (await pathExists(recordPath)) {
-            throw new RunRecordMutationError(`Run ${record.runId} already exists at ${displayPath}.`);
-        }
-        await atomicWriteJson(recordPath, record);
-        await upsertRunIndexEntry(runsFilePath, {
-            runId: record.runId,
-            createdAt: record.createdAt,
-            status: record.status,
-        });
-        registerBufferEntry({
-            key: recordPath,
-            runId: record.runId,
-            recordPath,
-            lockPath,
-            runsDir: runsRoot,
-            runsFilePath,
-            root,
-            record,
-            lastPersistedStatus: record.status,
-            dirty: false,
-        });
-    }
-    catch (error) {
-        if (error instanceof RunRecordMutationError) {
-            throw error;
-        }
-        if (isFileSystemError(error)) {
-            throw new RunRecordMutationError(`Failed to initialize run history at ${displayPath}: ${error.message}`);
-        }
-        throw error;
-    }
-    finally {
-        await releaseLock();
-    }
-}
-export async function rewriteRunRecord(options) {
-    const { root, runsFilePath, runId, mutate } = options;
-    const runsRoot = getRunsDirectory(runsFilePath);
-    const sessionsDir = getSessionsDirectory(runsFilePath);
-    const recordPath = join(sessionsDir, runId, RUN_RECORD_FILENAME);
-    const lockPath = join(runsRoot, HISTORY_LOCK_FILENAME);
-    const entry = await getOrLoadBufferEntry({
-        key: recordPath,
-        runId,
-        recordPath,
-        lockPath,
-        runsDir: runsRoot,
-        runsFilePath,
-        root,
-    });
-    const mutated = mutate(entry.record);
-    if (mutated.runId !== runId) {
-        throw new RunRecordMutationError(`Refusing to change run identifier while rewriting history for ${runId}.`);
-    }
-    entry.record = mutated;
-    entry.dirty = true;
-    const shouldFlushImmediately = shouldForceFlush(entry.record.status);
-    if (shouldFlushImmediately) {
-        await flushBufferEntry(entry, { force: true });
-        await disposeBufferEntry(entry);
-    }
-    else {
-        scheduleBufferFlush(entry);
-    }
-    return mutated;
-}
-export async function getRunRecordSnapshot(options) {
-    const { runsFilePath, runId } = options;
-    const sessionsDir = getSessionsDirectory(runsFilePath);
-    const recordPath = join(sessionsDir, runId, RUN_RECORD_FILENAME);
-    const buffered = runRecordBuffers.get(recordPath);
-    if (buffered) {
-        return structuredClone(buffered.record);
-    }
-    try {
-        return await readRunRecordFromDisk(recordPath);
-    }
-    catch (error) {
-        if (error instanceof RunRecordNotFoundError) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-function shouldForceFlush(status) {
-    return status !== "running" && status !== "queued";
-}
-export async function flushAllRunRecordBuffers() {
-    const entries = Array.from(runRecordBuffers.values());
-    for (const entry of entries) {
-        await flushBufferEntry(entry, { force: true });
-        await disposeBufferEntry(entry);
-    }
-}
-export async function disposeRunRecordBuffer(options) {
-    const { runsFilePath, runId } = options;
-    const recordPath = join(getSessionsDirectory(runsFilePath), runId, RUN_RECORD_FILENAME);
-    const entry = runRecordBuffers.get(recordPath);
-    if (!entry) {
-        return;
-    }
-    await disposeBufferEntry(entry);
-}
-export async function flushRunRecordBuffer(options) {
-    const { runsFilePath, runId } = options;
-    const recordPath = join(getSessionsDirectory(runsFilePath), runId, RUN_RECORD_FILENAME);
-    const entry = runRecordBuffers.get(recordPath);
-    if (!entry) {
-        return;
-    }
-    await flushBufferEntry(entry, { force: true });
-    await disposeBufferEntry(entry);
-}
-function registerBufferEntry(entry) {
-    runRecordBuffers.set(entry.key, entry);
-}
-async function getOrLoadBufferEntry(template) {
-    const existing = runRecordBuffers.get(template.key);
-    if (existing) {
-        return existing;
-    }
-    const record = await readRunRecordFromDisk(template.recordPath);
-    const entry = {
-        ...template,
-        record,
-        lastPersistedStatus: record.status,
-        dirty: false,
-    };
-    runRecordBuffers.set(template.key, entry);
-    return entry;
-}
-function scheduleBufferFlush(entry) {
-    if (entry.flushTimer) {
-        return;
-    }
-    const timer = setTimeout(() => {
-        entry.flushTimer = undefined;
-        void flushBufferEntry(entry).catch((error) => {
-            console.warn(`[voratiq] Failed to flush run ${entry.runId} history: ${error.message}`);
-        });
-    }, BUFFER_FLUSH_DELAY_MS);
-    if (typeof timer.unref === "function") {
-        timer.unref();
-    }
-    entry.flushTimer = timer;
-}
-async function flushBufferEntry(entry, options = {}) {
-    const { force = false } = options;
-    if (!entry.dirty && !force) {
-        return;
-    }
-    if (entry.flushPromise) {
-        await entry.flushPromise;
-        return;
-    }
-    if (entry.flushTimer) {
-        clearTimeout(entry.flushTimer);
-        entry.flushTimer = undefined;
-    }
-    await mkdir(entry.runsDir, { recursive: true });
-    await mkdir(dirname(entry.recordPath), { recursive: true });
-    const promise = (async () => {
-        const release = await acquireHistoryLock(entry.lockPath);
-        try {
-            await atomicWriteJson(entry.recordPath, entry.record);
-            entry.dirty = false;
-            if (entry.lastPersistedStatus !== entry.record.status) {
-                await upsertRunIndexEntry(entry.runsFilePath, {
-                    runId: entry.runId,
-                    createdAt: entry.record.createdAt,
-                    status: entry.record.status,
-                });
-                entry.lastPersistedStatus = entry.record.status;
-            }
-        }
-        finally {
-            await release();
-        }
-    })();
-    entry.flushPromise = promise;
-    try {
-        await promise;
-    }
-    finally {
-        entry.flushPromise = undefined;
-    }
-}
-async function disposeBufferEntry(entry) {
-    const current = runRecordBuffers.get(entry.key);
-    if (!current || current !== entry) {
-        return;
-    }
-    if (entry.flushTimer) {
-        clearTimeout(entry.flushTimer);
-        entry.flushTimer = undefined;
-    }
-    if (entry.flushPromise) {
-        await entry.flushPromise;
-    }
-    runRecordBuffers.delete(entry.key);
-}
-export function buildRunPredicate(filters = {}) {
-    const predicates = [];
-    if (filters.runId) {
-        const runId = filters.runId;
-        predicates.push((record) => record.runId === runId);
-    }
-    if (filters.agentId) {
-        const agentId = filters.agentId;
-        predicates.push((record) => record.agents.some((agent) => agent.agentId === agentId));
-    }
-    if (filters.specPath) {
-        const specPath = filters.specPath;
-        predicates.push((record) => record.spec.path === specPath);
-    }
-    if (filters.activeOnly || !filters.includeDeleted) {
-        predicates.push((record) => record.status !== "pruned");
-    }
-    return (record) => predicates.every((predicate) => predicate(record));
-}
-export async function fetchRuns(input) {
-    const warnings = [];
-    const predicate = buildRunPredicate(input.filters ?? {});
-    const records = await readRunRecords({
-        root: input.root,
-        runsFilePath: input.runsFilePath,
-        limit: input.limit,
-        predicate,
-        onWarning: (warning) => warnings.push(warning),
-    });
-    return { records, warnings };
-}
-export async function fetchRunsSafely(input) {
-    const { runId, filters, ...rest } = input;
-    const augmentedFilters = { ...(filters ?? {}), ...(runId ? { runId } : {}) };
-    const result = await fetchRuns({
-        ...rest,
-        filters: augmentedFilters,
-    }).catch((error) => {
-        if (runId && isFileSystemError(error) && error.code === "ENOENT") {
-            throw new RunRecordNotFoundError(runId);
-        }
-        throw error;
-    });
-    if (runId) {
-        const warning = result.warnings.find((entry) => entry.runId === runId);
-        if (warning) {
-            if (warning.kind === "parse-error") {
-                throw new RunRecordParseError(warning.displayPath, warning.details);
-            }
-            throw new RunRecordNotFoundError(runId);
-        }
-        if (result.records.length === 0) {
-            throw new RunRecordNotFoundError(runId);
-        }
-    }
-    return result;
-}
-async function readRunRecordFromDisk(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        const result = runRecordSchema.safeParse(parsed);
-        if (!result.success) {
-            const issues = result.error.issues
-                .map((issue) => issue.message)
-                .join(", ");
-            throw new RunRecordParseError(path, issues);
-        }
-        return result.data;
-    }
-    catch (error) {
-        if (isFileSystemError(error) && error.code === "ENOENT") {
-            const runId = extractRunIdFromPath(path);
-            throw new RunRecordNotFoundError(runId);
-        }
-        if (error instanceof SyntaxError) {
-            throw new RunRecordParseError(path, error.message);
-        }
-        throw error;
-    }
-}
-function extractRunIdFromPath(path) {
-    const segments = path.split(/[/\\]/);
-    const runIdIndex = segments.length - 2;
-    return segments[runIdIndex] ?? "unknown";
-}
-async function atomicWriteJson(path, payload) {
-    const dir = dirname(path);
-    const tempPath = join(dir, `${randomBytes(8).toString("hex")}.tmp`);
-    const serialized = `${JSON.stringify(payload, null, 2)}\n`;
-    await writeFile(tempPath, serialized, { encoding: "utf8" });
-    await rename(tempPath, path);
-}
-function getRunsDirectory(runsFilePath) {
-    return dirname(runsFilePath);
-}
-function getSessionsDirectory(runsFilePath) {
-    return join(getRunsDirectory(runsFilePath), "sessions");
-}
-async function readRunIndex(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        const trimmed = raw.trim();
-        if (!trimmed) {
-            return { version: RUN_INDEX_VERSION, sessions: [] };
-        }
-        const parsed = JSON.parse(trimmed);
-        const sessions = Array.isArray(parsed.sessions)
-            ? parsed.sessions
-            : Array.isArray(parsed.runs)
-                ? parsed.runs
-                : [];
-        return {
-            version: parsed.version ?? RUN_INDEX_VERSION,
-            sessions,
-        };
-    }
-    catch (error) {
-        if (isFileSystemError(error) && error.code === "ENOENT") {
-            return { version: RUN_INDEX_VERSION, sessions: [] };
-        }
-        if (error instanceof SyntaxError) {
-            throw new RunRecordParseError(path, error.message);
-        }
-        throw error;
-    }
-}
-async function upsertRunIndexEntry(indexPath, entry) {
-    const payload = await readRunIndex(indexPath);
-    const existingIndex = payload.sessions.findIndex((run) => run.runId === entry.runId);
-    if (existingIndex >= 0) {
-        payload.sessions[existingIndex] = {
-            ...payload.sessions[existingIndex],
-            ...entry,
-        };
-    }
-    else {
-        payload.sessions.push(entry);
-    }
-    payload.version = RUN_INDEX_VERSION;
-    await atomicWriteJson(indexPath, payload);
-}
-const RUN_RECORDS_TEST_HOOKS = Symbol.for("voratiq.records.persistence.testHooks");
-function registerRunRecordsTestHooks() {
-    const registry = globalThis;
-    registry[RUN_RECORDS_TEST_HOOKS] = {
-        setImplementation: setReadRunRecordsImplementation,
-        resetImplementation: resetReadRunRecordsImplementation,
-        getBufferSnapshot: snapshotRunRecordBuffers,
-    };
-}
-function snapshotRunRecordBuffers() {
-    return Array.from(runRecordBuffers.values()).map((entry) => ({
-        key: entry.key,
-        runId: entry.runId,
-        hasFlushTimer: Boolean(entry.flushTimer),
-    }));
-}
-let runRecordsTestHooksRegistered = false;
-export function enableRunRecordsTestHooks() {
-    assertTestHookRegistrationEnabled("records persistence");
-    if (runRecordsTestHooksRegistered) {
-        return;
-    }
-    registerRunRecordsTestHooks();
-    runRecordsTestHooksRegistered = true;
-}
-export function areRunRecordsTestHooksRegistered() {
-    return runRecordsTestHooksRegistered;
-}
-export { RUN_RECORDS_TEST_HOOKS };