task-o-matic-core 0.1.0

package/src/lib/ai-service/base-operations.ts

@@ -0,0 +1,139 @@
+import { streamText, type LanguageModel } from "ai";
+import { AIConfig, StreamingOptions, RetryConfig } from "../../types";
+import { JSONParser } from "./json-parser";
+import { Context7Client } from "./mcp-client";
+import { RetryHandler } from "./retry-handler";
+import { ModelProvider } from "./model-provider";
+
+export class BaseOperations {
+  protected jsonParser = new JSONParser();
+  protected context7Client = new Context7Client();
+  protected retryHandler = new RetryHandler();
+  protected modelProvider = new ModelProvider();
+
+  /**
+   * Merges AI configuration with proper precedence.
+   *
+   * Configuration precedence (highest to lowest):
+   * 1. Method parameter `config` (operation-specific overrides)
+   * 2. ConfigManager global config (project-level settings)
+   * 3. Environment variables (OPENAI_API_KEY, etc.)
+   * 4. Provider defaults (defined in config.ts)
+   *
+   * @param config - Optional operation-specific config overrides
+   * @returns Merged AIConfig with all precedence levels applied
+   *
+   * @example
+   * ```typescript
+   * // Override just the model for this operation
+   * const finalConfig = this.mergeAIConfig({ model: "gpt-4o" });
+   *
+   * // Use default config (from ConfigManager + env vars)
+   * const finalConfig = this.mergeAIConfig();
+   * ```
+   */
+  protected mergeAIConfig(config?: Partial<AIConfig>): AIConfig {
+    // Get base config (includes ConfigManager + env vars + defaults)
+    const baseConfig = this.modelProvider.getAIConfig();
+
+    // Apply operation-specific overrides (highest priority)
+    return { ...baseConfig, ...config };
+  }
+
+  /**
+   * Handles Context7 tool results by caching documentation.
+   * Extracts and saves documentation from get-library-docs tool results.
+   *
+   * @param chunk - The chunk to check for Context7 tool results
+   * @protected
+   */
+  protected handleContext7ToolResult(chunk: any): void {
+    if (chunk.type === "tool-result" && chunk.toolName === "get-library-docs") {
+      const docs = chunk.output;
+      const libraryID = chunk.input?.context7CompatibleLibraryID || "unknown";
+      const topic = chunk.input?.topic || "general";
+
+      if (docs && typeof docs === "object" && "content" in docs) {
+        this.context7Client.saveContext7Documentation(
+          libraryID,
+          docs.content,
+          topic
+        );
+      } else if (docs && typeof docs === "string") {
+        this.context7Client.saveContext7Documentation(libraryID, docs, topic);
+      }
+    }
+  }
+
+  async streamText(
+    prompt: string,
+    config?: Partial<AIConfig>,
+    systemPrompt?: string,
+    userMessage?: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: Partial<RetryConfig>
+  ): Promise<string> {
+    // Merge config with proper precedence (Bug fix 2.9)
+    const aiConfig = this.mergeAIConfig(config);
+
+    return this.retryHandler.executeWithRetry(
+      async () => {
+        const model = this.modelProvider.getModel(aiConfig);
+
+        const result = streamText({
+          model,
+          system: systemPrompt,
+          messages: [{ role: "user", content: userMessage || prompt }],
+          maxRetries: 0,
+          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);
+                }
+                // Handle Context7 tool result caching
+                this.handleContext7ToolResult(chunk);
+              }
+            : undefined,
+          onFinish: streamingOptions?.onFinish
+            ? ({ text, finishReason, usage }) => {
+                streamingOptions.onFinish!({
+                  text,
+                  finishReason,
+                  usage,
+                  isAborted: false,
+                });
+              }
+            : undefined,
+          ...(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"
+    );
+  }
+}

package/src/lib/ai-service/documentation-operations.ts

@@ -0,0 +1,438 @@
+import { streamText, stepCountIs } from "ai";
+import type { ToolSet } from "ai";
+import {
+  AIConfig,
+  DocumentationDetection,
+  StreamingOptions,
+  RetryConfig,
+  TaskDocumentation,
+} from "../../types";
+import { PromptBuilder } from "../prompt-builder";
+import { TASK_ENHANCEMENT_SYSTEM_PROMPT } from "../../prompts";
+import { getContextBuilder, getStorage } from "../../utils/ai-service-factory";
+import { filesystemTools } from "./filesystem-tools";
+import { BaseOperations } from "./base-operations";
+import { logger } from "../logger";
+
+export class DocumentationOperations extends BaseOperations {
+  async enhanceTaskWithDocumentation(
+    taskId: string,
+    taskTitle: string,
+    taskDescription: string,
+    stackInfo?: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: Partial<RetryConfig>,
+    config?: Partial<AIConfig>,
+    existingResearch?: Record<string, Array<{ query: string; doc: string }>>,
+    enableFilesystemTools?: boolean
+  ): Promise<string> {
+    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 = 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 = 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 as ToolSet),
+            ...(enableFilesystemTools ? filesystemTools : {}),
+          };
+
+          const result = await streamText({
+            model,
+            tools: allTools,
+            system:
+              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: 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.info(
+              `AI made tool calls: ${JSON.stringify(toolCalls.map((tc) => ({ tool: tc?.toolName, input: tc?.input })))}`
+            );
+          }
+
+          if (toolResults.length > 0) {
+            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: string,
+    taskTitle: string,
+    taskDescription: string,
+    stackInfo?: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: Partial<RetryConfig>,
+    config?: Partial<AIConfig>,
+    existingResearch?: (TaskDocumentation | undefined)[],
+    enableFilesystemTools?: boolean
+  ): Promise<DocumentationDetection> {
+    // @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 = 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: Array<{
+            name: string;
+            context7Id: string;
+            reason: string;
+            searchQuery: string;
+          }> = [];
+          const files: string[] = [];
+
+          const allTools = {
+            ...(mcpTools as ToolSet),
+            ...(enableFilesystemTools ? filesystemTools : {}),
+          };
+
+          const result = await 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: 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 as {
+                            context7CompatibleLibraryID: string;
+                            tokens?: number;
+                            topic?: string;
+                          };
+                          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 as Array<{
+                                type: string;
+                                text: string;
+                              }>;
+                              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 as string;
+                            }
+                          } 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.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 = getStorage();
+              const taskDocFile = await storage.saveTaskDocumentation(
+                taskId,
+                fullText
+              );
+              files.push(taskDocFile);
+            } catch (error) {
+              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: Array<{ name: string; context7Id: string; reason: string }>,
+    documentContents: Array<{ library: string; content: string }>,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: Partial<RetryConfig>
+  ): Promise<string> {
+    // 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 = 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 = 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"
+    );
+  }
+}

