voratiq 0.1.0-beta.0

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

@@ -0,0 +1,35 @@
+import { CliError } from "../../cli/errors.js";
+export declare class ApplyError extends CliError {
+    constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
+}
+export declare class ApplyRunDeletedError extends ApplyError {
+    readonly runId: string;
+    constructor(runId: string);
+}
+export declare class ApplyRunMetadataCorruptedError extends ApplyError {
+    constructor(detail: string);
+}
+export declare class ApplyAgentNotFoundError extends ApplyError {
+    readonly runId: string;
+    readonly agentId: string;
+    constructor(runId: string, agentId: string);
+}
+export declare class ApplyAgentDiffNotRecordedError extends ApplyError {
+    readonly runId: string;
+    readonly agentId: string;
+    constructor(runId: string, agentId: string);
+}
+export declare class ApplyAgentDiffMissingOnDiskError extends ApplyError {
+    readonly diffPath: string;
+    constructor(diffPath: string);
+}
+export interface ApplyBaseMismatchOptions {
+    baseRevisionSha: string;
+    headRevision: string;
+}
+export declare class ApplyBaseMismatchError extends ApplyError {
+    constructor(options: ApplyBaseMismatchOptions);
+}
+export declare class ApplyPatchApplicationError extends ApplyError {
+    constructor(detail: string, diffPath: string, runId: string, agentId: string);
+}

package/dist/commands/apply/errors.js

@@ -0,0 +1,73 @@
+import { CliError } from "../../cli/errors.js";
+export class ApplyError extends CliError {
+    constructor(headline, detailLines = [], hintLines = []) {
+        super(headline, detailLines, hintLines);
+        this.name = "ApplyError";
+    }
+}
+export class ApplyRunDeletedError extends ApplyError {
+    runId;
+    constructor(runId) {
+        super(`Run ${runId} has been deleted.`, [], ["Re-run the spec to generate fresh artifacts before applying."]);
+        this.runId = runId;
+        this.name = "ApplyRunDeletedError";
+    }
+}
+export class ApplyRunMetadataCorruptedError extends ApplyError {
+    constructor(detail) {
+        super("Run history is corrupted; cannot apply.", [detail], [
+            "Inspect `.voratiq/runs/index.json` and the affected run directory under `.voratiq/runs/<id>` or regenerate the run with `voratiq run`.",
+        ]);
+        this.name = "ApplyRunMetadataCorruptedError";
+    }
+}
+export class ApplyAgentNotFoundError extends ApplyError {
+    runId;
+    agentId;
+    constructor(runId, agentId) {
+        super(`Agent ${agentId} not found in run ${runId}.`, [], [`To review run information: voratiq review --run ${runId}.`]);
+        this.runId = runId;
+        this.agentId = agentId;
+        this.name = "ApplyAgentNotFoundError";
+    }
+}
+export class ApplyAgentDiffNotRecordedError extends ApplyError {
+    runId;
+    agentId;
+    constructor(runId, agentId) {
+        super(`Agent ${agentId} did not record a diff for run ${runId}.`, [
+            `Select an agent that produced a diff via \`voratiq review --run ${runId}\`.`,
+        ]);
+        this.runId = runId;
+        this.agentId = agentId;
+        this.name = "ApplyAgentDiffNotRecordedError";
+    }
+}
+export class ApplyAgentDiffMissingOnDiskError extends ApplyError {
+    diffPath;
+    constructor(diffPath) {
+        super("Recorded diff is missing from disk.", [`Expected diff at ${diffPath} but it was not found.`], ["Ensure the run directory still exists or re-run the agents."]);
+        this.diffPath = diffPath;
+        this.name = "ApplyAgentDiffMissingOnDiskError";
+    }
+}
+export class ApplyBaseMismatchError extends ApplyError {
+    constructor(options) {
+        const { baseRevisionSha, headRevision } = options;
+        super(`Repository HEAD (${shortSha(headRevision)}) no longer matches the run's base revision (${shortSha(baseRevisionSha)}).`, [
+            "Reset to the recorded base or rerun the specification, or pass `--ignore-base-mismatch` to proceed at your own risk.",
+        ]);
+        this.name = "ApplyBaseMismatchError";
+    }
+}
+export class ApplyPatchApplicationError extends ApplyError {
+    constructor(detail, diffPath, runId, agentId) {
+        super("Failed to apply the recorded diff.", [detail, `Inspect the patch at ${diffPath} for additional context.`], [
+            `Resolve the conflict and rerun \`voratiq apply --run ${runId} --agent ${agentId}\`.`,
+        ]);
+        this.name = "ApplyPatchApplicationError";
+    }
+}
+function shortSha(sha) {
+    return sha.length > 12 ? sha.slice(0, 12) : sha;
+}

