voratiq 0.1.0-beta.0

package/dist/configs/agents/types.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const agentIdSchema: z.ZodString;
+export type AgentId = z.infer<typeof agentIdSchema>;
+export declare const agentConfigEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    binary: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    extraArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type AgentConfigEntry = z.infer<typeof agentConfigEntrySchema>;
+export declare const agentsConfigSchema: z.ZodObject<{
+    agents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        binary: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        extraArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AgentsConfig = z.infer<typeof agentsConfigSchema>;
+export declare const agentDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    binary: z.ZodString;
+    argv: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AgentDefinition = z.infer<typeof agentDefinitionSchema>;
+export declare const agentCatalogSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    binary: z.ZodString;
+    argv: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;
+export type AgentCatalog = z.infer<typeof agentCatalogSchema>;

package/dist/configs/agents/types.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export const agentIdSchema = z.string().regex(/^[a-z0-9_-]{1,32}$/u, {
+    message: "Agent id must match /^[a-z0-9_-]{1,32}$/",
+});
+export const agentConfigEntrySchema = z.object({
+    id: agentIdSchema,
+    provider: z.string().min(1, { message: "Agent provider cannot be empty" }),
+    model: z.string().min(1, { message: "Agent model cannot be empty" }),
+    enabled: z.boolean().optional().default(true),
+    binary: z.string().optional().default(""),
+    extraArgs: z
+        .array(z
+        .string()
+        .trim()
+        .min(1, { message: "`extraArgs` entries cannot be empty" }))
+        .nonempty({ message: "`extraArgs` must include at least one value" })
+        .optional(),
+});
+export const agentsConfigSchema = z.object({
+    agents: z.array(agentConfigEntrySchema).default([]),
+});
+export const agentDefinitionSchema = z.object({
+    id: agentIdSchema,
+    provider: z.string().min(1, { message: "Agent provider cannot be empty" }),
+    model: z.string().min(1, { message: "Agent model cannot be empty" }),
+    binary: z.string(),
+    argv: z
+        .array(z.string())
+        .min(1, { message: "Agent argv must include at least one argument" }),
+});
+export const agentCatalogSchema = z.array(agentDefinitionSchema);

package/dist/configs/environment/detect.d.ts

@@ -0,0 +1,17 @@
+import { type EnvironmentConfig } from "./types.js";
+export interface DetectEnvironmentOptions {
+    root: string;
+    interactive: boolean;
+    promptPath?: PromptPathHandler;
+}
+export type PromptPathHandler = (options: PromptPathOptions) => Promise<string>;
+export interface PromptPathOptions {
+    message: string;
+    defaultValue?: string;
+    prefaceLines?: string[];
+}
+export interface EnvironmentDetectionResult {
+    config: EnvironmentConfig;
+    detectedEntries: string[];
+}
+export declare function detectEnvironmentConfig(options: DetectEnvironmentOptions): Promise<EnvironmentDetectionResult>;

package/dist/configs/environment/detect.js

@@ -0,0 +1,79 @@
+import { stat } from "node:fs/promises";
+import { pathExists } from "../../utils/fs.js";
+import { resolvePath } from "../../utils/path.js";
+import { normalizeEnvironmentConfig } from "./types.js";
+const PYTHON_PATH_CANDIDATES = [".venv", "venv"];
+const PYTHON_MARKER_FILES = [
+    "pyproject.toml",
+    "requirements.txt",
+    "requirements-dev.txt",
+    "setup.cfg",
+    "setup.py",
+    "Pipfile",
+    "poetry.lock",
+    "uv.lock",
+];
+export async function detectEnvironmentConfig(options) {
+    const { root, interactive, promptPath } = options;
+    const entries = [];
+    const config = {};
+    const nodeModulesDetected = await detectNodeDependencies(root);
+    if (nodeModulesDetected) {
+        config.node = { dependencyRoots: ["node_modules"] };
+        entries.push("node");
+    }
+    const pythonPath = await detectPythonEnvironmentPath(root);
+    if (pythonPath) {
+        config.python = { path: pythonPath };
+        entries.push(`python.path=${pythonPath}`);
+    }
+    else if (interactive && promptPath && (await hasPythonMarkers(root))) {
+        const selection = (await promptPath({
+            message: "Enter the path to an existing Python virtual environment (press Enter to skip)",
+            defaultValue: ".venv",
+            prefaceLines: [
+                "",
+                "Detected Python project markers but no virtual environment directory.",
+            ],
+        })).trim();
+        if (selection.length > 0) {
+            config.python = { path: selection };
+            entries.push(`python.path=${selection}`);
+        }
+    }
+    return {
+        config: normalizeEnvironmentConfig(config),
+        detectedEntries: entries,
+    };
+}
+async function detectNodeDependencies(root) {
+    return pathExists(resolvePath(root, "node_modules"));
+}
+async function detectPythonEnvironmentPath(root) {
+    for (const candidate of PYTHON_PATH_CANDIDATES) {
+        const absolute = resolvePath(root, candidate);
+        if (await pathExists(absolute)) {
+            if (await isDirectorySafe(absolute)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+async function hasPythonMarkers(root) {
+    for (const marker of PYTHON_MARKER_FILES) {
+        if (await pathExists(resolvePath(root, marker))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function isDirectorySafe(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/configs/environment/errors.d.ts

@@ -0,0 +1,12 @@
+import { WorkspaceError } from "../../workspace/errors.js";
+export declare class EnvironmentConfigError extends WorkspaceError {
+    constructor(message: string);
+}
+export declare class MissingEnvironmentConfigError extends EnvironmentConfigError {
+    readonly filePath: string;
+    constructor(filePath: string);
+}
+export declare class EnvironmentConfigParseError extends EnvironmentConfigError {
+    readonly filePath: string;
+    constructor(filePath: string, detail?: string);
+}

package/dist/configs/environment/errors.js

@@ -0,0 +1,26 @@
+import { WorkspaceError } from "../../workspace/errors.js";
+const DEFAULT_ENVIRONMENT_ERROR_CONTEXT = "Invalid workspace environment configuration";
+export class EnvironmentConfigError extends WorkspaceError {
+    constructor(message) {
+        super(message);
+        this.name = "EnvironmentConfigError";
+    }
+}
+export class MissingEnvironmentConfigError extends EnvironmentConfigError {
+    filePath;
+    constructor(filePath) {
+        super(`Missing workspace environment configuration at ${filePath}`);
+        this.filePath = filePath;
+        this.name = "MissingEnvironmentConfigError";
+    }
+}
+export class EnvironmentConfigParseError extends EnvironmentConfigError {
+    filePath;
+    constructor(filePath, detail) {
+        super(detail
+            ? `${DEFAULT_ENVIRONMENT_ERROR_CONTEXT} (${filePath}): ${detail}`
+            : `${DEFAULT_ENVIRONMENT_ERROR_CONTEXT} at ${filePath}`);
+        this.filePath = filePath;
+        this.name = "EnvironmentConfigParseError";
+    }
+}

package/dist/configs/environment/loader.d.ts

@@ -0,0 +1,10 @@
+import { type EnvironmentConfig } from "./types.js";
+export declare const DEFAULT_ENVIRONMENT_FILE_DISPLAY: string;
+export interface LoadEnvironmentConfigOptions {
+    root?: string;
+    filePath?: string;
+    optional?: boolean;
+}
+export declare function loadEnvironmentConfig(options?: LoadEnvironmentConfigOptions): EnvironmentConfig;
+export declare function readEnvironmentConfig(content: string): EnvironmentConfig;
+export declare function serializeEnvironmentConfig(config: EnvironmentConfig): string;

package/dist/configs/environment/loader.js

@@ -0,0 +1,80 @@
+import { parseYamlDocument, } from "../../utils/yaml-reader.js";
+import { formatWorkspacePath, resolveWorkspacePath, VORATIQ_ENVIRONMENT_FILE, } from "../../workspace/structure.js";
+import { createConfigLoader } from "../shared/loader-factory.js";
+import { formatYamlErrorDetail } from "../shared/yaml-error-formatter.js";
+import { EnvironmentConfigParseError, MissingEnvironmentConfigError, } from "./errors.js";
+import { environmentConfigSchema, getNodeDependencyRoots, getPythonEnvironmentPath, isNodeEnvironmentDisabled, isPythonEnvironmentDisabled, normalizeEnvironmentConfig, } from "./types.js";
+export const DEFAULT_ENVIRONMENT_FILE_DISPLAY = formatWorkspacePath(VORATIQ_ENVIRONMENT_FILE);
+const DEFAULT_ENVIRONMENT_ERROR_CONTEXT = "Failed to parse workspace environment configuration";
+const loadEnvironmentConfigInternal = createConfigLoader({
+    resolveFilePath: (root, options) => options.filePath ?? resolveWorkspacePath(root, VORATIQ_ENVIRONMENT_FILE),
+    handleMissing: ({ filePath, options }) => {
+        if (options.optional) {
+            return {};
+        }
+        throw new MissingEnvironmentConfigError(filePath);
+    },
+    parse: (content, { filePath }) => {
+        try {
+            return readEnvironmentConfig(content);
+        }
+        catch (error) {
+            if (error instanceof EnvironmentConfigParseError) {
+                throw error;
+            }
+            throw new EnvironmentConfigParseError(filePath, error instanceof Error
+                ? error.message
+                : DEFAULT_ENVIRONMENT_ERROR_CONTEXT);
+        }
+    },
+});
+export function loadEnvironmentConfig(options = {}) {
+    return loadEnvironmentConfigInternal(options);
+}
+export function readEnvironmentConfig(content) {
+    const parsed = parseYamlDocument(content, {
+        formatError: formatEnvironmentYamlError,
+    });
+    const config = environmentConfigSchema.parse(parsed);
+    return normalizeEnvironmentConfig(config);
+}
+function formatEnvironmentYamlError(detail) {
+    const errorDetail = formatYamlErrorDetail(detail, {
+        fallbackReason: DEFAULT_ENVIRONMENT_ERROR_CONTEXT,
+    });
+    return new EnvironmentConfigParseError(DEFAULT_ENVIRONMENT_FILE_DISPLAY, errorDetail);
+}
+export function serializeEnvironmentConfig(config) {
+    const lines = [];
+    const nodeDisabled = isNodeEnvironmentDisabled(config);
+    const nodeRoots = getNodeDependencyRoots(config);
+    const pythonDisabled = isPythonEnvironmentDisabled(config);
+    const pythonPath = getPythonEnvironmentPath(config);
+    if (nodeDisabled) {
+        lines.push("node: false");
+        if (pythonPath || pythonDisabled) {
+            lines.push("");
+        }
+    }
+    else if (nodeRoots.length > 0) {
+        lines.push("node:");
+        lines.push("  dependencyRoots:");
+        for (const root of nodeRoots) {
+            lines.push(`    - ${root}`);
+        }
+        if (pythonPath || pythonDisabled) {
+            lines.push("");
+        }
+    }
+    if (pythonDisabled) {
+        lines.push("python: false");
+    }
+    else if (pythonPath && pythonPath.length > 0) {
+        lines.push("python:");
+        lines.push(`  path: ${pythonPath}`);
+    }
+    if (lines.length === 0) {
+        return "";
+    }
+    return lines.join("\n");
+}

package/dist/configs/environment/types.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const environmentNodeConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
+    dependencyRoots: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodLiteral<false>]>;
+export declare const environmentPythonConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodLiteral<false>]>;
+export declare const environmentConfigSchema: z.ZodObject<{
+    node: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        dependencyRoots: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodLiteral<false>]>>;
+    python: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodLiteral<false>]>>;
+}, z.core.$strict>;
+export type EnvironmentConfig = z.infer<typeof environmentConfigSchema>;
+export declare function normalizeEnvironmentConfig(config: EnvironmentConfig): EnvironmentConfig;
+export declare function isNodeEnvironmentDisabled(environment: EnvironmentConfig): boolean;
+export declare function getNodeDependencyRoots(environment: EnvironmentConfig): readonly string[];
+export declare function isPythonEnvironmentDisabled(environment: EnvironmentConfig): boolean;
+export declare function getPythonEnvironmentPath(environment: EnvironmentConfig): string | undefined;

package/dist/configs/environment/types.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { assertRepoRelativePath } from "../../utils/path.js";
+function formatEnvironmentPathError(label, value, reason) {
+    const displayValue = value.length === 0 ? "<empty>" : value;
+    return `Invalid ${label} "${displayValue}": ${reason}.`;
+}
+function createEnvironmentPathSchema(label) {
+    return z.string().superRefine((value, ctx) => {
+        if (value.length === 0) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: formatEnvironmentPathError(label, value, "value must be a non-empty string."),
+            });
+            return;
+        }
+        if (value.includes("\0")) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: formatEnvironmentPathError(label, value, "paths may not contain null bytes."),
+            });
+            return;
+        }
+        try {
+            assertRepoRelativePath(value);
+        }
+        catch {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: formatEnvironmentPathError(label, value, "paths must stay within the repository (no absolute entries, '..', or backslashes)."),
+            });
+        }
+    });
+}
+const dependencyRoot = createEnvironmentPathSchema("node.dependencyRoots[]");
+const pythonPath = createEnvironmentPathSchema("python.path");
+export const environmentNodeConfigSchema = z.union([
+    z
+        .object({
+        dependencyRoots: z.array(dependencyRoot).min(1),
+    })
+        .strict(),
+    z.literal(false),
+]);
+export const environmentPythonConfigSchema = z.union([
+    z
+        .object({
+        path: pythonPath,
+    })
+        .strict(),
+    z.literal(false),
+]);
+export const environmentConfigSchema = z
+    .object({
+    node: environmentNodeConfigSchema.optional(),
+    python: environmentPythonConfigSchema.optional(),
+})
+    .strict();
+export function normalizeEnvironmentConfig(config) {
+    const normalized = {};
+    if (config.node === false) {
+        normalized.node = false;
+    }
+    else if (config.node?.dependencyRoots?.length) {
+        normalized.node = {
+            dependencyRoots: [...new Set(config.node.dependencyRoots)],
+        };
+    }
+    const pythonPath = getPythonEnvironmentPath(config);
+    if (pythonPath) {
+        normalized.python = {
+            path: pythonPath,
+        };
+    }
+    else if (isPythonEnvironmentDisabled(config)) {
+        normalized.python = false;
+    }
+    return normalized;
+}
+export function isNodeEnvironmentDisabled(environment) {
+    return environment.node === false;
+}
+export function getNodeDependencyRoots(environment) {
+    const node = environment.node;
+    if (node && typeof node === "object") {
+        return node.dependencyRoots;
+    }
+    return [];
+}
+export function isPythonEnvironmentDisabled(environment) {
+    return environment.python === false;
+}
+export function getPythonEnvironmentPath(environment) {
+    const python = environment.python;
+    if (python && typeof python === "object") {
+        return python.path;
+    }
+    return undefined;
+}

