task-o-matic-core 0.1.0

package/src/lib/ai-service/json-parser.ts

@@ -0,0 +1,203 @@
+import { JSONParseResult } from "../../types";
+
+export 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(text: string): string | null {
+    // 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: Array<{ start: number; char: string }> = [];
+    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
+   */
+  private extractBalancedString(
+    text: string,
+    startIndex: number,
+    startChar: string
+  ): string | null {
+    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
+   */
+  private cleanJSON(text: string): string {
+    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")
+   */
+  private normalizeKeys(obj: any): any {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.normalizeKeys(item));
+    }
+
+    if (typeof obj === "object") {
+      const normalized: any = {};
+      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<T>(text: string): JSONParseResult<T> {
+    // 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 as T,
+        rawText: text,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        rawText: text,
+      };
+    }
+  }
+}

package/src/lib/ai-service/mcp-client.ts

@@ -0,0 +1,54 @@
+import { experimental_createMCPClient } from "@ai-sdk/mcp";
+import { getStorage } from "../../utils/ai-service-factory";
+import { ToolSet, Tool } from "ai";
+
+export class Context7Client {
+  private mcpClient: any = null;
+
+  async initializeMCPClient() {
+    if (this.mcpClient) return this.mcpClient;
+
+    try {
+      // Connect to Context7 MCP server using HTTP transport
+      this.mcpClient = await experimental_createMCPClient({
+        transport: {
+          type: "http",
+          url: "https://mcp.context7.com/mcp",
+          headers: {
+            CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY || "",
+          },
+        },
+      });
+      return this.mcpClient;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getMCPTools(): Promise<ToolSet> {
+    const client = await this.initializeMCPClient();
+    if (!client) {
+      throw new Error("Failed to initialize MCP client");
+    }
+    
+    // Return original tools without wrapping - tool wrapping doesn't work with MCP tools
+    // Context7 result saving will be handled in ai-operations.ts by processing toolResults
+    return await client.tools();
+  }
+
+  async closeMCPConnection() {
+    if (this.mcpClient) {
+      await this.mcpClient.close();
+      this.mcpClient = null;
+    }
+  }
+
+  async saveContext7Documentation(
+    library: string,
+    query: string,
+    content: string,
+  ): Promise<string> {
+    const storage = getStorage();
+    return await storage.saveContext7Documentation(library, query, content);
+  }
+}

package/src/lib/ai-service/model-provider.ts

@@ -0,0 +1,192 @@
+import { openai } from "@ai-sdk/openai";
+import { anthropic, createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+// import { createGeminiProvider } from "ai-sdk-provider-gemini-cli";
+// import { GeminiProviderProxy } from "./gemini-proxy";
+import type { LanguageModel } from "ai";
+import { AIConfig } from "../../types";
+import { configManager } from "../config";
+import {
+  createStandardError,
+  TaskOMaticErrorCodes,
+} from "../../utils/task-o-matic-error";
+
+export class ModelProvider {
+  public getAIConfig(): AIConfig {
+    const config = configManager.getAIConfig();
+    const envConfig = this.getEnvConfig(config.provider);
+
+    // Override with environment variables if available
+    return {
+      ...config,
+      apiKey: config.apiKey || envConfig.apiKey,
+      baseURL: config.baseURL || envConfig.baseURL,
+    };
+  }
+
+  /**
+   * Get environment-based config using ConfigManager's getEnv callback.
+   * This ensures all env var access goes through a single source of truth.
+   */
+  private getEnvConfig(provider: string) {
+    // Use a helper to get env vars - if configManager has custom callbacks,
+    // this will use those; otherwise falls back to process.env
+    const getEnv = (key: string): string | undefined => {
+      try {
+        // Access through config structure which was built with getEnv callbacks
+        // or fall back to process.env for backwards compatibility
+        return process.env[key];
+      } catch {
+        return undefined;
+      }
+    };
+
+    const envConfigMap: Record<string, { apiKey?: string; baseURL?: string }> =
+      {
+        openai: {
+          apiKey: getEnv("OPENAI_API_KEY"),
+        },
+        anthropic: {
+          apiKey: getEnv("ANTHROPIC_API_KEY"),
+        },
+        zai: {
+          apiKey: getEnv("ZAI_API_KEY"),
+        },
+        openrouter: {
+          apiKey: getEnv("OPENROUTER_API_KEY"),
+          baseURL: "https://openrouter.ai/api/v1",
+        },
+        custom: {
+          apiKey: getEnv("CUSTOM_API_KEY"),
+          baseURL: getEnv("CUSTOM_API_URL"),
+        },
+      };
+
+    return envConfigMap[provider] || {};
+  }
+
+  getModel(aiConfig: AIConfig): LanguageModel {
+    const { provider, model, apiKey, baseURL } = aiConfig;
+
+    switch (provider) {
+      case "openai":
+        if (!apiKey)
+          throw createStandardError(
+            TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR,
+            "OpenAI API key is required",
+            {
+              suggestions: [
+                "Set the OPENAI_API_KEY environment variable.",
+                "Run `task-o-matic config set-ai-key <key>`",
+              ],
+            }
+          );
+        return openai(model);
+
+      case "anthropic":
+        if (!apiKey)
+          throw createStandardError(
+            TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR,
+            "Anthropic API key is required",
+            {
+              suggestions: [
+                "Set the ANTHROPIC_API_KEY environment variable.",
+                "Run `task-o-matic config set-ai-key <key>`",
+              ],
+            }
+          );
+        return anthropic(model);
+
+      case "openrouter":
+        if (!apiKey)
+          throw createStandardError(
+            TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR,
+            "OpenRouter API key is required",
+            {
+              suggestions: [
+                "Set the OPENROUTER_API_KEY environment variable.",
+                "Run `task-o-matic config set-ai-key <key>`",
+              ],
+            }
+          );
+        const openRouterProvider = createOpenRouter({
+          apiKey,
+          headers: {
+            "HTTP-Referer": "https://task-o-matic.dev",
+            "X-Title": "Task-O-Matic",
+          },
+        });
+        return openRouterProvider(model);
+
+      case "custom":
+        if (!apiKey)
+          throw createStandardError(
+            TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR,
+            "Custom API key is required for custom provider",
+            {
+              suggestions: [
+                "Set the CUSTOM_API_KEY environment variable.",
+                "Run `task-o-matic config set-ai-key <key>`",
+              ],
+            }
+          );
+        if (!baseURL)
+          throw createStandardError(
+            TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR,
+            "Custom provider requires baseURL",
+            {
+              suggestions: [
+                "Set the CUSTOM_API_URL environment variable.",
+                "Run `task-o-matic config set-ai-provider-url <url>`",
+              ],
+            }
+          );
+        const customProvider = createOpenAICompatible({
+          name: "custom",
+          apiKey,
+          baseURL,
+        });
+        return customProvider(model);
+
+      // disable for now, import error in the app
+      // case "gemini":
+      //   // Use Gemini CLI provider with OAuth via Proxy to handle lazy loading
+      //   return new GeminiProviderProxy(model, {
+      //     authType: "oauth-personal",
+      //   });
+
+      case "zai":
+        if (!apiKey)
+          throw createStandardError(
+            TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR,
+            "Z.AI Coding plan API key is required",
+            {
+              suggestions: [
+                "Set the ZAI_API_KEY environment variable.",
+                "Run `task-o-matic config set-ai-key <key>`",
+              ],
+            }
+          );
+
+        const zaiProvider = createAnthropic({
+          baseURL: "https://api.z.ai/api/anthropic/v1",
+          apiKey,
+        });
+
+        return zaiProvider(model);
+
+      default:
+        throw createStandardError(
+          TaskOMaticErrorCodes.AI_CONFIGURATION_ERROR,
+          `Unsupported provider: ${provider}`,
+          {
+            suggestions: [
+              "Use one of the supported providers: 'openai', 'anthropic', 'openrouter', 'custom', 'zai'.",
+              "Run `task-o-matic config set-ai-provider <provider>`",
+            ],
+          }
+        );
+    }
+  }
+}