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

package/dist/commands/reduce/command.js

@@ -0,0 +1,145 @@
+import { verifyAgentProviders } from "../../agents/runtime/auth.js";
+import { executeCompetitionWithAdapter } from "../../competition/command-adapter.js";
+import { AgentNotFoundError } from "../../configs/agents/errors.js";
+import { loadEnvironmentConfig } from "../../configs/environment/loader.js";
+import { createReduceCompetitionAdapter, } from "../../domain/reduce/competition/adapter.js";
+import { flushReductionRecordBuffer, readReductionRecords, } from "../../domain/reduce/persistence/adapter.js";
+import { toErrorMessage } from "../../utils/errors.js";
+import { resolveEffectiveMaxParallel } from "../shared/max-parallel.js";
+import { resolveReductionCompetitors } from "../shared/resolve-reduction-competitors.js";
+import { generateSessionId } from "../shared/session-id.js";
+import { ReduceAgentNotFoundError, ReduceGenerationFailedError, ReducePreflightError, } from "./errors.js";
+import { assertReductionTargetEligible } from "./targets.js";
+export async function executeReduceCommand(input) {
+    const { root, specsFilePath, runsFilePath, reductionsFilePath, messagesFilePath, verificationsFilePath, target, agentIds, agentOverrideFlag, profileName, maxParallel: requestedMaxParallel, extraContextFiles = [], renderer, } = input;
+    await assertReductionTargetEligible({
+        root,
+        specsFilePath,
+        runsFilePath,
+        reductionsFilePath,
+        messagesFilePath,
+        verificationsFilePath,
+        target,
+    });
+    const reducers = resolveReduceAgents({
+        root,
+        agentIds,
+        agentOverrideFlag,
+        profileName,
+    });
+    await assertReducePreflight(reducers);
+    const environment = loadEnvironmentConfig({ root });
+    const reductionId = generateSessionId();
+    const createdAt = new Date().toISOString();
+    const effectiveMaxParallel = resolveEffectiveMaxParallel({
+        competitorCount: reducers.length,
+        requestedMaxParallel,
+    });
+    renderer?.begin({
+        reductionId,
+        createdAt,
+        workspacePath: `.voratiq/reduce/sessions/${reductionId}`,
+        status: "running",
+    });
+    let executionError;
+    let reductionResults;
+    try {
+        reductionResults = await executeCompetitionWithAdapter({
+            candidates: reducers,
+            maxParallel: effectiveMaxParallel,
+            adapter: createReduceCompetitionAdapter({
+                root,
+                reductionId,
+                createdAt,
+                reductionsFilePath,
+                specsFilePath,
+                runsFilePath,
+                messagesFilePath,
+                verificationsFilePath,
+                target,
+                environment,
+                extraContextFiles,
+                renderer,
+            }),
+        });
+    }
+    catch (error) {
+        executionError = error;
+    }
+    finally {
+        await flushReductionRecordBuffer({
+            reductionsFilePath,
+            sessionId: reductionId,
+        }).catch(() => { });
+    }
+    if (executionError) {
+        renderer?.complete("failed");
+        throw new ReduceGenerationFailedError([
+            `Reduction session \`${reductionId}\` failed: ${toErrorMessage(executionError)}`,
+        ]);
+    }
+    if (!reductionResults || reductionResults.length === 0) {
+        renderer?.complete("failed");
+        throw new ReduceGenerationFailedError([
+            `Reduction session \`${reductionId}\` did not produce any result.`,
+        ]);
+    }
+    const persistedRecord = await readReductionSessionRecord({
+        root,
+        reductionsFilePath,
+        reductionId,
+    });
+    if (!persistedRecord) {
+        renderer?.complete("failed");
+        throw new ReduceGenerationFailedError([
+            `Reduction session \`${reductionId}\` record not found after execution.`,
+        ]);
+    }
+    renderer?.complete(persistedRecord.status, {
+        startedAt: persistedRecord.startedAt,
+        completedAt: persistedRecord.completedAt,
+    });
+    return {
+        reductionId,
+        target,
+        reducerAgentIds: reducers.map((reducer) => reducer.id),
+        reductions: reductionResults,
+    };
+}
+function resolveReduceAgents(options) {
+    const { agentIds, root, agentOverrideFlag, profileName } = options;
+    try {
+        const resolution = resolveReductionCompetitors({
+            root,
+            cliAgentIds: agentIds,
+            cliOverrideFlag: agentOverrideFlag,
+            profileName,
+        });
+        return [...resolution.competitors];
+    }
+    catch (error) {
+        if (error instanceof AgentNotFoundError) {
+            throw new ReduceAgentNotFoundError(error.agentId);
+        }
+        throw error;
+    }
+}
+async function assertReducePreflight(agents) {
+    const providerIssues = await verifyAgentProviders(agents.map((agent) => ({
+        id: agent.id,
+        provider: agent.provider,
+    })));
+    if (providerIssues.length > 0) {
+        throw new ReducePreflightError(providerIssues, []);
+    }
+}
+async function readReductionSessionRecord(options) {
+    const { root, reductionsFilePath, reductionId } = options;
+    const records = await readReductionRecords({
+        root,
+        reductionsFilePath,
+        limit: 1,
+        predicate: (record) => record.sessionId === reductionId,
+    });
+    return records[0];
+}

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