package/src/lib/ai-service/filesystem-tools.ts

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

package/src/lib/ai-service/gemini-proxy.ts.bak

@@ -0,0 +1,52 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+
+let _createGeminiProvider: any = null;
+
+function getCreateGeminiProvider() {
+  if (_createGeminiProvider) return _createGeminiProvider;
+
+  if (typeof window !== "undefined") {
+    throw new Error(
+      "GeminiProviderProxy is only available in Node.js CLI environments."
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  _createGeminiProvider =
+    require("ai-sdk-provider-gemini-cli").createGeminiProvider;
+  return _createGeminiProvider;
+}
+
+export class GeminiProviderProxy implements LanguageModelV2 {
+  readonly specificationVersion = "v2";
+  readonly provider = "gemini";
+  readonly modelId: string;
+  readonly defaultObjectGenerationMode = "json";
+  readonly supportedUrls: Record<string, RegExp[]> = {};
+  private readonly config: any;
+  private realModel: LanguageModelV2 | null = null;
+
+  constructor(modelId: string, config: any) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  private getRealModel(): LanguageModelV2 {
+    if (!this.realModel) {
+      const createGeminiProvider = getCreateGeminiProvider();
+      const provider = createGeminiProvider(this.config);
+      this.realModel = provider(this.modelId);
+    }
+    return this.realModel!;
+  }
+
+  async doGenerate(options: any): Promise<any> {
+    const model = this.getRealModel();
+    return model.doGenerate(options);
+  }
+
+  async doStream(options: any): Promise<any> {
+    const model = this.getRealModel();
+    return model.doStream(options);
+  }
+}