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

package/dist/domain/message/model/types.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { agentIdSchema } from "../../../configs/agents/types.js";
+import { extractedTokenUsageSchema } from "../../../domain/run/model/types.js";
+import { extraContextMetadataEntrySchema, persistedExtraContextPathSchema, } from "../../../persistence/extra-context.js";
+import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-schema.js";
+import { messageRecipientStatusSchema, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES, } from "../../../status/index.js";
+import { validateOperationLifecycleTimestamps, validateRecordLifecycleTimestamps, } from "../../shared/lifecycle.js";
+export { messageRecipientStatusSchema, messageStatusSchema, TERMINAL_MESSAGE_RECIPIENT_STATUSES, TERMINAL_MESSAGE_STATUSES, };
+const RUNNING_MESSAGE_RECORD_STATUSES = [
+    "running",
+];
+export const messageRecipientEntrySchema = z
+    .object({
+    agentId: agentIdSchema,
+    status: messageRecipientStatusSchema,
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    outputPath: repoRelativeRecordPathSchema.optional(),
+    stdoutPath: repoRelativeRecordPathSchema.optional(),
+    stderrPath: repoRelativeRecordPathSchema.optional(),
+    tokenUsage: extractedTokenUsageSchema.optional(),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((recipient, ctx) => {
+    if (recipient.status === "succeeded" && !recipient.outputPath) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["outputPath"],
+            message: "succeeded message recipients must persist `outputPath`",
+        });
+    }
+    validateOperationLifecycleTimestamps({
+        status: recipient.status,
+        startedAt: recipient.startedAt,
+        completedAt: recipient.completedAt,
+    }, ctx, {
+        queued: ["queued"],
+        running: ["running"],
+        terminal: TERMINAL_MESSAGE_RECIPIENT_STATUSES,
+    });
+});
+export const messageRecordSchema = z
+    .object({
+    sessionId: z.string(),
+    createdAt: z.string(),
+    startedAt: z.string(),
+    completedAt: z.string().optional(),
+    status: messageStatusSchema,
+    baseRevisionSha: z.string().optional(),
+    prompt: z.string(),
+    sourceInteractiveSessionId: z.string().optional(),
+    extraContext: z.array(persistedExtraContextPathSchema).optional(),
+    extraContextMetadata: z.array(extraContextMetadataEntrySchema).optional(),
+    recipients: z
+        .array(messageRecipientEntrySchema)
+        .min(1)
+        .superRefine((recipients, ctx) => {
+        const seen = new Set();
+        for (const recipient of recipients) {
+            if (seen.has(recipient.agentId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `Duplicate message recipient agent id: ${recipient.agentId}`,
+                });
+                return;
+            }
+            seen.add(recipient.agentId);
+        }
+    }),
+    error: z.string().nullable().optional(),
+})
+    .superRefine((record, ctx) => {
+    validateRecordLifecycleTimestamps({
+        status: record.status,
+        createdAt: record.createdAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    }, ctx, {
+        queued: [],
+        running: RUNNING_MESSAGE_RECORD_STATUSES,
+        terminal: TERMINAL_MESSAGE_STATUSES,
+    });
+});
+export function deriveMessageStatusFromRecipients(recipientStatuses) {
+    const hasSuccess = recipientStatuses.some((status) => status === "succeeded");
+    return hasSuccess ? "succeeded" : "failed";
+}

package/dist/domain/message/persistence/adapter.d.ts

