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

package/dist/commands/auto/command.js

@@ -0,0 +1,433 @@
+import { classifyAutoVerificationSelection } from "../../policy/index.js";
+import { mapRunStatusToExitCode } from "../../status/index.js";
+import { HintedError, toErrorMessage } from "../../utils/errors.js";
+import { validateAutoCommandOptions } from "./validation.js";
+export async function executeAutoCommand(options, dependencies) {
+    assertAutoOptionCompatibility(options);
+    const hasDescription = typeof options.description === "string" &&
+        options.description.trim().length > 0;
+    const description = typeof options.description === "string" ? options.description : undefined;
+    const now = dependencies.now ?? Date.now.bind(Date);
+    const overallStart = now();
+    const events = [];
+    let bodyOutputEmitted = false;
+    const recordEvent = (event) => {
+        events.push(event);
+        if (event.kind === "body") {
+            bodyOutputEmitted = true;
+        }
+        dependencies.onEvent?.(event);
+    };
+    let hardFailure = false;
+    let actionRequired = false;
+    let actionRequiredDetail;
+    let specStartedAt;
+    let specStatus = "skipped";
+    let specPath;
+    let specDetail;
+    let specSessionId;
+    let runStartedAt;
+    let runStatus = "skipped";
+    let runId;
+    let runDetail;
+    let runRecordStatus;
+    let runCreatedAt;
+    let runSpecPath;
+    let runBaseRevisionSha;
+    let verifyStartedAt;
+    let verifyStatus = "skipped";
+    let verifyDetail;
+    let verifySelection;
+    let applyStartedAt;
+    let applyStatus = "skipped";
+    let applyAgentId;
+    let applyDetail;
+    const markActionRequired = (detail) => {
+        actionRequired = true;
+        actionRequiredDetail = detail;
+        applyStatus = "skipped";
+        applyDetail = detail;
+        recordEvent({
+            kind: "action_required",
+            detail,
+            separateWithDivider: bodyOutputEmitted,
+        });
+    };
+    let resolvedSpecPath = options.specPath;
+    if (hasDescription && description) {
+        specStartedAt = now();
+        try {
+            const specResult = await dependencies.runSpecStage({
+                description,
+                profile: options.profile,
+                maxParallel: options.maxParallel,
+                suppressHint: true,
+            });
+            specStatus = "succeeded";
+            specSessionId = specResult.sessionId;
+            recordEvent({ kind: "body", body: specResult.body });
+        }
+        catch (error) {
+            specStatus = "failed";
+            specDetail = toHeadline(error);
+            hardFailure = true;
+            recordEvent({ kind: "error", error });
+        }
+    }
+    if (!hardFailure && !actionRequired && hasDescription) {
+        if (!specSessionId) {
+            specStatus = "failed";
+            specDetail = "Spec stage did not return a session id.";
+            hardFailure = true;
+        }
+        else {
+            try {
+                const specVerifyResult = await dependencies.runVerifyStage({
+                    target: {
+                        kind: "spec",
+                        sessionId: specSessionId,
+                    },
+                    agentIds: options.verifyAgentIds
+                        ? [...options.verifyAgentIds]
+                        : undefined,
+                    agentOverrideFlag: "--verify-agent",
+                    profile: options.profile,
+                    maxParallel: options.maxParallel,
+                    suppressHint: true,
+                });
+                recordEvent({
+                    kind: "body",
+                    body: specVerifyResult.body,
+                    stderr: specVerifyResult.stderr,
+                    exitCode: specVerifyResult.exitCode,
+                });
+                if (specVerifyResult.exitCode === 1) {
+                    specStatus = "failed";
+                    specDetail = "One or more spec verifiers failed.";
+                    hardFailure = true;
+                }
+                else if (typeof specVerifyResult.selectedSpecPath === "string" &&
+                    specVerifyResult.selectedSpecPath.trim().length > 0) {
+                    resolvedSpecPath = specVerifyResult.selectedSpecPath;
+                    specPath = specVerifyResult.selectedSpecPath;
+                }
+                else if (specVerifyResult.selection?.state === "resolvable") {
+                    specStatus = "failed";
+                    specDetail =
+                        "Spec verification returned a resolvable selection without a selected spec path.";
+                    hardFailure = true;
+                }
+                else {
+                    const specSelectionDisposition = classifyAutoVerificationSelection({
+                        targetKind: "spec",
+                        selection: specVerifyResult.selection,
+                    });
+                    if (specSelectionDisposition.kind !== "action_required") {
+                        throw new Error("Spec verification without a selected spec path must require manual action.");
+                    }
+                    specDetail = specSelectionDisposition.detail;
+                    markActionRequired(specSelectionDisposition.detail);
+                }
+            }
+            catch (error) {
+                specStatus = "failed";
+                specDetail = toHeadline(error);
+                hardFailure = true;
+                recordEvent({ kind: "error", error });
+            }
+        }
+    }
+    if (!resolvedSpecPath && !hardFailure && !actionRequired && hasDescription) {
+        specStatus = "failed";
+        specDetail = "Spec verification did not select a spec path.";
+        hardFailure = true;
+    }
+    if (!hardFailure && !actionRequired && resolvedSpecPath) {
+        runStartedAt = now();
+        try {
+            const runResult = await dependencies.runRunStage({
+                specPath: resolvedSpecPath,
+                agentIds: options.runAgentIds ? [...options.runAgentIds] : undefined,
+                agentOverrideFlag: "--run-agent",
+                profile: options.profile,
+                maxParallel: options.maxParallel,
+                branch: options.branch,
+            });
+            const expectedRunExitCode = mapRunStatusToExitCode(runResult.report.status);
+            const resolvedRunExitCode = typeof runResult.exitCode === "number"
+                ? runResult.exitCode
+                : expectedRunExitCode;
+            if (typeof runResult.exitCode === "number" &&
+                runResult.exitCode !== expectedRunExitCode) {
+                throw new HintedError("Run status/exit code mismatch.", {
+                    detailLines: [
+                        `Status: \`${runResult.report.status}\`.`,
+                        `Exit code: ${runResult.exitCode}.`,
+                    ],
+                    hintLines: ["Re-run the command."],
+                });
+            }
+            runStatus = resolvedRunExitCode === 0 ? "succeeded" : "failed";
+            runId = runResult.report.runId;
+            runRecordStatus = runResult.report.status;
+            runCreatedAt = runResult.report.createdAt;
+            runSpecPath = runResult.report.spec?.path;
+            runBaseRevisionSha = runResult.report.baseRevisionSha;
+            if (runStatus === "failed") {
+                const statusDetail = runRecordStatus
+                    ? `status \`${runRecordStatus}\``
+                    : "a non-success status";
+                runDetail =
+                    runDetail ??
+                        `Run completed with ${statusDetail} (exit code ${resolvedRunExitCode}).`;
+                hardFailure = true;
+            }
+            recordEvent({
+                kind: "body",
+                body: runResult.body,
+                exitCode: runResult.exitCode,
+            });
+        }
+        catch (error) {
+            runStatus = "failed";
+            runDetail = toHeadline(error);
+            hardFailure = true;
+            recordEvent({ kind: "error", error });
+        }
+    }
+    const shouldAttemptVerifyRun = runId !== undefined &&
+        (!hardFailure || (!hasDescription && runStatus !== "skipped"));
+    if (shouldAttemptVerifyRun && runId) {
+        verifyStartedAt = now();
+        try {
+            const verifyResult = await dependencies.runVerifyStage({
+                target: {
+                    kind: "run",
+                    sessionId: runId,
+                },
+                agentIds: options.verifyAgentIds
+                    ? [...options.verifyAgentIds]
+                    : undefined,
+                agentOverrideFlag: "--verify-agent",
+                profile: options.profile,
+                maxParallel: options.maxParallel,
+                suppressHint: options.apply === true,
+            });
+            verifyStatus = "succeeded";
+            verifySelection = verifyResult.selection;
+            if (verifyResult.exitCode === 1) {
+                verifyStatus = "failed";
+                verifyDetail = "One or more verifiers failed.";
+                hardFailure = true;
+            }
+            recordEvent({
+                kind: "body",
+                body: verifyResult.body,
+                stderr: verifyResult.stderr,
+                exitCode: verifyResult.exitCode,
+            });
+            for (const warning of verifyResult.selectionWarnings ?? []) {
+                verifyDetail = warning;
+                recordEvent({
+                    kind: "warning",
+                    detail: warning,
+                    separateWithDivider: bodyOutputEmitted,
+                });
+            }
+            if (verifySelection?.state === "unresolved") {
+                const verifySelectionDisposition = classifyAutoVerificationSelection({
+                    targetKind: "run",
+                    selection: verifySelection,
+                });
+                applyAutoVerificationSelectionDisposition({
+                    disposition: verifySelectionDisposition,
+                    onActionRequired: markActionRequired,
+                    onVerifyDetail: (detail) => {
+                        verifyDetail = detail;
+                    },
+                });
+            }
+        }
+        catch (error) {
+            verifyStatus = "failed";
+            verifyDetail = toHeadline(error);
+            hardFailure = true;
+            recordEvent({ kind: "error", error });
+        }
+    }
+    if (options.apply &&
+        runId &&
+        verifyStatus === "succeeded" &&
+        !actionRequired &&
+        (!hasDescription || runStatus === "succeeded")) {
+        applyStartedAt = now();
+        try {
+            if (!verifySelection) {
+                throw new HintedError("Verify stage did not return a selection policy.", {
+                    hintLines: [
+                        "Re-run `voratiq verify` to regenerate verification data.",
+                    ],
+                });
+            }
+            classifyAutoVerificationSelection({
+                targetKind: "run",
+                selection: verifySelection,
+            });
+            if (verifySelection.state !== "resolvable") {
+                throw new HintedError("Verify stage did not return a resolvable selection.", {
+                    hintLines: [
+                        "Re-run `voratiq verify` to inspect the unresolved decision.",
+                    ],
+                });
+            }
+            else {
+                const applyResult = await dependencies.runApplyStage({
+                    runId,
+                    agentId: verifySelection.selectedCanonicalAgentId,
+                    commit: options.commit ?? false,
+                });
+                applyStatus = "succeeded";
+                applyAgentId = verifySelection.selectedCanonicalAgentId;
+                recordEvent({
+                    kind: "body",
+                    body: applyResult.body,
+                    exitCode: applyResult.exitCode,
+                });
+                if (applyResult.exitCode === 1) {
+                    applyStatus = "failed";
+                    applyDetail = "Apply stage reported a non-zero exit code.";
+                    hardFailure = true;
+                }
+            }
+        }
+        catch (error) {
+            applyStatus = "failed";
+            applyDetail = toHeadline(error);
+            hardFailure = true;
+            recordEvent({ kind: "error", error });
+        }
+    }
+    const overallDurationMs = now() - overallStart;
+    const specDurationMs = specStartedAt !== undefined ? now() - specStartedAt : undefined;
+    const runDurationMs = runStartedAt !== undefined ? now() - runStartedAt : undefined;
+    const verifyDurationMs = verifyStartedAt !== undefined ? now() - verifyStartedAt : undefined;
+    const applyDurationMs = applyStartedAt !== undefined ? now() - applyStartedAt : undefined;
+    const autoStatus = resolveAutoTerminalStatus({
+        hardFailure,
+        actionRequired,
+    });
+    const autoDetail = resolveAutoTerminalDetail({
+        status: autoStatus,
+        actionRequiredDetail,
+        applyDetail,
+        verifyDetail,
+        runDetail,
+        specDetail,
+    });
+    const normalizedApplyDetail = truncateOutcomeDetail(applyDetail);
+    const exitCode = mapAutoTerminalStatusToExitCode(autoStatus);
+    return {
+        exitCode,
+        runId,
+        ...(applyAgentId ? { appliedAgentId: applyAgentId } : {}),
+        auto: {
+            status: autoStatus,
+            ...(autoDetail ? { detail: autoDetail } : {}),
+        },
+        apply: {
+            status: applyStatus,
+            ...(normalizedApplyDetail ? { detail: normalizedApplyDetail } : {}),
+        },
+        summary: {
+            status: autoStatus,
+            totalDurationMs: overallDurationMs,
+            spec: {
+                status: specStatus,
+                ...(typeof specDurationMs === "number"
+                    ? { durationMs: specDurationMs }
+                    : {}),
+                ...(specPath ? { specPath } : {}),
+                ...(specDetail ? { detail: specDetail } : {}),
+            },
+            run: {
+                status: runStatus,
+                ...(typeof runDurationMs === "number"
+                    ? { durationMs: runDurationMs }
+                    : {}),
+                ...(runId ? { runId } : {}),
+                ...(runRecordStatus ? { runStatus: runRecordStatus } : {}),
+                ...(runCreatedAt ? { createdAt: runCreatedAt } : {}),
+                ...(runSpecPath ? { specPath: runSpecPath } : {}),
+                ...(runBaseRevisionSha ? { baseRevisionSha: runBaseRevisionSha } : {}),
+                ...(runDetail ? { detail: runDetail } : {}),
+            },
+            verify: {
+                status: verifyStatus,
+                ...(typeof verifyDurationMs === "number"
+                    ? { durationMs: verifyDurationMs }
+                    : {}),
+                ...(verifyDetail ? { detail: verifyDetail } : {}),
+            },
+            apply: {
+                status: applyStatus,
+                ...(typeof applyDurationMs === "number"
+                    ? { durationMs: applyDurationMs }
+                    : {}),
+                ...(applyAgentId ? { agentId: applyAgentId } : {}),
+                ...(normalizedApplyDetail ? { detail: normalizedApplyDetail } : {}),
+            },
+        },
+        events,
+    };
+}
+function assertAutoOptionCompatibility(options) {
+    validateAutoCommandOptions(options);
+}
+function resolveAutoTerminalStatus(options) {
+    if (options.hardFailure) {
+        return "failed";
+    }
+    if (options.actionRequired) {
+        return "action_required";
+    }
+    return "succeeded";
+}
+function mapAutoTerminalStatusToExitCode(status) {
+    return status === "succeeded" ? 0 : 1;
+}
+function truncateOutcomeDetail(detail) {
+    if (!detail) {
+        return undefined;
+    }
+    const trimmed = detail.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    return trimmed.length > 256 ? trimmed.slice(0, 256) : trimmed;
+}
+function resolveAutoTerminalDetail(options) {
+    if (options.status === "action_required") {
+        return truncateOutcomeDetail(options.actionRequiredDetail ?? options.applyDetail);
+    }
+    if (options.status === "failed") {
+        return truncateOutcomeDetail(options.applyDetail ??
+            options.verifyDetail ??
+            options.runDetail ??
+            options.specDetail);
+    }
+    return undefined;
+}
+function toHeadline(error) {
+    return error instanceof HintedError ? error.headline : toErrorMessage(error);
+}
+function applyAutoVerificationSelectionDisposition(options) {
+    const { disposition, onVerifyDetail, onActionRequired } = options;
+    switch (disposition.kind) {
+        case "proceed":
+            return;
+        case "action_required":
+            onVerifyDetail(disposition.detail);
+            onActionRequired(disposition.detail);
+            return;
+    }
+}

