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

package/dist/commands/list/command.js

@@ -1,60 +1,617 @@
-import { fetchRunsSafely, } from "../../records/persistence.js";
-import { renderListTranscript } from "../../render/transcripts/list.js";
+import { readMessageRecords, } from "../../domain/message/persistence/adapter.js";
+import { readReductionRecords, } from "../../domain/reduce/persistence/adapter.js";
+import { readRunRecords, } from "../../domain/run/persistence/adapter.js";
+import { readSpecRecords, } from "../../domain/spec/persistence/adapter.js";
+import { TERMINAL_VERIFICATION_STATUSES } from "../../domain/verify/model/types.js";
+import { readVerificationRecords, } from "../../domain/verify/persistence/adapter.js";
+import { renderListTableTranscript, renderMessageList, renderReduceList, renderRunList, renderSpecList, renderVerifyList, } from "../../render/transcripts/list.js";
+import { formatMessageElapsed, formatMessageRecipientDuration, renderMessageTranscript, } from "../../render/transcripts/message.js";
+import { formatReduceElapsed, formatReducerDuration, renderReduceTranscript, } from "../../render/transcripts/reduce.js";
+import { formatRunElapsed, renderRunTranscript, } from "../../render/transcripts/run.js";
+import { formatSpecAgentDuration, formatSpecElapsed, renderSpecTranscript, } from "../../render/transcripts/spec.js";
+import { formatVerifyElapsed, renderVerifyTranscript, } from "../../render/transcripts/verify.js";
+import { formatAgentDuration } from "../../render/utils/agents.js";
+import { formatRenderLifecycleDuration } from "../../render/utils/duration.js";
+import { formatCompactDiffStatistics } from "../../utils/diff.js";
 import { pathExists } from "../../utils/fs.js";
+import { getMessageSessionDirectoryPath, getReductionSessionDirectoryPath, getRunDirectoryPath, getSpecSessionDirectoryPath, getVerificationSessionDirectoryPath, } from "../../workspace/structure.js";
 const DEFAULT_LIMIT = 10;
