voratiq 0.1.0-beta.21 → 0.1.0-beta.22

package/dist/preflight/agents.js

@@ -0,0 +1,71 @@
+import { verifyAgentProviders } from "../agents/runtime/auth.js";
+import { loadAgentCatalogDiagnostics } from "../configs/agents/loader.js";
+import { collectSettingsPreflightIssues } from "./settings.js";
+export async function collectConfiguredAgentReadiness(input) {
+    const { root, resolvedAgentIds, includeSettings = true } = input;
+    const catalogDiagnostics = loadAgentCatalogDiagnostics({ root });
+    const settingsIssues = includeSettings
+        ? [...collectSettingsPreflightIssues(root)]
+        : [];
+    if (resolvedAgentIds) {
+        if (resolvedAgentIds.length === 0) {
+            return {
+                agents: [],
+                issues: settingsIssues,
+                preProviderIssueCount: settingsIssues.length,
+                noAgentsEnabled: true,
+            };
+        }
+        const selectedAgentIds = new Set(resolvedAgentIds);
+        const catalogById = new Map(catalogDiagnostics.catalog.map((agent) => [agent.id, agent]));
+        const agents = resolvedAgentIds.flatMap((agentId) => {
+            const agent = catalogById.get(agentId);
+            return agent ? [agent] : [];
+        });
+        const catalogIssues = catalogDiagnostics.issues.filter((issue) => selectedAgentIds.has(issue.agentId));
+        const readiness = await collectResolvedAgentReadiness({
+            root,
+            agents,
+            includeSettings,
+        });
+        return {
+            agents,
+            issues: [...catalogIssues, ...readiness.issues],
+            preProviderIssueCount: catalogIssues.length + readiness.preProviderIssueCount,
+            noAgentsEnabled: false,
+        };
+    }
+    if (catalogDiagnostics.enabledAgents.length === 0) {
+        return {
+            agents: [],
+            issues: settingsIssues,
+            preProviderIssueCount: settingsIssues.length,
+            noAgentsEnabled: true,
+        };
+    }
+    const readiness = await collectResolvedAgentReadiness({
+        root,
+        agents: catalogDiagnostics.catalog,
+        includeSettings,
+    });
+    return {
+        agents: catalogDiagnostics.catalog,
+        issues: [...catalogDiagnostics.issues, ...readiness.issues],
+        preProviderIssueCount: catalogDiagnostics.issues.length + readiness.preProviderIssueCount,
+        noAgentsEnabled: false,
+    };
+}
+export async function collectResolvedAgentReadiness(input) {
+    const { root, agents, includeSettings = true } = input;
+    const preProviderIssues = includeSettings
+        ? [...collectSettingsPreflightIssues(root)]
+        : [];
+    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({
+        id: agent.id,
+        provider: agent.provider,
+    })));
+    return {
+        issues: [...preProviderIssues, ...providerIssues],
+        preProviderIssueCount: preProviderIssues.length,
+    };
+}

package/dist/preflight/environment.d.ts

@@ -0,0 +1,6 @@
+import type { EnvironmentConfig } from "../configs/environment/types.js";
+export interface LoadOperatorEnvironmentOptions {
+    readonly root: string;
+    readonly errorMode?: "raw" | "workspace-missing";
+}
+export declare function loadOperatorEnvironment(options: LoadOperatorEnvironmentOptions): EnvironmentConfig;

package/dist/preflight/environment.js

@@ -0,0 +1,17 @@
+import { EnvironmentConfigParseError, MissingEnvironmentConfigError, } from "../configs/environment/errors.js";
+import { DEFAULT_ENVIRONMENT_FILE_DISPLAY, loadEnvironmentConfig, } from "../configs/environment/loader.js";
+import { WorkspaceMissingEntryError } from "../workspace/errors.js";
+export function loadOperatorEnvironment(options) {
+    const { root, errorMode = "raw" } = options;
+    try {
+        return loadEnvironmentConfig({ root });
+    }
+    catch (error) {
+        if (errorMode === "workspace-missing" &&
+            (error instanceof MissingEnvironmentConfigError ||
+                error instanceof EnvironmentConfigParseError)) {
+            throw new WorkspaceMissingEntryError(DEFAULT_ENVIRONMENT_FILE_DISPLAY);
+        }
+        throw error;
+    }
+}

package/dist/preflight/formatting.d.ts

@@ -0,0 +1,5 @@
+import { type PreflightIssue } from "../competition/shared/preflight.js";
+export declare const OPERATOR_PREFLIGHT_UNLABELED_AGENT_IDS: readonly ["settings"];
+export declare const SETTINGS_PREFLIGHT_HINT: "Review `settings.yaml` and correct invalid values.";
+export declare function formatOperatorPreflightIssueLines(issues: readonly PreflightIssue[]): string[];
+export declare function resolveOperatorPreflightHintLines(issues: readonly PreflightIssue[], preProviderIssueCount: number): readonly string[] | undefined;

package/dist/preflight/formatting.js

@@ -0,0 +1,20 @@
+import { formatPreflightIssueLines, PREFLIGHT_HINT, } from "../competition/shared/preflight.js";
+export const OPERATOR_PREFLIGHT_UNLABELED_AGENT_IDS = ["settings"];
+export const SETTINGS_PREFLIGHT_HINT = "Review `settings.yaml` and correct invalid values.";
+export function formatOperatorPreflightIssueLines(issues) {
+    return formatPreflightIssueLines(issues, {
+        unlabeledAgentIds: OPERATOR_PREFLIGHT_UNLABELED_AGENT_IDS,
+    });
+}
+export function resolveOperatorPreflightHintLines(issues, preProviderIssueCount) {
+    const preProviderIssues = issues.slice(0, preProviderIssueCount);
+    const hasSettingsIssue = preProviderIssues.some((issue) => issue.agentId === "settings");
+    const hasRepairableWorkspaceIssue = preProviderIssues.some((issue) => issue.agentId !== "settings");
+    if (hasSettingsIssue) {
+        return [SETTINGS_PREFLIGHT_HINT];
+    }
+    if (hasRepairableWorkspaceIssue) {
+        return [PREFLIGHT_HINT];
+    }
+    return [];
+}

package/dist/preflight/index.d.ts

@@ -11,6 +11,8 @@ export interface WorkspacePaths {
     reductionsFile?: string;
     messagesDir?: string;
     messagesFile?: string;
+    interactiveDir?: string;
+    interactiveFile?: string;
     specsDir: string;
     specsFile: string;
     verificationsDir?: string;

package/dist/preflight/index.js

@@ -1,11 +1,11 @@
 import { isAbsolute, resolve } from "node:path";
-import { executeInitCommand } from "../commands/init/command.js";
+import { executeDoctorReconcile } from "../commands/doctor/reconcile.js";
 import { ensureFileExists, pathExists } from "../utils/fs.js";
 import { assertGitRepository, runGitCommand, } from "../utils/git.js";
 import { relativeToRoot } from "../utils/path.js";
 import { collectMissingSandboxDependencies, formatSandboxDependencyList, } from "../workspace/sandbox-requirements.js";
 import { repairWorkspaceStructure, validateWorkspace, } from "../workspace/setup.js";
-import { resolveWorkspacePath, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
+import { resolveWorkspacePath, VORATIQ_INTERACTIVE_DIR, VORATIQ_INTERACTIVE_FILE, VORATIQ_MESSAGE_DIR, VORATIQ_MESSAGE_FILE, VORATIQ_REDUCTION_DIR, VORATIQ_REDUCTION_FILE, VORATIQ_RUN_DIR, VORATIQ_RUN_FILE, VORATIQ_SPEC_DIR, VORATIQ_SPEC_FILE, VORATIQ_VERIFICATION_DIR, VORATIQ_VERIFICATION_FILE, } from "../workspace/structure.js";
 import { DirtyWorkingTreeError, SandboxDependenciesError, SpecNotFoundError, } from "./errors.js";
 export async function resolveCliContext(options = {}) {
     const { requireWorkspace = true, workspaceAutoInitMode = "never", restoreShippedVerificationTemplates = true, } = options;
@@ -18,13 +18,7 @@ export async function resolveCliContext(options = {}) {
     if (requireWorkspace) {
         let workspaceMissing = !initialWorkspaceExists;
         if (workspaceAutoInitMode === "when-missing" && workspaceMissing) {
-            await executeInitCommand({
-                root,
-                preset: "pro",
-                presetProvided: false,
-                assumeYes: true,
-                interactive: false,
-            });
+            await executeDoctorReconcile({ root });
             workspaceAutoInitialized = true;
             workspaceMissing = false;
         }
@@ -45,6 +39,8 @@ export async function resolveCliContext(options = {}) {
         reductionsFile: resolveWorkspacePath(root, VORATIQ_REDUCTION_FILE),
         messagesDir: resolveWorkspacePath(root, VORATIQ_MESSAGE_DIR),
         messagesFile: resolveWorkspacePath(root, VORATIQ_MESSAGE_FILE),
+        interactiveDir: resolveWorkspacePath(root, VORATIQ_INTERACTIVE_DIR),
+        interactiveFile: resolveWorkspacePath(root, VORATIQ_INTERACTIVE_FILE),
         specsDir: resolveWorkspacePath(root, VORATIQ_SPEC_DIR),
         specsFile: resolveWorkspacePath(root, VORATIQ_SPEC_FILE),
         verificationsDir: resolveWorkspacePath(root, VORATIQ_VERIFICATION_DIR),

package/dist/preflight/operator.d.ts

@@ -0,0 +1,32 @@
+import type { PreflightIssue } from "../competition/shared/preflight.js";
+import type { AgentDefinition } from "../configs/agents/types.js";
+import type { EnvironmentConfig } from "../configs/environment/types.js";
+export interface PrepareConfiguredOperatorReadinessInput {
+    readonly root: string;
+    readonly resolvedAgentIds?: readonly string[];
+    readonly includeSettings?: boolean;
+    readonly includeEnvironment?: boolean;
+    readonly environmentErrorMode?: "raw" | "workspace-missing";
+}
+export interface PreparedConfiguredOperatorReadiness {
+    readonly agents: readonly AgentDefinition[];
+    readonly issues: readonly PreflightIssue[];
+    readonly preProviderIssueCount: number;
+    readonly noAgentsEnabled: boolean;
+    readonly environment?: EnvironmentConfig;
+}
+export interface PrepareResolvedOperatorReadinessInput {
+    readonly root: string;
+    readonly agents: readonly AgentDefinition[];
+    readonly includeSettings?: boolean;
+    readonly includeEnvironment?: boolean;
+    readonly environmentErrorMode?: "raw" | "workspace-missing";
+}
+export interface PreparedResolvedOperatorReadiness {
+    readonly agents: readonly AgentDefinition[];
+    readonly issues: readonly PreflightIssue[];
+    readonly preProviderIssueCount: number;
+    readonly environment?: EnvironmentConfig;
+}
+export declare function prepareConfiguredOperatorReadiness(input: PrepareConfiguredOperatorReadinessInput): Promise<PreparedConfiguredOperatorReadiness>;
+export declare function prepareResolvedOperatorReadiness(input: PrepareResolvedOperatorReadinessInput): Promise<PreparedResolvedOperatorReadiness>;

package/dist/preflight/operator.js

@@ -0,0 +1,40 @@
+import { collectConfiguredAgentReadiness, collectResolvedAgentReadiness, } from "./agents.js";
+import { loadOperatorEnvironment } from "./environment.js";
+export async function prepareConfiguredOperatorReadiness(input) {
+    const { root, resolvedAgentIds, includeSettings = true, includeEnvironment = false, environmentErrorMode = "raw", } = input;
+    const readiness = await collectConfiguredAgentReadiness({
+        root,
+        resolvedAgentIds,
+        includeSettings,
+    });
+    const environment = includeEnvironment
+        ? loadOperatorEnvironment({
+            root,
+            errorMode: environmentErrorMode,
+        })
+        : undefined;
+    return {
+        ...readiness,
+        ...(environment ? { environment } : {}),
+    };
+}
+export async function prepareResolvedOperatorReadiness(input) {
+    const { root, agents, includeSettings = true, includeEnvironment = false, environmentErrorMode = "raw", } = input;
+    const readiness = await collectResolvedAgentReadiness({
+        root,
+        agents,
+        includeSettings,
+    });
+    const environment = includeEnvironment
+        ? loadOperatorEnvironment({
+            root,
+            errorMode: environmentErrorMode,
+        })
+        : undefined;
+    return {
+        agents,
+        issues: readiness.issues,
+        preProviderIssueCount: readiness.preProviderIssueCount,
+        ...(environment ? { environment } : {}),
+    };
+}

package/dist/preflight/settings.d.ts

@@ -0,0 +1,2 @@
+import type { PreflightIssue } from "../competition/shared/preflight.js";
+export declare function collectSettingsPreflightIssues(root: string): readonly PreflightIssue[];

package/dist/preflight/settings.js

@@ -0,0 +1,17 @@
+import { loadRepoSettings } from "../configs/settings/loader.js";
+import { toErrorMessage } from "../utils/errors.js";
+const SETTINGS_ISSUE_AGENT_ID = "settings";
+export function collectSettingsPreflightIssues(root) {
+    try {
+        loadRepoSettings({ root });
+        return [];
+    }
+    catch (error) {
+        return [
+            {
+                agentId: SETTINGS_ISSUE_AGENT_ID,
+                message: toErrorMessage(error),
+            },
+        ];
+    }
+}

package/dist/render/transcripts/interactive.d.ts

@@ -0,0 +1,16 @@
+export interface InteractiveTranscriptAgentBlock {
+    agentId: string;
+    status: "running" | "succeeded" | "failed";
+    duration: string;
+    outputPath?: string;
+}
+export interface InteractiveTranscriptOptions {
+    sessionId: string;
+    createdAt: string;
+    elapsed: string;
+    workspacePath: string;
+    status: "running" | "succeeded" | "failed";
+    agents: readonly InteractiveTranscriptAgentBlock[];
+    isTty?: boolean;
+}
+export declare function renderInteractiveTranscript(options: InteractiveTranscriptOptions): string;

package/dist/render/transcripts/interactive.js

@@ -0,0 +1,42 @@
+import { getAgentStatusStyle, getRunStatusStyle } from "../../status/colors.js";
+import { renderTranscript } from "../utils/transcript.js";
+import { buildStandardSessionShellSection, formatTranscriptStatusLabel, renderTranscriptStatusTable, resolveTranscriptShellStyle, } from "../utils/transcript-shell.js";
+const DASH = "—";
+export function renderInteractiveTranscript(options) {
+    const style = { isTty: options.isTty };
+    const resolvedStyle = resolveTranscriptShellStyle(style);
+    const sections = [];
+    sections.push(buildStandardSessionShellSection({
+        badgeText: options.sessionId,
+        badgeVariant: "interactive",
+        status: {
+            value: options.status,
+            color: getRunStatusStyle(options.status).cli,
+        },
+        elapsed: options.elapsed,
+        createdAt: options.createdAt,
+        workspacePath: options.workspacePath,
+        style,
+    }));
+    if (options.agents.length > 0) {
+        sections.push(renderTranscriptStatusTable({
+            rows: options.agents,
+            agent: (row) => row.agentId,
+            status: (row) => formatTranscriptStatusLabel(row.status, getAgentStatusStyle(row.status).cli, resolvedStyle),
+            duration: (row) => row.duration,
+        }));
+        sections.push(["---"]);
+    }
+    options.agents.forEach((agent, index) => {
+        const block = [
+            `Agent: ${agent.agentId}`,
+            "",
+            `Output: ${agent.outputPath ?? DASH}`,
+        ];
+        if (index < options.agents.length - 1) {
+            block.push("", "---");
+        }
+        sections.push(block);
+    });
+    return renderTranscript({ sections });
+}

package/dist/render/transcripts/list.d.ts

@@ -3,10 +3,51 @@ import type { ReductionRecord } from "../../domain/reduce/model/types.js";
 import type { RunRecord } from "../../domain/run/model/types.js";
 import type { SpecRecord } from "../../domain/spec/model/types.js";
 import type { VerificationRecord } from "../../domain/verify/model/types.js";
+export interface RunListTableSession {
+    id: string;
+    target: string;
+    status: string;
+    createdAt: string;
+}
+export interface SpecListTableSession {
+    id: string;
+    description: string | null;
+    status: string;
+    createdAt: string;
+}
+export interface ReduceListTableSession {
+    id: string;
+    target: string;
+    status: string;
+    createdAt: string;
+}
+export interface VerifyListTableSession {
+    id: string;
+    target: string;
+    status: string;
+    createdAt: string;
+}
+export interface MessageListTableSession {
+    id: string;
+    target: string;
+    status: string;
+    createdAt: string;
+}
+export interface InteractiveListTableSession {
+    id: string;
+    status: string;
+    createdAt: string;
+}
 export declare function renderRunList(records: readonly RunRecord[]): string;
+export declare function renderRunListTable(sessions: readonly RunListTableSession[]): string;
 export declare function renderListTranscript(records: readonly RunRecord[]): string;
 export declare function renderSpecList(records: readonly SpecRecord[]): string;
+export declare function renderSpecListTable(sessions: readonly SpecListTableSession[]): string;
 export declare function renderReduceList(records: readonly ReductionRecord[]): string;
+export declare function renderReduceListTable(sessions: readonly ReduceListTableSession[]): string;
 export declare function renderMessageList(records: readonly MessageRecord[]): string;
+export declare function renderMessageListTable(sessions: readonly MessageListTableSession[]): string;
+export declare function renderInteractiveListTable(sessions: readonly InteractiveListTableSession[]): string;
 export declare function renderVerifyList(records: readonly VerificationRecord[]): string;
+export declare function renderVerifyListTable(sessions: readonly VerifyListTableSession[]): string;
 export declare function renderListTableTranscript(tableOutput: string): string;

package/dist/render/transcripts/list.js

@@ -1,9 +1,9 @@
+import { formatTargetTablePreview } from "../../utils/list-target.js";
 import { formatRunTimestamp } from "../utils/records.js";
 import { renderTable } from "../utils/table.js";
 import { renderTranscript } from "../utils/transcript.js";
 const DASH = "—";
 const SPEC_DESCRIPTION_PREVIEW_LENGTH = 32;
-const MESSAGE_PROMPT_PREVIEW_LENGTH = 32;
 export function renderRunList(records) {
     const rows = records.map((record) => ({
         run: record.runId,
@@ -25,6 +25,29 @@ export function renderRunList(records) {
     ];
     return renderTable({ columns, rows }).join("\n");
 }
+export function renderRunListTable(sessions) {
+    return renderTable({
+        columns: [
+            {
+                header: "RUN",
+                accessor: (session) => session.id,
+            },
+            {
+                header: "TARGET",
+                accessor: (session) => session.target,
+            },
+            {
+                header: "STATUS",
+                accessor: (session) => session.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (session) => formatRunTimestamp(session.createdAt),
+            },
+        ],
+        rows: sessions,
+    }).join("\n");
+}
 export function renderListTranscript(records) {
     if (records.length === 0) {
         return "";
@@ -55,6 +78,29 @@ export function renderSpecList(records) {
         rows: records,
     }).join("\n");
 }
+export function renderSpecListTable(sessions) {
+    return renderTable({
+        columns: [
+            {
+                header: "SPEC",
+                accessor: (session) => session.id,
+            },
+            {
+                header: "DESCRIPTION",
+                accessor: (session) => truncatePreview(session.description, SPEC_DESCRIPTION_PREVIEW_LENGTH),
+            },
+            {
+                header: "STATUS",
+                accessor: (session) => session.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (session) => formatRunTimestamp(session.createdAt),
+            },
+        ],
+        rows: sessions,
+    }).join("\n");
+}
 export function renderReduceList(records) {
     return renderTable({
         columns: [
@@ -78,6 +124,29 @@ export function renderReduceList(records) {
         rows: records,
     }).join("\n");
 }
+export function renderReduceListTable(sessions) {
+    return renderTable({
+        columns: [
+            {
+                header: "REDUCE",
+                accessor: (session) => session.id,
+            },
+            {
+                header: "TARGET",
+                accessor: (session) => session.target,
+            },
+            {
+                header: "STATUS",
+                accessor: (session) => session.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (session) => formatRunTimestamp(session.createdAt),
+            },
+        ],
+        rows: sessions,
+    }).join("\n");
+}
 export function renderMessageList(records) {
     return renderTable({
         columns: [
@@ -86,8 +155,8 @@ export function renderMessageList(records) {
                 accessor: (record) => record.sessionId,
             },
             {
-                header: "PROMPT",
-                accessor: (record) => truncatePreview(record.prompt, MESSAGE_PROMPT_PREVIEW_LENGTH),
+                header: "TARGET",
+                accessor: (record) => normalizeMessageTargetPreview(record),
             },
             {
                 header: "STATUS",
@@ -101,6 +170,48 @@ export function renderMessageList(records) {
         rows: records,
     }).join("\n");
 }
+export function renderMessageListTable(sessions) {
+    return renderTable({
+        columns: [
+            {
+                header: "MESSAGE",
+                accessor: (session) => session.id,
+            },
+            {
+                header: "TARGET",
+                accessor: (session) => session.target,
+            },
+            {
+                header: "STATUS",
+                accessor: (session) => session.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (session) => formatRunTimestamp(session.createdAt),
+            },
+        ],
+        rows: sessions,
+    }).join("\n");
+}
+export function renderInteractiveListTable(sessions) {
+    return renderTable({
+        columns: [
+            {
+                header: "INTERACTIVE",
+                accessor: (session) => session.id,
+            },
+            {
+                header: "STATUS",
+                accessor: (session) => session.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (session) => formatRunTimestamp(session.createdAt),
+            },
+        ],
+        rows: sessions,
+    }).join("\n");
+}
 export function renderVerifyList(records) {
     return renderTable({
         columns: [
@@ -124,6 +235,29 @@ export function renderVerifyList(records) {
         rows: records,
     }).join("\n");
 }
+export function renderVerifyListTable(sessions) {
+    return renderTable({
+        columns: [
+            {
+                header: "VERIFY",
+                accessor: (session) => session.id,
+            },
+            {
+                header: "TARGET",
+                accessor: (session) => session.target,
+            },
+            {
+                header: "STATUS",
+                accessor: (session) => session.status.toUpperCase(),
+            },
+            {
+                header: "CREATED",
+                accessor: (session) => formatRunTimestamp(session.createdAt),
+            },
+        ],
+        rows: sessions,
+    }).join("\n");
+}
 export function renderListTableTranscript(tableOutput) {
     if (tableOutput.trim().length === 0) {
         return "";
@@ -148,3 +282,18 @@ function truncatePreview(value, maxLength) {
     }
     return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
 }
+function normalizeMessageTargetPreview(record) {
+    if (!record.target) {
+        return DASH;
+    }
+    return formatTargetTablePreview(record.target.agentId
+        ? {
+            kind: record.target.kind,
+            sessionId: record.target.sessionId,
+            agentId: record.target.agentId,
+        }
+        : {
+            kind: record.target.kind,
+            sessionId: record.target.sessionId,
+        });
+}

package/dist/render/transcripts/message.d.ts

@@ -44,6 +44,7 @@ export interface MessageTranscriptOptions {
     elapsed: string;
     workspacePath: string;
     status: "queued" | "running" | "succeeded" | "failed" | "aborted";
+    targetDisplay?: string;
     recipients: readonly MessageTranscriptRecipientBlock[];
     isTty?: boolean;
     includeSummarySection?: boolean;
@@ -68,5 +69,5 @@ export declare function formatMessageRecipientDuration(input: {
     startedAt?: string;
     completedAt?: string;
     now?: number;
-}): string | undefined;
+}): string;
 export {};