@@ -0,0 +1,17 @@
+import { CliError } from "../../cli/errors.js";
+import { type PreflightIssue } from "../../competition/shared/preflight.js";
+export type ReducePreflightIssue = PreflightIssue;
+export declare class ReduceError extends CliError {
+    constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
+}
+export declare class ReduceAgentNotFoundError extends ReduceError {
+    readonly agentId: string;
+    constructor(agentId: string);
+}
+export declare class ReducePreflightError extends ReduceError {
+    readonly issues: readonly ReducePreflightIssue[];
+    constructor(issues: readonly ReducePreflightIssue[], hintLines?: readonly string[]);
+}
+export declare class ReduceGenerationFailedError extends ReduceError {
+    constructor(detailLines?: readonly string[]);
+}

package/dist/commands/reduce/errors.js

@@ -0,0 +1,32 @@
+import { CliError } from "../../cli/errors.js";
+import { formatPreflightIssueLines, PREFLIGHT_HINT, } from "../../competition/shared/preflight.js";
+export class ReduceError extends CliError {
+    constructor(headline, detailLines = [], hintLines) {
+        super(headline, detailLines, hintLines);
+        this.name = "ReduceError";
+    }
+}
+export class ReduceAgentNotFoundError extends ReduceError {
+    agentId;
+    constructor(agentId) {
+        super(`Agent \`${agentId}\` not found in \`agents.yaml\`.`, [], ["Add this agent to `agents.yaml`."]);
+        this.agentId = agentId;
+        this.name = "ReduceAgentNotFoundError";
+    }
+}
+export class ReducePreflightError extends ReduceError {
+    issues;
+    constructor(issues, hintLines = [PREFLIGHT_HINT]) {
+        super("Preflight failed. Aborting reduction.", formatPreflightIssueLines(issues), hintLines);
+        this.issues = Array.from(issues);
+        this.name = "ReducePreflightError";
+    }
+}
+export class ReduceGenerationFailedError extends ReduceError {
+    constructor(detailLines = []) {
+        super("Reduction failed.", detailLines, [
+            "Inspect reducer stderr logs to diagnose the failure.",
+        ]);
+        this.name = "ReduceGenerationFailedError";
+    }
+}

package/dist/commands/reduce/targets.d.ts

@@ -0,0 +1,11 @@
+import { type ReductionTarget } from "../../domain/reduce/model/types.js";
+export interface ReductionTargetValidationInput {
+    root: string;
+    specsFilePath: string;
+    runsFilePath: string;
+    reductionsFilePath: string;
+    messagesFilePath: string;
+    verificationsFilePath: string;
+    target: ReductionTarget;
+}
+export declare function assertReductionTargetEligible(input: ReductionTargetValidationInput): Promise<void>;

package/dist/commands/reduce/targets.js

