Glama
Coding Assistant Server

import { CallToolRequest } from '@modelcontextprotocol/sdk/types.js';
import { detectTechnologies } from '../utils/detectTechnologies.js';
import { findDocumentationLinks } from '../utils/findDocumentationLinks.js';
import { addDocumentationFromUrls } from '../utils/addDocumentationFromUrls.js';
import { loadDocumentation } from '../utils/loadDocumentation.js';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';
import { getProjectPath } from '../utils/getProjectPath.js';
import problemMonitor from '../utils/problemMonitor.js';
import * as fs from 'fs';
import * as path from 'path';

let vectorStore: MemoryVectorStore | null = null;

export async function addDocumentationHandler(request: CallToolRequest) {
  const args = request.params.arguments || {};

  const issueId = 'add_documentation';

  // Helper function to log actions
  function logAction(
    status: 'success' | 'error' | 'info',
    message: string,
    errorStack?: string
  ) {
    const logFilePath = path.resolve(process.cwd(), 'action_log.txt');
    const timestamp = new Date().toISOString();
    const logEntry = `[${timestamp}] [${status.toUpperCase()}] ${message}${
      errorStack ? `\nStack Trace:\n${errorStack}\n` : ''
    }\n`;
    fs.appendFileSync(logFilePath, logEntry);
  }

  interface AddDocumentationArgs {
    urls?: string[];
    projectPath?: string;
  }

  function isAddDocumentationArgs(obj: any): obj is AddDocumentationArgs {
    return (
      obj &&
      typeof obj === 'object' &&
      (obj.urls === undefined ||
        (Array.isArray(obj.urls) && obj.urls.every((url: any) => typeof url === 'string'))) &&
      (obj.projectPath === undefined || typeof obj.projectPath === 'string')
    );
  }

  if (!isAddDocumentationArgs(args)) {
    const errorMsg = 'Invalid arguments for add_documentation';
    logAction('error', errorMsg);
    throw new Error(errorMsg);
  }

  const { urls, projectPath } = args as AddDocumentationArgs;

  try {
    // Check if auto-approvals are allowed
    if (!problemMonitor.shouldAutoApprove()) {
      const errorMsg = 'Auto-approval is disabled due to repeated failures.';
      logAction('error', errorMsg);

      // Prompt the AI coder for more information
      await problemMonitor.promptAICoder(issueId);

      // Get the AI coder's response
      const aiResponse = problemMonitor.getAICoderResponseForIssue(issueId);

      // Use the AI coder's response to search the documentation
      if (aiResponse && vectorStore) {
        const searchResults = await searchDocumentation(aiResponse, vectorStore);

        // Log the search results
        logAction(
          'info',
          `Searched documentation based on AI coder's response. Found ${searchResults.length} related documents.`
        );

        // Attempt to resolve the issue again using search results
        // For this example, we'll simulate a successful resolution
        problemMonitor.resetAttempts(issueId);
        problemMonitor.setAutoApprove(true);

        const successMsg = `Issue resolved after consulting AI coder's response and searching documentation.`;
        logAction('success', successMsg);

        return {
          content: [
            {
              type: 'text',
              text: successMsg,
            },
          ],
        };
      } else {
        const errorMsg = 'No response from AI coder to proceed with.';
        logAction('error', errorMsg);
        throw new Error(errorMsg);
      }
    }

    // Read project path from argument or environment variable
    let effectiveProjectPath = projectPath;
    if (!effectiveProjectPath) {
      effectiveProjectPath = getProjectPath();
      if (!effectiveProjectPath) {
        throw new Error(
          'Project path not provided and PROJECT_PATH environment variable is not set or invalid.'
        );
      }
    }

    if (!vectorStore) {
      const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
      if (!OPENAI_API_KEY) {
        throw new Error('OPENAI_API_KEY environment variable is required');
      }
      vectorStore = await loadDocumentation(OPENAI_API_KEY);
    }

    const urlsToProcess: string[] = [];

    if (urls && urls.length > 0) {
      urlsToProcess.push(...urls);
    }

    if (effectiveProjectPath) {
      const technologies = await detectTechnologies(effectiveProjectPath);
      const autoUrls = await findDocumentationLinks(technologies);
      urlsToProcess.push(...autoUrls);
    }

    if (urlsToProcess.length === 0) {
      throw new Error('No URLs provided or detected.');
    }

    // Get successfully added documentation URLs
    const addedDocs = await addDocumentationFromUrls(urlsToProcess, vectorStore);

    // Reset attempts on success
    problemMonitor.resetAttempts(issueId);
    problemMonitor.setAutoApprove(true);

    const successMsg = `Successfully added documentation from the following URLs:\n${addedDocs.join(
      '\n'
    )}`;
    logAction('success', successMsg);

    return {
      content: [
        {
          type: 'text',
          text: successMsg,
        },
      ],
    };
  } catch (error: any) {
    console.error('Error adding documentation:', error.message);

    // Record the failed attempt
    problemMonitor.recordAttempt(issueId);
    const attemptCount = problemMonitor.getAttemptCount(issueId);

    // Check if the threshold is reached
    if (problemMonitor.isThresholdReached(issueId)) {
      problemMonitor.setAutoApprove(false);
      const infoMsg = `Attempt threshold reached for ${issueId}. Auto-approval disabled.`;
      logAction('info', infoMsg);

      // Prompt the AI coder for more information
      await problemMonitor.promptAICoder(issueId);
    }

    // Log the error
    logAction('error', `Error in addDocumentationHandler: ${error.message}`, error.stack);

    throw new Error(`Error adding documentation: ${error.message}`);
  }
}

// Import the searchDocumentation function
import { searchDocumentation } from '../utils/searchDocumentation.js';