voratiq 0.1.0-beta.0

package/dist/records/types.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { agentIdSchema } from "../configs/agents/types.js";
+import { evalSlugSchema, evalStatusSchema } from "../configs/evals/types.js";
+import { agentStatusSchema as sharedAgentStatusSchema, applyStatusEnum, runStatusSchema, } from "../status/index.js";
+import { assertRepoRelativePath } from "../utils/path.js";
+function validateRepoRelativePath(value, ctx) {
+    try {
+        assertRepoRelativePath(value);
+    }
+    catch (error) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: error instanceof Error ? error.message : "invalid repo-relative path",
+        });
+    }
+}
+const repoRelativePathSchema = z
+    .string()
+    .superRefine((value, ctx) => validateRepoRelativePath(value, ctx));
+export const runSpecDescriptorSchema = z.object({
+    path: repoRelativePathSchema,
+});
+export const agentStatusSchema = sharedAgentStatusSchema;
+export const TERMINAL_AGENT_STATUSES = [
+    "succeeded",
+    "failed",
+    "errored",
+    "skipped",
+    "aborted",
+];
+export const EVAL_REQUIRED_AGENT_STATUSES = [
+    "succeeded",
+    "failed",
+    "errored",
+    "skipped",
+];
+export const IN_PROGRESS_AGENT_STATUSES = [
+    "queued",
+    "running",
+];
+const CHAT_ARTIFACT_FORMATS = [
+    "json",
+    "jsonl",
+];
+const WATCHDOG_TRIGGERS = ["silence", "wall-clock", "fatal-pattern"];
+export const watchdogMetadataSchema = z.object({
+    /** Silence timeout in milliseconds that was enforced. */
+    silenceTimeoutMs: z.number(),
+    /** Wall-clock cap in milliseconds that was enforced. */
+    wallClockCapMs: z.number(),
+    /** Which watchdog trigger caused termination, if any. */
+    trigger: z.enum(WATCHDOG_TRIGGERS).optional(),
+});
+export const agentArtifactStateSchema = z.object({
+    diffAttempted: z.boolean().optional(),
+    diffCaptured: z.boolean().optional(),
+    stdoutCaptured: z.boolean().optional(),
+    stderrCaptured: z.boolean().optional(),
+    summaryCaptured: z.boolean().optional(),
+    chatCaptured: z.boolean().optional(),
+    chatFormat: z.enum(CHAT_ARTIFACT_FORMATS).optional(),
+});
+export const agentEvalSnapshotSchema = z.object({
+    slug: evalSlugSchema,
+    status: evalStatusSchema,
+    exitCode: z.number().nullable().optional(),
+    command: z.string().optional(),
+    hasLog: z.boolean().optional(),
+    error: z.string().optional(),
+});
+export const agentInvocationRecordSchema = z
+    .object({
+    agentId: agentIdSchema,
+    model: z.string(),
+    status: agentStatusSchema,
+    startedAt: z.string().optional(),
+    completedAt: z.string().optional(),
+    commitSha: z.string().optional(),
+    artifacts: agentArtifactStateSchema.optional(),
+    evals: z.array(agentEvalSnapshotSchema).optional(),
+    error: z.string().optional(),
+    warnings: z.array(z.string()).optional(),
+    diffStatistics: z.string().optional(),
+    watchdog: watchdogMetadataSchema.optional(),
+})
+    .superRefine((data, ctx) => {
+    if (IN_PROGRESS_AGENT_STATUSES.includes(data.status)) {
+        return;
+    }
+    if (TERMINAL_AGENT_STATUSES.includes(data.status)) {
+        if (!data.startedAt) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["startedAt"],
+                message: "startedAt is required once the agent completes",
+            });
+        }
+        if (!data.completedAt) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["completedAt"],
+                message: "completedAt is required once the agent completes",
+            });
+        }
+        if (EVAL_REQUIRED_AGENT_STATUSES.includes(data.status) && !data.evals) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["evals"],
+                message: "eval results are required once the agent completes",
+            });
+        }
+    }
+});
+export const applyStatusSchema = z.object({
+    agentId: agentIdSchema,
+    status: applyStatusEnum,
+    appliedAt: z.string(),
+    ignoredBaseMismatch: z.boolean(),
+    detail: z.string().max(256).nullable().optional(),
+});
+export const runRecordSchema = z.object({
+    runId: z.string(),
+    baseRevisionSha: z.string(),
+    rootPath: repoRelativePathSchema,
+    spec: runSpecDescriptorSchema,
+    status: runStatusSchema,
+    createdAt: z.string(),
+    agents: z.array(agentInvocationRecordSchema),
+    applyStatus: applyStatusSchema.optional(),
+    deletedAt: z.string().nullable().optional(),
+});