package/dist/commands/apply/types.d.ts

@@ -0,0 +1,13 @@
+import type { AgentInvocationRecord } from "../../records/types.js";
+import type { RunStatus } from "../../status/index.js";
+export interface ApplyResult {
+    runId: string;
+    specPath: string;
+    status: RunStatus;
+    createdAt: string;
+    baseRevisionSha: string;
+    headRevision: string;
+    agent: AgentInvocationRecord;
+    diffPath: string;
+    ignoredBaseMismatch: boolean;
+}

package/dist/commands/apply/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/errors.d.ts

@@ -0,0 +1,4 @@
+import { CliError } from "../cli/errors.js";
+export declare class RunNotFoundCliError extends CliError {
+    constructor(runId: string);
+}

package/dist/commands/errors.js

@@ -0,0 +1,7 @@
+import { CliError } from "../cli/errors.js";
+export class RunNotFoundCliError extends CliError {
+    constructor(runId) {
+        super(`Run ${runId} not found.`, ["To review past runs: voratiq list"]);
+        this.name = "RunNotFoundCliError";
+    }
+}

package/dist/commands/fetch.d.ts

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

package/dist/commands/fetch.js

@@ -0,0 +1,25 @@
+import { RunRecordNotFoundError } from "../records/errors.js";
+import { fetchRunsSafely } from "../records/persistence.js";
+import { RunNotFoundCliError } from "./errors.js";
+export async function fetchRunSafely(options) {
+    const { root, runsFilePath, runId, onDeleted } = options;
+    const { records } = await fetchRunsSafely({
+        root,
+        runsFilePath,
+        runId,
+        filters: { includeDeleted: true },
+    }).catch((error) => {
+        if (error instanceof RunRecordNotFoundError) {
+            throw new RunNotFoundCliError(runId);
+        }
+        throw error;
+    });
+    const runRecord = records[0];
+    if (!runRecord) {
+        throw new RunNotFoundCliError(runId);
+    }
+    if (runRecord.deletedAt) {
+        throw onDeleted(runRecord);
+    }
+    return runRecord;
+}

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

@@ -0,0 +1,3 @@
+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>;

package/dist/commands/init/agents.js