@@ -0,0 +1,271 @@
+import { dirname } from "node:path";
+import { CliError } from "../../cli/errors.js";
+import { RunNotFoundCliError } from "../../cli/errors.js";
+import { TERMINAL_MESSAGE_STATUSES } from "../../domain/message/model/types.js";
+import { readMessageRecords } from "../../domain/message/persistence/adapter.js";
+import { TERMINAL_REDUCTION_STATUSES, } from "../../domain/reduce/model/types.js";
+import { readReductionRecords } from "../../domain/reduce/persistence/adapter.js";
+import { buildRunRecordView } from "../../domain/run/model/enhanced.js";
+import { RunRecordNotFoundError } from "../../domain/run/model/errors.js";
+import { fetchRunsSafely } from "../../domain/run/persistence/adapter.js";
+import { TERMINAL_SPEC_STATUSES } from "../../domain/spec/model/types.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 { TERMINAL_RUN_STATUSES } from "../../status/index.js";
+import { pathExists } from "../../utils/fs.js";
+import { normalizePathForDisplay, relativeToRoot, resolvePath, } from "../../utils/path.js";
+import { REDUCTION_DATA_FILENAME } from "../../workspace/structure.js";
+export async function assertReductionTargetEligible(input) {
+    const { target } = input;
+    switch (target.type) {
+        case "spec":
+            await assertSpecTargetEligible(input);
+            return;
+        case "run":
+            await assertRunTargetEligible(input);
+            return;
+        case "reduce":
+            await assertReductionTargetEligibleInternal(input);
+            return;
+        case "verify":
+            await assertVerificationTargetEligible(input);
+            return;
+        case "message":
+            await assertMessageTargetEligible(input);
+            return;
+    }
+}
+async function assertSpecTargetEligible(input) {
+    const { root, specsFilePath, target } = input;
+    const [record] = await readSpecRecords({
+        root,
+        specsFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.id,
+    });
+    if (!record) {
+        throw new CliError(`Spec session \`${target.id}\` not found.`, [], [
+            "Re-run `voratiq spec` or confirm the session id in `.voratiq/spec/index.json`.",
+        ]);
+    }
+    if (!TERMINAL_SPEC_STATUSES.includes(record.status)) {
+        throw new CliError(`Spec session \`${target.id}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the spec to finish or re-run `voratiq spec`."]);
+    }
+    if (record.status !== "succeeded") {
+        throw new CliError(`Spec session \`${target.id}\` did not succeed.`, [`Status: \`${record.status}\`.`], ["Re-run `voratiq spec` to generate a complete spec artifact."]);
+    }
+    const generatedAgents = record.agents.filter((agent) => agent.status === "succeeded" && agent.outputPath && agent.dataPath);
+    if (generatedAgents.length === 0) {
+        throw new CliError(`Spec session \`${target.id}\` has no complete generated artifacts.`, [], ["Re-run `voratiq spec` to regenerate the spec artifacts."]);
+    }
+    const missing = [];
+    for (const agent of generatedAgents) {
+        if (!agent.outputPath || !agent.dataPath)
+            continue;
+        const markdownAbsolute = resolvePath(root, agent.outputPath);
+        if (!(await pathExists(markdownAbsolute))) {
+            missing.push(normalizePathForDisplay(agent.outputPath));
+        }
+        const dataAbsolute = resolvePath(root, agent.dataPath);
+        if (!(await pathExists(dataAbsolute))) {
+            missing.push(normalizePathForDisplay(agent.dataPath));
+        }
+    }
+    if (missing.length > 0) {
+        throw new CliError(`Spec session \`${target.id}\` is missing artifact files.`, missing.map((path) => `Missing: \`${path}\`.`), ["Re-run `voratiq spec` to regenerate the spec artifacts."]);
+    }
+}
+async function assertRunTargetEligible(input) {
+    const { root, runsFilePath, target } = input;
+    const { records } = await fetchRunsSafely({
+        root,
+        runsFilePath,
+        runId: target.id,
+        filters: { includeDeleted: true },
+    }).catch((error) => {
+        if (error instanceof RunRecordNotFoundError) {
+            throw new RunNotFoundCliError(target.id);
+        }
+        throw error;
+    });
+    const record = records[0];
+    if (!record) {
+        throw new RunNotFoundCliError(target.id);
+    }
+    if (!isRunStatusCompleteForReduction(record.status)) {
+        throw new CliError(`Run \`${target.id}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the run to finish before reducing."]);
+    }
+    if (record.status === "aborted") {
+        throw new CliError(`Run \`${target.id}\` did not complete.`, [`Status: \`${record.status}\`.`], ["Re-run `voratiq run` to generate a complete artifact set."]);
+    }
+    assertRunArtifactsPresent(record.status, target.id);
+    const enhanced = await buildRunRecordView(record, { workspaceRoot: root });
+    const missing = await findMissingRunArtifacts(root, enhanced);
+    if (missing.length > 0) {
+        throw new CliError(`Run \`${target.id}\` is missing required artifacts.`, missing.map((path) => `Missing: \`${path}\`.`), ["Re-run `voratiq run` to regenerate the run artifacts."]);
+    }
+}
+function isRunStatusCompleteForReduction(status) {
+    return status === "pruned" || TERMINAL_RUN_STATUSES.includes(status);
+}
+function assertRunArtifactsPresent(status, runId) {
+    if (status === "succeeded" ||
+        status === "failed" ||
+        status === "errored" ||
+        status === "pruned") {
+        return;
+    }
+    throw new CliError(`Run \`${runId}\` is not eligible for reduction.`, [`Status: \`${status}\`.`], ["Re-run `voratiq run` to generate a complete artifact set."]);
+}
+async function assertVerificationTargetEligible(input) {
+    const { root, verificationsFilePath, target } = input;
+    const [record] = await readVerificationRecords({
+        root,
+        verificationsFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.id,
+    });
+    if (!record) {
+        throw new CliError(`Verification session \`${target.id}\` not found.`, [], [
+            "Re-run `voratiq verify` or confirm the session id in `.voratiq/verify/index.json`.",
+        ]);
+    }
+    if (!TERMINAL_VERIFICATION_STATUSES.includes(record.status)) {
+        throw new CliError(`Verification session \`${target.id}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the verification to finish or re-run `voratiq verify`."]);
+    }
+    if (record.status === "aborted") {
+        throw new CliError(`Verification session \`${target.id}\` did not complete.`, [`Status: \`${record.status}\`.`], ["Re-run `voratiq verify` to generate a complete artifact set."]);
+    }
+    const missing = await findMissingVerificationArtifacts(root, record.methods);
+    if (missing.length > 0) {
+        throw new CliError(`Verification session \`${target.id}\` is missing required artifacts.`, missing.map((path) => `Missing: \`${path}\`.`), ["Re-run `voratiq verify` to regenerate verification artifacts."]);
+    }
+}
+async function assertReductionTargetEligibleInternal(input) {
+    const { root, reductionsFilePath, target } = input;
+    if (!(await pathExists(reductionsFilePath))) {
+        throw new CliError(`Reduction session \`${target.id}\` not found.`, [], ["Confirm the session id in `.voratiq/reduce/index.json`."]);
+    }
+    const [record] = await readReductionRecords({
+        root,
+        reductionsFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.id,
+    });
+    if (!record) {
+        throw new CliError(`Reduction session \`${target.id}\` not found.`, [], ["Confirm the session id in `.voratiq/reduce/index.json`."]);
+    }
+    if (!TERMINAL_REDUCTION_STATUSES.includes(record.status)) {
+        throw new CliError(`Reduction session \`${target.id}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the reduction to finish before reducing."]);
+    }
+    if (record.status !== "succeeded") {
+        throw new CliError(`Reduction session \`${target.id}\` did not complete.`, [`Status: \`${record.status}\`.`], ["Re-run `voratiq reduce` to generate a complete artifact set."]);
+    }
+    const missing = await findMissingReductionArtifacts(root, record.reducers);
+    if (missing.length > 0) {
+        throw new CliError(`Reduction session \`${target.id}\` is missing required artifacts.`, missing.map((path) => `Missing: \`${path}\`.`), ["Re-run `voratiq reduce` to regenerate reduction artifacts."]);
+    }
+}
+async function assertMessageTargetEligible(input) {
+    const { root, messagesFilePath, target } = input;
+    const [record] = await readMessageRecords({
+        root,
+        messagesFilePath,
+        limit: 1,
+        predicate: (entry) => entry.sessionId === target.id,
+    });
+    if (!record) {
+        throw new CliError(`Message session \`${target.id}\` not found.`, [], [
+            "Re-run `voratiq message` or confirm the session id in `.voratiq/message/index.json`.",
+        ]);
+    }
+    if (!TERMINAL_MESSAGE_STATUSES.includes(record.status)) {
+        throw new CliError(`Message session \`${target.id}\` is not complete.`, [`Status: \`${record.status}\`.`], ["Wait for the message to finish before reducing."]);
+    }
+    if (record.status !== "succeeded") {
+        throw new CliError(`Message session \`${target.id}\` did not complete.`, [`Status: \`${record.status}\`.`], ["Re-run `voratiq message` to generate a complete artifact set."]);
+    }
+    const generatedRecipients = record.recipients.filter((recipient) => recipient.status === "succeeded" &&
+        typeof recipient.outputPath === "string");
+    if (generatedRecipients.length === 0) {
+        throw new CliError(`Message session \`${target.id}\` has no generated artifacts.`, [], ["Re-run `voratiq message` to regenerate the message artifacts."]);
+    }
+    const missing = await findMissingMessageArtifacts(root, generatedRecipients);
+    if (missing.length > 0) {
+        throw new CliError(`Message session \`${target.id}\` is missing required artifacts.`, missing.map((path) => `Missing: \`${path}\`.`), ["Re-run `voratiq message` to regenerate the message artifacts."]);
+    }
+}
+async function findMissingVerificationArtifacts(root, methods) {
+    const missing = [];
+    const seen = new Set();
+    for (const method of methods) {
+        if (!method.artifactPath) {
+            continue;
+        }
+        const artifactPath = normalizePathForDisplay(method.artifactPath);
+        const artifactAbsolute = resolvePath(root, artifactPath);
+        if (!(await pathExists(artifactAbsolute))) {
+            registerMissing(missing, seen, artifactPath);
+        }
+    }
+    return missing;
+}
+async function findMissingReductionArtifacts(root, reducers) {
+    const missing = [];
+    const seen = new Set();
+    for (const reducer of reducers) {
+        const outputPath = reducer.outputPath;
+        const outputAbsolute = resolvePath(root, outputPath);
+        if (!(await pathExists(outputAbsolute))) {
+            registerMissing(missing, seen, outputPath);
+        }
+        const dataPath = reducer.dataPath ??
+            normalizePathForDisplay(relativeToRoot(root, resolvePath(root, dirname(outputPath), REDUCTION_DATA_FILENAME)));
+        const dataAbsolute = resolvePath(root, dataPath);
+        if (!(await pathExists(dataAbsolute))) {
+            registerMissing(missing, seen, dataPath);
+        }
+    }
+    return missing;
+}
+async function findMissingMessageArtifacts(root, recipients) {
+    const missing = [];
+    const seen = new Set();
+    for (const recipient of recipients) {
+        const outputPath = recipient.outputPath;
+        const outputAbsolute = resolvePath(root, outputPath);
+        if (!(await pathExists(outputAbsolute))) {
+            registerMissing(missing, seen, outputPath);
+        }
+    }
+    return missing;
+}
+async function findMissingRunArtifacts(root, run) {
+    const missing = [];
+    const seen = new Set();
+    const specAbsolute = resolvePath(root, run.spec.path);
+    if (!(await pathExists(specAbsolute))) {
+        registerMissing(missing, seen, normalizePathForDisplay(run.spec.path));
+    }
+    for (const agent of run.agents) {
+        const candidatePaths = [agent.assets.diffPath, agent.assets.summaryPath];
+        for (const candidatePath of candidatePaths) {
+            if (!candidatePath) {
+                continue;
+            }
+            const absolute = resolvePath(root, candidatePath);
+            if (!(await pathExists(absolute))) {
+                registerMissing(missing, seen, normalizePathForDisplay(candidatePath));
+            }
+        }
+    }
+    return missing;
+}
+function registerMissing(missing, seen, path) {
+    if (seen.has(path)) {
+        return;
+    }
+    seen.add(path);
+    missing.push(path);
+}

