task-o-matic-core 0.1.0

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

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentationOperations = void 0;
+const ai_1 = require("ai");
+const prompt_builder_1 = require("../prompt-builder");
+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 logger_1 = require("../logger");
+class DocumentationOperations extends base_operations_1.BaseOperations {
+    async enhanceTaskWithDocumentation(taskId, taskTitle, taskDescription, stackInfo, streamingOptions, retryConfig, config, existingResearch, enableFilesystemTools) {
+        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);
+            const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+            const builtContext = await contextBuilder.buildContext("1.1");
+            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 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;
+            const allTools = {
+                ...mcpTools,
+                ...(enableFilesystemTools ? filesystem_tools_1.filesystemTools : {}),
+            };
+            const result = await (0, ai_1.streamText)({
+                model,
+                tools: allTools,
+                system: prompts_1.TASK_ENHANCEMENT_SYSTEM_PROMPT +
+                    `
+
+You have access to Context7 documentation tools${enableFilesystemTools ? " and filesystem tools" : ""}.
+
+## Available Tools:
+- Context7 MCP tools (context7_resolve_library_id, context7_get_library_docs) for library documentation
+${enableFilesystemTools
+                        ? `- readFile: Read the contents of any file in the project
+- listDirectory: List contents of directories`
+                        : ""}
+
+## Research Strategy:
+1. Use Context7 MCP tools for library documentation research
+${enableFilesystemTools
+                        ? `2. Use filesystem tools to understand project structure, existing code, and dependencies`
+                        : ""}
+${enableFilesystemTools ? "3" : "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,
+                stopWhen: (0, ai_1.stepCountIs)(8),
+                onError: ({ error }) => {
+                    streamingOptions?.onError?.(error);
+                    throw error;
+                },
+                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,
+            });
+            const toolCalls = await result.toolCalls;
+            const toolResults = await result.toolResults;
+            if (toolCalls.length > 0) {
+                logger_1.logger.info(`AI made tool calls: ${JSON.stringify(toolCalls.map((tc) => ({ tool: tc?.toolName, input: tc?.input })))}`);
+            }
+            if (toolResults.length > 0) {
+                logger_1.logger.info(`Tool results received: ${JSON.stringify(toolResults.map((tr) => ({
+                    tool: tr?.toolName,
+                    output: tr?.output,
+                })))}`);
+            }
+            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, enableFilesystemTools) {
+        // @ts-expect-error tool result type discrepency i cant be bothered with (that will probably bite me later...)
+        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);
+            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.";
+            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;
+            const libraries = [];
+            const files = [];
+            const allTools = {
+                ...mcpTools,
+                ...(enableFilesystemTools ? filesystem_tools_1.filesystemTools : {}),
+            };
+            const result = await (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),
+                onError: ({ error }) => {
+                    streamingOptions?.onError?.(error);
+                    throw error;
+                },
+                onChunk: streamingOptions?.onChunk
+                    ? ({ chunk }) => {
+                        if (chunk.type === "text-delta") {
+                            streamingOptions.onChunk(chunk.text);
+                        }
+                        else if (chunk.type === "reasoning-delta") {
+                            streamingOptions.onReasoning?.(chunk.text);
+                        }
+                        else if (chunk.type === "tool-result") {
+                            if (chunk.toolName === "get-library-docs" && chunk.output) {
+                                (async () => {
+                                    try {
+                                        const input = chunk.input;
+                                        const libraryId = input.context7CompatibleLibraryID;
+                                        const libraryName = libraryId.split("/").pop() || "unknown";
+                                        const timestamp = Date.now();
+                                        const filename = input.topic ?? `${libraryName}-${timestamp}`;
+                                        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) {
+                                            const docFile = await this.context7Client.saveContext7Documentation(libraryName, filename, content);
+                                            libraries.push({
+                                                name: libraryName,
+                                                context7Id: libraryId,
+                                                reason: "Documentation fetched for task implementation",
+                                                searchQuery: filename,
+                                            });
+                                            files.push(docFile);
+                                        }
+                                    }
+                                    catch (error) {
+                                        logger_1.logger.error(`Failed to save Context7 documentation: ${error}`);
+                                    }
+                                })();
+                            }
+                        }
+                    }
+                    : undefined,
+                onFinish: streamingOptions?.onFinish
+                    ? ({ text, finishReason, usage }) => {
+                        streamingOptions.onFinish({
+                            text,
+                            finishReason,
+                            usage,
+                            isAborted: false,
+                        });
+                    }
+                    : undefined,
+            });
+            let fullText = "";
+            for await (const textPart of result.textStream) {
+                fullText += textPart;
+            }
+            const toolResults = await result.toolResults;
+            const toolCalls = await result.toolCalls;
+            if (fullText.trim()) {
+                try {
+                    const storage = (0, ai_service_factory_1.getStorage)();
+                    const taskDocFile = await storage.saveTaskDocumentation(taskId, fullText);
+                    files.push(taskDocFile);
+                }
+                catch (error) {
+                    logger_1.logger.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,
+            };
+        }, retryConfig, "Documentation needs analysis")
+            .finally(async () => {
+            await this.context7Client.closeMCPConnection();
+        });
+    }
+    async generateDocumentationRecap(libraries, documentContents, streamingOptions, retryConfig) {
+        // Build variables for PromptBuilder
+        const librariesList = libraries
+            .map((lib) => `- ${lib.name} (${lib.context7Id}): ${lib.reason}`)
+            .join("\n");
+        const documentationContents = documentContents
+            .map((doc) => `## ${doc.library}\n${doc.content.substring(0, 500)}...`)
+            .join("\n\n");
+        const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "documentation-recap",
+            type: "user",
+            variables: {
+                LIBRARIES_LIST: librariesList,
+                DOCUMENTATION_CONTENTS: documentationContents,
+            },
+        });
+        if (!promptResult.success) {
+            throw new Error(`Failed to build documentation recap prompt: ${promptResult.error}`);
+        }
+        const systemPromptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+            name: "documentation-recap",
+            type: "system",
+            variables: {},
+        });
+        return this.retryHandler.executeWithRetry(async () => {
+            return this.streamText(promptResult.prompt, undefined, systemPromptResult.prompt, undefined, streamingOptions, { maxAttempts: 1 });
+        }, retryConfig, "Documentation recap generation");
+    }
+}
+exports.DocumentationOperations = DocumentationOperations;