@@ -0,0 +1,159 @@
+import { readAgentsConfig } from "../../configs/agents/loader.js";
+import { renderAgentPromptPreface } from "../../render/transcripts/init.js";
+import { detectBinary } from "../../utils/binaries.js";
+import { isDefaultYamlTemplate, loadYamlConfig, persistYamlConfig, } from "../../utils/yaml.js";
+import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_AGENTS_FILE, } from "../../workspace/structure.js";
+import { buildDefaultAgentsTemplate, DEFAULT_AGENT_DEFAULTS, sanitizeAgentIdFromModel, serializeAgentsConfigEntries, } from "../../workspace/templates.js";
+export const AGENTS_CONFIG_DISPLAY_PATH = formatWorkspacePath(VORATIQ_AGENTS_FILE);
+export async function configureAgents(root, options) {
+    const filePath = resolveWorkspacePath(root, VORATIQ_AGENTS_FILE);
+    const defaultTemplate = buildDefaultAgentsTemplate();
+    const loadResult = await loadYamlConfig(filePath, readAgentsConfig);
+    const defaultStatus = isDefaultYamlTemplate(loadResult.snapshot, defaultTemplate);
+    const configCreated = !loadResult.snapshot.exists;
+    const canInteract = canConfirm(options);
+    if (!canInteract || (!defaultStatus && loadResult.snapshot.exists)) {
+        return buildAgentSummary(loadResult.config.agents, computeZeroDetections(loadResult.config.agents), configCreated, false);
+    }
+    const lifecycle = scanWorkspaceForAgentDefaults(loadResult.config, defaultStatus);
+    const configChanged = await applyAgentOperatorChoices(lifecycle, options);
+    const snapshotResult = finalizeAgentConfigSnapshot(lifecycle);
+    const updated = await persistYamlConfig({
+        filePath,
+        serialized: snapshotResult.serialized,
+        original: loadResult.snapshot,
+        defaultTemplate,
+        isDefaultTemplate: defaultStatus,
+    });
+    return buildAgentSummary(snapshotResult.entries, lifecycle.zeroDetections, configCreated, updated || configChanged);
+}
+function scanWorkspaceForAgentDefaults(config, isDefaultTemplate) {
+    const templatesById = new Map();
+    for (const entry of config.agents) {
+        templatesById.set(entry.id, entry);
+    }
+    const templateStates = [];
+    const templateIds = new Set();
+    const templateEntries = DEFAULT_AGENT_DEFAULTS.map((template) => ({
+        template,
+        defaultId: sanitizeAgentIdFromModel(template.model),
+    }));
+    for (const { template, defaultId } of templateEntries) {
+        templateIds.add(defaultId);
+        const existing = isDefaultTemplate
+            ? undefined
+            : templatesById.get(defaultId);
+        const detectedBinary = detectBinary(template.provider);
+        const baseEntry = existing ?? buildEntryFromTemplate(template, defaultId);
+        const entry = cloneAgentEntry(baseEntry);
+        entry.binary = detectedBinary ?? entry.binary ?? "";
+        entry.enabled = entry.enabled !== false;
+        templateStates.push({
+            template,
+            existing,
+            entry,
+            detectedBinary,
+        });
+    }
+    const userDefined = [];
+    for (const entry of config.agents) {
+        if (!templateIds.has(entry.id)) {
+            userDefined.push(cloneAgentEntry(entry));
+        }
+    }
+    const zeroDetections = templateStates.every((state) => !hasBinary(state.entry.binary));
+    return {
+        templates: templateStates,
+        userDefined,
+        zeroDetections,
+    };
+}
+function buildEntryFromTemplate(template, defaultId) {
+    return {
+        id: defaultId,
+        provider: template.provider,
+        model: template.model,
+        enabled: false,
+        binary: "",
+    };
+}
+function cloneAgentEntry(entry) {
+    return {
+        id: entry.id,
+        provider: entry.provider,
+        model: entry.model,
+        enabled: entry.enabled !== false,
+        binary: entry.binary ?? "",
+        extraArgs: entry.extraArgs && entry.extraArgs.length > 0
+            ? [...entry.extraArgs]
+            : undefined,
+    };
+}
+async function applyAgentOperatorChoices(state, options) {
+    const confirm = options.confirm;
+    if (!confirm) {
+        state.zeroDetections = state.templates.every((templateState) => !hasBinary(templateState.entry.binary));
+        return false;
+    }
+    let firstPrompt = true;
+    let changed = false;
+    for (const templateState of state.templates) {
+        const hasDetectedBinary = hasBinary(templateState.entry.binary);
+        if (!hasDetectedBinary) {
+            templateState.entry.enabled = false;
+            continue;
+        }
+        const initialEnabled = templateState.entry.enabled !== false;
+        const defaultValue = templateState.existing !== undefined
+            ? templateState.existing.enabled !== false
+            : true;
+        const prefaceLines = renderAgentPromptPreface({
+            agentId: templateState.entry.id,
+            binaryPath: templateState.entry.binary ?? "",
+            detected: hasDetectedBinary,
+            firstPrompt,
+        });
+        const shouldEnable = await confirm({
+            message: "Enable?",
+            defaultValue,
+            prefaceLines,
+        });
+        if (shouldEnable !== initialEnabled) {
+            changed = true;
+        }
+        templateState.entry.enabled = shouldEnable;
+        firstPrompt = false;
+    }
+    state.zeroDetections = state.templates.every((templateState) => !hasBinary(templateState.entry.binary));
+    return changed;
+}
+function buildFinalAgentEntries(state) {
+    const finalEntries = state.templates.map((templateState) => templateState.entry);
+    return [...finalEntries, ...state.userDefined];
+}
+function finalizeAgentConfigSnapshot(state) {
+    const entries = buildFinalAgentEntries(state);
+    const serialized = serializeAgentsConfigEntries(entries);
+    return { entries, serialized };
+}
+function buildAgentSummary(entries, zeroDetections, configCreated, configUpdated) {
+    const enabledAgents = entries
+        .filter((entry) => entry.enabled !== false)
+        .map((entry) => entry.id);
+    return {
+        configPath: AGENTS_CONFIG_DISPLAY_PATH,
+        enabledAgents,
+        zeroDetections,
+        configCreated,
+        configUpdated,
+    };
+}
+function hasBinary(binary) {
+    return Boolean(binary && binary.trim().length > 0);
+}
+function computeZeroDetections(entries) {
+    return !entries.some((entry) => hasBinary(entry.binary));
+}
+function canConfirm(options) {
+    return Boolean(options.confirm);
+}

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

