task-o-matic 0.0.14 → 0.0.15

package/dist/lib/ai-service/task-operations.js

@@ -1,95 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskOperations = void 0;
-const ai_1 = require("ai");
 const prompt_builder_1 = require("../prompt-builder");
 const stack_formatter_1 = require("../../utils/stack-formatter");
 const prompts_1 = require("../../prompts");
 const ai_service_factory_1 = require("../../utils/ai-service-factory");
 const filesystem_tools_1 = require("./filesystem-tools");
 const base_operations_1 = require("./base-operations");
+const ai_operation_utility_1 = require("../../utils/ai-operation-utility");
 class TaskOperations extends base_operations_1.BaseOperations {
+    aiOperationUtility = new ai_operation_utility_1.AIOperationUtility();
     async breakdownTask(task, config, promptOverride, userMessage, streamingOptions, retryConfig, fullContent, stackInfo, existingSubtasks, enableFilesystemTools) {
-        return this.retryHandler.executeWithRetry(async () => {
-            let prompt;
-            if (promptOverride) {
-                prompt = promptOverride;
+        // Build prompt
+        let prompt;
+        if (promptOverride) {
+            prompt = promptOverride;
+        }
+        else {
+            const variables = {
+                TASK_TITLE: task.title,
+                TASK_DESCRIPTION: task.description || "No description",
+            };
+            if (fullContent) {
+                variables.TASK_CONTENT = fullContent;
             }
-            else {
-                const variables = {
-                    TASK_TITLE: task.title,
-                    TASK_DESCRIPTION: task.description || "No description",
-                };
-                if (fullContent) {
-                    variables.TASK_CONTENT = fullContent;
-                }
-                if (existingSubtasks && existingSubtasks.length > 0) {
-                    const existingSubtasksText = existingSubtasks
-                        .map((subtask, index) => `${index + 1}. ${subtask.title}: ${subtask.description || "No description"}`)
-                        .join("\n");
-                    variables.EXISTING_SUBTASKS = existingSubtasksText;
-                }
-                if (stackInfo) {
-                    variables.STACK_INFO = stackInfo;
-                }
-                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
-                    name: "task-breakdown",
-                    type: "user",
-                    variables,
-                });
-                if (!promptResult.success) {
-                    throw new Error(`Failed to build task breakdown prompt: ${promptResult.error}`);
-                }
-                prompt = promptResult.prompt;
+            if (existingSubtasks && existingSubtasks.length > 0) {
+                const existingSubtasksText = existingSubtasks
+                    .map((subtask, index) => `${index + 1}. ${subtask.title}: ${subtask.description || "No description"}`)
+                    .join("\n");
+                variables.EXISTING_SUBTASKS = existingSubtasksText;
+            }
+            if (stackInfo) {
+                variables.STACK_INFO = stackInfo;
+            }
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "task-breakdown",
+                type: "user",
+                variables,
+            });
+            if (!promptResult.success) {
+                throw new Error(`Failed to build task breakdown prompt: ${promptResult.error}`);
             }
-            let response;
-            if (enableFilesystemTools) {
-                const model = this.modelProvider.getModel({
-                    ...this.modelProvider.getAIConfig(),
-                    ...config,
-                });
-                const allTools = {
-                    ...filesystem_tools_1.filesystemTools,
-                };
-                const result = await (0, ai_1.streamText)({
-                    model,
-                    tools: allTools,
-                    system: prompts_1.TASK_BREAKDOWN_SYSTEM_PROMPT +
-                        `
+            prompt = promptResult.prompt;
+        }
+        // Execute AI operation with proper error handling
+        const result = await this.aiOperationUtility.executeAIOperation("Task breakdown", async () => {
+            // Prepare tools if filesystem tools are enabled
+            const tools = enableFilesystemTools ? filesystem_tools_1.filesystemTools : undefined;
+            const response = await this.aiOperationUtility.streamTextWithTools(prompts_1.TASK_BREAKDOWN_SYSTEM_PROMPT +
+                (enableFilesystemTools
+                    ? `
 
 You have access to filesystem tools that allow you to:
 - readFile: Read the contents of any file in the project
 - listDirectory: List contents of directories
 
-Use these tools to understand the project structure, existing code, and dependencies when breaking down tasks into subtasks.`,
-                    messages: [{ role: "user", content: userMessage || prompt }],
-                    maxRetries: 0,
-                    onChunk: streamingOptions?.onChunk
-                        ? ({ chunk }) => {
-                            if (chunk.type === "text-delta") {
-                                streamingOptions.onChunk(chunk.text);
-                            }
-                            else if (chunk.type === "reasoning-delta") {
-                                streamingOptions.onReasoning?.(chunk.text);
-                            }
-                        }
-                        : undefined,
-                    onFinish: streamingOptions?.onFinish
-                        ? ({ text, finishReason, usage }) => {
-                            streamingOptions.onFinish({
-                                text,
-                                finishReason,
-                                usage,
-                                isAborted: false,
-                            });
-                        }
-                        : undefined,
-                });
-                response = await result.text;
-            }
-            else {
-                response = await this.streamText("", config, prompts_1.TASK_BREAKDOWN_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
-            }
+Use these tools to understand the project structure, existing code, and dependencies when breaking down tasks into subtasks.`
+                    : ""), userMessage || prompt, config, streamingOptions, tools);
             const parseResult = this.jsonParser.parseJSONFromResponse(response);
             if (!parseResult.success) {
                 throw new Error(parseResult.error || "Failed to parse task breakdown response");
@@ -100,126 +67,121 @@ Use these tools to understand the project structure, existing code, and dependen
                 content: subtask.description || "",
                 estimatedEffort: subtask.effort,
             }));
-        }, retryConfig, "Task breakdown");
+        }, {
+            streamingOptions,
+            retryConfig,
+            aiConfig: config,
+            maxRetries: retryConfig?.maxAttempts || 2,
+        });
+        // Return the result directly (errors are thrown, not returned)
+        return result.result;
     }
     async enhanceTask(title, description, config, promptOverride, userMessage, taskId, streamingOptions, retryConfig) {
-        return this.retryHandler.executeWithRetry(async () => {
-            let contextInfo = "";
-            let prdContent = "";
-            if (taskId) {
-                const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
-                try {
-                    const context = await contextBuilder.buildContext(taskId);
-                    if (context.documentation || context.stack || context.prdContent) {
-                        contextInfo = "\n\nAvailable Context:\n";
-                        if (context.stack) {
-                            contextInfo += (0, stack_formatter_1.formatStackForContext)(context.stack) + "\n";
-                        }
-                        if (context.documentation) {
-                            contextInfo += `Documentation Available: ${context.documentation.recap}\n`;
-                            if (context.documentation.files.length > 0) {
-                                contextInfo += `Documentation Files: ${context.documentation.files
-                                    .map((f) => f.path)
-                                    .join(", ")}\n`;
-                            }
-                        }
-                        if (context.prdContent) {
-                            prdContent = context.prdContent;
+        // Build context
+        let contextInfo = "";
+        let prdContent = "";
+        if (taskId) {
+            const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+            try {
+                const context = await contextBuilder.buildContext(taskId);
+                if (context.documentation || context.stack || context.prdContent) {
+                    contextInfo = "\n\nAvailable Context:\n";
+                    if (context.stack) {
+                        contextInfo += (0, stack_formatter_1.formatStackForContext)(context.stack) + "\n";
+                    }
+                    if (context.documentation) {
+                        contextInfo += `Documentation Available: ${context.documentation.recap}\n`;
+                        if (context.documentation.files.length > 0) {
+                            contextInfo += `Documentation Files: ${context.documentation.files
+                                .map((f) => f.path)
+                                .join(", ")}\n`;
                         }
                     }
-                }
-                catch (error) {
-                    throw error;
+                    if (context.prdContent) {
+                        prdContent = context.prdContent;
+                    }
                 }
             }
-            let prompt;
-            if (promptOverride) {
-                prompt = promptOverride;
+            catch (error) {
+                throw error;
             }
-            else {
-                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
-                    name: "task-enhancement",
-                    type: "user",
-                    variables: {
-                        TASK_TITLE: title,
-                        TASK_DESCRIPTION: description || "None",
-                        CONTEXT_INFO: contextInfo,
-                        PRD_CONTENT: prdContent || "No PRD content available",
-                    },
-                });
-                if (!promptResult.success) {
-                    throw new Error(`Failed to build task enhancement prompt: ${promptResult.error}`);
-                }
-                prompt = promptResult.prompt;
+        }
+        // Build prompt
+        let prompt;
+        if (promptOverride) {
+            prompt = promptOverride;
+        }
+        else {
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "task-enhancement",
+                type: "user",
+                variables: {
+                    TASK_TITLE: title,
+                    TASK_DESCRIPTION: description || "None",
+                    CONTEXT_INFO: contextInfo,
+                    PRD_CONTENT: prdContent || "No PRD content available",
+                },
+            });
+            if (!promptResult.success) {
+                throw new Error(`Failed to build task enhancement prompt: ${promptResult.error}`);
             }
-            return this.streamText("", config, prompts_1.TASK_ENHANCEMENT_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
-        }, retryConfig, "Task enhancement");
+            prompt = promptResult.prompt;
+        }
+        // Execute AI operation with proper error handling
+        const result = await this.aiOperationUtility.executeAIOperation("Task enhancement", async () => {
+            return await this.aiOperationUtility.streamText("", config, prompts_1.TASK_ENHANCEMENT_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+        }, {
+            streamingOptions,
+            retryConfig,
+            aiConfig: config,
+            maxRetries: retryConfig?.maxAttempts || 2,
+        });
+        // Return the result directly (errors are thrown, not returned)
+        return result.result;
     }
     async planTask(taskContext, taskDetails, config, promptOverride, userMessage, streamingOptions, retryConfig) {
-        return this.retryHandler.executeWithRetry(async () => {
-            let prompt;
-            if (promptOverride) {
-                prompt = promptOverride;
-            }
-            else {
-                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
-                    name: "task-planning",
-                    type: "user",
-                    variables: {
-                        TASK_CONTEXT: taskContext,
-                        TASK_DETAILS: taskDetails,
-                    },
-                });
-                if (!promptResult.success) {
-                    throw new Error(`Failed to build task planning prompt: ${promptResult.error}`);
-                }
-                prompt = promptResult.prompt;
-            }
-            const model = this.modelProvider.getModel({
-                ...this.modelProvider.getAIConfig(),
-                ...config,
+        // Build prompt
+        let prompt;
+        if (promptOverride) {
+            prompt = promptOverride;
+        }
+        else {
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "task-planning",
+                type: "user",
+                variables: {
+                    TASK_CONTEXT: taskContext,
+                    TASK_DETAILS: taskDetails,
+                },
             });
+            if (!promptResult.success) {
+                throw new Error(`Failed to build task planning prompt: ${promptResult.error}`);
+            }
+            prompt = promptResult.prompt;
+        }
+        // Execute AI operation with proper error handling
+        const result = await this.aiOperationUtility.executeAIOperation("Task planning", async () => {
             const mcpTools = await this.context7Client.getMCPTools();
             const allTools = {
                 ...mcpTools,
                 ...filesystem_tools_1.filesystemTools,
             };
-            const result = (0, ai_1.streamText)({
-                model,
-                tools: allTools,
-                system: prompts_1.TASK_PLANNING_SYSTEM_PROMPT +
-                    `
+            return await this.aiOperationUtility.streamTextWithTools(prompts_1.TASK_PLANNING_SYSTEM_PROMPT +
+                `
 
 You have access to filesystem tools that allow you to:
 - readFile: Read the contents of any file in the project
 - listDirectory: List contents of directories
 
-Use these tools to understand the project structure, existing code, and dependencies when creating implementation plans.`,
-                messages: [{ role: "user", content: userMessage || prompt }],
-                maxRetries: 0,
-                onChunk: streamingOptions?.onChunk
-                    ? ({ chunk }) => {
-                        if (chunk.type === "text-delta") {
-                            streamingOptions.onChunk(chunk.text);
-                        }
-                        else if (chunk.type === "reasoning-delta") {
-                            streamingOptions.onReasoning?.(chunk.text);
-                        }
-                    }
-                    : undefined,
-                onFinish: streamingOptions?.onFinish
-                    ? ({ text, finishReason, usage }) => {
-                        streamingOptions.onFinish({
-                            text,
-                            finishReason,
-                            usage,
-                            isAborted: false,
-                        });
-                    }
-                    : undefined,
-            });
-            return (await result).text;
-        }, retryConfig, "Task planning");
+Use these tools to understand the project structure, existing code, and dependencies when creating implementation plans.`, userMessage || prompt, config, streamingOptions, allTools);
+        }, {
+            streamingOptions,
+            retryConfig,
+            aiConfig: config,
+            maxRetries: retryConfig?.maxAttempts || 2,
+        });
+        // Return the result directly (errors are thrown, not returned)
+        return result.result;
     }
 }
 exports.TaskOperations = TaskOperations;

package/dist/lib/benchmark/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/lib/benchmark/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAA0B,MAAM,SAAS,CAAC;AAOzE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAkD;;IAMpE,QAAQ,CAAC,EAAE,EAAE,sBAAsB;IAInC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAInD,IAAI,IAAI,sBAAsB,EAAE;IAIhC,OAAO,CAAC,gBAAgB;CA2RzB;AAED,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/lib/benchmark/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAA0B,MAAM,SAAS,CAAC;AAOzE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAkD;;IAMpE,QAAQ,CAAC,EAAE,EAAE,sBAAsB;IAInC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAInD,IAAI,IAAI,sBAAsB,EAAE;IAIhC,OAAO,CAAC,gBAAgB;CAsRzB;AAED,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/dist/lib/benchmark/registry.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.benchmarkRegistry = exports.BenchmarkRegistry = void 0;
 const prd_1 = require("../../services/prd");
-const tasks_1 = require("../../services/tasks"); // We'll need to instantiate this or use a singleton if available
+const tasks_1 = require("../../services/tasks");
 const workflow_benchmark_1 = require("../../services/workflow-benchmark");
 class BenchmarkRegistry {
     operations = new Map();
@@ -59,17 +59,13 @@ class BenchmarkRegistry {
             },
         });
         // Task Breakdown Adapter
-        // Note: TaskService is a class, we need an instance.
-        // In a real app we should use dependency injection or a singleton.
-        // For now, we'll create a new instance or assume one is available.
-        const taskService = new tasks_1.TaskService();
         this.register({
             id: "task-breakdown",
             name: "Task Breakdown",
             description: "Break down a task into subtasks",
             validateInput: (input) => typeof input.taskId === "string",
             execute: async (input, aiOptions, streamingOptions) => {
-                return await taskService.splitTask(input.taskId, aiOptions, input.prompt, input.message, streamingOptions, // streaming options
+                return await tasks_1.taskService.splitTask(input.taskId, aiOptions, input.prompt, input.message, streamingOptions, // streaming options
                 input.tools);
             },
         });
@@ -90,7 +86,7 @@ class BenchmarkRegistry {
             description: "Create a new task with AI enhancement using Context7 documentation",
             validateInput: (input) => typeof input.title === "string" && input.title.length > 0,
             execute: async (input, aiOptions, streamingOptions) => {
-                return await taskService.createTask({
+                return await tasks_1.taskService.createTask({
                     title: input.title,
                     content: input.content,
                     parentId: input.parentId,
@@ -108,7 +104,7 @@ class BenchmarkRegistry {
             description: "Enhance an existing task with AI using Context7 documentation",
             validateInput: (input) => typeof input.taskId === "string",
             execute: async (input, aiOptions, streamingOptions) => {
-                return await taskService.enhanceTask(input.taskId, aiOptions, streamingOptions);
+                return await tasks_1.taskService.enhanceTask(input.taskId, aiOptions, streamingOptions);
             },
         });
         // Task Planning
@@ -118,7 +114,7 @@ class BenchmarkRegistry {
             description: "Create a detailed implementation plan for a task",
             validateInput: (input) => typeof input.taskId === "string",
             execute: async (input, aiOptions, streamingOptions) => {
-                return await taskService.planTask(input.taskId, aiOptions, streamingOptions);
+                return await tasks_1.taskService.planTask(input.taskId, aiOptions, streamingOptions);
             },
         });
         // Task Documentation
@@ -128,7 +124,7 @@ class BenchmarkRegistry {
             description: "Analyze and generate documentation for a task",
             validateInput: (input) => typeof input.taskId === "string",
             execute: async (input, aiOptions, streamingOptions) => {
-                return await taskService.documentTask(input.taskId, input.force || false, aiOptions, streamingOptions);
+                return await tasks_1.taskService.documentTask(input.taskId, input.force || false, aiOptions, streamingOptions);
             },
         });
         // PRD Creation

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"]>;
+/**
+ * Zod schema for AI Configuration
+ */
+export declare const AIConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<["openai", "anthropic", "openrouter", "custom"]>;
+    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: "openai" | "anthropic" | "openrouter" | "custom";
+    model: string;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    context7Enabled?: boolean | undefined;
+    reasoning?: {
+        maxTokens?: number | undefined;
+    } | undefined;
+}, {
+    provider: "openai" | "anthropic" | "openrouter" | "custom";
+    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"]>;
+        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: "openai" | "anthropic" | "openrouter" | "custom";
+        model: string;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        context7Enabled?: boolean | undefined;
+        reasoning?: {
+            maxTokens?: number | undefined;
+        } | undefined;
+    }, {
+        provider: "openai" | "anthropic" | "openrouter" | "custom";
+        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: "openai" | "anthropic" | "openrouter" | "custom";
+        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: "openai" | "anthropic" | "openrouter" | "custom";
+        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;AAGxB;;GAEG;AACH,eAAO,MAAM,gBAAgB,4DAI3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BzB,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,CAAC,MAAM,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CA0BhF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAuB5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC,CAiBlG;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC,CAiBtG;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC,CAsBzC"}