package/dist/lib/ai-service/filesystem-tools.d.ts

@@ -0,0 +1,69 @@
+export declare const readFileTool: import("ai").Tool<{
+    filePath: string;
+}, {
+    success: boolean;
+    content: string;
+    path: string;
+    size: number;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    content?: undefined;
+    path?: undefined;
+    size?: undefined;
+}>;
+export declare const listDirectoryTool: import("ai").Tool<{
+    dirPath: string;
+}, {
+    success: boolean;
+    contents: {
+        name: string;
+        type: string;
+        path: string;
+        size: number | undefined;
+    }[];
+    directory: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    contents: never[];
+    directory?: undefined;
+}>;
+export declare const filesystemTools: {
+    readFile: import("ai").Tool<{
+        filePath: string;
+    }, {
+        success: boolean;
+        content: string;
+        path: string;
+        size: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        content?: undefined;
+        path?: undefined;
+        size?: undefined;
+    }>;
+    listDirectory: import("ai").Tool<{
+        dirPath: string;
+    }, {
+        success: boolean;
+        contents: {
+            name: string;
+            type: string;
+            path: string;
+            size: number | undefined;
+        }[];
+        directory: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        contents: never[];
+        directory?: undefined;
+    }>;
+};
+//# sourceMappingURL=filesystem-tools.d.ts.map

package/dist/lib/ai-service/filesystem-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-tools.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/filesystem-tools.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;EAwBvB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;EAoC5B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG3B,CAAC"}