@@ -0,0 +1,2 @@
+import type { InitCommandInput, InitCommandResult } from "./types.js";
+export declare function executeInitCommand(input: InitCommandInput): Promise<InitCommandResult>;

package/dist/commands/init/command.js

@@ -0,0 +1,40 @@
+import { writeCommandPreface } from "../../cli/output.js";
+import { buildInitializationPrompt } from "../../render/transcripts/init.js";
+import { createWorkspace } from "../../workspace/setup.js";
+import { formatWorkspacePath, VORATIQ_SANDBOX_FILE, } from "../../workspace/structure.js";
+import { configureAgents } from "./agents.js";
+import { configureEnvironment } from "./environment.js";
+import { configureEvals } from "./evals.js";
+export async function executeInitCommand(input) {
+    const { root, interactive, confirm, prompt } = input;
+    const workspaceResult = await createWorkspace(root);
+    const initializationPrompt = buildInitializationPrompt();
+    writeCommandPreface(initializationPrompt);
+    const agentSummary = await configureAgents(root, {
+        interactive,
+        confirm,
+    });
+    const environmentSummary = await configureEnvironment(root, {
+        interactive,
+        confirm,
+        prompt,
+    });
+    const evalSummary = await configureEvals(root, {
+        interactive,
+        confirm,
+    }, environmentSummary.config);
+    const sandboxSummary = buildSandboxSummary(workspaceResult);
+    return {
+        workspaceResult,
+        agentSummary,
+        environmentSummary,
+        evalSummary,
+        sandboxSummary,
+    };
+}
+function buildSandboxSummary(workspaceResult) {
+    const configPath = formatWorkspacePath(VORATIQ_SANDBOX_FILE);
+    const normalizedCreated = workspaceResult.createdFiles.map((file) => file.replace(/\\/g, "/"));
+    const configCreated = normalizedCreated.includes(configPath);
+    return { configPath, configCreated };
+}

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

@@ -0,0 +1,2 @@
+import type { EnvironmentInitSummary, InitConfigureOptions } from "./types.js";
+export declare function configureEnvironment(root: string, options: InitConfigureOptions): Promise<EnvironmentInitSummary>;

package/dist/commands/init/environment.js

