task-o-matic-core 0.1.0

package/dist/lib/config-validation.d.ts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+/**
+ * Zod schema for AI Provider
+ */
+export declare const AIProviderSchema: z.ZodEnum<["openai", "anthropic", "openrouter", "custom", "gemini", "zai"]>;
+/**
+ * Zod schema for AI Configuration
+ */
+export declare const AIConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<["openai", "anthropic", "openrouter", "custom", "gemini", "zai"]>;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseURL: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    context7Enabled: z.ZodOptional<z.ZodBoolean>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens?: number | undefined;
+    }, {
+        maxTokens?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "custom" | "openai" | "anthropic" | "openrouter" | "gemini" | "zai";
+    model: string;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    context7Enabled?: boolean | undefined;
+    reasoning?: {
+        maxTokens?: number | undefined;
+    } | undefined;
+}, {
+    provider: "custom" | "openai" | "anthropic" | "openrouter" | "gemini" | "zai";
+    model: string;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    context7Enabled?: boolean | undefined;
+    reasoning?: {
+        maxTokens?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * Zod schema for full Config object
+ */
+export declare const ConfigSchema: z.ZodObject<{
+    ai: z.ZodObject<{
+        provider: z.ZodEnum<["openai", "anthropic", "openrouter", "custom", "gemini", "zai"]>;
+        model: z.ZodString;
+        apiKey: z.ZodOptional<z.ZodString>;
+        baseURL: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        context7Enabled: z.ZodOptional<z.ZodBoolean>;
+        reasoning: z.ZodOptional<z.ZodObject<{
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxTokens?: number | undefined;
+        }, {
+            maxTokens?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "custom" | "openai" | "anthropic" | "openrouter" | "gemini" | "zai";
+        model: string;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        context7Enabled?: boolean | undefined;
+        reasoning?: {
+            maxTokens?: number | undefined;
+        } | undefined;
+    }, {
+        provider: "custom" | "openai" | "anthropic" | "openrouter" | "gemini" | "zai";
+        model: string;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        context7Enabled?: boolean | undefined;
+        reasoning?: {
+            maxTokens?: number | undefined;
+        } | undefined;
+    }>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    ai: {
+        provider: "custom" | "openai" | "anthropic" | "openrouter" | "gemini" | "zai";
+        model: string;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        context7Enabled?: boolean | undefined;
+        reasoning?: {
+            maxTokens?: number | undefined;
+        } | undefined;
+    };
+    workingDirectory?: string | undefined;
+}, {
+    ai: {
+        provider: "custom" | "openai" | "anthropic" | "openrouter" | "gemini" | "zai";
+        model: string;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        context7Enabled?: boolean | undefined;
+        reasoning?: {
+            maxTokens?: number | undefined;
+        } | undefined;
+    };
+    workingDirectory?: string | undefined;
+}>;
+/**
+ * Validation result type
+ */
+export interface ValidationResult<T> {
+    success: boolean;
+    data?: T;
+    errors?: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+/**
+ * Validate AI configuration
+ *
+ * @param config - AI configuration to validate
+ * @returns Validated and typed configuration
+ * @throws {TaskOMaticError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const aiConfig = {
+ *   provider: "openai",
+ *   model: "gpt-4",
+ *   temperature: 0.7,
+ *   maxTokens: 4000
+ * };
+ *
+ * const validated = validateAIConfig(aiConfig);
+ * // validated is now type-safe and guaranteed valid
+ * ```
+ */
+export declare function validateAIConfig(config: unknown): z.infer<typeof AIConfigSchema>;
+/**
+ * Validate full configuration object
+ *
+ * @param config - Configuration object to validate
+ * @returns Validated and typed configuration
+ * @throws {TaskOMaticError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   ai: {
+ *     provider: "anthropic",
+ *     model: "claude-sonnet-4.5",
+ *     temperature: 0.5
+ *   },
+ *   workingDirectory: "/path/to/project"
+ * };
+ *
+ * const validated = validateConfig(config);
+ * ```
+ */
+export declare function validateConfig(config: unknown): z.infer<typeof ConfigSchema>;
+/**
+ * Safe validation that returns a result object instead of throwing
+ *
+ * @param config - Configuration to validate
+ * @returns Validation result with success flag and data or errors
+ *
+ * @example
+ * ```typescript
+ * const result = safeValidateConfig(userInput);
+ * if (result.success) {
+ *   console.log("Valid config:", result.data);
+ * } else {
+ *   console.error("Validation errors:", result.errors);
+ * }
+ * ```
+ */
+export declare function safeValidateConfig(config: unknown): ValidationResult<z.infer<typeof ConfigSchema>>;
+/**
+ * Safe AI config validation
+ *
+ * @param config - AI configuration to validate
+ * @returns Validation result with success flag and data or errors
+ */
+export declare function safeValidateAIConfig(config: unknown): ValidationResult<z.infer<typeof AIConfigSchema>>;
+/**
+ * Validate partial AI config (for updates)
+ *
+ * @param config - Partial AI configuration to validate
+ * @returns Validated partial configuration
+ * @throws {TaskOMaticError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * // Only validating fields that are present
+ * const updates = {
+ *   temperature: 0.8
+ * };
+ *
+ * const validated = validatePartialAIConfig(updates);
+ * ```
+ */
+export declare function validatePartialAIConfig(config: unknown): Partial<z.infer<typeof AIConfigSchema>>;
+//# sourceMappingURL=config-validation.d.ts.map

package/dist/lib/config-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-validation.d.ts","sourceRoot":"","sources":["../../src/lib/config-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;GAEG;AACH,eAAO,MAAM,gBAAgB,6EAI3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvB,CAAC;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,MAAM,CAAC,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACJ;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,GACd,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CA0BhC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAuB5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,OAAO,GACd,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC,CAiBhD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,GACd,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC,CAiBlD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC,CAsBzC"}

package/dist/lib/config-validation.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigSchema = exports.AIConfigSchema = exports.AIProviderSchema = void 0;
+exports.validateAIConfig = validateAIConfig;
+exports.validateConfig = validateConfig;
+exports.safeValidateConfig = safeValidateConfig;
+exports.safeValidateAIConfig = safeValidateAIConfig;
+exports.validatePartialAIConfig = validatePartialAIConfig;
+const zod_1 = require("zod");
+const task_o_matic_error_1 = require("../utils/task-o-matic-error");
+/**
+ * Zod schema for AI Provider
+ */
+const types_1 = require("../types");
+/**
+ * Zod schema for AI Provider
+ */
+exports.AIProviderSchema = zod_1.z.enum(types_1.AI_PROVIDERS_LIST, {
+    errorMap: () => ({
+        message: `Provider must be one of: ${types_1.AI_PROVIDERS_LIST.join(", ")}`,
+    }),
+});
+/**
+ * Zod schema for AI Configuration
+ */
+exports.AIConfigSchema = zod_1.z.object({
+    provider: exports.AIProviderSchema,
+    model: zod_1.z.string().min(1, "Model name cannot be empty"),
+    apiKey: zod_1.z.string().optional(),
+    baseURL: zod_1.z
+        .string()
+        .url("Base URL must be a valid URL")
+        .optional()
+        .or(zod_1.z.literal("")),
+    maxTokens: zod_1.z
+        .number()
+        .int("Max tokens must be an integer")
+        .positive("Max tokens must be positive")
+        .max(1000000, "Max tokens cannot exceed 1,000,000")
+        .optional(),
+    temperature: zod_1.z
+        .number()
+        .min(0, "Temperature must be between 0 and 2")
+        .max(2, "Temperature must be between 0 and 2")
+        .optional(),
+    context7Enabled: zod_1.z.boolean().optional(),
+    reasoning: zod_1.z
+        .object({
+        maxTokens: zod_1.z
+            .number()
+            .int("Reasoning max tokens must be an integer")
+            .positive("Reasoning max tokens must be positive")
+            .max(100000, "Reasoning max tokens cannot exceed 100,000")
+            .optional(),
+    })
+        .optional(),
+});
+/**
+ * Zod schema for full Config object
+ */
+exports.ConfigSchema = zod_1.z.object({
+    ai: exports.AIConfigSchema,
+    workingDirectory: zod_1.z.string().optional(),
+});
+/**
+ * Validate AI configuration
+ *
+ * @param config - AI configuration to validate
+ * @returns Validated and typed configuration
+ * @throws {TaskOMaticError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const aiConfig = {
+ *   provider: "openai",
+ *   model: "gpt-4",
+ *   temperature: 0.7,
+ *   maxTokens: 4000
+ * };
+ *
+ * const validated = validateAIConfig(aiConfig);
+ * // validated is now type-safe and guaranteed valid
+ * ```
+ */
+function validateAIConfig(config) {
+    try {
+        return exports.AIConfigSchema.parse(config);
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const errors = error.errors.map((err) => ({
+                path: err.path.join("."),
+                message: err.message,
+            }));
+            throw new task_o_matic_error_1.TaskOMaticError("AI configuration validation failed", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR,
+                context: JSON.stringify(config, null, 2),
+                suggestions: [
+                    "Check that all required fields are present",
+                    "Verify provider is one of: openai, anthropic, openrouter, custom",
+                    "Ensure model name is not empty",
+                    "Check temperature is between 0 and 2",
+                    "Verify maxTokens is a positive integer",
+                    ...errors.map((e) => `Fix ${e.path}: ${e.message}`),
+                ],
+                metadata: { errors },
+            });
+        }
+        throw error;
+    }
+}
+/**
+ * Validate full configuration object
+ *
+ * @param config - Configuration object to validate
+ * @returns Validated and typed configuration
+ * @throws {TaskOMaticError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   ai: {
+ *     provider: "anthropic",
+ *     model: "claude-sonnet-4.5",
+ *     temperature: 0.5
+ *   },
+ *   workingDirectory: "/path/to/project"
+ * };
+ *
+ * const validated = validateConfig(config);
+ * ```
+ */
+function validateConfig(config) {
+    try {
+        return exports.ConfigSchema.parse(config);
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const errors = error.errors.map((err) => ({
+                path: err.path.join("."),
+                message: err.message,
+            }));
+            throw new task_o_matic_error_1.TaskOMaticError("Configuration validation failed", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR,
+                context: JSON.stringify(config, null, 2),
+                suggestions: [
+                    "Check that all required fields are present",
+                    "Verify the configuration structure is correct",
+                    ...errors.map((e) => `Fix ${e.path}: ${e.message}`),
+                ],
+                metadata: { errors },
+            });
+        }
+        throw error;
+    }
+}
+/**
+ * Safe validation that returns a result object instead of throwing
+ *
+ * @param config - Configuration to validate
+ * @returns Validation result with success flag and data or errors
+ *
+ * @example
+ * ```typescript
+ * const result = safeValidateConfig(userInput);
+ * if (result.success) {
+ *   console.log("Valid config:", result.data);
+ * } else {
+ *   console.error("Validation errors:", result.errors);
+ * }
+ * ```
+ */
+function safeValidateConfig(config) {
+    const result = exports.ConfigSchema.safeParse(config);
+    if (result.success) {
+        return {
+            success: true,
+            data: result.data,
+        };
+    }
+    else {
+        return {
+            success: false,
+            errors: result.error.errors.map((err) => ({
+                path: err.path.join("."),
+                message: err.message,
+            })),
+        };
+    }
+}
+/**
+ * Safe AI config validation
+ *
+ * @param config - AI configuration to validate
+ * @returns Validation result with success flag and data or errors
+ */
+function safeValidateAIConfig(config) {
+    const result = exports.AIConfigSchema.safeParse(config);
+    if (result.success) {
+        return {
+            success: true,
+            data: result.data,
+        };
+    }
+    else {
+        return {
+            success: false,
+            errors: result.error.errors.map((err) => ({
+                path: err.path.join("."),
+                message: err.message,
+            })),
+        };
+    }
+}
+/**
+ * Validate partial AI config (for updates)
+ *
+ * @param config - Partial AI configuration to validate
+ * @returns Validated partial configuration
+ * @throws {TaskOMaticError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * // Only validating fields that are present
+ * const updates = {
+ *   temperature: 0.8
+ * };
+ *
+ * const validated = validatePartialAIConfig(updates);
+ * ```
+ */
+function validatePartialAIConfig(config) {
+    try {
+        return exports.AIConfigSchema.partial().parse(config);
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const errors = error.errors.map((err) => ({
+                path: err.path.join("."),
+                message: err.message,
+            }));
+            throw new task_o_matic_error_1.TaskOMaticError("AI configuration update validation failed", {
+                code: task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR,
+                context: JSON.stringify(config, null, 2),
+                suggestions: [
+                    "Check that field values are valid",
+                    ...errors.map((e) => `Fix ${e.path}: ${e.message}`),
+                ],
+                metadata: { errors },
+            });
+        }
+        throw error;
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,55 @@
+import { AIConfig } from "../types";
+export interface Config {
+    ai: AIConfig;
+    workingDirectory?: string;
+}
+export interface ConfigCallbacks {
+    read: (key: string) => Promise<string | null>;
+    write: (key: string, value: string) => Promise<void>;
+    getEnv: (key: string) => string | undefined;
+}
+import PROVIDER_DEFAULTS from "./provider-defaults.json";
+export { PROVIDER_DEFAULTS as providerDefaults };
+export declare function createDefaultConfigCallbacks(workingDir?: string): ConfigCallbacks;
+export declare class ConfigManager {
+    private config;
+    private customWorkingDir;
+    private callbacks;
+    constructor(callbacks?: ConfigCallbacks, workingDirectory?: string);
+    setWorkingDirectory(dir: string): void;
+    setCallbacks(callbacks: ConfigCallbacks): void;
+    getWorkingDirectory(): string;
+    getTaskOMaticDir(): string;
+    private loadEnvConfig;
+    load(): Promise<Config>;
+    save(): Promise<void>;
+    getConfig(): Config;
+    getAIConfig(): AIConfig;
+    setAIConfig(aiConfig: Partial<AIConfig>): Promise<void>;
+    setConfig(config: Config): void;
+    getConfigFilePath(): string;
+    /**
+     * Validate configuration independently of load().
+     * Can be used to validate config before applying changes.
+     */
+    validate(configToValidate?: Partial<Config>): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+export declare const configManager: ConfigManager;
+/**
+ * Helper function to set working directory and reload config.
+ * Combines the common pattern of setWorkingDirectory + load.
+ *
+ * @param dir - Working directory path
+ * @param manager - ConfigManager instance (defaults to singleton)
+ * @returns Loaded config
+ *
+ * @example
+ * ```typescript
+ * await setupWorkingDirectory("/path/to/project");
+ * ```
+ */
+export declare function setupWorkingDirectory(dir: string, manager?: ConfigManager): Promise<Config>;
+//# sourceMappingURL=config.d.ts.map

package/dist/lib/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAA6C,MAAM,UAAU,CAAC;AAU/E,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,QAAQ,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9C,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC7C;AAID,OAAO,iBAAiB,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,iBAAiB,IAAI,gBAAgB,EAAE,CAAC;AAsBjD,wBAAgB,4BAA4B,CAC1C,UAAU,GAAE,MAAc,GACzB,eAAe,CA+BjB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,SAAS,CAAkB;gBAEvB,SAAS,CAAC,EAAE,eAAe,EAAE,gBAAgB,CAAC,EAAE,MAAM;IAiBlE,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAQtC,YAAY,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAK9C,mBAAmB,IAAI,MAAM;IAI7B,gBAAgB,IAAI,MAAM;IAI1B,OAAO,CAAC,aAAa;IA0Df,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IA0EvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB3B,SAAS,IAAI,MAAM;IAqBnB,WAAW,IAAI,QAAQ;IAIjB,WAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB7D,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK/B,iBAAiB,IAAI,MAAM;IAI3B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG;QAC5C,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,MAAM,EAAE,CAAC;KAClB;CAwEF;AAED,eAAO,MAAM,aAAa,eAAsB,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,aAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAGjB"}