@mgsoftwarebv/mcp-server-bridge 2.15.1 → 2.17.0

package/dist/index.js

@@ -4,6 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ListToolsRequestSchema, ListResourcesRequestSchema, CallToolRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { createClient } from '@supabase/supabase-js';
 import { createHash } from 'crypto';
+import { Octokit } from '@octokit/rest';
 
 var args = process.argv.slice(2);
 var apiKey = args.find((arg) => arg.startsWith("--api-key="))?.split("=")[1] || process.env.MG_TICKETS_API_KEY;
@@ -67,6 +68,99 @@ async function downloadImageAsBase64(storageKey) {
     return null;
   }
 }
+async function getGithubTokenForProject(projectId, teamId) {
+  try {
+    const { data: repoData, error: repoError } = await supabase.from("project_github_repositories").select("repository_full_name").eq("project_id", projectId).eq("team_id", teamId).single();
+    if (repoError || !repoData) {
+      console.error(`No GitHub repository linked to project ${projectId}`);
+      return null;
+    }
+    const { data: appData, error: appError } = await supabase.from("apps").select("config").eq("team_id", teamId).eq("app_id", "github").single();
+    if (appError || !appData?.config?.access_token) {
+      console.error(`GitHub app not connected for team ${teamId}`);
+      return null;
+    }
+    const accessToken = appData.config.access_token;
+    const repositoryFullName = repoData.repository_full_name;
+    const [owner, repo] = repositoryFullName.split("/");
+    if (!owner || !repo) {
+      console.error(`Invalid repository full name: ${repositoryFullName}`);
+      return null;
+    }
+    return {
+      token: accessToken,
+      repositoryFullName,
+      owner,
+      repo
+    };
+  } catch (error) {
+    console.error("Error getting GitHub token for project:", error);
+    return null;
+  }
+}
+async function transitionToNextPhase(sessionId, currentPhase) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const phaseOrder = ["analysis", "bug_investigation", "development", "communication"];
+    const { data: allPhases, error: fetchError } = await supabase.from("ai_time_logs").select("*").eq("ai_session_id", sessionId).order("activity_type");
+    if (fetchError || !allPhases) {
+      console.error("Failed to fetch phases for transition:", fetchError);
+      return;
+    }
+    let currentPhaseType = currentPhase;
+    if (!currentPhaseType) {
+      const activePhase = allPhases.find((p) => p.status === "in_progress");
+      currentPhaseType = activePhase?.activity_type;
+    }
+    if (!currentPhaseType) {
+      const analysisPhase = allPhases.find((p) => p.activity_type === "analysis");
+      if (analysisPhase && analysisPhase.status === "pending" && analysisPhase.estimated_duration_seconds > 0) {
+        await supabase.from("ai_time_logs").update({
+          status: "in_progress",
+          started_at: now.toISOString()
+        }).eq("id", analysisPhase.id);
+        console.error("\u2705 Started analysis phase");
+      }
+      return;
+    }
+    const currentPhaseRecord = allPhases.find((p) => p.activity_type === currentPhaseType && p.status === "in_progress");
+    if (currentPhaseRecord) {
+      const duration = Math.round((now.getTime() - new Date(currentPhaseRecord.started_at).getTime()) / 1e3);
+      await supabase.from("ai_time_logs").update({
+        status: "completed",
+        ended_at: now.toISOString(),
+        duration_seconds: duration
+      }).eq("id", currentPhaseRecord.id);
+      console.error(`\u2705 Completed phase: ${currentPhaseType} (${duration}s)`);
+    }
+    const currentIndex = phaseOrder.indexOf(currentPhaseType);
+    if (currentIndex === -1 || currentIndex === phaseOrder.length - 1) {
+      console.error("No next phase to transition to");
+      return;
+    }
+    for (let i = currentIndex + 1; i < phaseOrder.length; i++) {
+      const nextPhaseType = phaseOrder[i];
+      const nextPhase = allPhases.find((p) => p.activity_type === nextPhaseType);
+      if (!nextPhase) continue;
+      if (nextPhase.estimated_duration_seconds === 0) {
+        await supabase.from("ai_time_logs").update({ status: "skipped" }).eq("id", nextPhase.id);
+        console.error(`\u23ED\uFE0F Skipped phase: ${nextPhaseType} (0 minutes estimated)`);
+        continue;
+      }
+      if (nextPhase.status === "pending") {
+        await supabase.from("ai_time_logs").update({
+          status: "in_progress",
+          started_at: now.toISOString()
+        }).eq("id", nextPhase.id);
+        console.error(`\u2705 Started next phase: ${nextPhaseType}`);
+        return;
+      }
+    }
+    console.error("All remaining phases skipped or completed");
+  } catch (error) {
+    console.error("Error transitioning to next phase:", error);
+  }
+}
 var server = new Server(
   {
     name: "mg-tickets-mcp-bridge",
@@ -416,6 +510,113 @@ var TOOLS = [
       },
       required: ["workDescription", "estimatedHours"]
     }
+  },
+  // === GITHUB TOOLS ===
+  {
+    name: "search-github-code",
+    description: "Search for code in a GitHub repository. Use this to find relevant files, functions, or code patterns related to a ticket.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Project ID (UUID) - Required to identify which GitHub repository to search"
+        },
+        query: {
+          type: "string",
+          description: "Search query (e.g., function name, class name, error message, component name)"
+        },
+        language: {
+          type: "string",
+          description: 'Optional: Filter by programming language (e.g., "typescript", "python", "javascript")'
+        },
+        path: {
+          type: "string",
+          description: 'Optional: Filter by file path pattern (e.g., "src/components")'
+        },
+        maxResults: {
+          type: "number",
+          default: 10,
+          maximum: 30,
+          description: "Maximum number of results to return (default: 10, max: 30)"
+        }
+      },
+      required: ["projectId", "query"]
+    }
+  },
+  {
+    name: "get-github-file",
+    description: "Get the contents of a specific file from a GitHub repository. Use this after finding relevant files to read their full content.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Project ID (UUID)"
+        },
+        filePath: {
+          type: "string",
+          description: 'Full path to the file in the repository (e.g., "src/components/Button.tsx")'
+        },
+        ref: {
+          type: "string",
+          description: "Optional: Git reference (branch, tag, or commit SHA). Defaults to repository default branch."
+        }
+      },
+      required: ["projectId", "filePath"]
+    }
+  },
+  {
+    name: "list-github-directory",
+    description: "List files and directories in a GitHub repository directory. Use this to explore repository structure.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Project ID (UUID)"
+        },
+        directoryPath: {
+          type: "string",
+          description: 'Path to directory (e.g., "src/components"). Use empty string or "/" for root directory.'
+        },
+        ref: {
+          type: "string",
+          description: "Optional: Git reference (branch, tag, or commit SHA). Defaults to repository default branch."
+        }
+      },
+      required: ["projectId", "directoryPath"]
+    }
+  },
+  {
+    name: "search-github-issues",
+    description: "Search for GitHub issues and pull requests related to a topic. Useful to find similar past issues or relevant discussions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Project ID (UUID)"
+        },
+        query: {
+          type: "string",
+          description: "Search query for issues/PRs"
+        },
+        state: {
+          type: "string",
+          enum: ["open", "closed", "all"],
+          default: "all",
+          description: "Filter by issue state"
+        },
+        maxResults: {
+          type: "number",
+          default: 10,
+          maximum: 30,
+          description: "Maximum number of results to return"
+        }
+      },
+      required: ["projectId", "query"]
+    }
   }
 ];
 var RESOURCES = [
@@ -444,24 +645,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
   return { resources: RESOURCES };
 });