package/dist/lib/ai-service/filesystem-tools.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filesystemTools = exports.listDirectoryTool = exports.readFileTool = void 0;
+const ai_1 = require("ai");
+const v3_1 = require("zod/v3");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+exports.readFileTool = (0, ai_1.tool)({
+    description: "Read the contents of a file",
+    inputSchema: v3_1.z.object({
+        filePath: v3_1.z.string().describe("Path to the file to read"),
+    }),
+    execute: async ({ filePath }) => {
+        try {
+            const resolvedPath = (0, path_1.resolve)(filePath);
+            const content = await (0, promises_1.readFile)(resolvedPath, "utf-8");
+            const stats = await (0, promises_1.stat)(resolvedPath);
+            return {
+                success: true,
+                content,
+                path: (0, path_1.relative)(process.cwd(), resolvedPath),
+                size: stats.size,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    },
+});
+exports.listDirectoryTool = (0, ai_1.tool)({
+    description: "List contents of a directory",
+    inputSchema: v3_1.z.object({
+        dirPath: v3_1.z.string().describe("Directory path to list"),
+    }),
+    execute: async ({ dirPath }) => {
+        try {
+            const resolvedPath = (0, path_1.resolve)(dirPath);
+            const entries = await (0, promises_1.readdir)(resolvedPath, { withFileTypes: true });
+            const contents = await Promise.all(entries.map(async (entry) => {
+                const fullPath = (0, path_1.join)(resolvedPath, entry.name);
+                const stats = await (0, promises_1.stat)(fullPath);
+                return {
+                    name: entry.name,
+                    type: entry.isDirectory() ? "directory" : "file",
+                    path: (0, path_1.relative)(process.cwd(), fullPath),
+                    size: entry.isFile() ? stats.size : undefined,
+                };
+            }));
+            return {
+                success: true,
+                contents,
+                directory: (0, path_1.relative)(process.cwd(), resolvedPath),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+                contents: [],
+            };
+        }
+    },
+});
+exports.filesystemTools = {
+    readFile: exports.readFileTool,
+    listDirectory: exports.listDirectoryTool,
+};

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

@@ -0,0 +1,34 @@
+import { JSONParseResult } from "../../types";
+export declare class JSONParser {
+    /**
+     * Extracts JSON from text that may contain markdown codeblocks or other formatting
+     */
+    /**
+     * Extracts the first valid JSON object or array from text using a stack-based approach
+     * This is much more robust than regex for nested structures or text with multiple brace pairs
+     */
+    private extractJSONString;
+    /**
+     * Extracts a balanced string starting from a specific index
+     */
+    private extractBalancedString;
+    /**
+     * Cleans JSON string by removing comments and trailing commas
+     * This handles "valid JS object" format that LLMs often output
+     */
+    private cleanJSON;
+    /**
+     * Normalizes object keys to handle case variations (e.g., "Tasks" -> "tasks")
+     */
+    private normalizeKeys;
+    /**
+     * Parses JSON from AI text response with improved error handling
+     * Now supports:
+     * - Extracting from markdown codeblocks (```json, ```JSON, or ```)
+     * - Stack-based extraction for robustness against surrounding text
+     * - Comment and trailing comma removal
+     * - Case-insensitive property names
+     */
+    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;;OAEG;IACH;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA8DzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA2C7B;;;OAGG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;IACH,OAAO,CAAC,aAAa;IAsBrB;;;;;;;OAOG;IACH,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC;CAwC3D"}

package/dist/lib/ai-service/json-parser.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONParser = void 0;
+class JSONParser {
+    /**
+     * Extracts JSON from text that may contain markdown codeblocks or other formatting
+     */
+    /**
+     * Extracts the first valid JSON object or array from text using a stack-based approach
+     * This is much more robust than regex for nested structures or text with multiple brace pairs
+     */
+    extractJSONString(text) {
+        // 1. Try to extract from markdown codeblock first (most reliable)
+        const codeblockPatterns = [
+            /```json\s*([\s\S]*?)```/i,
+            /```JSON\s*([\s\S]*?)```/i,
+            /```\s*([\s\S]*?)```/,
+        ];
+        for (const pattern of codeblockPatterns) {
+            const match = text.match(pattern);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+        // 2. Stack-based extraction for raw text
+        // Find all potential start indices ({ or [)
+        const candidates = [];
+        for (let i = 0; i < text.length; i++) {
+            if (text[i] === "{" || text[i] === "[") {
+                candidates.push({ start: i, char: text[i] });
+            }
+        }
+        // console.log(
+        //   `[DEBUG] Found ${candidates.length} candidates for JSON extraction`
+        // );
+        // Try to extract a valid JSON from each candidate start
+        for (const candidate of candidates) {
+            const extracted = this.extractBalancedString(text, candidate.start, candidate.char);
+            if (extracted) {
+                // 1. Try raw parse first (safest if valid JSON)
+                try {
+                    JSON.parse(extracted);
+                    return extracted;
+                }
+                catch (e) {
+                    // Ignore, fall through to cleaning
+                }
+                // 2. Try cleaning (comments, trailing commas)
+                try {
+                    const cleaned = this.cleanJSON(extracted);
+                    JSON.parse(cleaned);
+                    return cleaned;
+                }
+                catch (e) {
+                    // console.error(
+                    //   `[DEBUG] JSON Parse failed for candidate at index ${candidate.start}:`,
+                    //   e
+                    // );
+                    // If parse fails, continue to next candidate
+                    continue;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Extracts a balanced string starting from a specific index
+     */
+    extractBalancedString(text, startIndex, startChar) {
+        const endChar = startChar === "{" ? "}" : "]";
+        let balance = 0;
+        let inString = false;
+        let escaped = false;
+        for (let i = startIndex; i < text.length; i++) {
+            const char = text[i];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (!inString) {
+                if (char === startChar) {
+                    balance++;
+                }
+                else if (char === endChar) {
+                    balance--;
+                    if (balance === 0) {
+                        return text.substring(startIndex, i + 1);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Cleans JSON string by removing comments and trailing commas
+     * This handles "valid JS object" format that LLMs often output
+     */
+    cleanJSON(text) {
+        return text
+            .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "") // Remove comments
+            .replace(/,(\s*[}\]])/g, "$1") // Remove trailing commas
+            .trim();
+    }
+    /**
+     * Normalizes object keys to handle case variations (e.g., "Tasks" -> "tasks")
+     */
+    normalizeKeys(obj) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.normalizeKeys(item));
+        }
+        if (typeof obj === "object") {
+            const normalized = {};
+            for (const key in obj) {
+                // Convert first letter to lowercase
+                const normalizedKey = key.charAt(0).toLowerCase() + key.slice(1);
+                normalized[normalizedKey] = this.normalizeKeys(obj[key]);
+            }
+            return normalized;
+        }
+        return obj;
+    }
+    /**
+     * Parses JSON from AI text response with improved error handling
+     * Now supports:
+     * - Extracting from markdown codeblocks (```json, ```JSON, or ```)
+     * - Stack-based extraction for robustness against surrounding text
+     * - Comment and trailing comma removal
+     * - Case-insensitive property names
+     */
+    parseJSONFromResponse(text) {
+        // console.log(`[DEBUG] JSONParser received text (${text.length} chars)`);
+        // console.log(
+        //   `[DEBUG] First 100 chars: ${JSON.stringify(text.substring(0, 100))}`
+        // );
+        // console.log(`[DEBUG] Last 100 chars: ${JSON.stringify(text.slice(-100))}`);
+        try {
+            // Try to extract JSON from the response
+            const jsonStr = this.extractJSONString(text);
+            if (!jsonStr) {
+                // console.error("[DEBUG] extractJSONString returned null");
+                return {
+                    success: false,
+                    error: "Could not extract JSON from AI response. No JSON object or codeblock found.",
+                    rawText: text,
+                };
+            }
+            // Parse the JSON (it should be clean now)
+            let parsed = JSON.parse(jsonStr);
+            // Normalize keys to handle case variations (Tasks -> tasks, etc.)
+            parsed = this.normalizeKeys(parsed);
+            return {
+                success: true,
+                data: parsed,
+                rawText: text,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                rawText: text,
+            };
+        }
+    }
+}
+exports.JSONParser = JSONParser;

package/dist/lib/ai-service/mcp-client.d.ts

@@ -0,0 +1,9 @@
+import { ToolSet } from "ai";
+export declare class Context7Client {
+    private mcpClient;
+    initializeMCPClient(): Promise<any>;
+    getMCPTools(): Promise<ToolSet>;
+    closeMCPConnection(): Promise<void>;
+    saveContext7Documentation(library: string, query: string, content: string): Promise<string>;
+}
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/lib/ai-service/mcp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/mcp-client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAQ,MAAM,IAAI,CAAC;AAEnC,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAa;IAExB,mBAAmB;IAoBnB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAW/B,kBAAkB;IAOlB,yBAAyB,CAC7B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC;CAInB"}