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

package/dist/contracts/list.d.ts

@@ -0,0 +1,207 @@
+import { z } from "zod";
+export declare const listOperators: readonly ["spec", "run", "reduce", "verify", "message"];
+export declare const listModes: readonly ["table", "detail"];
+export type ListOperator = (typeof listOperators)[number];
+export type ListMode = (typeof listModes)[number];
+interface ListJsonRecordBase {
+    id: string;
+    status: string;
+    createdAt: string;
+}
+interface ListJsonTargetRef {
+    kind: string;
+    id: string;
+}
+export interface RunListJsonTableRecord extends ListJsonRecordBase {
+    specPath: string;
+}
+export interface SpecListJsonTableRecord extends ListJsonRecordBase {
+    description: string | null;
+}
+export interface TargetedListJsonTableRecord extends ListJsonRecordBase {
+    target: ListJsonTargetRef;
+}
+export interface MessageListJsonTableRecord extends ListJsonRecordBase {
+    promptPreview: string | null;
+}
+export type ListJsonTableRecord = RunListJsonTableRecord | SpecListJsonTableRecord | TargetedListJsonTableRecord | MessageListJsonTableRecord;
+export interface RunListJsonRow {
+    agentId: string;
+    status: string;
+    duration: string;
+    changes: string | null;
+}
+export interface SpecListJsonRow {
+    agentId: string;
+    status: string;
+    duration: string;
+}
+export interface ReduceListJsonRow {
+    agentId: string;
+    status: string;
+    duration: string;
+}
+export interface VerifyListJsonRow {
+    agentId: string | null;
+    verifier: string;
+    status: string;
+    duration: string;
+}
+export interface MessageListJsonRow {
+    agentId: string;
+    status: string;
+    duration: string;
+}
+export type ListJsonRow = RunListJsonRow | SpecListJsonRow | ReduceListJsonRow | VerifyListJsonRow | MessageListJsonRow;
+export interface SpecListJsonArtifact {
+    kind: "spec";
+    agentId: string;
+    path: string | null;
+}
+export interface ReductionListJsonArtifact {
+    kind: "reduction";
+    agentId: string;
+    path: string | null;
+}
+export interface VerificationListJsonArtifact {
+    kind: "result";
+    agentId: string | null;
+    verifier: string;
+    path: string | null;
+}
+export interface MessageListJsonArtifact {
+    kind: "output";
+    agentId: string;
+    path: string | null;
+}
+export type ListJsonArtifact = SpecListJsonArtifact | ReductionListJsonArtifact | VerificationListJsonArtifact | MessageListJsonArtifact;
+export interface ListJsonTableOutput {
+    operator: ListOperator;
+    mode: "table";
+    records: ListJsonTableRecord[];
+    warnings: string[];
+}
+export interface ListJsonDetailOutput {
+    operator: ListOperator;
+    mode: "detail";
+    sessionId: string;
+    session: {
+        id: string;
+        status: string;
+        createdAt: string;
+        elapsed?: string;
+        workspacePath: string;
+        target?: ListJsonTargetRef;
+        rows: ListJsonRow[];
+        artifacts: ListJsonArtifact[];
+    } | null;
+    warnings: string[];
+}
+export type ListJsonOutput = ListJsonTableOutput | ListJsonDetailOutput;
+export declare const listOperatorSchema: z.ZodEnum<{
+    message: "message";
+    reduce: "reduce";
+    spec: "spec";
+    run: "run";
+    verify: "verify";
+}>;
+export declare const listModeSchema: z.ZodEnum<{
+    detail: "detail";
+    table: "table";
+}>;
+export declare const listJsonOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operator: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+    }>;
+    mode: z.ZodLiteral<"table">;
+    records: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodString;
+        specPath: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodString;
+        target: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$loose>, z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodString;
+        promptPreview: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>]>>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    operator: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+    }>;
+    mode: z.ZodLiteral<"detail">;
+    sessionId: z.ZodString;
+    session: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodString;
+        elapsed: z.ZodOptional<z.ZodString>;
+        workspacePath: z.ZodString;
+        target: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$loose>>;
+        rows: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            agentId: z.ZodString;
+            status: z.ZodString;
+            duration: z.ZodString;
+            changes: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            agentId: z.ZodString;
+            status: z.ZodString;
+            duration: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            agentId: z.ZodNullable<z.ZodString>;
+            verifier: z.ZodString;
+            status: z.ZodString;
+            duration: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            agentId: z.ZodString;
+            status: z.ZodString;
+            duration: z.ZodString;
+        }, z.core.$loose>]>>;
+        artifacts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"spec">;
+            agentId: z.ZodString;
+            path: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"reduction">;
+            agentId: z.ZodString;
+            path: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"result">;
+            agentId: z.ZodNullable<z.ZodString>;
+            verifier: z.ZodString;
+            path: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>, z.ZodObject<{
+            kind: z.ZodLiteral<"output">;
+            agentId: z.ZodString;
+            path: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>]>>;
+    }, z.core.$loose>>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$loose>], "mode">;
+export declare function parseListJsonOutput(input: unknown): ListJsonOutput;
+export {};

package/dist/contracts/list.js

@@ -0,0 +1,154 @@
+import { z } from "zod";
+export const listOperators = [
+    "spec",
+    "run",
+    "reduce",
+    "verify",
+    "message",
+];
+export const listModes = ["table", "detail"];
+export const listOperatorSchema = z.enum(listOperators);
+export const listModeSchema = z.enum(listModes);
+const listJsonTargetRefSchema = z
+    .object({
+    kind: z.string(),
+    id: z.string(),
+})
+    .passthrough();
+const listJsonRecordBaseSchema = z
+    .object({
+    id: z.string(),
+    status: z.string(),
+    createdAt: z.string(),
+})
+    .passthrough();
+const runListJsonTableRecordSchema = listJsonRecordBaseSchema
+    .extend({
+    specPath: z.string(),
+})
+    .passthrough();
+const specListJsonTableRecordSchema = listJsonRecordBaseSchema
+    .extend({
+    description: z.string().nullable(),
+})
+    .passthrough();
+const targetedListJsonTableRecordSchema = listJsonRecordBaseSchema
+    .extend({
+    target: listJsonTargetRefSchema,
+})
+    .passthrough();
+const messageListJsonTableRecordSchema = listJsonRecordBaseSchema
+    .extend({
+    promptPreview: z.string().nullable(),
+})
+    .passthrough();
+const runListJsonRowSchema = z
+    .object({
+    agentId: z.string(),
+    status: z.string(),
+    duration: z.string(),
+    changes: z.string().nullable(),
+})
+    .passthrough();
+const stageListJsonRowSchema = z
+    .object({
+    agentId: z.string(),
+    status: z.string(),
+    duration: z.string(),
+})
+    .passthrough();
+const verifyListJsonRowSchema = z
+    .object({
+    agentId: z.string().nullable(),
+    verifier: z.string(),
+    status: z.string(),
+    duration: z.string(),
+})
+    .passthrough();
+const messageListJsonRowSchema = z
+    .object({
+    agentId: z.string(),
+    status: z.string(),
+    duration: z.string(),
+})
+    .passthrough();
+const specListJsonArtifactSchema = z
+    .object({
+    kind: z.literal("spec"),
+    agentId: z.string(),
+    path: z.string().nullable(),
+})
+    .passthrough();
+const reductionListJsonArtifactSchema = z
+    .object({
+    kind: z.literal("reduction"),
+    agentId: z.string(),
+    path: z.string().nullable(),
+})
+    .passthrough();
+const verificationListJsonArtifactSchema = z
+    .object({
+    kind: z.literal("result"),
+    agentId: z.string().nullable(),
+    verifier: z.string(),
+    path: z.string().nullable(),
+})
+    .passthrough();
+const messageListJsonArtifactSchema = z
+    .object({
+    kind: z.literal("output"),
+    agentId: z.string(),
+    path: z.string().nullable(),
+})
+    .passthrough();
+const listJsonDetailSessionSchema = z
+    .object({
+    id: z.string(),
+    status: z.string(),
+    createdAt: z.string(),
+    elapsed: z.string().optional(),
+    workspacePath: z.string(),
+    target: listJsonTargetRefSchema.optional(),
+    rows: z.array(z.union([
+        runListJsonRowSchema,
+        stageListJsonRowSchema,
+        verifyListJsonRowSchema,
+        messageListJsonRowSchema,
+    ])),
+    artifacts: z.array(z.union([
+        specListJsonArtifactSchema,
+        reductionListJsonArtifactSchema,
+        verificationListJsonArtifactSchema,
+        messageListJsonArtifactSchema,
+    ])),
+})
+    .passthrough();
+const listJsonTableOutputSchema = z
+    .object({
+    operator: listOperatorSchema,
+    mode: z.literal("table"),
+    records: z.array(z.union([
+        runListJsonTableRecordSchema,
+        specListJsonTableRecordSchema,
+        targetedListJsonTableRecordSchema,
+        messageListJsonTableRecordSchema,
+    ])),
+    warnings: z.array(z.string()),
+})
+    .passthrough();
+const listJsonDetailOutputSchema = z
+    .object({
+    operator: listOperatorSchema,
+    mode: z.literal("detail"),
+    sessionId: z.string(),
+    session: listJsonDetailSessionSchema.nullable(),
+    warnings: z.array(z.string()),
+})
+    .passthrough();
+export const listJsonOutputSchema = z.discriminatedUnion("mode", [
+    listJsonTableOutputSchema,
+    listJsonDetailOutputSchema,
+]);
+export function parseListJsonOutput(input) {
+    return listJsonOutputSchema.parse(input);
+}