package/dist/commands/root-launcher/command.d.ts

@@ -0,0 +1,31 @@
+import { type CommandOutputWriter } from "../../cli/output.js";
+import { loadAgentCatalogDiagnostics } from "../../configs/agents/loader.js";
+import { prepareNativeInteractiveSession, spawnPreparedInteractiveSession } from "../../interactive/index.js";
+import { resolveCliContext } from "../../preflight/index.js";
+import type { VoratiqCliTarget } from "../../utils/voratiq-cli-target.js";
+export interface RootLauncherPromptOptions {
+    message: string;
+}
+export interface RootLauncherConfirmOptions {
+    message: string;
+    defaultValue?: boolean;
+    prefaceLines?: readonly string[];
+}
+export interface RootLauncherWorkflow {
+    prompt(options: RootLauncherPromptOptions): Promise<string>;
+    confirm(options: RootLauncherConfirmOptions): Promise<boolean>;
+    close(): void;
+}
+export interface RootLauncherWorkflowFactoryOptions {
+    onUnavailable: () => never;
+}
+export interface RootLauncherCommandOptions {
+    resolveContext?: typeof resolveCliContext;
+    loadDiagnostics?: typeof loadAgentCatalogDiagnostics;
+    createWorkflow?: (options: RootLauncherWorkflowFactoryOptions) => RootLauncherWorkflow;
+    prepareSession?: (options: Parameters<typeof prepareNativeInteractiveSession>[0]) => ReturnType<typeof prepareNativeInteractiveSession>;
+    spawnSession?: (prepared: Parameters<typeof spawnPreparedInteractiveSession>[0], options: Parameters<typeof spawnPreparedInteractiveSession>[1]) => ReturnType<typeof spawnPreparedInteractiveSession>;
+    selfCliTarget?: VoratiqCliTarget;
+    writeOutput?: CommandOutputWriter;
+}
+export declare function runRootLauncherCommand(options: RootLauncherCommandOptions): Promise<void>;