@@ -0,0 +1,43 @@
+import type { MessageRecord } from "../model/types.js";
+export type MessageRecordPredicate = (record: MessageRecord) => boolean;
+export interface MessageRecordWarningMissing {
+    kind: "missing-record";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+}
+export interface MessageRecordWarningParse {
+    kind: "parse-error";
+    sessionId: string;
+    recordPath: string;
+    displayPath: string;
+    details: string;
+}
+export type MessageRecordWarning = MessageRecordWarningMissing | MessageRecordWarningParse;
+export interface ReadMessageRecordsOptions {
+    root: string;
+    messagesFilePath: string;
+    limit?: number;
+    predicate?: MessageRecordPredicate;
+    onWarning?: (warning: MessageRecordWarning) => void;
+}
+export interface RewriteMessageRecordOptions {
+    root: string;
+    messagesFilePath: string;
+    sessionId: string;
+    mutate: (record: MessageRecord) => MessageRecord;
+    forceFlush?: boolean;
+}
+export interface AppendMessageRecordOptions {
+    root: string;
+    messagesFilePath: string;
+    record: MessageRecord;
+}
+export declare function readMessageRecords(options: ReadMessageRecordsOptions): Promise<MessageRecord[]>;
+export declare function appendMessageRecord(options: AppendMessageRecordOptions): Promise<void>;
+export declare function rewriteMessageRecord(options: RewriteMessageRecordOptions): Promise<MessageRecord>;
+export declare function flushMessageRecordBuffer(options: {
+    messagesFilePath: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function flushAllMessageRecordBuffers(): Promise<void>;

package/dist/domain/message/persistence/adapter.js

@@ -0,0 +1,124 @@
+import { dirname, join } from "node:path";
+import { mapSessionStoreError, sessionStoreErrorMapper, } from "../../../persistence/error-mapping.js";
+import { SessionRecordParseError } from "../../../persistence/errors.js";
+import { acquireHistoryLock } from "../../../persistence/history-lock.js";
+import { createSessionStore, } from "../../../persistence/session-store.js";
+import { messageRecordSchema, TERMINAL_MESSAGE_STATUSES, } from "../model/types.js";
+const MESSAGE_INDEX_VERSION = 1;
+const MESSAGE_RECORD_FILENAME = "record.json";
+const MESSAGE_HISTORY_LOCK_FILENAME = "history.lock";
+const messagePersistence = createSessionStore({
+    recordFilename: MESSAGE_RECORD_FILENAME,
+    indexVersion: MESSAGE_INDEX_VERSION,
+    acquireLock: acquireHistoryLock,
+    parseRecord: ({ path, raw }) => {
+        const parsed = JSON.parse(raw);
+        const result = messageRecordSchema.safeParse(parsed);
+        if (!result.success) {
+            const issues = result.error.issues
+                .map((issue) => issue.message)
+                .join(", ");
+            throw new SessionRecordParseError(path, issues);
+        }
+        return result.data;
+    },
+    buildIndexEntry: (record) => ({
+        sessionId: record.sessionId,
+        createdAt: record.createdAt,
+        status: record.status,
+    }),
+    getIndexEntryId: (entry) => entry.sessionId,
+    shouldForceFlush: (record) => TERMINAL_MESSAGE_STATUSES.includes(record.status),
+    getRecordId: (record) => record.sessionId,
+    getRecordStatus: (record) => record.status,
+    readIndexEntries: (parsed) => {
+        const payload = parsed;
+        return Array.isArray(payload.sessions) ? payload.sessions : [];
+    },
+});
+export async function readMessageRecords(options) {
+    const { root, messagesFilePath, limit, predicate, onWarning } = options;
+    const paths = buildMessagePaths(root, messagesFilePath);
+    try {
+        return await messagePersistence.readRecords({
+            paths,
+            limit,
+            predicate,
+            onWarning: onWarning
+                ? (warning) => onWarning(mapWarning(warning))
+                : undefined,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function appendMessageRecord(options) {
+    const { root, messagesFilePath, record } = options;
+    const paths = buildMessagePaths(root, messagesFilePath);
+    try {
+        await messagePersistence.appendRecord({ paths, record });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function rewriteMessageRecord(options) {
+    const { root, messagesFilePath, sessionId, mutate, forceFlush = false, } = options;
+    const paths = buildMessagePaths(root, messagesFilePath);
+    try {
+        return await messagePersistence.rewriteRecord({
+            paths,
+            sessionId,
+            mutate,
+            forceFlush,
+        });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushMessageRecordBuffer(options) {
+    const { messagesFilePath, sessionId } = options;
+    const paths = buildMessagePaths("", messagesFilePath);
+    try {
+        await messagePersistence.flushRecordBuffer({ paths, sessionId });
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+export async function flushAllMessageRecordBuffers() {
+    try {
+        await messagePersistence.flushAllRecordBuffers();
+    }
+    catch (error) {
+        throw mapSessionStoreError(error, sessionStoreErrorMapper);
+    }
+}
+function buildMessagePaths(root, messagesFilePath) {
+    const messagesRoot = dirname(messagesFilePath);
+    return {
+        root,
+        indexPath: messagesFilePath,
+        sessionsDir: join(messagesRoot, "sessions"),
+        lockPath: join(messagesRoot, MESSAGE_HISTORY_LOCK_FILENAME),
+    };
+}
+function mapWarning(warning) {
+    if (warning.kind === "parse-error") {
+        return {
+            kind: "parse-error",
+            sessionId: warning.sessionId,
+            recordPath: warning.recordPath,
+            displayPath: warning.displayPath,
+            details: warning.details,
+        };
+    }
+    return {
+        kind: "missing-record",
+        sessionId: warning.sessionId,
+        recordPath: warning.recordPath,
+        displayPath: warning.displayPath,
+    };
+}

package/dist/domain/reduce/competition/adapter.d.ts

@@ -0,0 +1,42 @@
+import type { CompetitionCommandAdapter } from "../../../competition/command-adapter.js";
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { ReductionTarget } from "../../../domain/reduce/model/types.js";
+import type { ExtractedTokenUsage } from "../../../domain/run/model/types.js";
+import type { ReduceProgressRenderer } from "../../../render/transcripts/reduce.js";
+import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
+import { type AgentWorkspacePaths } from "../../../workspace/layout.js";
+export type ReduceCompetitionCandidate = AgentDefinition;
+export interface ReductionCompetitionExecution {
+    readonly agentId: string;
+    readonly outputPath: string;
+    readonly dataPath: string;
+    readonly status: "succeeded" | "failed";
+    readonly tokenUsage?: ExtractedTokenUsage;
+    readonly tokenUsageResult: TokenUsageResult;
+    readonly error?: string;
+}
+interface PreparedReduceCompetitionCandidate {
+    readonly candidate: ReduceCompetitionCandidate;
+    readonly workspacePaths: AgentWorkspacePaths;
+    readonly outputPath: string;
+    readonly dataPath: string;
+    readonly prompt: string;
+}
+export interface CreateReduceCompetitionAdapterInput {
+    readonly root: string;
+    readonly reductionId: string;
+    readonly createdAt: string;
+    readonly reductionsFilePath: string;
+    readonly specsFilePath: string;
+    readonly runsFilePath: string;
+    readonly messagesFilePath: string;
+    readonly verificationsFilePath: string;
+    readonly target: ReductionTarget;
+    readonly environment: EnvironmentConfig;
+    readonly extraContextFiles?: readonly ResolvedExtraContextFile[];
+    readonly renderer?: ReduceProgressRenderer;
+}
+export declare function createReduceCompetitionAdapter(input: CreateReduceCompetitionAdapterInput): CompetitionCommandAdapter<ReduceCompetitionCandidate, PreparedReduceCompetitionCandidate, ReductionCompetitionExecution>;
+export {};