package/dist/domain/interactive/model/types.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+export declare const interactiveSessionStatusSchema: z.ZodEnum<{
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+}>;
+export type InteractiveSessionStatus = z.infer<typeof interactiveSessionStatusSchema>;
+export declare const toolAttachmentStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    "not-requested": "not-requested";
+    attached: "attached";
+}>;
+export type ToolAttachmentStatus = z.infer<typeof toolAttachmentStatusSchema>;
+export declare const interactiveLaunchFailureCodeSchema: z.ZodEnum<{
+    provider_resolution_failed: "provider_resolution_failed";
+    auth_staging_failed: "auth_staging_failed";
+    binary_resolution_failed: "binary_resolution_failed";
+    config_generation_failed: "config_generation_failed";
+    process_spawn_failed: "process_spawn_failed";
+    provider_launch_failed: "provider_launch_failed";
+}>;
+export type InteractiveLaunchFailureCode = z.infer<typeof interactiveLaunchFailureCodeSchema>;
+export declare const interactiveSessionIndexEntrySchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+}, z.core.$strict>;
+export type InteractiveSessionIndexEntry = z.infer<typeof interactiveSessionIndexEntrySchema>;
+export declare const interactiveSessionIndexRecordSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    sessions: z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodString;
+        createdAt: z.ZodString;
+        status: z.ZodEnum<{
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type InteractiveSessionIndexRecord = z.infer<typeof interactiveSessionIndexRecordSchema>;
+export declare const interactiveSessionErrorRecordSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        provider_resolution_failed: "provider_resolution_failed";
+        auth_staging_failed: "auth_staging_failed";
+        binary_resolution_failed: "binary_resolution_failed";
+        config_generation_failed: "config_generation_failed";
+        process_spawn_failed: "process_spawn_failed";
+        provider_launch_failed: "provider_launch_failed";
+    }>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type InteractiveSessionErrorRecord = z.infer<typeof interactiveSessionErrorRecordSchema>;
+export declare const interactiveSessionChatRecordSchema: z.ZodObject<{
+    captured: z.ZodBoolean;
+    format: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        jsonl: "jsonl";
+    }>>;
+    artifactPath: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type InteractiveSessionChatRecord = z.infer<typeof interactiveSessionChatRecordSchema>;
+export declare const interactiveSessionRecordSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    agentId: z.ZodString;
+    task: z.ZodOptional<z.ZodString>;
+    toolAttachmentStatus: z.ZodEnum<{
+        failed: "failed";
+        "not-requested": "not-requested";
+        attached: "attached";
+    }>;
+    chat: z.ZodOptional<z.ZodObject<{
+        captured: z.ZodBoolean;
+        format: z.ZodOptional<z.ZodEnum<{
+            json: "json";
+            jsonl: "jsonl";
+        }>>;
+        artifactPath: z.ZodOptional<z.ZodString>;
+        errorMessage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodEnum<{
+            provider_resolution_failed: "provider_resolution_failed";
+            auth_staging_failed: "auth_staging_failed";
+            binary_resolution_failed: "binary_resolution_failed";
+            config_generation_failed: "config_generation_failed";
+            process_spawn_failed: "process_spawn_failed";
+            provider_launch_failed: "provider_launch_failed";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type InteractiveSessionRecord = z.infer<typeof interactiveSessionRecordSchema>;

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

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { agentIdSchema } from "../../../configs/agents/types.js";
+import { repoRelativeRecordPathSchema } from "../../../persistence/record-path-schema.js";
+const INTERACTIVE_SESSION_STATUS_VALUES = [
+    "running",
+    "succeeded",
+    "failed",
+];
+const TOOL_ATTACHMENT_STATUS_VALUES = [
+    "not-requested",
+    "attached",
+    "failed",
+];
+const CHAT_ARTIFACT_FORMAT_VALUES = ["json", "jsonl"];
+const INTERACTIVE_LAUNCH_FAILURE_CODE_VALUES = [
+    "provider_resolution_failed",
+    "auth_staging_failed",
+    "binary_resolution_failed",
+    "config_generation_failed",
+    "process_spawn_failed",
+    "provider_launch_failed",
+];
+export const interactiveSessionStatusSchema = z.enum(INTERACTIVE_SESSION_STATUS_VALUES);
+export const toolAttachmentStatusSchema = z.enum(TOOL_ATTACHMENT_STATUS_VALUES);
+export const interactiveLaunchFailureCodeSchema = z.enum(INTERACTIVE_LAUNCH_FAILURE_CODE_VALUES);
+export const interactiveSessionIndexEntrySchema = z
+    .object({
+    sessionId: z.string().min(1),
+    createdAt: z.string().min(1),
+    status: interactiveSessionStatusSchema,
+})
+    .strict();
+export const interactiveSessionIndexRecordSchema = z
+    .object({
+    version: z.literal(1),
+    sessions: z.array(interactiveSessionIndexEntrySchema),
+})
+    .strict();
+export const interactiveSessionErrorRecordSchema = z
+    .object({
+    code: interactiveLaunchFailureCodeSchema,
+    message: z.string().min(1),
+})
+    .strict();
+const chatArtifactFormatSchema = z.enum(CHAT_ARTIFACT_FORMAT_VALUES);
+export const interactiveSessionChatRecordSchema = z
+    .object({
+    captured: z.boolean(),
+    format: chatArtifactFormatSchema.optional(),
+    artifactPath: repoRelativeRecordPathSchema.optional(),
+    errorMessage: z.string().min(1).optional(),
+})
+    .strict()
+    .superRefine((chat, ctx) => {
+    if (chat.captured) {
+        if (!chat.format) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["format"],
+                message: "captured interactive chat must persist `format`",
+            });
+        }
+        if (!chat.artifactPath) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["artifactPath"],
+                message: "captured interactive chat must persist a repo-relative `artifactPath`",
+            });
+        }
+    }
+});
+export const interactiveSessionRecordSchema = z
+    .object({
+    sessionId: z.string().min(1),
+    createdAt: z.string().min(1),
+    status: interactiveSessionStatusSchema,
+    agentId: agentIdSchema,
+    task: z.string().min(1).optional(),
+    toolAttachmentStatus: toolAttachmentStatusSchema,
+    chat: interactiveSessionChatRecordSchema.optional(),
+    error: interactiveSessionErrorRecordSchema.optional(),
+})
+    .strict();

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

