task-o-matic 0.0.1

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

@@ -0,0 +1,648 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIOperations = void 0;
+const ai_1 = require("ai");
+const context_builder_1 = require("../context-builder");
+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 json_parser_1 = require("./json-parser");
+const mcp_client_1 = require("./mcp-client");
+const retry_handler_1 = require("./retry-handler");
+const model_provider_1 = require("./model-provider");
+class AIOperations {
+    jsonParser = new json_parser_1.JSONParser();
+    context7Client = new mcp_client_1.Context7Client();
+    retryHandler = new retry_handler_1.RetryHandler();
+    modelProvider = new model_provider_1.ModelProvider();
+    // private researchTools = new ResearchTools(); // COMMENTED OUT - TESTING
+    async streamText(prompt, config, systemPrompt, userMessage, streamingOptions, retryConfig) {
+        const aiConfig = { ...this.modelProvider.getAIConfig(), ...config };
+        return this.retryHandler.executeWithRetry(async () => {
+            const model = this.modelProvider.getModel(aiConfig);
+            const result = (0, ai_1.streamText)({
+                model,
+                system: systemPrompt,
+                messages: [{ role: "user", content: userMessage || prompt }],
+                maxRetries: 0, // Disable built-in retries since we handle them manually
+                onError: ({ error }) => {
+                    // Call user's error callback if provided
+                    streamingOptions?.onError?.(error);
+                    // Re-throw the FULL error to maintain existing error handling behavior
+                    throw error;
+                },
+                onChunk: streamingOptions?.onChunk
+                    ? ({ chunk }) => {
+                        if (chunk.type === "text-delta") {
+                            streamingOptions.onChunk(chunk.text);
+                        }
+                        else if (chunk.type === "tool-result" &&
+                            chunk.toolName === "get-library-docs") {
+                            const docs = chunk.output;
+                            if (docs && typeof docs === "object" && "content" in docs) {
+                                this.context7Client.saveContext7Documentation(chunk.input?.context7CompatibleLibraryID || "unknown", docs.content, chunk.input?.topic || "general");
+                            }
+                            else if (docs && typeof docs === "string") {
+                                this.context7Client.saveContext7Documentation(chunk.input?.context7CompatibleLibraryID || "unknown", docs, chunk.input?.topic || "general");
+                            }
+                        }
+                    }
+                    : undefined,
+                onFinish: streamingOptions?.onFinish
+                    ? ({ text, finishReason, usage }) => {
+                        streamingOptions.onFinish({
+                            text,
+                            finishReason,
+                            usage,
+                            isAborted: false,
+                        });
+                    }
+                    : undefined,
+                // Add reasoning configuration only for OpenRouter with explicit reasoning parameter
+                ...(aiConfig.provider === "openrouter" &&
+                    aiConfig.reasoning &&
+                    aiConfig.reasoning.maxTokens
+                    ? {
+                        providerOptions: {
+                            openrouter: {
+                                reasoning: {
+                                    max_tokens: aiConfig.reasoning.maxTokens,
+                                },
+                            },
+                        },
+                    }
+                    : {}),
+            });
+            let fullText = "";
+            for await (const textPart of result.textStream) {
+                fullText += textPart;
+            }
+            return fullText;
+        }, retryConfig, "AI streaming");
+    }
+    async parsePRD(prdContent, config, promptOverride, userMessage, streamingOptions, retryConfig, workingDirectory) {
+        return this.retryHandler.executeWithRetry(async () => {
+            // Get stack context for better PRD parsing using PromptBuilder
+            // Pass working directory explicitly to avoid process.cwd() issues
+            let stackInfo = "";
+            try {
+                stackInfo = await prompt_builder_1.PromptBuilder.detectStackInfo(workingDirectory);
+                if (stackInfo === "Not detected") {
+                    stackInfo = "";
+                }
+            }
+            catch (error) {
+                // Stack info not available, will use empty string
+            }
+            // Use PromptBuilder if no prompt override provided
+            let enhancedPrompt;
+            if (promptOverride) {
+                enhancedPrompt = promptOverride;
+            }
+            else {
+                const variables = {
+                    PRD_CONTENT: prdContent,
+                };
+                // Only include stack info if we have it
+                if (stackInfo) {
+                    variables.STACK_INFO = stackInfo;
+                }
+                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                    name: "prd-parsing",
+                    type: "user",
+                    variables,
+                });
+                if (!promptResult.success) {
+                    throw new Error(`Failed to build PRD parsing prompt: ${promptResult.error}`);
+                }
+                enhancedPrompt = promptResult.prompt; // TypeScript: prompt is guaranteed when success is true
+            }
+            const response = await this.streamText("", // empty prompt since we use messages
+            config, prompts_1.PRD_PARSING_SYSTEM_PROMPT, userMessage || enhancedPrompt, streamingOptions, { maxAttempts: 1 });
+            // Parse JSON from response using proper typing
+            const parseResult = this.jsonParser.parseJSONFromResponse(response);
+            if (!parseResult.success) {
+                throw new Error(parseResult.error || "Failed to parse PRD response");
+            }
+            const parsed = parseResult.data;
+            // Transform to our format with proper IDs for dependencies
+            const tasks = (parsed?.tasks || []).map((task, index) => {
+                const taskId = task.id || (index + 1).toString();
+                // Extract all AI-generated keys except the ones we handle separately
+                const { title, description, content, effort, dependencies, ...extraData } = task;
+                // Create comprehensive content from all AI data
+                let fullContent = "";
+                if (description || content) {
+                    fullContent = description || content || "";
+                }
+                // Add any extra AI-generated data as structured content
+                if (Object.keys(extraData).length > 0) {
+                    fullContent += "\n\n## Additional AI-Generated Information\n";
+                    for (const [key, value] of Object.entries(extraData)) {
+                        fullContent += `\n**${key}:** ${JSON.stringify(value, null, 2)}`;
+                    }
+                }
+                return {
+                    id: taskId,
+                    title: task.title,
+                    description: (task.description || task.content || "").substring(0, 200) +
+                        ((task.description || task.content || "").length > 200
+                            ? "..."
+                            : ""),
+                    content: fullContent,
+                    status: "todo",
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                    estimatedEffort: task.effort,
+                    dependencies: task.dependencies || [],
+                    tags: task.tags || [],
+                };
+            });
+            return {
+                tasks,
+                summary: parsed?.summary || "PRD parsed successfully",
+                estimatedDuration: parsed?.estimatedDuration || "Unknown",
+                confidence: parsed?.confidence || 0.7,
+            };
+        }, retryConfig, "PRD parsing");
+    }
+    async breakdownTask(task, config, promptOverride, userMessage, streamingOptions, retryConfig, fullContent, stackInfo, existingSubtasks) {
+        return this.retryHandler.executeWithRetry(async () => {
+            // Use PromptBuilder if no prompt override provided
+            let prompt;
+            if (promptOverride) {
+                prompt = promptOverride;
+            }
+            else {
+                // Build enhanced variables for task breakdown
+                const variables = {
+                    TASK_TITLE: task.title,
+                    TASK_DESCRIPTION: task.description || "No description",
+                };
+                // Add full content if available
+                if (fullContent) {
+                    variables.TASK_CONTENT = fullContent;
+                }
+                // Add existing subtasks if available
+                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;
+                }
+                // Add stack info if available
+                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;
+            }
+            const response = await this.streamText("", // empty prompt since we use messages
+            config, prompts_1.TASK_BREAKDOWN_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+            // Parse JSON from response using proper typing
+            const parseResult = this.jsonParser.parseJSONFromResponse(response);
+            if (!parseResult.success) {
+                throw new Error(parseResult.error || "Failed to parse task breakdown response");
+            }
+            const parsed = parseResult.data;
+            // Return plain task data - let storage layer handle IDs and metadata
+            return (parsed?.subtasks || []).map((subtask) => ({
+                title: subtask.title,
+                content: subtask.description || "",
+                estimatedEffort: subtask.effort,
+            }));
+        }, retryConfig, "Task breakdown");
+    }
+    async enhanceTask(title, description, config, promptOverride, userMessage, taskId, streamingOptions, retryConfig) {
+        return this.retryHandler.executeWithRetry(async () => {
+            let contextInfo = "";
+            let prdContent = "";
+            // If taskId is provided, include existing documentation context
+            if (taskId) {
+                const contextBuilder = new context_builder_1.ContextBuilder();
+                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;
+                        }
+                    }
+                }
+                catch (error) {
+                    throw error;
+                }
+            }
+            // Use PromptBuilder if no prompt override provided
+            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}`);
+                }
+                prompt = promptResult.prompt;
+            }
+            return this.streamText("", // empty prompt since we use messages
+            config, prompts_1.TASK_ENHANCEMENT_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+        }, retryConfig, "Task enhancement");
+    }
+    async reworkPRD(prdContent, feedback, config, promptOverride, userMessage, streamingOptions, retryConfig, workingDirectory) {
+        return this.retryHandler.executeWithRetry(async () => {
+            // Get stack context for better PRD rework using PromptBuilder
+            // Pass working directory explicitly to avoid process.cwd() issues
+            let stackInfo = "";
+            try {
+                stackInfo = await prompt_builder_1.PromptBuilder.detectStackInfo(workingDirectory);
+                if (stackInfo === "Not detected") {
+                    stackInfo = "";
+                }
+            }
+            catch (error) {
+                // Stack info not available, will use empty string
+            }
+            // Use PromptBuilder if no prompt override provided
+            let prompt;
+            if (promptOverride) {
+                prompt = promptOverride;
+            }
+            else {
+                const variables = {
+                    PRD_CONTENT: prdContent,
+                    USER_FEEDBACK: feedback,
+                };
+                // Only include stack info if we have it
+                if (stackInfo) {
+                    variables.STACK_INFO = stackInfo;
+                }
+                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                    name: "prd-rework",
+                    type: "user",
+                    variables,
+                });
+                if (!promptResult.success) {
+                    throw new Error(`Failed to build PRD rework prompt: ${promptResult.error}`);
+                }
+                prompt = promptResult.prompt;
+            }
+            return this.streamText("", // empty prompt since we use messages
+            config, prompts_1.PRD_REWORK_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+        }, retryConfig, "PRD rework");
+    }
+    // Context7 Integration Methods
+    async enhanceTaskWithDocumentation(taskId, taskTitle, taskDescription, stackInfo, streamingOptions, retryConfig, config, existingResearch) {
+        return this.retryHandler
+            .executeWithRetry(async () => {
+            // Context7 integration via HTTP calls
+            const mcpTools = await this.context7Client.getMCPTools();
+            const defaultAIConfig = this.modelProvider.getAIConfig();
+            const aiConfig = config
+                ? { ...defaultAIConfig, ...config }
+                : defaultAIConfig;
+            const model = this.modelProvider.getModel(aiConfig);
+            // Get custom research tools
+            // const customResearchTools = this.researchTools.getResearchTools();
+            // Build context for this operation using the actual task ID
+            const contextBuilder = new context_builder_1.ContextBuilder();
+            const builtContext = await contextBuilder.buildContext("1.1");
+            // Build existing research context
+            const existingResearchContext = existingResearch
+                ? Object.entries(existingResearch)
+                    .map(([lib, entries]) => `### ${lib}\n${entries.map((e) => `- Query: "${e.query}"`).join("\n")}`)
+                    .join("\n\n")
+                : "No existing research available.";
+            // const existingResearchContext = existingResearch
+            //   ? "## Existing research\n" +
+            //     existingResearch
+            //       .map(
+            //         (rs) =>
+            //           rs &&
+            //           `${rs.recap}\n#### librairies\n${rs.libraries.join(`- \n`)}\n\n#### files:\n${rs.libraries.join(`- \n`)}`,
+            //       )
+            //       .join("\n\n")
+            //   : "No existing research available.";
+            // Use PromptBuilder for consistent prompt handling
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "task-enhancement",
+                type: "user",
+                variables: {
+                    TASK_TITLE: taskTitle,
+                    TASK_DESCRIPTION: taskDescription,
+                    CONTEXT_INFO: `Technology stack: ${stackInfo || "Not specified"}`,
+                    EXISTING_RESEARCH: existingResearchContext,
+                    PRD_CONTENT: builtContext.prdContent || "No PRD content available",
+                },
+            });
+            if (!promptResult.success) {
+                throw new Error(`Failed to build task enhancement prompt: ${promptResult.error}`);
+            }
+            const prompt = promptResult.prompt;
+            // Merge Context7 MCP tools with custom research tools
+            const allTools = {
+                ...mcpTools,
+                // ...customResearchTools,
+            };
+            const result = (0, ai_1.streamText)({
+                model,
+                tools: allTools, // Context7 MCP tools + custom research tools
+                system: prompts_1.TASK_ENHANCEMENT_SYSTEM_PROMPT +
+                    `
+
+You have access to Context7 documentation tools.
+
+## Research Strategy:
+1. Use Context7 MCP tools (context7_resolve_library_id, context7_get_library_docs) for any new research needed
+2. Synthesize information from all sources to enhance the task
+
+Technology stack context: ${stackInfo || "Not specified"}
+
+## Available Cached Research:
+${existingResearchContext}`,
+                messages: [
+                    {
+                        role: "user",
+                        content: prompt,
+                    },
+                ],
+                maxRetries: 0, // Disable built-in retries since we handle them manually
+                stopWhen: (0, ai_1.stepCountIs)(8), // Allow more steps for comprehensive research
+                onError: ({ error }) => {
+                    // Call user's error callback if provided
+                    streamingOptions?.onError?.(error);
+                    // Re-throw errors to maintain existing error handling behavior
+                    throw error;
+                },
+                onChunk: streamingOptions?.onChunk
+                    ? ({ chunk }) => {
+                        if (chunk.type === "text-delta") {
+                            streamingOptions.onChunk(chunk.text);
+                        }
+                    }
+                    : undefined,
+                onFinish: streamingOptions?.onFinish
+                    ? ({ text, finishReason, usage }) => {
+                        streamingOptions.onFinish({
+                            text,
+                            finishReason,
+                            usage,
+                            isAborted: false,
+                        });
+                    }
+                    : undefined,
+            });
+            // Process tool calls and results properly
+            const toolCalls = await result.toolCalls;
+            const toolResults = await result.toolResults;
+            // Log tool interactions for debugging
+            if (toolCalls.length > 0) {
+                console.log("AI made tool calls:", toolCalls.map((tc) => ({ tool: tc.toolName, input: tc.input })));
+            }
+            if (toolResults.length > 0) {
+                console.log("Tool results received:", toolResults.map((tr) => ({
+                    tool: tr.toolName,
+                    output: tr.output,
+                })));
+            }
+            // Process the stream properly to ensure tool calls execute
+            let fullText = "";
+            for await (const textPart of result.textStream) {
+                fullText += textPart;
+                if (streamingOptions?.onChunk) {
+                    streamingOptions.onChunk(textPart);
+                }
+            }
+            return fullText;
+        }, retryConfig, "Task enhancement with documentation")
+            .finally(async () => {
+            await this.context7Client.closeMCPConnection();
+        });
+    }
+    async analyzeDocumentationNeeds(taskId, taskTitle, taskDescription, stackInfo, streamingOptions, retryConfig, config, existingResearch) {
+        return this.retryHandler
+            .executeWithRetry(async () => {
+            const mcpTools = await this.context7Client.getMCPTools();
+            const defaultAIConfig = this.modelProvider.getAIConfig();
+            const aiConfig = config
+                ? { ...defaultAIConfig, ...config }
+                : defaultAIConfig;
+            const model = this.modelProvider.getModel(aiConfig);
+            // Build existing research context
+            const existingResearchContext = existingResearch
+                ? "## Existing research\n" +
+                    existingResearch
+                        .map((rs) => rs &&
+                        `${rs.recap}\n#### librairies\n${rs.libraries.join(`- \n`)}\n\n#### files:\n${rs.libraries.join(`- \n`)}`)
+                        .join("\n\n")
+                : "No existing research available.";
+            // Use PromptBuilder for consistent prompt handling
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "documentation-detection",
+                type: "user",
+                variables: {
+                    TASK_TITLE: taskTitle,
+                    TASK_DESCRIPTION: taskDescription,
+                    STACK_INFO: stackInfo || "Not specified",
+                    EXISTING_RESEARCH: existingResearchContext,
+                },
+            });
+            if (!promptResult.success) {
+                throw new Error(`Failed to build documentation detection prompt: ${promptResult.error}`);
+            }
+            const prompt = promptResult.prompt;
+            // Track actual libraries and files saved
+            const libraries = [];
+            const files = [];
+            // Merge Context7 MCP tools with custom research tools
+            const allTools = {
+                ...mcpTools,
+            };
+            const result = (0, ai_1.streamText)({
+                model,
+                tools: allTools,
+                system: `You are an expert developer.\nYou have access to Context7 MCP tools for documentation research.\nFetch documentation relevant to the task in the project context and create a document giving that knowledge to the AI assistant that will implement the task.`,
+                messages: [{ role: "user", content: prompt }],
+                maxRetries: 0,
+                stopWhen: (0, ai_1.stepCountIs)(8), // Allow more steps for comprehensive analysis
+                onError: ({ error }) => {
+                    // Call user's error callback if provided
+                    streamingOptions?.onError?.(error);
+                    // Re-throw errors to maintain existing error handling behavior
+                    throw error;
+                },
+                onChunk: streamingOptions?.onChunk
+                    ? ({ chunk }) => {
+                        if (chunk.type === "text-delta") {
+                            streamingOptions.onChunk(chunk.text);
+                        }
+                        else if (chunk.type === "tool-result") {
+                            // Save Context7 documentation if this is a library docs result
+                            if (chunk.toolName === "get-library-docs" && chunk.output) {
+                                (async () => {
+                                    try {
+                                        // Extract library from the tool input
+                                        const input = chunk.input;
+                                        const libraryId = input.context7CompatibleLibraryID;
+                                        // Generate unique filename using library ID and timestamp
+                                        const libraryName = libraryId.split("/").pop() || "unknown";
+                                        const timestamp = Date.now();
+                                        const filename = input.topic ?? `${libraryName}-${timestamp}`;
+                                        // Extract content from tool result object
+                                        let content = "";
+                                        if (chunk.output &&
+                                            typeof chunk.output === "object") {
+                                            if ("content" in chunk.output) {
+                                                const contentArray = chunk.output
+                                                    .content;
+                                                if (Array.isArray(contentArray)) {
+                                                    content = contentArray
+                                                        .map((item) => item.text || "")
+                                                        .join("\n");
+                                                }
+                                                else {
+                                                    content = String(contentArray);
+                                                }
+                                            }
+                                            else if ("text" in chunk.output) {
+                                                content = chunk.output.text;
+                                            }
+                                        }
+                                        else if (typeof chunk.output === "string") {
+                                            content = chunk.output;
+                                        }
+                                        if (content) {
+                                            // Save documentation and get the file path
+                                            const docFile = await this.context7Client.saveContext7Documentation(libraryName, filename, content);
+                                            // BUILD THE LIBRARIES ARRAY WITH ACTUAL DATA
+                                            libraries.push({
+                                                name: libraryName,
+                                                context7Id: libraryId,
+                                                reason: "Documentation fetched for task implementation",
+                                                searchQuery: filename,
+                                            });
+                                            // TRACK THE ACTUAL FILE PATH
+                                            files.push(docFile);
+                                        }
+                                    }
+                                    catch (error) {
+                                        console.error("Failed to save Context7 documentation:", error);
+                                    }
+                                })();
+                            }
+                        }
+                    }
+                    : undefined,
+                onFinish: streamingOptions?.onFinish
+                    ? ({ text, finishReason, usage }) => {
+                        streamingOptions.onFinish({
+                            text,
+                            finishReason,
+                            usage,
+                            isAborted: false,
+                        });
+                    }
+                    : undefined,
+            });
+            // Process the stream properly to ensure tool calls execute
+            let fullText = "";
+            for await (const textPart of result.textStream) {
+                fullText += textPart;
+            }
+            // Get tool results for processing
+            const toolResults = await result.toolResults;
+            const toolCalls = await result.toolCalls;
+            // Save the generated documentation to a task-specific file
+            if (fullText.trim()) {
+                try {
+                    const storage = (0, ai_service_factory_1.getStorage)();
+                    const taskDocFile = await storage.saveTaskDocumentation(taskId, fullText);
+                    files.push(taskDocFile);
+                }
+                catch (error) {
+                    console.error("Failed to save task documentation:", error);
+                }
+            }
+            return {
+                libraries,
+                confidence: libraries.length > 0 ? 0.8 : 0.3,
+                toolResults: toolResults.map((tr) => ({
+                    toolName: tr.toolName,
+                    output: tr.output,
+                })),
+                files, // Return actual files saved
+            };
+        }, retryConfig, "Documentation needs analysis")
+            .finally(async () => {
+            await this.context7Client.closeMCPConnection();
+        });
+    }
+    async generateDocumentationRecap(libraries, documentContents, streamingOptions, retryConfig) {
+        const prompt = `Create a concise recap of the documentation fetched for these libraries:
+
+Libraries:
+${libraries.map((lib) => `- ${lib.name} (${lib.context7Id}): ${lib.reason}`).join("\n")}
+
+Documentation Contents:
+${documentContents.map((doc) => `## ${doc.library}\n${doc.content.substring(0, 500)}...`).join("\n\n")}
+
+Please provide a 2-3 sentence summary of what documentation is available and how it relates to the task.`;
+        return this.retryHandler.executeWithRetry(async () => {
+            return this.streamText(prompt, undefined, "You are a technical writer who creates concise summaries of documentation collections.", undefined, streamingOptions, { maxAttempts: 1 });
+        }, retryConfig, "Documentation recap generation");
+    }
+    async planTask(taskContext, taskDetails, config, promptOverride, userMessage, streamingOptions, retryConfig) {
+        return this.retryHandler.executeWithRetry(async () => {
+            // Use PromptBuilder if no prompt override provided
+            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 response = await this.streamText("", // empty prompt since we use messages
+            config, prompts_1.TASK_PLANNING_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+            // Return the plan text directly - no JSON parsing needed
+            return response;
+        }, retryConfig, "Task planning");
+    }
+}
+exports.AIOperations = AIOperations;

package/dist/lib/ai-service/json-parser.d.ts

@@ -0,0 +1,9 @@
+import { JSONParseResult } from "../../types";
+export declare class JSONParser {
+    /**
+     * Parses JSON from AI text response with improved error handling
+     * @deprecated Use generateObject instead for structured output
+     */
+    parseJSONFromResponse<T>(text: string): JSONParseResult<T>;
+}
+//# sourceMappingURL=json-parser.d.ts.map

package/dist/lib/ai-service/json-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-parser.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/json-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,qBAAa,UAAU;IACrB;;;OAGG;IACH,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC;CA4B3D"}