-async function updatePhaseTransition(sessionId, fromPhase, toPhase) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const { data: prevPhase } = await supabase.from("ai_time_logs").select("*").eq("ai_session_id", sessionId).eq("activity_type", fromPhase).eq("status", "in_progress").single();
-  if (prevPhase) {
-    const duration = Math.round(
-      (new Date(now).getTime() - new Date(prevPhase.started_at).getTime()) / 1e3
-    );
-    await supabase.from("ai_time_logs").update({
-      ended_at: now,
-      duration_seconds: duration,
-      status: "completed"
-    }).eq("id", prevPhase.id);
-  }
-  await supabase.from("ai_time_logs").update({
-    started_at: now,
-    status: "in_progress"
-  }).eq("ai_session_id", sessionId).eq("activity_type", toPhase).eq("status", "pending");
-}
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   if (!authContext) {
     return {
@@ -1021,12 +1204,19 @@ ${context.ticketData ? `Ticket: ${context.ticketData.ticket_number} - ${context.
           const allCompleted = currentTodos.every((t) => t.status === "completed");
           const { data: currentPhase } = await supabase.from("ai_time_logs").select("activity_type, status").eq("ai_session_id", session.id).eq("status", "in_progress").single();
           if (hasInProgress && currentPhase?.activity_type === "analysis") {
-            await updatePhaseTransition(session.id, "analysis", "development");
-            phaseTransition = "Analysis \u2192 Development";
+            await transitionToNextPhase(session.id, "analysis");
+            phaseTransition = "Analysis completed \u2192 Next phase started (Investigation/Development)";
+          }
+          if (hasInProgress && currentPhase?.activity_type === "bug_investigation") {
+            const completedCount = currentTodos.filter((t) => t.status === "completed").length;
+            if (completedCount > 0) {
+              await transitionToNextPhase(session.id, "bug_investigation");
+              phaseTransition = "Investigation completed \u2192 Development phase started";
+            }
           }
           if (allCompleted && currentPhase?.activity_type === "development") {
-            await updatePhaseTransition(session.id, "development", "communication");
-            phaseTransition = "Development \u2192 Communication";
+            await transitionToNextPhase(session.id, "development");
+            phaseTransition = "Development completed \u2192 Communication phase started";
           }
         }
         return {
@@ -1471,6 +1661,297 @@ ${efficiencyNotes}
           }]
         };
       }
+      // === GITHUB TOOLS ===
+      case "search-github-code": {
+        const { projectId, query, language, path, maxResults = 10 } = args2;
+        const githubInfo = await getGithubTokenForProject(projectId, authContext.teamId);
+        if (!githubInfo) {
+          return {
+            content: [{
+              type: "text",
+              text: "\u274C GitHub not configured for this project. Please:\n1. Connect GitHub app for your team\n2. Link a GitHub repository to this project"
+            }]
+          };
+        }
+        try {
+          const octokit = new Octokit({ auth: githubInfo.token });
+          let searchQuery = `${query} repo:${githubInfo.repositoryFullName}`;
+          if (language) searchQuery += ` language:${language}`;
+          if (path) searchQuery += ` path:${path}`;
+          console.error(`\u{1F50D} Searching GitHub: ${searchQuery}`);
+          const { data } = await octokit.rest.search.code({
+            q: searchQuery,
+            per_page: Math.min(maxResults, 30)
+          });
+          if (!data.items || data.items.length === 0) {
+            return {
+              content: [{
+                type: "text",
+                text: `\u{1F50D} No code found matching "${query}" in ${githubInfo.repositoryFullName}`
+              }]
+            };
+          }
+          let responseText = `\u{1F50D} **Found ${data.items.length} code matches in ${githubInfo.repositoryFullName}:**
+
+`;
+          for (const item of data.items) {
+            responseText += `\u{1F4C4} **${item.path}**
+`;
+            responseText += `   Repository: ${item.repository.full_name}
+`;
+            responseText += `   URL: ${item.html_url}
+`;
+            if (item.score) responseText += `   Relevance: ${item.score.toFixed(2)}
+`;
+            responseText += `
+`;
+          }
+          responseText += `
+\u{1F4A1} Use \`get-github-file\` to read the full content of any file.`;
+          return {
+            content: [{
+              type: "text",
+              text: responseText
+            }]
+          };
+        } catch (error) {
+          console.error("GitHub search error:", error);
+          if (error.status === 403 && error.message?.includes("rate limit")) {
+            return {
+              content: [{
+                type: "text",
+                text: "\u26A0\uFE0F GitHub API rate limit exceeded. Please try again later."
+              }]
+            };
+          }
+          if (error.status === 401) {
+            return {
+              content: [{
+                type: "text",
+                text: "\u274C GitHub token invalid. Please reconnect the GitHub app."
+              }]
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `\u274C GitHub search failed: ${error.message || "Unknown error"}`
+            }]
+          };
+        }
+      }
+      case "get-github-file": {
+        const { projectId, filePath, ref } = args2;
+        const githubInfo = await getGithubTokenForProject(projectId, authContext.teamId);
+        if (!githubInfo) {
+          return {
+            content: [{
+              type: "text",
+              text: "\u274C GitHub not configured for this project."
+            }]
+          };
+        }
+        try {
+          const octokit = new Octokit({ auth: githubInfo.token });
+          console.error(`\u{1F4C4} Reading file: ${filePath} from ${githubInfo.repositoryFullName}`);
+          const { data } = await octokit.rest.repos.getContent({
+            owner: githubInfo.owner,
+            repo: githubInfo.repo,
+            path: filePath,
+            ref
+          });
+          if (Array.isArray(data) || data.type !== "file") {
+            return {
+              content: [{
+                type: "text",
+                text: `\u274C "${filePath}" is not a file or contains multiple items.`
+              }]
+            };
+          }
+          const content = Buffer.from(data.content, "base64").toString("utf-8");
+          let responseText = `\u{1F4C4} **File: ${filePath}**
+`;
+          responseText += `Repository: ${githubInfo.repositoryFullName}
+`;
+          responseText += `Size: ${data.size} bytes
+`;
+          responseText += `URL: ${data.html_url}
+
+`;
+          responseText += `**Content:**
+\`\`\`
+${content}
+\`\`\``;
+          return {
+            content: [{
+              type: "text",
+              text: responseText
+            }]
+          };
+        } catch (error) {
+          console.error("GitHub get file error:", error);
+          if (error.status === 404) {
+            return {
+              content: [{
+                type: "text",
+                text: `\u274C File not found: ${filePath}`
+              }]
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `\u274C Failed to read file: ${error.message || "Unknown error"}`
+            }]
+          };
+        }
+      }
+      case "list-github-directory": {
+        const { projectId, directoryPath, ref } = args2;
+        const githubInfo = await getGithubTokenForProject(projectId, authContext.teamId);
+        if (!githubInfo) {
+          return {
+            content: [{
+              type: "text",
+              text: "\u274C GitHub not configured for this project."
+            }]
+          };
+        }
+        try {
+          const octokit = new Octokit({ auth: githubInfo.token });
+          const normalizedPath = !directoryPath || directoryPath === "/" ? "" : directoryPath;
+          console.error(`\u{1F4C1} Listing directory: ${normalizedPath || "(root)"} in ${githubInfo.repositoryFullName}`);
+          const { data } = await octokit.rest.repos.getContent({
+            owner: githubInfo.owner,
+            repo: githubInfo.repo,
+            path: normalizedPath,
+            ref
+          });
+          if (!Array.isArray(data)) {
+            return {
+              content: [{
+                type: "text",
+                text: `\u274C "${directoryPath}" is not a directory.`
+              }]
+            };
+          }
+          let responseText = `\u{1F4C1} **Directory: ${directoryPath || "(root)"}**
+`;
+          responseText += `Repository: ${githubInfo.repositoryFullName}
+`;
+          responseText += `Items: ${data.length}
+
+`;
+          const directories = data.filter((item) => item.type === "dir");
+          const files = data.filter((item) => item.type === "file");
+          if (directories.length > 0) {
+            responseText += `**\u{1F4C1} Directories (${directories.length}):**
+`;
+            for (const dir of directories) {
+              responseText += `   - ${dir.name}/
+`;
+            }
+            responseText += `
+`;
+          }
+          if (files.length > 0) {
+            responseText += `**\u{1F4C4} Files (${files.length}):**
+`;
+            for (const file of files) {
+              responseText += `   - ${file.name} (${file.size} bytes)
+`;
+            }
+          }
+          return {
+            content: [{
+              type: "text",
+              text: responseText
+            }]
+          };
+        } catch (error) {
+          console.error("GitHub list directory error:", error);
+          if (error.status === 404) {
+            return {
+              content: [{
+                type: "text",
+                text: `\u274C Directory not found: ${directoryPath}`
+              }]
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `\u274C Failed to list directory: ${error.message || "Unknown error"}`
+            }]
+          };
+        }
+      }
+      case "search-github-issues": {
+        const { projectId, query, state = "all", maxResults = 10 } = args2;
+        const githubInfo = await getGithubTokenForProject(projectId, authContext.teamId);
+        if (!githubInfo) {
+          return {
+            content: [{
+              type: "text",
+              text: "\u274C GitHub not configured for this project."
+            }]
+          };
+        }
+        try {
+          const octokit = new Octokit({ auth: githubInfo.token });
+          let searchQuery = `${query} repo:${githubInfo.repositoryFullName} is:issue`;
+          if (state !== "all") searchQuery += ` state:${state}`;
+          console.error(`\u{1F50D} Searching GitHub issues: ${searchQuery}`);
+          const { data } = await octokit.rest.search.issuesAndPullRequests({
+            q: searchQuery,
+            per_page: Math.min(maxResults, 30)
+          });
+          if (!data.items || data.items.length === 0) {
+            return {
+              content: [{
+                type: "text",
+                text: `\u{1F50D} No issues found matching "${query}" in ${githubInfo.repositoryFullName}`
+              }]
+            };
+          }
+          let responseText = `\u{1F50D} **Found ${data.items.length} issues in ${githubInfo.repositoryFullName}:**
+
+`;
+          for (const issue of data.items) {
+            const isPR = !!issue.pull_request;
+            const emoji = isPR ? "\u{1F500}" : "\u{1F41B}";
+            const type = isPR ? "PR" : "Issue";
+            responseText += `${emoji} **${type} #${issue.number}: ${issue.title}**
+`;
+            responseText += `   State: ${issue.state}
+`;
+            responseText += `   Author: ${issue.user?.login || "Unknown"}
+`;
+            responseText += `   URL: ${issue.html_url}
+`;
+            if (issue.labels && issue.labels.length > 0) {
+              responseText += `   Labels: ${issue.labels.map((l) => typeof l === "string" ? l : l.name).join(", ")}
+`;
+            }
+            responseText += `
+`;
+          }
+          return {
+            content: [{
+              type: "text",
+              text: responseText
+            }]
+          };
+        } catch (error) {
+          console.error("GitHub search issues error:", error);
+          return {
+            content: [{
+              type: "text",
+              text: `\u274C Failed to search issues: ${error.message || "Unknown error"}`
+            }]
+          };
+        }
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }