@ebowwa/tooling-mcp 0.1.0 → 0.1.2

package/bin/tooling-mcp.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+// Wrapper script to run tooling-mcp with bun
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const mainScript = join(__dirname, "..", "dist", "index.js");
+
+// Run the main script with bun
+const proc = spawn("bun", ["run", mainScript, ...process.argv.slice(2)], {
+  stdio: "inherit",
+  env: process.env
+});
+
+proc.on("exit", (code) => process.exit(code ?? 0));

package/dist/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env bun
+// @bun
+
+// index.ts
+import { StateManager } from "@ebowwa/tooling/src/state";
+import { SyncManager } from "@ebowwa/tooling/src/sync";
+import { getGitStatus } from "@ebowwa/tooling/src/git";
+var state = new StateManager;
+var sync = new SyncManager(state);
+async function statusTool() {
+  const statuses = await sync.getStatus();
+  const lines = [
+    "\uD83D\uDCCA 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 ? " \u26A0\uFE0F dirty" : "";
+    const behind = status.commitsBehind ? ` \u2193${status.commitsBehind}` : "";
+    const ahead = status.commitsAhead ? ` \u2191${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(`
+`);
+}
+async function listReposTool() {
+  const lines = [
+    "\uD83D\uDCC1 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(`
+`);
+}
+async function getRepoPathTool(repoName) {
+  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(", ")}`);
+  }
+}
+async function syncTool(repo) {
+  try {
+    let result;
+    if (repo) {
+      result = await sync.syncRepo(repo);
+      return `Synced ${repo}: ${result.synced ? "\u2713 success" : "\u2717 failed"}${result.error ? ` - ${result.error}` : ""}`;
+    } else {
+      result = await sync.syncAll();
+      const lines = ["\uD83D\uDD04 Sync Results", ""];
+      for (const [name, r] of Object.entries(result.repos)) {
+        lines.push(`  ${r.synced ? "\u2713" : "\u2717"} ${name}`);
+      }
+      if (result.errors.length > 0) {
+        lines.push("", "Errors:");
+        result.errors.forEach((e) => lines.push(`  - ${e}`));
+      }
+      return lines.join(`
+`);
+    }
+  } catch (error) {
+    throw new Error(`Sync failed: ${error}`);
+  }
+}
+async function gitStatusTool(repoName) {
+  try {
+    const path = state.getRepoPath(repoName);
+    const status = await getGitStatus(path);
+    const lines = [
+      `\uD83D\uDCCB 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(`
+`);
+  } catch (error) {
+    throw new Error(`Failed to get git status for '${repoName}': ${error}`);
+  }
+}
+var MCP_PORT = parseInt(process.env.MCP_PORT || "8912");
+Bun.serve({
+  port: MCP_PORT,
+  fetch: async (req) => {
+    const url = new URL(req.url);
+    if (url.pathname === "/health") {
+      return Response.json({ status: "ok", port: MCP_PORT });
+    }
+    if (url.pathname === "/mcp") {
+      if (req.method === "POST") {
+        const body = await req.json();
+        const { tool, args } = body;
+        try {
+          let result;
+          switch (tool) {
+            case "status":
+              result = await statusTool();
+              break;
+            case "list_repos":
+              result = await listReposTool();
+              break;
+            case "get_repo_path":
+              result = await getRepoPathTool(args?.repo);
+              break;
+            case "sync":
+              result = await syncTool(args?.repo);
+              break;
+            case "git_status":
+              result = await gitStatusTool(args?.repo);
+              break;
+            default:
+              return Response.json({ error: `Unknown tool: ${tool}` }, { status: 400 });
+          }
+          return Response.json({ result });
+        } catch (error) {
+          return Response.json({ error: String(error) }, { status: 500 });
+        }
+      }
+      return Response.json({
+        name: "tooling-mcp",
+        version: "0.1.0",
+        tools: [
+          { name: "status", description: "Get status of all repos in the monorepo" },
+          { name: "list_repos", description: "List all discovered repos" },
+          { name: "get_repo_path", description: "Get filesystem path to a repo", args: ["repo"] },
+          { name: "sync", description: "Sync all repos or a specific repo", args: ["repo?"] },
+          { name: "git_status", description: "Get detailed git status for a repo", args: ["repo"] }
+        ]
+      });
+    }
+    return Response.json({ error: "Not found" }, { status: 404 });
+  }
+});
+console.log(`\uD83D\uDE80 Tooling MCP Server running on port ${MCP_PORT}`);
+console.log(`   Health: http://localhost:${MCP_PORT}/health`);
+console.log(`   MCP:    http://localhost:${MCP_PORT}/mcp`);

package/dist/stdio/stdio.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// stdio.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var toolingModule = null;
+async function loadTooling() {
+  if (toolingModule === null) {
+    try {
+      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;
+}
+async function statusTool(StateManager, SyncManager) {
+  const state = new StateManager;
+  const sync = new SyncManager(state);
+  const statuses = await sync.getStatus();
+  const lines = [
+    "\uD83D\uDCCA 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 ? " \u26A0\uFE0F dirty" : "";
+    const behind = status.commitsBehind ? ` \u2193${status.commitsBehind}` : "";
+    const ahead = status.commitsAhead ? ` \u2191${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(`
+`);
+}
+async function listReposTool(StateManager) {
+  const state = new StateManager;
+  const lines = [
+    "\uD83D\uDCC1 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(`
+`);
+}
+async function getRepoPathTool(StateManager, repoName) {
+  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(", ")}`);
+  }
+}
+async function syncTool(StateManager, SyncManager, repo) {
+  const state = new StateManager;
+  const sync = new SyncManager(state);
+  try {
+    let result;
+    if (repo) {
+      result = await sync.syncRepo(repo);
+      return `Synced ${repo}: ${result.synced ? "\u2713 success" : "\u2717 failed"}${result.error ? ` - ${result.error}` : ""}`;
+    } else {
+      result = await sync.syncAll();
+      const lines = ["\uD83D\uDD04 Sync Results", ""];
+      for (const [name, r] of Object.entries(result.repos)) {
+        lines.push(`  ${r.synced ? "\u2713" : "\u2717"} ${name}`);
+      }
+      if (result.errors.length > 0) {
+        lines.push("", "Errors:");
+        result.errors.forEach((e) => lines.push(`  - ${e}`));
+      }
+      return lines.join(`
+`);
+    }
+  } catch (error) {
+    throw new Error(`Sync failed: ${error}`);
+  }
+}
+async function gitStatusTool(StateManager, getGitStatus, repoName) {
+  const state = new StateManager;
+  try {
+    const path = state.getRepoPath(repoName);
+    const status = await getGitStatus(path);
+    const lines = [
+      `\uD83D\uDCCB 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(`
+`);
+  } catch (error) {
+    throw new Error(`Failed to get git status for '${repoName}': ${error}`);
+  }
+}
+var server = new Server({
+  name: "@ebowwa/tooling-mcp",
+  version: "0.1.0"
+}, {
+  capabilities: {
+    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"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    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.repo;
+        const result = await getRepoPathTool(StateManager, repo);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      case "sync": {
+        const repo = args.repo;
+        const result = await syncTool(StateManager, SyncManager, repo);
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      }
+      case "git_status": {
+        const repo = args.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
+    };
+  }
+});
+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);
+});