@@ -0,0 +1,76 @@
+import { detectEnvironmentConfig } from "../../configs/environment/detect.js";
+import { readEnvironmentConfig, serializeEnvironmentConfig, } from "../../configs/environment/loader.js";
+import { getNodeDependencyRoots, getPythonEnvironmentPath, isNodeEnvironmentDisabled, isPythonEnvironmentDisabled, } from "../../configs/environment/types.js";
+import { loadYamlConfig, persistYamlConfig } from "../../utils/yaml.js";
+import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_ENVIRONMENT_FILE, } from "../../workspace/structure.js";
+import { buildDefaultEnvironmentTemplate } from "../../workspace/templates.js";
+const ENVIRONMENT_CONFIG_DISPLAY_PATH = formatWorkspacePath(VORATIQ_ENVIRONMENT_FILE);
+export async function configureEnvironment(root, options) {
+    const filePath = resolveWorkspacePath(root, VORATIQ_ENVIRONMENT_FILE);
+    const defaultTemplate = buildDefaultEnvironmentTemplate();
+    const loadResult = await loadYamlConfig(filePath, readEnvironmentConfig);
+    const existingConfig = loadResult.config;
+    const detection = await detectEnvironmentConfig({
+        root,
+        interactive: options.interactive,
+        promptPath: options.prompt ?? undefined,
+    });
+    const mergedConfig = mergeEnvironmentConfig(existingConfig, detection.config);
+    const finalSerialized = resolveSerializedConfig(mergedConfig, defaultTemplate);
+    const configUpdated = await persistYamlConfig({
+        filePath,
+        serialized: finalSerialized,
+        original: loadResult.snapshot,
+        defaultTemplate,
+    });
+    return {
+        configPath: ENVIRONMENT_CONFIG_DISPLAY_PATH,
+        detectedEntries: describeEnvironmentEntries(mergedConfig),
+        configCreated: !loadResult.snapshot.exists,
+        configUpdated,
+        config: mergedConfig,
+    };
+}
+function mergeEnvironmentConfig(existing, detected) {
+    const merged = { ...existing };
+    if (!isNodeEnvironmentDisabled(merged)) {
+        const detectedRoots = getNodeDependencyRoots(detected);
+        const existingRoots = getNodeDependencyRoots(merged);
+        if (detectedRoots.length > 0 && existingRoots.length === 0) {
+            merged.node = {
+                dependencyRoots: [...detectedRoots],
+            };
+        }
+    }
+    if (!isPythonEnvironmentDisabled(merged)) {
+        const detectedPath = getPythonEnvironmentPath(detected);
+        const existingPath = getPythonEnvironmentPath(merged);
+        if (detectedPath && !existingPath) {
+            merged.python = { path: detectedPath };
+        }
+    }
+    return merged;
+}
+function resolveSerializedConfig(config, defaultTemplate) {
+    const serialized = serializeEnvironmentConfig(config);
+    return serialized.trim().length > 0 ? serialized : defaultTemplate;
+}
+function describeEnvironmentEntries(config) {
+    const entries = [];
+    if (isNodeEnvironmentDisabled(config)) {
+        entries.push("node (disabled)");
+    }
+    else if (getNodeDependencyRoots(config).length > 0) {
+        entries.push("node");
+    }
+    if (isPythonEnvironmentDisabled(config)) {
+        entries.push("python (disabled)");
+    }
+    else {
+        const pythonPath = getPythonEnvironmentPath(config);
+        if (pythonPath) {
+            entries.push("python");
+        }
+    }
+    return entries;
+}

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

@@ -0,0 +1,4 @@
+import { type EnvironmentConfig } from "../../configs/environment/types.js";
+import type { EvalInitSummary, InitConfigureOptions } from "./types.js";
+export declare const EVALS_CONFIG_DISPLAY_PATH: string;
+export declare function configureEvals(root: string, options: InitConfigureOptions, environment: EnvironmentConfig): Promise<EvalInitSummary>;