+const DASH = "—";
 export async function executeListCommand(input) {
-    const { root, runsFilePath, specPath, runId, includePruned } = input;
+    const mode = input.sessionId ? "detail" : "table";
     const limit = input.limit ?? DEFAULT_LIMIT;
-    const result = await listRuns({
-        root,
-        runsFilePath,
+    if (mode === "detail") {
+        return await executeDetailMode(input);
+    }
+    return await executeTableMode({
+        ...input,
         limit,
-        specPath,
-        runId,
-        includePruned,
     });
+}
+async function executeTableMode(input) {
+    const { operator, limit, verbose = false } = input;
+    const query = await readOperatorRecords({ ...input, limit: undefined });
+    const filtered = verbose
+        ? query.records
+        : query.records.filter((record) => shouldIncludeInDefaultTable(operator, getRecordStatus(record)));
+    const records = filtered.slice(0, limit);
+    const warnings = query.warnings;
+    const output = renderTableOutput(operator, records);
     return {
-        warnings: result.warnings,
-        output: result.output,
+        warnings,
+        output,
+        mode: "table",
+        json: {
+            operator,
+            mode: "table",
+            records: records.map((record) => toJsonTableRecord(operator, record)),
+            warnings,
+        },
     };
 }
-async function listRuns(options) {
-    const { root, runsFilePath, limit, specPath, runId, includePruned } = options;
-    if (!(await pathExists(runsFilePath))) {
-        return { warnings: [] };
+async function executeDetailMode(input) {
+    const { operator } = input;
+    const sessionId = input.sessionId;
+    if (!sessionId) {
+        throw new Error("Session ID is required for detail mode.");
     }
-    const filters = {};
-    if (includePruned) {
-        filters.includeDeleted = true;
+    const query = await readOperatorRecords({
+        ...input,
+        limit: 1,
+        predicate: (record) => getRecordId(operator, record) === sessionId,
+    });
+    const warnings = query.warnings;
+    const record = query.records[0];
+    if (!record) {
+        return {
+            warnings,
+            output: `${operator} session \`${sessionId}\` not found.`,
+            mode: "detail",
+            json: {
+                operator,
+                mode: "detail",
+                sessionId,
+                session: null,
+                warnings,
+            },
+        };
     }
-    if (specPath) {
-        filters.specPath = specPath;
+    return {
+        warnings,
+        output: renderDetailOutput(operator, record),
+        mode: "detail",
+        json: {
+            operator,
+            mode: "detail",
+            sessionId,
+            session: toJsonDetailSession(operator, record),
+            warnings,
+        },
+    };
+}
+function renderTableOutput(operator, records) {
+    if (records.length === 0) {
+        return undefined;
     }
-    if (runId) {
-        filters.runId = runId;
+    const table = operator === "run"
+        ? renderRunList(records)
+        : operator === "spec"
+            ? renderSpecList(records)
+            : operator === "message"
+                ? renderMessageList(records)
+                : operator === "reduce"
+                    ? renderReduceList(records)
+                    : renderVerifyList(records);
+    return renderListTableTranscript(table);
+}
+function renderDetailOutput(operator, record) {
+    if (operator === "run") {
+        const runRecord = record;
+        return renderRunTranscript({
+            runId: runRecord.runId,
+            status: runRecord.status,
+            workspacePath: getRunDirectoryPath(runRecord.runId),
+            createdAt: runRecord.createdAt,
+            startedAt: runRecord.startedAt,
+            completedAt: runRecord.completedAt,
+            agents: runRecord.agents.map((agent) => ({
+                agentId: agent.agentId,
+                status: agent.status,
+                startedAt: agent.startedAt,
+                completedAt: agent.completedAt,
+                diffStatistics: agent.diffStatistics,
+            })),
+            isTty: process.stdout.isTTY,
+        });
     }
-    const { records, warnings } = await fetchRunsSafely({
-        root,
-        runsFilePath,
-        limit,
-        filters: Object.keys(filters).length > 0 ? filters : undefined,
+    if (operator === "spec") {
+        const specRecord = record;
+        return renderSpecTranscript({
+            sessionId: specRecord.sessionId,
+            createdAt: specRecord.createdAt,
+            elapsed: formatSpecElapsed({
+                status: specRecord.status,
+                startedAt: specRecord.startedAt,
+                completedAt: specRecord.completedAt,
+            }) ?? DASH,
+            workspacePath: getSpecSessionDirectoryPath(specRecord.sessionId),
+            status: specRecord.status,
+            agents: specRecord.agents.map((agent) => ({
+                agentId: agent.agentId,
+                status: agent.status,
+                duration: formatSpecAgentDuration({
+                    status: agent.status,
+                    startedAt: agent.startedAt,
+                    completedAt: agent.completedAt,
+                }),
+                outputPath: agent.outputPath,
+                dataPath: agent.dataPath,
+                errorLine: agent.error ?? undefined,
+            })),
+            isTty: process.stdout.isTTY,
+        }, { suppressHint: true });
+    }
+    if (operator === "reduce") {
+        const reductionRecord = record;
+        return renderReduceTranscript({
+            reductionId: reductionRecord.sessionId,
+            createdAt: reductionRecord.createdAt,
+            elapsed: formatReduceElapsed({
+                status: reductionRecord.status,
+                startedAt: reductionRecord.startedAt,
+                completedAt: reductionRecord.completedAt,
+            }) ?? DASH,
+            workspacePath: getReductionSessionDirectoryPath(reductionRecord.sessionId),
+            status: reductionRecord.status,
+            reducers: reductionRecord.reducers.map((reducer) => ({
+                reducerAgentId: reducer.agentId,
+                status: reducer.status,
+                duration: formatReducerDuration({
+                    status: reducer.status,
+                    startedAt: reducer.startedAt,
+                    completedAt: reducer.completedAt,
+                }),
+                outputPath: reducer.outputPath,
+                dataPath: reducer.dataPath,
+                errorLine: reducer.error ?? undefined,
+            })),
+            suppressHint: true,
+            isTty: process.stdout.isTTY,
+        });
+    }
+    if (operator === "message") {
+        const messageRecord = record;
+        return renderMessageTranscript({
+            messageId: messageRecord.sessionId,
+            createdAt: messageRecord.createdAt,
+            elapsed: formatMessageElapsed({
+                status: messageRecord.status,
+                startedAt: messageRecord.startedAt,
+                completedAt: messageRecord.completedAt,
+            }) ?? DASH,
+            workspacePath: getMessageSessionDirectoryPath(messageRecord.sessionId),
+            status: messageRecord.status,
+            recipients: messageRecord.recipients.map((recipient) => ({
+                agentId: recipient.agentId,
+                status: recipient.status,
+                duration: formatMessageRecipientDuration({
+                    status: recipient.status,
+                    startedAt: recipient.startedAt,
+                    completedAt: recipient.completedAt,
+                }) ?? DASH,
+                outputPath: recipient.outputPath,
+                errorLine: recipient.error ?? undefined,
+            })),
+            isTty: process.stdout.isTTY,
+        });
+    }
+    const verificationRecord = record;
+    return renderVerifyTranscript({
+        verificationId: verificationRecord.sessionId,
+        createdAt: verificationRecord.createdAt,
+        elapsed: formatVerifyElapsed({
+            status: verificationRecord.status,
+            startedAt: verificationRecord.startedAt,
+            completedAt: verificationRecord.completedAt,
+        }) ?? DASH,
+        workspacePath: getVerificationSessionDirectoryPath(verificationRecord.sessionId),
+        target: verificationRecord.target,
+        status: verificationRecord.status,
+        methods: verificationRecord.methods.map((method) => ({
+            verifierLabel: method.method === "programmatic"
+                ? "programmatic"
+                : (method.template ?? "rubric"),
+            agentLabel: method.verifierId,
+            status: method.status,
+            duration: formatVerifyMethodDuration(method),
+            artifactPath: method.artifactPath,
+            errorLine: method.error ?? undefined,
+        })),
+        suppressHint: true,
+        isTty: process.stdout.isTTY,
     });
-    const formattedWarnings = warnings.map((warning) => formatWarningMessage(warning));
-    if (records.length === 0) {
-        const hasFilters = specPath || runId;
-        const emptyMessage = hasFilters
-            ? "No records match the provided filters."
-            : undefined;
-        return { warnings: formattedWarnings, output: emptyMessage };
+}
+function toJsonTableRecord(operator, record) {
+    if (operator === "run") {
+        const runRecord = record;
+        return {
+            id: runRecord.runId,
+            status: runRecord.status,
+            createdAt: runRecord.createdAt,
+            specPath: runRecord.spec.path,
+        };
+    }
+    if (operator === "spec") {
+        const specRecord = record;
+        return {
+            id: specRecord.sessionId,
+            status: specRecord.status,
+            createdAt: specRecord.createdAt,
+            description: normalizeDescription(specRecord.description),
+        };
+    }
+    if (operator === "reduce") {
+        const reductionRecord = record;
+        return {
+            id: reductionRecord.sessionId,
+            status: reductionRecord.status,
+            createdAt: reductionRecord.createdAt,
+            target: {
+                kind: reductionRecord.target.type,
+                id: reductionRecord.target.id,
+            },
+        };
+    }
+    if (operator === "message") {
+        const messageRecord = record;
+        return {
+            id: messageRecord.sessionId,
+            status: messageRecord.status,
+            createdAt: messageRecord.createdAt,
+            promptPreview: normalizePreviewText(messageRecord.prompt),
+        };
+    }
+    const verificationRecord = record;
+    return {
+        id: verificationRecord.sessionId,
+        status: verificationRecord.status,
+        createdAt: verificationRecord.createdAt,
+        target: {
+            kind: verificationRecord.target.kind,
+            id: verificationRecord.target.sessionId,
+        },
+    };
+}
+function toJsonDetailSession(operator, record) {
+    if (operator === "run") {
+        const runRecord = record;
+        return {
+            id: runRecord.runId,
+            status: runRecord.status,
+            createdAt: runRecord.createdAt,
+            elapsed: formatRunRecordElapsed(runRecord),
+            workspacePath: getRunDirectoryPath(runRecord.runId),
+            rows: runRecord.agents.map(toRunJsonRow),
+            artifacts: [],
+        };
+    }
+    if (operator === "spec") {
+        const specRecord = record;
+        return {
+            id: specRecord.sessionId,
+            status: specRecord.status,
+            createdAt: specRecord.createdAt,
+            elapsed: formatSpecRecordElapsed(specRecord),
+            workspacePath: getSpecSessionDirectoryPath(specRecord.sessionId),
+            rows: specRecord.agents.map(toSpecJsonRow),
+            artifacts: specRecord.agents.map(toSpecArtifact),
+        };
+    }
+    if (operator === "reduce") {
+        const reductionRecord = record;
+        return {
+            id: reductionRecord.sessionId,
+            status: reductionRecord.status,
+            createdAt: reductionRecord.createdAt,
+            elapsed: formatReductionRecordElapsed(reductionRecord),
+            workspacePath: getReductionSessionDirectoryPath(reductionRecord.sessionId),
+            target: {
+                kind: reductionRecord.target.type,
+                id: reductionRecord.target.id,
+            },
+            rows: reductionRecord.reducers.map(toReductionJsonRow),
+            artifacts: reductionRecord.reducers.map(toReductionArtifact),
+        };
+    }
+    if (operator === "message") {
+        const messageRecord = record;
+        return {
+            id: messageRecord.sessionId,
+            status: messageRecord.status,
+            createdAt: messageRecord.createdAt,
+            elapsed: formatMessageRecordElapsed(messageRecord),
+            workspacePath: getMessageSessionDirectoryPath(messageRecord.sessionId),
+            rows: messageRecord.recipients.map(toMessageJsonRow),
+            artifacts: messageRecord.recipients.flatMap(toMessageArtifacts),
+        };
+    }
+    const verificationRecord = record;
+    return {
+        id: verificationRecord.sessionId,
+        status: verificationRecord.status,
+        createdAt: verificationRecord.createdAt,
+        elapsed: formatVerificationRecordElapsed(verificationRecord),
+        workspacePath: getVerificationSessionDirectoryPath(verificationRecord.sessionId),
+        target: {
+            kind: verificationRecord.target.kind,
+            id: verificationRecord.target.sessionId,
+        },
+        rows: verificationRecord.methods.map(toVerificationJsonRow),
+        artifacts: verificationRecord.methods.map(toVerificationArtifact),
+    };
+}
+function formatRunRecordElapsed(record) {
+    return formatRunElapsed({
+        status: record.status,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    });
+}
+function formatSpecRecordElapsed(record) {
+    return formatSpecElapsed({
+        status: record.status,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    });
+}
+function formatReductionRecordElapsed(record) {
+    return formatReduceElapsed({
+        status: record.status,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    });
+}
+function formatMessageRecordElapsed(record) {
+    return formatMessageElapsed({
+        status: record.status,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    });
+}
+function normalizePreviewText(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function formatVerificationRecordElapsed(record) {
+    return formatVerifyElapsed({
+        status: record.status,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
+    });
+}
+function formatRunRowDuration(agent) {
+    return agent.status === "running"
+        ? DASH
+        : (formatAgentDuration(agent) ?? DASH);
+}
+function toRunJsonRow(agent) {
+    return {
+        agentId: agent.agentId,
+        status: agent.status,
+        duration: formatRunRowDuration(agent),
+        changes: formatCompactDiffStatistics(agent.diffStatistics) ?? null,
+    };
+}
+function formatSpecRowDuration(agent) {
+    return (formatSpecAgentDuration({
+        status: agent.status,
+        startedAt: agent.startedAt,
+        completedAt: agent.completedAt,
+    }) ?? DASH);
+}
+function toSpecJsonRow(agent) {
+    return {
+        agentId: agent.agentId,
+        status: agent.status,
+        duration: formatSpecRowDuration(agent),
+    };
+}
+function toSpecArtifact(agent) {
+    return {
+        kind: "spec",
+        agentId: agent.agentId,
+        path: agent.outputPath ?? null,
+    };
+}
+function formatReductionRowDuration(reducer) {
+    return (formatReducerDuration({
+        status: reducer.status,
+        startedAt: reducer.startedAt,
+        completedAt: reducer.completedAt,
+    }) ?? DASH);
+}
+function toReductionJsonRow(reducer) {
+    return {
+        agentId: reducer.agentId,
+        status: reducer.status,
+        duration: formatReductionRowDuration(reducer),
+    };
+}
+function toReductionArtifact(reducer) {
+    return {
+        kind: "reduction",
+        agentId: reducer.agentId,
+        path: reducer.outputPath ?? null,
+    };
+}
+function toMessageJsonRow(recipient) {
+    return {
+        agentId: recipient.agentId,
+        status: recipient.status,
+        duration: formatMessageRecipientDuration({
+            status: recipient.status,
+            startedAt: recipient.startedAt,
+            completedAt: recipient.completedAt,
+        }) ?? DASH,
+    };
+}
+function toMessageArtifacts(recipient) {
+    return [
+        {
+            kind: "output",
+            agentId: recipient.agentId,
+            path: recipient.outputPath ?? null,
+        },
+    ];
+}
+function getVerificationMethodLabel(method) {
+    return method.method === "programmatic"
+        ? "programmatic"
+        : (method.template ?? "rubric");
+}
+function toVerificationJsonRow(method) {
+    return {
+        agentId: method.verifierId ?? null,
+        verifier: getVerificationMethodLabel(method),
+        status: method.status,
+        duration: formatVerifyMethodDuration(method),
+    };
+}
+function toVerificationArtifact(method) {
+    return {
+        kind: "result",
+        agentId: method.verifierId ?? null,
+        verifier: getVerificationMethodLabel(method),
+        path: method.artifactPath ?? null,
+    };
+}
+function shouldIncludeInDefaultTable(operator, status) {
+    if (status === "aborted") {
+        return false;
+    }
+    if (operator === "run" && status === "pruned") {
+        return false;
+    }
+    return true;
+}
+async function readOperatorRecords(input) {
+    const { root, operator } = input;
+    if (operator === "run") {
+        if (!(await pathExists(input.runsFilePath))) {
+            return { records: [], warnings: [] };
+        }
+        const warnings = [];
+        const records = await readRunRecords({
+            root,
+            runsFilePath: input.runsFilePath,
+            limit: input.limit,
+            predicate: input.predicate,
+            onWarning: (warning) => warnings.push(warning),
+        });
+        return {
+            records,
+            warnings: warnings.map(formatSessionWarning),
+        };
+    }
+    if (operator === "spec") {
+        if (!(await pathExists(input.specsFilePath))) {
+            return { records: [], warnings: [] };
+        }
+        const warnings = [];
+        const records = await readSpecRecords({
+            root,
+            specsFilePath: input.specsFilePath,
+            limit: input.limit,
+            predicate: input.predicate,
+            onWarning: (warning) => warnings.push(warning),
+        });
+        return {
+            records,
+            warnings: warnings.map(formatSessionWarning),
+        };
+    }
+    if (operator === "reduce") {
+        if (!(await pathExists(input.reductionsFilePath))) {
+            return { records: [], warnings: [] };
+        }
+        const warnings = [];
+        const records = await readReductionRecords({
+            root,
+            reductionsFilePath: input.reductionsFilePath,
+            limit: input.limit,
+            predicate: input.predicate,
+            onWarning: (warning) => warnings.push(warning),
+        });
+        return {
+            records,
+            warnings: warnings.map(formatSessionWarning),
+        };
     }
+    if (operator === "message") {
+        if (!(await pathExists(input.messagesFilePath))) {
+            return { records: [], warnings: [] };
+        }
+        const warnings = [];
+        const records = await readMessageRecords({
+            root,
+            messagesFilePath: input.messagesFilePath,
+            limit: input.limit,
+            predicate: input.predicate,
+            onWarning: (warning) => warnings.push(warning),
+        });
+        return {
+            records,
+            warnings: warnings.map(formatSessionWarning),
+        };
+    }
+    if (!(await pathExists(input.verificationsFilePath))) {
+        return { records: [], warnings: [] };
+    }
+    const warnings = [];
+    const records = await readVerificationRecords({
+        root,
+        verificationsFilePath: input.verificationsFilePath,
+        limit: input.limit,
+        predicate: input.predicate,
+        onWarning: (warning) => warnings.push(warning),
+    });
     return {
-        warnings: formattedWarnings,
-        output: renderListTranscript(records),
+        records,
+        warnings: warnings.map(formatSessionWarning),
     };
 }
-function formatWarningMessage(warning) {
-    if (warning.kind === "missing-record") {
-        return `Run ${warning.runId} was referenced in the index, but ${warning.displayPath} is missing.`;
+function getRecordStatus(record) {
+    if ("runId" in record) {
+        return record.status;
+    }
+    return record.status;
+}
+function getRecordId(operator, record) {
+    if (operator === "run") {
+        return record.runId;
     }
-    return `Ignored corrupt run data at ${warning.displayPath}: ${warning.details}`;
+    return record.sessionId;
+}
+function formatSessionWarning(warning) {
+    return `Ignoring corrupt session ${warning.displayPath}`;
+}
+function normalizeDescription(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function formatVerifyMethodDuration(method) {
+    return (formatRenderLifecycleDuration({
+        lifecycle: {
+            status: method.status,
+            startedAt: method.startedAt,
+            completedAt: method.completedAt,
+        },
+        terminalStatuses: TERMINAL_VERIFICATION_STATUSES,
+    }) ?? DASH);
 }

package/dist/commands/message/command.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedExtraContextFile } from "../../competition/shared/extra-context.js";
+import { type MessageCompetitionExecution } from "../../domain/message/competition/adapter.js";
+import { type MessageRecipientEntry, type MessageRecord } from "../../domain/message/model/types.js";
+import type { MessageProgressRenderer } from "../../render/transcripts/message.js";
+export interface ExecuteMessageCommandInput {
+    root: string;
+    messagesFilePath: string;
+    prompt: string;
+    agentIds?: readonly string[];
+    agentOverrideFlag?: string;
+    profileName?: string;
+    maxParallel?: number;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+    sourceInteractiveSessionId?: string;
+    renderer?: MessageProgressRenderer;
+}
+export interface ExecuteMessageCommandResult {
+    messageId: string;
+    record: MessageRecord;
+    recipients: readonly MessageRecipientEntry[];
+    executions: readonly MessageCompetitionExecution[];
+}
+export declare function executeMessageCommand(input: ExecuteMessageCommandInput): Promise<ExecuteMessageCommandResult>;