package/dist/commands/auto/errors.d.ts

@@ -0,0 +1,19 @@
+import { CliError } from "../../cli/errors.js";
+export declare class AutoPreflightError extends CliError {
+    constructor(issues: ReadonlyArray<{
+        kind: "missing-config-entry";
+        stage: "spec" | "run";
+        template: "spec-verification" | "run-verification";
+    } | {
+        kind: "missing-template";
+        stage: "spec" | "run";
+        template: "spec-verification" | "run-verification";
+        templatePath: string;
+    } | {
+        kind: "incomplete-template";
+        stage: "spec" | "run";
+        template: "spec-verification" | "run-verification";
+        templatePath: string;
+        missingFiles: readonly string[];
+    }>);
+}

package/dist/commands/auto/errors.js

@@ -0,0 +1,19 @@
+import { CliError } from "../../cli/errors.js";
+export class AutoPreflightError extends CliError {
+    constructor(issues) {
+        const detailLines = issues.map((issue) => {
+            switch (issue.kind) {
+                case "missing-config-entry":
+                    return `Missing selector rubric \`${issue.template}\` in \`.voratiq/verification.yaml\` for ${issue.stage}-stage auto resolution.`;
+                case "missing-template":
+                    return `Missing selector template \`${issue.templatePath}/\` for ${issue.stage}-stage auto resolution.`;
+                case "incomplete-template":
+                    return `Incomplete selector template \`${issue.templatePath}/\` for ${issue.stage}-stage auto resolution; missing ${issue.missingFiles.map((file) => `\`${file}\``).join(", ")}.`;
+            }
+        });
+        super("Preflight failed. Aborting auto.", detailLines, [
+            "Run `voratiq init` from the repository root, then retry.",
+        ]);
+        this.name = "AutoPreflightError";
+    }
+}

package/dist/commands/auto/validation.d.ts

@@ -0,0 +1,14 @@
+import type { VerificationConfig } from "../../configs/verification/types.js";
+interface AutoSelectorValidationCommandInput {
+    description?: string;
+    specPath?: string;
+    apply?: boolean;
+    commit?: boolean;
+}
+export declare function validateAutoVerificationConfig(options: {
+    root: string;
+    command: AutoSelectorValidationCommandInput;
+    verificationConfig: VerificationConfig;
+}): Promise<void>;
+export declare function validateAutoCommandOptions(options: AutoSelectorValidationCommandInput): void;
+export {};

package/dist/commands/auto/validation.js

@@ -0,0 +1,90 @@
+import { join } from "node:path";
+import { HintedError } from "../../utils/errors.js";
+import { isDirectory, isFile } from "../../utils/fs.js";
+import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_VERIFICATION_TEMPLATES_DIR, } from "../../workspace/structure.js";
+import { AutoPreflightError } from "./errors.js";
+export async function validateAutoVerificationConfig(options) {
+    const requiredSelectors = resolveRequiredAutoSelectors(options.command);
+    const issues = [];
+    for (const requirement of requiredSelectors) {
+        if (!hasSelectorTemplate(options.verificationConfig, requirement)) {
+            issues.push({
+                kind: "missing-config-entry",
+                stage: requirement.stage,
+                template: requirement.template,
+            });
+            continue;
+        }
+        const templateIssue = await resolveTemplateIssue(options.root, requirement);
+        if (templateIssue) {
+            issues.push(templateIssue);
+        }
+    }
+    if (issues.length > 0) {
+        throw new AutoPreflightError(issues);
+    }
+}
+export function validateAutoCommandOptions(options) {
+    const hasSpecPath = typeof options.specPath === "string" && options.specPath.trim().length > 0;
+    const hasDescription = typeof options.description === "string" &&
+        options.description.trim().length > 0;
+    if (hasSpecPath === hasDescription) {
+        throw new HintedError("Exactly one of `--spec` or `--description` is required.", {
+            hintLines: ["Pass exactly one."],
+        });
+    }
+    if (options.commit && !options.apply) {
+        throw new HintedError("Option `--commit` requires `--apply`.", {
+            hintLines: ["Add `--apply` when using `--commit`."],
+        });
+    }
+}
+function resolveRequiredAutoSelectors(command) {
+    if (typeof command.description === "string" &&
+        command.description.trim().length > 0) {
+        return [
+            { stage: "spec", template: "spec-verification" },
+            { stage: "run", template: "run-verification" },
+        ];
+    }
+    if (typeof command.specPath === "string" &&
+        command.specPath.trim().length > 0) {
+        return [{ stage: "run", template: "run-verification" }];
+    }
+    return [];
+}
+function hasSelectorTemplate(verificationConfig, requirement) {
+    const stageRubrics = requirement.stage === "spec"
+        ? verificationConfig.spec.rubric
+        : verificationConfig.run.rubric;
+    return stageRubrics.some((rubric) => rubric.template === requirement.template);
+}
+async function resolveTemplateIssue(root, requirement) {
+    const templateRoot = resolveWorkspacePath(root, join(VORATIQ_VERIFICATION_TEMPLATES_DIR, requirement.template));
+    const templatePath = formatWorkspacePath(VORATIQ_VERIFICATION_TEMPLATES_DIR, requirement.template);
+    if (!(await isDirectory(templateRoot))) {
+        return {
+            kind: "missing-template",
+            stage: requirement.stage,
+            template: requirement.template,
+            templatePath,
+        };
+    }
+    const requiredFiles = ["prompt.md", "rubric.md", "schema.yaml"];
+    const missingFiles = [];
+    for (const file of requiredFiles) {
+        if (!(await isFile(join(templateRoot, file)))) {
+            missingFiles.push(file);
+        }
+    }
+    if (missingFiles.length === 0) {
+        return undefined;
+    }
+    return {
+        kind: "incomplete-template",
+        stage: requirement.stage,
+        template: requirement.template,
+        templatePath,
+        missingFiles,
+    };
+}

package/dist/commands/fetch.d.ts

@@ -1,8 +1,8 @@
-import type { RunRecord } from "../records/types.js";
+import type { RunRecord } from "../domain/run/model/types.js";
 export interface FetchRunsCLIOptions {
     root: string;
     runsFilePath: string;
     runId: string;
-    onDeleted: (runRecord: RunRecord) => Error;
+    onDeleted?: (runRecord: RunRecord) => Error;
 }
 export declare function fetchRunSafely(options: FetchRunsCLIOptions): Promise<RunRecord>;

package/dist/commands/fetch.js

@@ -1,6 +1,6 @@
-import { RunRecordNotFoundError } from "../records/errors.js";
-import { fetchRunsSafely } from "../records/persistence.js";
-import { RunNotFoundCliError } from "./errors.js";
+import { RunNotFoundCliError } from "../cli/errors.js";
+import { RunRecordNotFoundError } from "../domain/run/model/errors.js";
+import { fetchRunsSafely } from "../domain/run/persistence/adapter.js";
 export async function fetchRunSafely(options) {
     const { root, runsFilePath, runId, onDeleted } = options;
     const { records } = await fetchRunsSafely({
@@ -18,7 +18,7 @@ export async function fetchRunSafely(options) {
     if (!runRecord) {
         throw new RunNotFoundCliError(runId);
     }
-    if (runRecord.deletedAt) {
+    if (runRecord.deletedAt && onDeleted) {
         throw onDeleted(runRecord);
     }
     return runRecord;

package/dist/commands/init/agents.d.ts

@@ -1,3 +1,4 @@
+import { type AgentPreset } from "../../workspace/templates.js";
 import type { AgentInitSummary, InitConfigureOptions } from "./types.js";
 export declare const AGENTS_CONFIG_DISPLAY_PATH: string;
-export declare function configureAgents(root: string, options: InitConfigureOptions): Promise<AgentInitSummary>;
+export declare function configureAgents(root: string, preset: AgentPreset, options: InitConfigureOptions): Promise<AgentInitSummary>;