@ebowwa/tooling-mcp 0.1.0 → 0.1.2

package/stdio.ts

@@ -0,0 +1,343 @@
+#!/usr/bin/env bun
+/**
+ * Codespaces Tooling MCP Server (stdio protocol)
+ *
+ * Model Context Protocol server for monorepo tooling operations
+ * Uses stdio transport for Claude Code integration
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+// The tooling functions are imported from @ebowwa/tooling package
+// These will be lazy-loaded to avoid import errors
+let toolingModule: {
+  StateManager: any;
+  SyncManager: any;
+  getGitStatus: any;
+} | null = null;
+
+async function loadTooling() {
+  if (toolingModule === null) {
+    try {
+      // Import from installed @ebowwa/tooling package
+      const tooling = await import("@ebowwa/tooling");
+
+      toolingModule = {
+        StateManager: tooling.StateManager,
+        SyncManager: tooling.SyncManager,
+        getGitStatus: tooling.getGitStatus,
+      };
+    } catch (error) {
+      throw new Error(`Failed to load @ebowwa/tooling: ${error}`);
+    }
+  }
+  return toolingModule;
+}
+
+// ==============
+// MCP Tools
+//=============
+
+/**
+ * Get status of all repos in the monorepo
+ */
+async function statusTool(StateManager: any, SyncManager: any): Promise<string> {
+  const state = new StateManager();
+  const sync = new SyncManager(state);
+
+  const statuses = await sync.getStatus();
+  const lines = [
+    "📊 Codespaces Monorepo Status",
+    "=".repeat(40),
+    "",
+    `Phase: ${state.phase}`,
+    `Current repo: ${state.currentRepo || "none"}`,
+    "",
+    "Repos:",
+  ];
+
+  for (const [repo, status] of Object.entries(statuses)) {
+    const dirty = status.dirty ? " ⚠️ dirty" : "";
+    const behind = status.commitsBehind ? ` ↓${status.commitsBehind}` : "";
+    const ahead = status.commitsAhead ? ` ↑${status.commitsAhead}` : "";
+
+    lines.push(`  ${repo}:`);
+    lines.push(`    branch: ${status.branch}${dirty}${behind}${ahead}`);
+    lines.push(`    commit: ${status.lastCommit?.slice(0, 8) || "unknown"}`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * List all discovered repos
+ */
+async function listReposTool(StateManager: any): Promise<string> {
+  const state = new StateManager();
+
+  const lines = [
+    "📁 Discovered Repositories",
+    "=".repeat(40),
+    "",
+  ];
+
+  for (const [name, remote] of Object.entries(state.remotes)) {
+    lines.push(`  ${name}:`);
+    lines.push(`    path: ${remote.path}`);
+    lines.push(`    url: ${remote.url}`);
+    lines.push(`    main branch: ${remote.mainBranch}`);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Get the filesystem path to a repo
+ */
+async function getRepoPathTool(StateManager: any, repoName: string): Promise<string> {
+  const state = new StateManager();
+
+  try {
+    const path = state.getRepoPath(repoName);
+    return `Path to '${repoName}': ${path}`;
+  } catch (error) {
+    throw new Error(`Unknown repo: ${repoName}. Available repos: ${Object.keys(state.remotes).join(", ")}`);
+  }
+}
+
+/**
+ * Sync all repos or a specific repo
+ */
+async function syncTool(StateManager: any, SyncManager: any, repo?: string): Promise<string> {
+  const state = new StateManager();
+  const sync = new SyncManager(state);
+
+  try {
+    let result;
+
+    if (repo) {
+      result = await sync.syncRepo(repo);
+      return `Synced ${repo}: ${result.synced ? "✓ success" : "✗ failed"}${result.error ? ` - ${result.error}` : ""}`;
+    } else {
+      result = await sync.syncAll();
+      const lines = ["🔄 Sync Results", ""];
+
+      for (const [name, r] of Object.entries(result.repos)) {
+        lines.push(`  ${r.synced ? "✓" : "✗"} ${name}`);
+      }
+
+      if (result.errors.length > 0) {
+        lines.push("", "Errors:");
+        result.errors.forEach((e: string) => lines.push(`  - ${e}`));
+      }
+
+      return lines.join("\n");
+    }
+  } catch (error) {
+    throw new Error(`Sync failed: ${error}`);
+  }
+}
+
+/**
+ * Get detailed git status for a repo
+ */
+async function gitStatusTool(StateManager: any, getGitStatus: any, repoName: string): Promise<string> {
+  const state = new StateManager();
+
+  try {
+    const path = state.getRepoPath(repoName);
+    const status = await getGitStatus(path);
+
+    const lines = [
+      `📋 Git Status: ${repoName}`,
+      "=".repeat(40),
+      "",
+      `Branch: ${status.branch}`,
+      `Dirty: ${status.dirty ? "Yes" : "No"}`,
+      `Commit: ${status.lastCommit || "unknown"}`,
+    ];
+
+    if (status.commitsBehind) {
+      lines.push(`Behind: ${status.commitsBehind} commits`);
+    }
+
+    if (status.commitsAhead) {
+      lines.push(`Ahead: ${status.commitsAhead} commits`);
+    }
+
+    return lines.join("\n");
+  } catch (error) {
+    throw new Error(`Failed to get git status for '${repoName}': ${error}`);
+  }
+}
+
+// ==============
+// MCP Server
+//=============
+
+// Create MCP server
+const server = new Server(
+  {
+    name: "@ebowwa/tooling-mcp",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "status",
+        description: "Get status of all repos in the monorepo",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+      {
+        name: "list_repos",
+        description: "List all discovered repos in the monorepo",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+      {
+        name: "get_repo_path",
+        description: "Get the filesystem path to a specific repo",
+        inputSchema: {
+          type: "object",
+          properties: {
+            repo: {
+              type: "string",
+              description: "Repository name (e.g., 'packages', 'com.hetzner.codespaces')",
+            },
+          },
+          required: ["repo"],
+        },
+      },
+      {
+        name: "sync",
+        description: "Sync all repos or a specific repo",
+        inputSchema: {
+          type: "object",
+          properties: {
+            repo: {
+              type: "string",
+              description: "Optional repository name to sync (if omitted, syncs all repos)",
+            },
+          },
+        },
+      },
+      {
+        name: "git_status",
+        description: "Get detailed git status for a repo",
+        inputSchema: {
+          type: "object",
+          properties: {
+            repo: {
+              type: "string",
+              description: "Repository name",
+            },
+          },
+          required: ["repo"],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    // Load tooling module lazily
+    const { StateManager, SyncManager, getGitStatus } = await loadTooling();
+
+    switch (name) {
+      case "status": {
+        const result = await statusTool(StateManager, SyncManager);
+        return {
+          content: [{ type: "text", text: result }],
+        };
+      }
+
+      case "list_repos": {
+        const result = await listReposTool(StateManager);
+        return {
+          content: [{ type: "text", text: result }],
+        };
+      }
+
+      case "get_repo_path": {
+        const repo = (args as { repo: string }).repo;
+        const result = await getRepoPathTool(StateManager, repo);
+        return {
+          content: [{ type: "text", text: result }],
+        };
+      }
+
+      case "sync": {
+        const repo = (args as { repo?: string }).repo;
+        const result = await syncTool(StateManager, SyncManager, repo);
+        return {
+          content: [{ type: "text", text: result }],
+        };
+      }
+
+      case "git_status": {
+        const repo = (args as { repo: string }).repo;
+        const result = await gitStatusTool(StateManager, getGitStatus, repo);
+        return {
+          content: [{ type: "text", text: result }],
+        };
+      }
+
+      default:
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unknown tool: ${name}`,
+            },
+          ],
+          isError: true,
+        };
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("@ebowwa/tooling-mcp server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error in tooling MCP server:", error);
+  process.exit(1);
+});