package/dist/render/interactions/confirmation.d.ts

@@ -0,0 +1,19 @@
+export interface ConfirmationOptions {
+    message: string;
+    defaultValue: boolean;
+    prefaceLines?: string[];
+}
+export interface PromptOptions {
+    message: string;
+    defaultValue?: string;
+    prefaceLines?: string[];
+}
+export interface ConfirmationInteractor {
+    confirm(options: ConfirmationOptions): Promise<boolean>;
+    prompt(options: PromptOptions): Promise<string>;
+    close(): void;
+}
+export interface ConfirmationInteractorOptions {
+    assumeYes?: boolean;
+}
+export declare function createConfirmationInteractor(options?: ConfirmationInteractorOptions): ConfirmationInteractor;

package/dist/render/interactions/confirmation.js

@@ -0,0 +1,63 @@
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+export function createConfirmationInteractor(options = {}) {
+    const { assumeYes = false } = options;
+    const readlineInterface = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        async confirm(options) {
+            const { message, defaultValue, prefaceLines = [] } = options;
+            if (assumeYes) {
+                return true;
+            }
+            for (const line of prefaceLines) {
+                if (line.length === 0) {
+                    process.stdout.write("\n");
+                }
+                else {
+                    process.stdout.write(`${line}\n`);
+                }
+            }
+            const suffix = defaultValue ? "(Y/n)" : "(y/N)";
+            for (;;) {
+                const response = await readlineInterface.question(`${message} ${suffix}: `);
+                const normalized = response.trim().toLowerCase();
+                if (normalized.length === 0) {
+                    return defaultValue;
+                }
+                if (normalized === "y" || normalized === "yes") {
+                    return true;
+                }
+                if (normalized === "n" || normalized === "no") {
+                    return false;
+                }
+                process.stdout.write("Please answer Y or N.\n");
+            }
+        },
+        async prompt(options) {
+            const { message, defaultValue, prefaceLines = [] } = options;
+            if (assumeYes) {
+                return defaultValue ?? "";
+            }
+            for (const line of prefaceLines) {
+                if (line.length === 0) {
+                    process.stdout.write("\n");
+                }
+                else {
+                    process.stdout.write(`${line}\n`);
+                }
+            }
+            const suffix = defaultValue && defaultValue.length > 0 ? ` [${defaultValue}]` : "";
+            const response = await readlineInterface.question(`${message}${suffix}: `);
+            if (response.trim().length === 0) {
+                return defaultValue ?? "";
+            }
+            return response.trim();
+        },
+        close() {
+            readlineInterface.close();
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { ApplyResult } from "../../commands/apply/types.js";
+export declare function renderApplyTranscript(result: ApplyResult): string;

package/dist/render/transcripts/apply.js

@@ -0,0 +1,52 @@
+import { colorize } from "../../utils/colors.js";
+import { formatRunWorkspaceRelative } from "../../workspace/layout.js";
+import { buildAgentArtifactPaths, buildAgentEvalViews, getAgentDirectoryPath, getAgentManifestPath, } from "../../workspace/structure.js";
+import { formatRunTimestamp } from "../utils/records.js";
+import { renderTranscriptWithMetadata } from "./shared.js";
+export function renderApplyTranscript(result) {
+    const agent = result.agent;
+    const artifacts = agent.artifacts ?? {};
+    const { startedAt, completedAt } = agent;
+    if (!startedAt || !completedAt) {
+        throw new Error("apply transcript requires agent lifecycle timestamps");
+    }
+    const assets = buildAgentArtifactPaths({
+        runId: result.runId,
+        agentId: agent.agentId,
+        artifacts,
+    });
+    const agentDisplay = {
+        ...agent,
+        startedAt,
+        completedAt,
+        baseDirectory: getAgentDirectoryPath(result.runId, agent.agentId),
+        runtimeManifestPath: getAgentManifestPath(result.runId, agent.agentId),
+        assets,
+        evals: buildAgentEvalViews({
+            runId: result.runId,
+            agentId: agent.agentId,
+            evals: agent.evals,
+        }),
+    };
+    const warnings = result.ignoredBaseMismatch
+        ? [
+            `${colorize("Warning:", "yellow")} Applied despite base mismatch (\`--ignore-base-mismatch\`).`,
+        ]
+        : undefined;
+    return renderTranscriptWithMetadata({
+        metadata: {
+            runId: result.runId,
+            status: result.status,
+            specPath: result.specPath,
+            workspacePath: formatRunWorkspaceRelative(result.runId),
+            createdAt: formatRunTimestamp(result.createdAt),
+            baseRevisionSha: result.baseRevisionSha,
+        },
+        agents: [agentDisplay],
+        warnings,
+        afterAgents: [[colorize("Diff applied to working tree.", "green")]],
+        hint: {
+            message: "Review changes (e.g., `git status`) and run tests before committing.",
+        },
+    });
+}

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

@@ -0,0 +1,18 @@
+import type { InitCommandResult } from "../../commands/init/types.js";
+import type { EvalSlug } from "../../configs/evals/types.js";
+export declare function buildInitializationPrompt(): string;
+interface AgentPromptRenderOptions {
+    agentId: string;
+    binaryPath?: string;
+    detected: boolean;
+    firstPrompt: boolean;
+}
+export declare function renderAgentPromptPreface({ agentId, binaryPath, detected, firstPrompt, }: AgentPromptRenderOptions): string[];
+interface EvalCommandPromptRenderOptions {
+    commandName: EvalSlug;
+    commandText: string;
+    firstPrompt: boolean;
+}
+export declare function renderEvalCommandPreface({ commandName, commandText, firstPrompt, }: EvalCommandPromptRenderOptions): string[];
+export declare function renderInitTranscript({ agentSummary, environmentSummary, evalSummary, sandboxSummary, }: InitCommandResult): string;
+export {};

package/dist/render/transcripts/init.js

@@ -0,0 +1,84 @@
+import { colorize } from "../../utils/colors.js";
+import { renderTranscript } from "../utils/transcript.js";
+export function buildInitializationPrompt() {
+    return "Initializing Voratiq…";
+}
+export function renderAgentPromptPreface({ agentId, binaryPath, detected, firstPrompt, }) {
+    const lines = [];
+    if (firstPrompt) {
+        lines.push("");
+        lines.push("Configuring agents…");
+        lines.push("");
+    }
+    if (detected && binaryPath) {
+        lines.push(`\`${agentId}\` binary detected: \`${binaryPath}\``);
+    }
+    else {
+        lines.push(`\`${agentId}\` binary not detected. Keeping disabled.`);
+    }
+    return lines;
+}
+export function renderEvalCommandPreface({ commandName, commandText, firstPrompt, }) {
+    const lines = [];
+    if (firstPrompt) {
+        lines.push("");
+        lines.push("Configuring evals…");
+        lines.push("");
+    }
+    lines.push(`\`${commandName}\` command detected: \`${commandText}\``);
+    return lines;
+}
+export function renderInitTranscript({ agentSummary, environmentSummary, evalSummary, sandboxSummary, }) {
+    const sections = [];
+    sections.push(buildAgentsSection(agentSummary));
+    sections.push(buildEnvironmentSection(environmentSummary));
+    sections.push(buildEvalsSection(evalSummary));
+    sections.push(buildSandboxSection(sandboxSummary));
+    sections.push([buildWorkspaceInitializedSection()]);
+    return renderTranscript({
+        sections,
+        hint: {
+            message: "To begin a run:\n  voratiq run --spec <path>",
+        },
+    });
+}
+function buildAgentsSection(summary) {
+    const lines = [];
+    if (summary.zeroDetections && summary.enabledAgents.length === 0) {
+        lines.push("No agents configured, unable to find agent binaries.");
+        lines.push(`To modify agent setup manually, edit \`${summary.configPath}\`.`);
+        return lines;
+    }
+    lines.push(`Agents configured (${formatEnabled(summary.enabledAgents)}).`);
+    lines.push(`To modify, edit \`${summary.configPath}\`.`);
+    return lines;
+}
+function buildEnvironmentSection(summary) {
+    const lines = [];
+    const details = summary.detectedEntries.length > 0
+        ? summary.detectedEntries.join(", ")
+        : "none";
+    lines.push(`Environment configured (${details}).`);
+    lines.push(`To modify, edit \`${summary.configPath}\`.`);
+    return lines;
+}
+function buildEvalsSection(summary) {
+    const lines = [];
+    if (summary.configuredEvals.length === 0) {
+        lines.push("No evals configured, unable to detect project tooling yet.");
+        lines.push(`To modify eval setup manually, edit \`${summary.configPath}\`.`);
+        return lines;
+    }
+    lines.push(`Evals configured (${formatEnabled(summary.configuredEvals)}).`);
+    lines.push(`To modify, edit \`${summary.configPath}\`.`);
+    return lines;
+}
+function buildSandboxSection(summary) {
+    return ["Sandbox configured.", `To modify, edit \`${summary.configPath}\`.`];
+}
+function buildWorkspaceInitializedSection() {
+    return colorize("Voratiq initialized.", "green");
+}
+function formatEnabled(values) {
+    return values.length > 0 ? values.join(", ") : "none";
+}

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

@@ -0,0 +1,3 @@
+import type { RunRecord } from "../../records/types.js";
+export declare function renderRunList(records: readonly RunRecord[]): string;
+export declare function renderListTranscript(records: readonly RunRecord[]): string;

package/dist/render/transcripts/list.js

@@ -0,0 +1,44 @@
+import { formatRunTimestamp } from "../utils/records.js";
+import { renderTable } from "../utils/table.js";
+import { renderTranscript } from "../utils/transcript.js";
+export function renderRunList(records) {
+    const rows = records.map((record) => ({
+        run: record.runId,
+        status: record.status.toUpperCase(),
+        spec: record.spec.path,
+        created: formatRunTimestamp(record.createdAt),
+    }));
+    const columns = [
+        { header: "RUN", accessor: (row) => row.run },
+        {
+            header: "STATUS",
+            accessor: (row) => row.status,
+        },
+        { header: "SPEC", accessor: (row) => row.spec },
+        {
+            header: "CREATED",
+            accessor: (row) => row.created,
+        },
+    ];
+    const lines = renderTable({
+        columns,
+        rows,
+    });
+    return lines.join("\n");
+}
+export function renderListTranscript(records) {
+    if (records.length === 0) {
+        return "";
+    }
+    const tableOutput = renderRunList(records);
+    const sections = [];
+    if (tableOutput.trim().length > 0) {
+        sections.push(tableOutput.split("\n"));
+    }
+    return renderTranscript({
+        sections,
+        hint: {
+            message: "To review a run in more detail:\n  voratiq review --run <run-id>",
+        },
+    });
+}

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

@@ -0,0 +1,16 @@
+import type { PruneResult } from "../../commands/prune/types.js";
+import type { RunStatus } from "../../status/index.js";
+export interface PruneConfirmationPrefaceOptions {
+    runId: string;
+    specPath: string;
+    runStatus: RunStatus;
+    createdAt: string;
+    runPath?: string;
+    workspaces: readonly string[];
+    directories: readonly string[];
+    branches: readonly string[];
+    purge: boolean;
+    previouslyDeletedAt?: string;
+}
+export declare function buildPruneConfirmationPreface(options: PruneConfirmationPrefaceOptions): string[];
+export declare function renderPruneTranscript(result: PruneResult): string;

package/dist/render/transcripts/prune.js

@@ -0,0 +1,50 @@
+import { colorize } from "../../utils/colors.js";
+import { formatRunTimestamp } from "../utils/records.js";
+import { buildRunMetadataSection } from "../utils/runs.js";
+import { renderTranscript } from "../utils/transcript.js";
+export function buildPruneConfirmationPreface(options) {
+    const { runId, specPath, runStatus, createdAt, runPath, workspaces, directories, branches, purge, previouslyDeletedAt, } = options;
+    const introLines = buildRunMetadataSection({
+        runId,
+        specPath,
+        status: runStatus,
+        workspacePath: runPath,
+        createdAt: formatRunTimestamp(createdAt),
+    });
+    const lines = ["", ...introLines];
+    if (previouslyDeletedAt) {
+        lines.push(`Marked deleted: ${previouslyDeletedAt}`, "Proceeding will update the deletion timestamp.");
+    }
+    if (purge) {
+        if (directories.length > 0) {
+            lines.push("", "Directories to be deleted:");
+            directories.forEach((directory) => lines.push(`  - ${directory}`));
+        }
+    }
+    else if (workspaces.length > 0) {
+        lines.push("", "Workspaces to be removed:");
+        workspaces.forEach((workspace) => lines.push(`  - ${workspace}`));
+    }
+    if (branches.length > 0) {
+        lines.push("", "Branches to be deleted:");
+        branches.forEach((branch) => lines.push(`  - ${branch}`));
+    }
+    lines.push("");
+    return lines;
+}
+export function renderPruneTranscript(result) {
+    if (result.status === "aborted") {
+        const sections = [
+            [colorize("Prune aborted; no changes were made.", "yellow")],
+        ];
+        return renderTranscript({
+            sections,
+            hint: {
+                message: `Re-run \`voratiq prune --run ${result.runId}\` when you are ready.`,
+            },
+        });
+    }
+    return renderTranscript({
+        sections: [[colorize("Run pruned successfully.", "green")]],
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { RunRecordEnhanced } from "../../records/enhanced.js";
+export declare function renderReviewTranscript(run: RunRecordEnhanced): string;

package/dist/render/transcripts/review.js

@@ -0,0 +1,36 @@
+import { colorize } from "../../utils/colors.js";
+import { formatRunWorkspaceRelative } from "../../workspace/layout.js";
+import { formatRunTimestamp } from "../utils/records.js";
+import { renderTranscriptWithMetadata } from "./shared.js";
+export function renderReviewTranscript(run) {
+    const enhanced = run;
+    const beforeAgents = enhanced.status === "pruned"
+        ? [
+            [
+                colorize("Note: Run was pruned; associated artifacts may no longer be available.", "yellow"),
+            ],
+        ]
+        : undefined;
+    const hasEvalIssues = enhanced.agents.some((agent) => agent.evals.some((evaluation) => evaluation.status === "failed" || evaluation.status === "errored"));
+    const warnings = hasEvalIssues
+        ? [
+            `${colorize("Warning:", "yellow")} Evaluation issues detected. Review logs before proceeding.`,
+        ]
+        : undefined;
+    return renderTranscriptWithMetadata({
+        metadata: {
+            runId: enhanced.runId,
+            status: enhanced.status,
+            specPath: enhanced.spec.path,
+            workspacePath: formatRunWorkspaceRelative(enhanced.runId),
+            createdAt: formatRunTimestamp(enhanced.createdAt),
+            baseRevisionSha: enhanced.baseRevisionSha,
+        },
+        agents: enhanced.agents,
+        beforeAgents,
+        warnings,
+        hint: {
+            message: `To integrate a solution:\n  voratiq apply --run ${run.runId} --agent <agent-id>`,
+        },
+    });
+}

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

@@ -0,0 +1,25 @@
+import type { AgentInvocationRecord, RunReport } from "../../records/types.js";
+type CliWriter = Pick<NodeJS.WriteStream, "write"> & {
+    isTTY?: boolean;
+};
+interface RunProgressContext {
+    runId: string;
+    status: RunReport["status"];
+    specPath: string;
+    workspacePath: string;
+    createdAt: string;
+    baseRevisionSha: string;
+}
+interface RunRendererOptions {
+    stdout?: CliWriter;
+    stderr?: CliWriter;
+    now?: () => number;
+}
+interface RunProgressRenderer {
+    begin(context?: RunProgressContext): void;
+    update(record: AgentInvocationRecord): void;
+    complete(report: RunReport): string;
+}
+export declare function createRunRenderer(options?: RunRendererOptions): RunProgressRenderer;
+export declare function buildRunTranscriptSections(report: RunReport): string[][];
+export type { RunProgressContext, RunProgressRenderer };