trabuco-mcp 1.5.4

package/README.md

@@ -0,0 +1,100 @@
+# trabuco-mcp
+
+MCP (Model Context Protocol) server for [Trabuco](https://github.com/arianlopezc/Trabuco) — generate and manage production-ready Java multi-module Maven projects via AI coding agents.
+
+## Quick Setup
+
+### Claude Code
+
+```bash
+claude mcp add trabuco -- npx -y trabuco-mcp
+```
+
+Or add to `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "trabuco": {
+      "command": "npx",
+      "args": ["-y", "trabuco-mcp"]
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "trabuco": {
+      "command": "npx",
+      "args": ["-y", "trabuco-mcp"]
+    }
+  }
+}
+```
+
+### VS Code / GitHub Copilot
+
+Add to `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "trabuco": {
+      "command": "npx",
+      "args": ["-y", "trabuco-mcp"]
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "trabuco": {
+      "command": "npx",
+      "args": ["-y", "trabuco-mcp"]
+    }
+  }
+}
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `init_project` | Generate a new Java project with specified modules, database, and options |
+| `add_module` | Add a module to an existing Trabuco project (with dry-run support) |
+| `run_doctor` | Run health checks on a project and optionally auto-fix issues |
+| `get_project_info` | Read project metadata from `.trabuco.json` or inferred from POM |
+| `list_modules` | List all available modules with descriptions and dependency info |
+| `check_docker` | Check if Docker is installed and running |
+| `get_version` | Get the Trabuco CLI version |
+| `scan_project` | Analyze a legacy Java project's structure and dependencies |
+| `migrate_project` | Full AI-powered migration of a legacy project |
+| `auth_status` | Check which AI providers have credentials configured |
+| `list_providers` | List supported AI providers with pricing and model info |
+
+## How It Works
+
+This package wraps the [Trabuco CLI](https://github.com/arianlopezc/Trabuco). On install, it downloads the correct Go binary for your platform. The `trabuco-mcp` command starts the MCP server over stdio — your AI agent handles the rest.
+
+## Requirements
+
+- **Node.js 16+** (for npx/npm)
+- **Java 17+** (for generated projects)
+- **Maven 3.8+** (for generated projects)
+- **Docker** (for Testcontainers and local development)
+
+## License
+
+MIT

package/install.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execFileSync } = require("child_process");
+const fs = require("fs");
+const https = require("https");
+const path = require("path");
+
+const VERSION = require("./package.json").version;
+const MAX_REDIRECTS = 5;
+const MAX_RETRIES = 3;
+const RETRY_BASE_MS = 1000;
+
+const PLATFORM_MAP = { darwin: "darwin", linux: "linux", win32: "windows" };
+const ARCH_MAP = { x64: "amd64", arm64: "arm64" };
+
+function getBinaryName() {
+  const os = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+  if (!os || !arch) {
+    console.error(
+      `Unsupported platform: ${process.platform}-${process.arch}\n` +
+        "Supported: darwin-x64, darwin-arm64, linux-x64, linux-arm64, win32-x64, win32-arm64"
+    );
+    process.exit(1);
+  }
+  const ext = process.platform === "win32" ? ".exe" : "";
+  return { remote: `trabuco-${os}-${arch}${ext}`, local: `trabuco${ext}` };
+}
+
+function getBinDir() {
+  const dir = path.join(__dirname, "bin");
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function versionMatches(binaryPath) {
+  try {
+    const out = execFileSync(binaryPath, ["version"], {
+      encoding: "utf8",
+      timeout: 5000,
+    }).trim();
+    // Output may be "trabuco version v1.5.3" or just "v1.5.3"
+    return out.includes(VERSION) || out.includes(`v${VERSION}`);
+  } catch {
+    return false;
+  }
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    followRedirects(url, 0, (err, res) => {
+      if (err) return reject(err);
+      if (res.statusCode !== 200) {
+        res.resume();
+        return reject(new Error(`HTTP ${res.statusCode} from ${url}`));
+      }
+      const file = fs.createWriteStream(dest);
+      res.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", (e) => {
+        fs.unlink(dest, () => {});
+        reject(e);
+      });
+    });
+  });
+}
+
+function followRedirects(url, hops, cb) {
+  if (hops >= MAX_REDIRECTS) return cb(new Error("Too many redirects"));
+  const get = url.startsWith("https://") ? https.get : require("http").get;
+  get(url, (res) => {
+    if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+      res.resume();
+      return followRedirects(res.headers.location, hops + 1, cb);
+    }
+    cb(null, res);
+  }).on("error", cb);
+}
+
+async function downloadWithRetry(url, dest) {
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      await download(url, dest);
+      return;
+    } catch (err) {
+      if (attempt === MAX_RETRIES) throw err;
+      const delay = RETRY_BASE_MS * Math.pow(2, attempt - 1);
+      console.log(
+        `Download attempt ${attempt}/${MAX_RETRIES} failed: ${err.message}. Retrying in ${delay}ms...`
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+}
+
+async function main() {
+  const { remote, local } = getBinaryName();
+  const binDir = getBinDir();
+  const binaryPath = path.join(binDir, local);
+
+  // Skip download if binary exists and version matches
+  if (fs.existsSync(binaryPath) && versionMatches(binaryPath)) {
+    console.log(`trabuco v${VERSION} already installed.`);
+    return;
+  }
+
+  const url = `https://github.com/arianlopezc/Trabuco/releases/download/v${VERSION}/${remote}`;
+  console.log(`Downloading trabuco v${VERSION} for ${process.platform}-${process.arch}...`);
+
+  try {
+    await downloadWithRetry(url, binaryPath);
+  } catch (err) {
+    console.error(
+      `Failed to download trabuco binary.\n` +
+        `  URL: ${url}\n` +
+        `  Error: ${err.message}\n\n` +
+        `You can install the CLI manually:\n` +
+        `  curl -sSL https://raw.githubusercontent.com/arianlopezc/Trabuco/main/scripts/install.sh | bash`
+    );
+    process.exit(1);
+  }
+
+  if (process.platform !== "win32") {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+
+  console.log(`trabuco v${VERSION} installed successfully.`);
+}
+
+main();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "trabuco-mcp",
+  "version": "1.5.4",
+  "description": "Generate production-ready Java projects via AI coding agents — MCP server for Trabuco CLI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arianlopezc/Trabuco.git",
+    "directory": "npm"
+  },
+  "homepage": "https://github.com/arianlopezc/Trabuco#cli-mcp-server",
+  "bugs": "https://github.com/arianlopezc/Trabuco/issues",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "java",
+    "maven",
+    "spring-boot",
+    "code-generation",
+    "ai",
+    "trabuco"
+  ],
+  "bin": {
+    "trabuco-mcp": "./run.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "files": [
+    "install.js",
+    "run.js",
+    "README.md"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
+}

package/run.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn } = require("child_process");
+const path = require("path");
+
+const ext = process.platform === "win32" ? ".exe" : "";
+const binaryPath = path.join(__dirname, "bin", `trabuco${ext}`);
+
+const fs = require("fs");
+if (!fs.existsSync(binaryPath)) {
+  console.error(
+    "trabuco binary not found. This usually means npm was run with --ignore-scripts.\n" +
+      "Run the postinstall script manually:\n\n" +
+      "  cd " + path.dirname(__filename) + " && node install.js\n"
+  );
+  process.exit(1);
+}
+
+const child = spawn(binaryPath, ["mcp"], {
+  stdio: "inherit",
+});
+
+// Forward signals to child process
+for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(sig, () => {
+    if (!child.killed) child.kill(sig);
+  });
+}
+
+child.on("close", (code, signal) => {
+  if (signal) {
+    // Re-raise the signal so the parent sees the correct exit reason
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code ?? 1);
+  }
+});