package/dist/configs/evals/defaults.d.ts

@@ -0,0 +1,8 @@
+export interface EvalDefault {
+    readonly slug: string;
+    readonly command?: string;
+}
+export declare const DEFAULT_EVAL_TEMPLATE_HEADER: readonly string[];
+export declare const DEFAULT_EVAL_DEFAULTS: readonly EvalDefault[];
+export declare function serializeEvalDefaults(defaults: readonly EvalDefault[]): string[];
+export declare function listEvalDefaults(): EvalDefault[];

package/dist/configs/evals/defaults.js

@@ -0,0 +1,28 @@
+export const DEFAULT_EVAL_TEMPLATE_HEADER = [
+    "# Eval commands run after each agent finishes its run.",
+    "# For each slug, provide the command that runs that eval.",
+    "# Leave any entry blank (or delete it entirely) to skip that eval.",
+    '# Example: format: "npm run format:check"',
+    "",
+];
+export const DEFAULT_EVAL_DEFAULTS = [
+    { slug: "format" },
+    { slug: "lint" },
+    { slug: "typecheck" },
+    { slug: "tests" },
+];
+export function serializeEvalDefaults(defaults) {
+    const lines = [...DEFAULT_EVAL_TEMPLATE_HEADER];
+    for (const { slug, command } of defaults) {
+        if (command && command.length > 0) {
+            lines.push(`${slug}: ${JSON.stringify(command)}`);
+        }
+        else {
+            lines.push(`${slug}:`);
+        }
+    }
+    return lines;
+}
+export function listEvalDefaults() {
+    return DEFAULT_EVAL_DEFAULTS.map((definition) => ({ ...definition }));
+}

package/dist/configs/evals/detect.d.ts

@@ -0,0 +1,10 @@
+import { type EnvironmentConfig } from "../environment/types.js";
+import type { EvalSlug } from "./types.js";
+export declare const CANONICAL_EVAL_SLUGS: EvalSlug[];
+export interface EvalSuggestion {
+    source: "node" | "python";
+    commands: Map<EvalSlug, string>;
+    notes: string[];
+    warnings: string[];
+}
+export declare function detectEvalSuggestions(root: string, environment: EnvironmentConfig): Promise<EvalSuggestion[]>;