@@ -0,0 +1,39 @@
+import type { InteractiveSessionRecord, InteractiveSessionStatus } from "../model/types.js";
+export interface InteractiveSessionPaths {
+    indexPath: string;
+    sessionRoot: string;
+    recordPath: string;
+    artifactsPath: string;
+    runtimePath: string;
+}
+export declare function resolveInteractiveSessionPaths(root: string, sessionId: string): InteractiveSessionPaths;
+export declare function ensureInteractiveSessionDirectories(options: {
+    sessionRoot: string;
+    artifactsPath: string;
+    runtimePath: string;
+}): Promise<void>;
+export declare function appendInteractiveSessionRecord(options: {
+    root: string;
+    record: InteractiveSessionRecord;
+}): Promise<void>;
+export declare function rewriteInteractiveSessionRecord(options: {
+    root: string;
+    sessionId: string;
+    mutate: (record: InteractiveSessionRecord) => InteractiveSessionRecord;
+    forceFlush?: boolean;
+}): Promise<InteractiveSessionRecord>;
+export declare function updateInteractiveSessionStatus(options: {
+    root: string;
+    sessionId: string;
+    status: InteractiveSessionStatus;
+}): Promise<InteractiveSessionRecord>;
+export declare function getInteractiveSessionRecordSnapshot(options: {
+    root: string;
+    sessionId: string;
+}): Promise<InteractiveSessionRecord | undefined>;
+export declare function flushAllInteractiveSessionBuffers(): Promise<void>;
+export declare function disposeInteractiveSessionBuffer(options: {
+    root: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function toInteractiveSessionRelativePath(root: string, absolutePath: string | undefined): string | undefined;