mcp-new 1.2.2 → 1.6.0

package/dist/{chunk-3JG4FVS2.js → chunk-LJNMSDBU.js}

@@ -40,12 +40,12 @@ function validateUrl(url) {
     return { valid: false, error: "Invalid URL format" };
   }
 }
-function validateFilePath(path7) {
-  if (!path7 || path7.trim().length === 0) {
+function validateFilePath(path11) {
+  if (!path11 || path11.trim().length === 0) {
     return { valid: false, error: "File path cannot be empty" };
   }
   const invalidChars = /[<>:"|?*]/;
-  if (invalidChars.test(path7)) {
+  if (invalidChars.test(path11)) {
     return { valid: false, error: "File path contains invalid characters" };
   }
   return { valid: true };
@@ -90,20 +90,270 @@ async function promptProjectDescription() {
   return description;
 }
 
+// src/utils/file-system.ts
+import fs from "fs-extra";
+import path from "path";
+import ejs from "ejs";
+async function ensureDir(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function writeFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+async function copyFile(src, dest) {
+  await fs.ensureDir(path.dirname(dest));
+  await fs.copyFile(src, dest);
+}
+async function copyDir(src, dest) {
+  await fs.copy(src, dest);
+}
+async function exists(filePath) {
+  return fs.pathExists(filePath);
+}
+async function remove(filePath) {
+  await fs.remove(filePath);
+}
+async function readDir(dirPath) {
+  return fs.readdir(dirPath);
+}
+async function isDirectory(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function renderTemplate(templatePath, data) {
+  const template = await readFile(templatePath);
+  return ejs.render(template, data, { async: false });
+}
+async function renderTemplateToFile(templatePath, outputPath, data) {
+  const content = await renderTemplate(templatePath, data);
+  const finalPath = outputPath.replace(/\.ejs$/, "");
+  await writeFile(finalPath, content);
+}
+async function walkDir(dirPath, callback) {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const isDir = entry.isDirectory();
+    await callback(fullPath, isDir);
+    if (isDir) {
+      await walkDir(fullPath, callback);
+    }
+  }
+}
+function getTemplateDir() {
+  const devPath = path.join(import.meta.dirname, "..", "templates");
+  const prodPath = path.join(import.meta.dirname, "..", "..", "templates");
+  if (fs.existsSync(devPath)) {
+    return devPath;
+  }
+  return prodPath;
+}
+function getTemplateDirForLanguage(language, pluginTemplateDir) {
+  if (pluginTemplateDir) {
+    return pluginTemplateDir;
+  }
+  return path.join(getTemplateDir(), language);
+}
+function resolveOutputPath(basePath, ...segments) {
+  return path.resolve(basePath, ...segments);
+}
+
+// src/plugins/discovery.ts
+import path2 from "path";
+
+// src/types/plugin.ts
+import { z } from "zod";
+var LanguagePluginManifestSchema = z.object({
+  languageId: z.string(),
+  languageDisplayName: z.string(),
+  templateDir: z.string().default("templates"),
+  installCommand: z.string().optional(),
+  runCommand: z.string().optional(),
+  buildCommand: z.string().optional(),
+  fileExtension: z.string().optional()
+});
+var PLUGIN_MANIFEST_FILE = "mcp-plugin.json";
+
+// src/plugins/discovery.ts
+async function discoverPlugins() {
+  const plugins = [];
+  const searchPaths = [
+    // Global npm modules
+    getGlobalNodeModulesPath(),
+    // Local node_modules
+    path2.join(process.cwd(), "node_modules"),
+    // Relative to this package
+    path2.join(import.meta.dirname, "..", "..", "node_modules")
+  ];
+  for (const searchPath of searchPaths) {
+    const scopedPath = path2.join(searchPath, "@mcp-new");
+    if (!await exists(scopedPath)) {
+      continue;
+    }
+    try {
+      const { readdir } = await import("fs/promises");
+      const entries = await readdir(scopedPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (!entry.name.startsWith("template-")) continue;
+        const pluginPath = path2.join(scopedPath, entry.name);
+        const plugin = await loadPlugin(pluginPath, `@mcp-new/${entry.name}`);
+        if (plugin) {
+          if (!plugins.some((p) => p.manifest.languageId === plugin.manifest.languageId)) {
+            plugins.push(plugin);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return plugins;
+}
+async function loadPlugin(packagePath, packageName) {
+  const manifestPath = path2.join(packagePath, PLUGIN_MANIFEST_FILE);
+  if (!await exists(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(manifestPath);
+    const rawManifest = JSON.parse(content);
+    const manifest = LanguagePluginManifestSchema.parse(rawManifest);
+    const templatePath = path2.join(packagePath, manifest.templateDir);
+    if (!await exists(templatePath)) {
+      console.warn(`Plugin ${packageName}: templates directory not found at ${templatePath}`);
+      return null;
+    }
+    return {
+      manifest,
+      packageName,
+      packagePath,
+      templatePath
+    };
+  } catch (error) {
+    console.warn(`Failed to load plugin ${packageName}:`, error);
+    return null;
+  }
+}
+function getGlobalNodeModulesPath() {
+  if (process.platform === "win32") {
+    return path2.join(process.env.APPDATA || "", "npm", "node_modules");
+  }
+  return "/usr/local/lib/node_modules";
+}
+function isPluginLanguage(languageId, plugins) {
+  return plugins.some((p) => p.manifest.languageId === languageId);
+}
+function getPluginForLanguage(languageId, plugins) {
+  return plugins.find((p) => p.manifest.languageId === languageId);
+}
+
+// src/plugins/registry.ts
+var PluginRegistry = class {
+  plugins = [];
+  initialized = false;
+  /**
+   * Initialize the registry by discovering installed plugins.
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.plugins = await discoverPlugins();
+    this.initialized = true;
+  }
+  /**
+   * Get all registered plugins.
+   */
+  getPlugins() {
+    return [...this.plugins];
+  }
+  /**
+   * Get a plugin by language ID.
+   */
+  getPlugin(languageId) {
+    return getPluginForLanguage(languageId, this.plugins);
+  }
+  /**
+   * Check if a language is provided by a plugin.
+   */
+  isPluginLanguage(languageId) {
+    return isPluginLanguage(languageId, this.plugins);
+  }
+  /**
+   * Get all available languages from plugins.
+   */
+  getPluginLanguages() {
+    return this.plugins.map((p) => ({
+      id: p.manifest.languageId,
+      name: p.manifest.languageDisplayName
+    }));
+  }
+  /**
+   * Get the template directory for a plugin language.
+   */
+  getPluginTemplateDir(languageId) {
+    const plugin = this.getPlugin(languageId);
+    return plugin?.templatePath;
+  }
+  /**
+   * Get the install command for a plugin language.
+   */
+  getPluginInstallCommand(languageId) {
+    const plugin = this.getPlugin(languageId);
+    return plugin?.manifest.installCommand;
+  }
+  /**
+   * Get the run command for a plugin language.
+   */
+  getPluginRunCommand(languageId) {
+    const plugin = this.getPlugin(languageId);
+    return plugin?.manifest.runCommand;
+  }
+  /**
+   * Reset the registry (for testing).
+   */
+  reset() {
+    this.plugins = [];
+    this.initialized = false;
+  }
+};
+var pluginRegistry = new PluginRegistry();
+
 // src/prompts/language.ts
 import inquirer2 from "inquirer";
+var BUILTIN_CHOICES = [
+  { name: "TypeScript", value: "typescript" },
+  { name: "Python", value: "python" },
+  { name: "Go", value: "go" },
+  { name: "Rust", value: "rust" },
+  { name: "Java", value: "java" },
+  { name: "Kotlin", value: "kotlin" },
+  { name: "C# (.NET)", value: "csharp" },
+  { name: "Elixir", value: "elixir" }
+];
 async function promptLanguage() {
+  const pluginLanguages = pluginRegistry.getPluginLanguages();
+  const choices = [...BUILTIN_CHOICES];
+  if (pluginLanguages.length > 0) {
+    choices.push(new inquirer2.Separator("\u2500\u2500 Plugins \u2500\u2500"));
+    for (const lang of pluginLanguages) {
+      choices.push({ name: `${lang.name} (plugin)`, value: lang.id });
+    }
+  }
   const { language } = await inquirer2.prompt([
     {
       type: "list",
       name: "language",
       message: "Select language:",
-      choices: [
-        { name: "TypeScript", value: "typescript" },
-        { name: "Python", value: "python" },
-        { name: "Go", value: "go" },
-        { name: "Rust", value: "rust" }
-      ],
+      choices,
       default: "typescript"
     }
   ]);
@@ -314,10 +564,28 @@ async function promptMultipleResources() {
   return resources;
 }
 
-// src/prompts/generation-method.ts
+// src/prompts/java-build-tool.ts
 import inquirer6 from "inquirer";
+async function promptJavaBuildTool() {
+  const { buildTool } = await inquirer6.prompt([
+    {
+      type: "list",
+      name: "buildTool",
+      message: "Select Java build tool:",
+      choices: [
+        { name: "Maven (pom.xml)", value: "maven" },
+        { name: "Gradle (build.gradle)", value: "gradle" }
+      ],
+      default: "maven"
+    }
+  ]);
+  return buildTool;
+}
+
+// src/prompts/generation-method.ts
+import inquirer7 from "inquirer";
 async function promptGenerationMethod() {
-  const { method } = await inquirer6.prompt([
+  const { method } = await inquirer7.prompt([
     {
       type: "list",
       name: "method",
@@ -346,8 +614,67 @@ async function promptGenerationMethod() {
   return method;
 }
 
+// src/types/config.ts
+import { z as z2 } from "zod";
+var BuiltinLanguageSchema = z2.enum([
+  "typescript",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "kotlin",
+  "csharp",
+  "elixir"
+]);
+var LanguageSchema = z2.string();
+var BUILTIN_LANGUAGES = [
+  "typescript",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "kotlin",
+  "csharp",
+  "elixir"
+];
+function isBuiltinLanguage(lang) {
+  return BUILTIN_LANGUAGES.includes(lang);
+}
+var JavaBuildToolSchema = z2.enum(["maven", "gradle"]);
+var TransportSchema = z2.enum(["stdio", "sse"]);
+var ToolParameterSchema = z2.object({
+  name: z2.string(),
+  type: z2.enum(["string", "number", "boolean", "object", "array"]),
+  description: z2.string(),
+  required: z2.boolean().default(true)
+});
+var ToolConfigSchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  parameters: z2.array(ToolParameterSchema).default([])
+});
+var ResourceConfigSchema = z2.object({
+  name: z2.string(),
+  uri: z2.string(),
+  description: z2.string(),
+  mimeType: z2.string().optional()
+});
+var ProjectConfigSchema = z2.object({
+  name: z2.string().min(1, "Project name is required"),
+  description: z2.string().default(""),
+  language: LanguageSchema,
+  transport: TransportSchema,
+  tools: z2.array(ToolConfigSchema).default([]),
+  resources: z2.array(ResourceConfigSchema).default([]),
+  includeExampleTool: z2.boolean().default(true),
+  skipInstall: z2.boolean().default(false),
+  initGit: z2.boolean().default(true),
+  javaBuildTool: JavaBuildToolSchema.optional()
+});
+var PresetIdSchema = z2.enum(["database", "rest-api", "filesystem"]);
+
 // src/prompts/preset.ts
-import inquirer7 from "inquirer";
+import inquirer8 from "inquirer";
 
 // src/presets/database.ts
 var DATABASE_PRESET = {
@@ -657,6 +984,230 @@ var FILESYSTEM_PRESET = {
   ]
 };
 
+// src/types/marketplace.ts
+import { z as z3 } from "zod";
+var ExternalPresetManifestSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  description: z3.string(),
+  version: z3.string(),
+  tools: z3.array(ToolConfigSchema),
+  author: z3.string().optional(),
+  repository: z3.string().optional()
+});
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function parsePresetIdentifier(identifier) {
+  if (identifier.startsWith("github:")) {
+    return {
+      type: "github",
+      identifier: identifier.replace("github:", "")
+    };
+  }
+  if (identifier.startsWith("@")) {
+    return {
+      type: "npm",
+      identifier
+    };
+  }
+  return {
+    type: "local",
+    identifier
+  };
+}
+function isExternalPreset(identifier) {
+  return identifier.startsWith("@") || identifier.startsWith("github:");
+}
+
+// src/marketplace/preset-resolver.ts
+import path4 from "path";
+import os2 from "os";
+import { execa } from "execa";
+import * as tar from "tar";
+
+// src/marketplace/cache.ts
+import path3 from "path";
+import os from "os";
+var CACHE_DIR = path3.join(os.homedir(), ".mcp-new", "preset-cache");
+function getCacheFilePath(source) {
+  const safeId = source.identifier.replace(/[^a-zA-Z0-9]/g, "_");
+  return path3.join(CACHE_DIR, `${source.type}_${safeId}.json`);
+}
+async function getCachedPreset(source) {
+  const cacheFile = getCacheFilePath(source);
+  if (!await exists(cacheFile)) {
+    return null;
+  }
+  try {
+    const content = await readFile(cacheFile);
+    const cached = JSON.parse(content);
+    const now = Date.now();
+    if (now - cached.cachedAt > CACHE_TTL_MS) {
+      return null;
+    }
+    return cached;
+  } catch {
+    return null;
+  }
+}
+async function setCachedPreset(source, manifest) {
+  await ensureDir(CACHE_DIR);
+  const cached = {
+    manifest,
+    cachedAt: Date.now(),
+    source
+  };
+  const cacheFile = getCacheFilePath(source);
+  await writeFile(cacheFile, JSON.stringify(cached, null, 2));
+}
+async function clearPresetCache() {
+  if (!await exists(CACHE_DIR)) {
+    return 0;
+  }
+  try {
+    const { readdir, stat, unlink } = await import("fs/promises");
+    const files = await readdir(CACHE_DIR);
+    let count = 0;
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        await unlink(path3.join(CACHE_DIR, file));
+        count++;
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function listCachedPresets() {
+  if (!await exists(CACHE_DIR)) {
+    return [];
+  }
+  try {
+    const { readdir } = await import("fs/promises");
+    const files = await readdir(CACHE_DIR);
+    const presets = [];
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const content = await readFile(path3.join(CACHE_DIR, file));
+          const cached = JSON.parse(content);
+          presets.push(cached);
+        } catch {
+        }
+      }
+    }
+    return presets;
+  } catch {
+    return [];
+  }
+}
+function getCacheDir() {
+  return CACHE_DIR;
+}
+
+// src/marketplace/preset-resolver.ts
+var TEMP_DIR = path4.join(os2.tmpdir(), "mcp-new-presets");
+async function resolveExternalPreset(source) {
+  const cached = await getCachedPreset(source);
+  if (cached) {
+    return cached.manifest;
+  }
+  let manifest;
+  switch (source.type) {
+    case "npm":
+      manifest = await resolveNpmPreset(source.identifier);
+      break;
+    case "github":
+      manifest = await resolveGitHubPreset(source.identifier);
+      break;
+    default:
+      throw new Error(`Unknown preset source type: ${source.type}`);
+  }
+  await setCachedPreset(source, manifest);
+  return manifest;
+}
+async function resolveNpmPreset(packageName) {
+  await ensureDir(TEMP_DIR);
+  const extractDir = path4.join(TEMP_DIR, `npm_${packageName.replace(/[^a-zA-Z0-9]/g, "_")}`);
+  try {
+    if (await exists(extractDir)) {
+      await remove(extractDir);
+    }
+    await ensureDir(extractDir);
+    const { stdout } = await execa("npm", ["pack", packageName, "--pack-destination", extractDir], {
+      cwd: extractDir
+    });
+    const tarballName = stdout.trim();
+    const tarballPath = path4.join(extractDir, tarballName);
+    await tar.x({
+      file: tarballPath,
+      cwd: extractDir
+    });
+    const manifestPath = path4.join(extractDir, "package", "mcp-preset.json");
+    if (!await exists(manifestPath)) {
+      throw new Error(
+        `Invalid preset package: ${packageName} - missing mcp-preset.json manifest file`
+      );
+    }
+    const manifestContent = await readFile(manifestPath);
+    const rawManifest = JSON.parse(manifestContent);
+    const manifest = ExternalPresetManifestSchema.parse(rawManifest);
+    return manifest;
+  } finally {
+    try {
+      if (await exists(extractDir)) {
+        await remove(extractDir);
+      }
+    } catch {
+    }
+  }
+}
+async function resolveGitHubPreset(repoPath) {
+  const [repo, branch = "main"] = repoPath.split("@");
+  const [owner, repoName] = repo.split("/");
+  if (!owner || !repoName) {
+    throw new Error(`Invalid GitHub preset format: ${repoPath}. Expected: user/repo[@branch]`);
+  }
+  await ensureDir(TEMP_DIR);
+  const extractDir = path4.join(TEMP_DIR, `github_${owner}_${repoName}`);
+  try {
+    if (await exists(extractDir)) {
+      await remove(extractDir);
+    }
+    await ensureDir(extractDir);
+    const tarballUrl = `https://github.com/${owner}/${repoName}/archive/refs/heads/${branch}.tar.gz`;
+    const tarballPath = path4.join(extractDir, "repo.tar.gz");
+    await execa("curl", ["-L", "-o", tarballPath, tarballUrl]);
+    await tar.x({
+      file: tarballPath,
+      cwd: extractDir
+    });
+    const { readdir } = await import("fs/promises");
+    const entries = await readdir(extractDir);
+    const repoDir = entries.find((e) => e.startsWith(`${repoName}-`));
+    if (!repoDir) {
+      throw new Error(`Failed to extract GitHub repository: ${repoPath}`);
+    }
+    const manifestPath = path4.join(extractDir, repoDir, "mcp-preset.json");
+    if (!await exists(manifestPath)) {
+      throw new Error(
+        `Invalid preset repository: ${repoPath} - missing mcp-preset.json manifest file`
+      );
+    }
+    const manifestContent = await readFile(manifestPath);
+    const rawManifest = JSON.parse(manifestContent);
+    const manifest = ExternalPresetManifestSchema.parse(rawManifest);
+    return manifest;
+  } finally {
+    try {
+      if (await exists(extractDir)) {
+        await remove(extractDir);
+      }
+    } catch {
+    }
+  }
+}
+
 // src/presets/index.ts
 var PRESETS = {
   database: DATABASE_PRESET,
@@ -670,6 +1221,28 @@ function getPreset(id) {
 function isValidPresetId(id) {
   return id in PRESETS;
 }
+async function getPresetByIdentifier(identifier) {
+  if (!isExternalPreset(identifier)) {
+    const preset = getPreset(identifier);
+    if (!preset) {
+      throw new Error(
+        `Unknown preset: ${identifier}. Valid local presets: ${PRESET_IDS.join(", ")}`
+      );
+    }
+    return preset;
+  }
+  const source = parsePresetIdentifier(identifier);
+  const manifest = await resolveExternalPreset(source);
+  return externalManifestToPreset(manifest);
+}
+function externalManifestToPreset(manifest) {
+  return {
+    id: manifest.id,
+    name: manifest.name,
+    description: manifest.description,
+    tools: manifest.tools
+  };
+}
 
 // src/prompts/preset.ts
 async function promptPreset() {
@@ -677,7 +1250,7 @@ async function promptPreset() {
     name: `${preset2.name} - ${preset2.description}`,
     value: preset2.id
   }));
-  const { preset } = await inquirer7.prompt([
+  const { preset } = await inquirer8.prompt([
     {
       type: "list",
       name: "preset",
@@ -689,6 +1262,24 @@ async function promptPreset() {
   return preset;
 }
 
+// src/prompts/ci-provider.ts
+import inquirer9 from "inquirer";
+async function promptCIProvider() {
+  const { provider } = await inquirer9.prompt([
+    {
+      type: "list",
+      name: "provider",
+      message: "Which CI/CD provider would you like to use?",
+      choices: [
+        { name: "GitHub Actions", value: "github" },
+        { name: "GitLab CI", value: "gitlab" },
+        { name: "CircleCI", value: "circleci" }
+      ]
+    }
+  ]);
+  return provider;
+}
+
 // src/prompts/index.ts
 async function runWizard(options = {}) {
   const name = await promptProjectName(options.defaultName);
@@ -697,6 +1288,10 @@ async function runWizard(options = {}) {
     description = await promptProjectDescription();
   }
   const language = options.presetLanguage || await promptLanguage();
+  let javaBuildTool;
+  if (language === "java" || language === "kotlin") {
+    javaBuildTool = options.presetJavaBuildTool || await promptJavaBuildTool();
+  }
   const transport = await promptTransport();
   const includeExampleTool = await promptIncludeExampleTool();
   let tools = [];
@@ -720,14 +1315,19 @@ async function runWizard(options = {}) {
     resources,
     includeExampleTool,
     skipInstall: false,
-    initGit: true
+    initGit: true,
+    javaBuildTool
   };
 }
-async function runQuickWizard(defaultName, presetLanguage) {
-  const name = await promptProjectName(defaultName);
+async function runQuickWizard(defaultName, presetLanguage, presetJavaBuildTool) {
+  const name = defaultName || await promptProjectName();
   const language = presetLanguage || await promptLanguage();
-  const transport = await promptTransport();
-  const includeExampleTool = await promptIncludeExampleTool();
+  let javaBuildTool;
+  if (language === "java" || language === "kotlin") {
+    javaBuildTool = presetJavaBuildTool || await promptJavaBuildTool();
+  }
+  const transport = "stdio";
+  const includeExampleTool = true;
   return {
     name,
     description: "",
@@ -737,102 +1337,33 @@ async function runQuickWizard(defaultName, presetLanguage) {
     resources: [],
     includeExampleTool,
     skipInstall: false,
-    initGit: true
+    initGit: true,
+    javaBuildTool
   };
 }
 
-// src/utils/file-system.ts
-import fs from "fs-extra";
-import path from "path";
-import ejs from "ejs";
-async function ensureDir(dirPath) {
-  await fs.ensureDir(dirPath);
-}
-async function writeFile(filePath, content) {
-  await fs.ensureDir(path.dirname(filePath));
-  await fs.writeFile(filePath, content, "utf-8");
-}
-async function readFile(filePath) {
-  return fs.readFile(filePath, "utf-8");
-}
-async function copyFile(src, dest) {
-  await fs.ensureDir(path.dirname(dest));
-  await fs.copyFile(src, dest);
-}
-async function copyDir(src, dest) {
-  await fs.copy(src, dest);
-}
-async function exists(filePath) {
-  return fs.pathExists(filePath);
-}
-async function remove(filePath) {
-  await fs.remove(filePath);
-}
-async function readDir(dirPath) {
-  return fs.readdir(dirPath);
-}
-async function isDirectory(filePath) {
-  try {
-    const stat = await fs.stat(filePath);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function renderTemplate(templatePath, data) {
-  const template = await readFile(templatePath);
-  return ejs.render(template, data, { async: false });
-}
-async function renderTemplateToFile(templatePath, outputPath, data) {
-  const content = await renderTemplate(templatePath, data);
-  const finalPath = outputPath.replace(/\.ejs$/, "");
-  await writeFile(finalPath, content);
-}
-async function walkDir(dirPath, callback) {
-  const entries = await fs.readdir(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry.name);
-    const isDir = entry.isDirectory();
-    await callback(fullPath, isDir);
-    if (isDir) {
-      await walkDir(fullPath, callback);
-    }
-  }
-}
-function getTemplateDir() {
-  const devPath = path.join(import.meta.dirname, "..", "templates");
-  const prodPath = path.join(import.meta.dirname, "..", "..", "templates");
-  if (fs.existsSync(devPath)) {
-    return devPath;
-  }
-  return prodPath;
-}
-function resolveOutputPath(basePath, ...segments) {
-  return path.resolve(basePath, ...segments);
-}
-
 // src/utils/git.ts
-import { execa } from "execa";
-import path2 from "path";
+import { execa as execa2 } from "execa";
+import path5 from "path";
 async function isGitInstalled() {
   try {
-    await execa("git", ["--version"]);
+    await execa2("git", ["--version"]);
     return true;
   } catch {
     return false;
   }
 }
 async function initGitRepository(projectPath) {
-  const gitDir = path2.join(projectPath, ".git");
+  const gitDir = path5.join(projectPath, ".git");
   if (await exists(gitDir)) {
     return;
   }
-  await execa("git", ["init"], { cwd: projectPath });
+  await execa2("git", ["init"], { cwd: projectPath });
 }
 async function createInitialCommit(projectPath) {
   try {
-    await execa("git", ["add", "."], { cwd: projectPath });
-    await execa("git", ["commit", "-m", "Initial commit from create-mcp-server"], {
+    await execa2("git", ["add", "."], { cwd: projectPath });
+    await execa2("git", ["commit", "-m", "Initial commit from create-mcp-server"], {
       cwd: projectPath
     });
   } catch {
@@ -841,8 +1372,8 @@ async function createInitialCommit(projectPath) {
 async function getGitUser() {
   try {
     const [nameResult, emailResult] = await Promise.all([
-      execa("git", ["config", "--get", "user.name"]).catch(() => ({ stdout: "" })),
-      execa("git", ["config", "--get", "user.email"]).catch(() => ({ stdout: "" }))
+      execa2("git", ["config", "--get", "user.name"]).catch(() => ({ stdout: "" })),
+      execa2("git", ["config", "--get", "user.email"]).catch(() => ({ stdout: "" }))
     ]);
     return {
       name: nameResult.stdout.trim() || void 0,
@@ -854,7 +1385,7 @@ async function getGitUser() {
 }
 async function isInsideGitRepository(dirPath) {
   try {
-    await execa("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dirPath });
+    await execa2("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dirPath });
     return true;
   } catch {
     return false;
@@ -903,30 +1434,55 @@ var logger = {
     });
     console.log(chalk.green("\u2514\u2500"));
   },
-  nextSteps: (projectName, language) => {
+  nextSteps: (projectName, language, javaBuildTool) => {
     logger.blank();
     let installCmd;
     let runCmd;
-    switch (language) {
-      case "typescript":
-        installCmd = "npm install";
-        runCmd = "npm run dev";
-        break;
-      case "python":
-        installCmd = "pip install -e .";
-        runCmd = "python -m src.server";
-        break;
-      case "go":
-        installCmd = "go mod download";
-        runCmd = "go run ./cmd/server";
-        break;
-      case "rust":
-        installCmd = "cargo build";
-        runCmd = "cargo run";
-        break;
-      default:
-        installCmd = "npm install";
-        runCmd = "npm run dev";
+    if (!isBuiltinLanguage(language)) {
+      const pluginInstallCmd = pluginRegistry.getPluginInstallCommand(language);
+      const pluginRunCmd = pluginRegistry.getPluginRunCommand(language);
+      installCmd = pluginInstallCmd || "# See plugin documentation for install command";
+      runCmd = pluginRunCmd || "# See plugin documentation for run command";
+    } else {
+      switch (language) {
+        case "typescript":
+          installCmd = "npm install";
+          runCmd = "npm run dev";
+          break;
+        case "python":
+          installCmd = "pip install -e .";
+          runCmd = "python -m src.server";
+          break;
+        case "go":
+          installCmd = "go mod download";
+          runCmd = "go run ./cmd/server";
+          break;
+        case "rust":
+          installCmd = "cargo build";
+          runCmd = "cargo run";
+          break;
+        case "java":
+        case "kotlin":
+          if (javaBuildTool === "gradle") {
+            installCmd = "./gradlew build";
+            runCmd = "./gradlew run";
+          } else {
+            installCmd = "mvn install";
+            runCmd = 'mvn exec:java -Dexec.mainClass="com.example.mcp.McpServer"';
+          }
+          break;
+        case "csharp":
+          installCmd = "dotnet restore";
+          runCmd = "dotnet run";
+          break;
+        case "elixir":
+          installCmd = "mix deps.get";
+          runCmd = "mix run --no-halt";
+          break;
+        default:
+          installCmd = "npm install";
+          runCmd = "npm run dev";
+      }
     }
     logger.box("Next steps:", [
       "",
@@ -995,8 +1551,8 @@ async function withSpinner(text, fn, successText, failText) {
 }
 
 // src/generators/base.ts
-import path3 from "path";
-import { execa as execa2 } from "execa";
+import path6 from "path";
+import { execa as execa3 } from "execa";
 var BaseGenerator = class {
   config;
   outputDir;
@@ -1008,14 +1564,14 @@ var BaseGenerator = class {
   }
   async createProjectStructure() {
     await ensureDir(this.outputDir);
-    await ensureDir(path3.join(this.outputDir, "src"));
+    await ensureDir(path6.join(this.outputDir, "src"));
   }
   async renderTemplates() {
     const templateData = this.getTemplateData();
     await walkDir(this.templateDir, async (filePath, isDir) => {
       if (isDir) return;
-      const relativePath = path3.relative(this.templateDir, filePath);
-      const outputPath = path3.join(this.outputDir, relativePath);
+      const relativePath = path6.relative(this.templateDir, filePath);
+      const outputPath = path6.join(this.outputDir, relativePath);
       if (filePath.endsWith(".ejs")) {
         await renderTemplateToFile(filePath, outputPath, templateData);
       } else {
@@ -1024,6 +1580,8 @@ var BaseGenerator = class {
     });
   }
   getTemplateData() {
+    const cleanName = this.config.name.replace(/[^a-zA-Z0-9]/g, "");
+    const capitalizedName = cleanName.charAt(0).toUpperCase() + cleanName.slice(1);
     return {
       name: this.config.name,
       description: this.config.description,
@@ -1031,7 +1589,12 @@ var BaseGenerator = class {
       transport: this.config.transport,
       tools: this.config.tools,
       resources: this.config.resources,
-      includeExampleTool: this.config.includeExampleTool
+      includeExampleTool: this.config.includeExampleTool,
+      javaBuildTool: this.config.javaBuildTool,
+      // Helper for Java/Elixir package name (lowercase, no special chars)
+      packageName: this.config.name.toLowerCase().replace(/[^a-z0-9]/g, ""),
+      // Helper for C#/Elixir namespace (PascalCase)
+      namespace: capitalizedName
     };
   }
   async installDependencies() {
@@ -1039,6 +1602,10 @@ var BaseGenerator = class {
       logger.info("Skipping dependency installation (--skip-install)");
       return;
     }
+    if (!isBuiltinLanguage(this.config.language)) {
+      await this.installPluginDependencies();
+      return;
+    }
     switch (this.config.language) {
       case "typescript":
         await this.installNodeDependencies();
@@ -1052,13 +1619,39 @@ var BaseGenerator = class {
       case "rust":
         await this.installRustDependencies();
         break;
+      case "java":
+      case "kotlin":
+        await this.installJavaDependencies();
+        break;
+      case "csharp":
+        await this.installDotnetDependencies();
+        break;
+      case "elixir":
+        await this.installElixirDependencies();
+        break;
+    }
+  }
+  async installPluginDependencies() {
+    const installCommand = pluginRegistry.getPluginInstallCommand(this.config.language);
+    if (!installCommand) {
+      logger.info(`No install command defined for plugin language: ${this.config.language}`);
+      return;
     }
+    await withSpinner(
+      "Installing dependencies...",
+      async () => {
+        const [cmd, ...args] = installCommand.split(" ");
+        await execa3(cmd, args, { cwd: this.outputDir });
+      },
+      "Dependencies installed",
+      "Failed to install dependencies"
+    );
   }
   async installNodeDependencies() {
     await withSpinner(
       "Installing dependencies...",
       async () => {
-        await execa2("npm", ["install"], { cwd: this.outputDir });
+        await execa3("npm", ["install"], { cwd: this.outputDir });
       },
       "Dependencies installed",
       "Failed to install dependencies"
@@ -1076,7 +1669,7 @@ var BaseGenerator = class {
     await withSpinner(
       "Installing dependencies...",
       async () => {
-        await execa2(pipCommand, ["install", "-r", "requirements.txt"], {
+        await execa3(pipCommand, ["install", "-r", "requirements.txt"], {
           cwd: this.outputDir
         });
       },
@@ -1094,10 +1687,10 @@ var BaseGenerator = class {
     await withSpinner(
       "Installing Go dependencies...",
       async () => {
-        await execa2("go", ["mod", "download"], {
+        await execa3("go", ["mod", "download"], {
           cwd: this.outputDir
         });
-        await execa2("go", ["mod", "tidy"], {
+        await execa3("go", ["mod", "tidy"], {
           cwd: this.outputDir
         });
       },
@@ -1115,7 +1708,7 @@ var BaseGenerator = class {
     await withSpinner(
       "Building Rust project...",
       async () => {
-        await execa2("cargo", ["build"], {
+        await execa3("cargo", ["build"], {
           cwd: this.outputDir
         });
       },
@@ -1123,10 +1716,92 @@ var BaseGenerator = class {
       "Failed to build project"
     );
   }
+  async installJavaDependencies() {
+    const buildTool = this.config.javaBuildTool || "maven";
+    if (buildTool === "maven") {
+      const hasMvn = await this.checkCommand("mvn");
+      if (!hasMvn) {
+        logger.warning("Maven not found. Please install dependencies manually:");
+        logger.code("mvn install");
+        return;
+      }
+      await withSpinner(
+        "Installing Maven dependencies...",
+        async () => {
+          await execa3("mvn", ["install", "-DskipTests"], {
+            cwd: this.outputDir
+          });
+        },
+        "Dependencies installed",
+        "Failed to install dependencies"
+      );
+    } else {
+      const hasGradle = await this.checkCommand("gradle");
+      const hasGradlew = await exists(path6.join(this.outputDir, "gradlew"));
+      if (!hasGradle && !hasGradlew) {
+        logger.warning("Gradle not found. Please install dependencies manually:");
+        logger.code("gradle build");
+        return;
+      }
+      const gradleCmd = hasGradlew ? "./gradlew" : "gradle";
+      await withSpinner(
+        "Installing Gradle dependencies...",
+        async () => {
+          await execa3(gradleCmd, ["build", "-x", "test"], {
+            cwd: this.outputDir
+          });
+        },
+        "Dependencies installed",
+        "Failed to install dependencies"
+      );
+    }
+  }
+  async installDotnetDependencies() {
+    const hasDotnet = await this.checkCommand("dotnet");
+    if (!hasDotnet) {
+      logger.warning(".NET SDK not found. Please install dependencies manually:");
+      logger.code("dotnet restore");
+      return;
+    }
+    await withSpinner(
+      "Restoring .NET dependencies...",
+      async () => {
+        await execa3("dotnet", ["restore"], {
+          cwd: this.outputDir
+        });
+        await execa3("dotnet", ["build"], {
+          cwd: this.outputDir
+        });
+      },
+      "Dependencies installed",
+      "Failed to install dependencies"
+    );
+  }
+  async installElixirDependencies() {
+    const hasMix = await this.checkCommand("mix");
+    if (!hasMix) {
+      logger.warning("Elixir/Mix not found. Please install dependencies manually:");
+      logger.code("mix deps.get");
+      return;
+    }
+    await withSpinner(
+      "Installing Elixir dependencies...",
+      async () => {
+        await execa3("mix", ["deps.get"], {
+          cwd: this.outputDir
+        });
+        await execa3("mix", ["compile"], {
+          cwd: this.outputDir
+        });
+      },
+      "Dependencies installed",
+      "Failed to install dependencies"
+    );
+  }
   async checkCommand(command) {
     try {
       const checkCmd = process.platform === "win32" ? "where" : "which";
-      await execa2(checkCmd, [command]);
+      await execa3(checkCmd, [command]);
       return true;
     } catch {
       return false;
@@ -1162,8 +1837,16 @@ var BaseGenerator = class {
   }
 };
 function createGeneratorContext(config, outputPath) {
-  const outputDir = outputPath || path3.resolve(process.cwd(), config.name);
-  const templateDir = path3.join(getTemplateDir(), config.language);
+  const outputDir = outputPath || path6.resolve(process.cwd(), config.name);
+  let templateDir;
+  const pluginTemplateDir = pluginRegistry.getPluginTemplateDir(config.language);
+  if (pluginTemplateDir) {
+    templateDir = pluginTemplateDir;
+  } else if ((config.language === "java" || config.language === "kotlin") && config.javaBuildTool) {
+    templateDir = path6.join(getTemplateDir(), config.language, config.javaBuildTool);
+  } else {
+    templateDir = path6.join(getTemplateDir(), config.language);
+  }
   return {
     config,
     outputDir,
@@ -1201,7 +1884,7 @@ var WizardGenerator = class extends BaseGenerator {
     await this.installDependencies();
     await this.initializeGit();
     logger.success(`Project ${this.config.name} created successfully!`);
-    logger.nextSteps(this.config.name, this.config.language);
+    logger.nextSteps(this.config.name, this.config.language, this.config.javaBuildTool);
   }
 };
 async function generateFromWizard(config, outputPath) {
@@ -1212,7 +1895,7 @@ async function generateFromWizard(config, outputPath) {
 
 // src/parsers/openapi.ts
 import YAML from "yaml";
-import inquirer8 from "inquirer";
+import inquirer10 from "inquirer";
 async function parseOpenAPISpec(content) {
   let spec;
   try {
@@ -1224,18 +1907,18 @@ async function parseOpenAPISpec(content) {
     throw new Error('Invalid OpenAPI specification. Missing "openapi" or "swagger" field.');
   }
   const endpoints = [];
-  for (const [path7, pathItem] of Object.entries(spec.paths)) {
+  for (const [path11, pathItem] of Object.entries(spec.paths)) {
     const methods = ["get", "post", "put", "delete", "patch", "options", "head"];
     for (const method of methods) {
       const operation = pathItem[method];
       if (!operation) continue;
-      const endpoint = parseOperation(path7, method, operation, spec);
+      const endpoint = parseOperation(path11, method, operation, spec);
       endpoints.push(endpoint);
     }
   }
   return endpoints;
 }
-function parseOperation(path7, method, operation, spec) {
+function parseOperation(path11, method, operation, spec) {
   const parameters = [];
   if (operation.parameters) {
     for (const param of operation.parameters) {
@@ -1259,7 +1942,7 @@ function parseOperation(path7, method, operation, spec) {
     }
   }
   return {
-    path: path7,
+    path: path11,
     method: method.toUpperCase(),
     operationId: operation.operationId || "",
     summary: operation.summary || "",
@@ -1312,7 +1995,7 @@ async function selectEndpoints(endpoints) {
     value: ep,
     checked: true
   }));
-  const { selected } = await inquirer8.prompt([
+  const { selected } = await inquirer10.prompt([
     {
       type: "checkbox",
       name: "selected",
@@ -1359,9 +2042,7 @@ var OpenAPIGenerator = class extends BaseGenerator {
     logger.title(`Creating ${this.config.name} from OpenAPI`);
     const isSafe = await this.checkOutputDir();
     if (!isSafe) {
-      throw new Error(
-        `Directory ${this.outputDir} already exists and is not empty.`
-      );
+      throw new Error(`Directory ${this.outputDir} already exists and is not empty.`);
     }
     await withSpinner(
       "Creating project structure...",
@@ -1381,7 +2062,7 @@ var OpenAPIGenerator = class extends BaseGenerator {
     await this.initializeGit();
     logger.success(`Project ${this.config.name} created successfully!`);
     logger.info(`Generated ${this.config.tools.length} tools from OpenAPI spec`);
-    logger.nextSteps(this.config.name, this.config.language);
+    logger.nextSteps(this.config.name, this.config.language, this.config.javaBuildTool);
   }
   setEndpoints(endpoints) {
     this._endpoints = endpoints;
@@ -1415,7 +2096,8 @@ async function generateFromOpenAPI(specPath, baseConfig) {
     resources: [],
     includeExampleTool: false,
     skipInstall: baseConfig.skipInstall || false,
-    initGit: baseConfig.initGit !== false
+    initGit: baseConfig.initGit !== false,
+    javaBuildTool: baseConfig.javaBuildTool
   };
   const context = createGeneratorContext(config);
   const generator = new OpenAPIGenerator(context);
@@ -1448,7 +2130,7 @@ function mapOpenAPIType(type) {
 
 // src/generators/from-prompt.ts
 import Anthropic from "@anthropic-ai/sdk";
-import inquirer9 from "inquirer";
+import inquirer11 from "inquirer";
 var SYSTEM_PROMPT = `You are an expert at designing MCP (Model Context Protocol) servers.
 Given a description of an API or functionality, you generate a list of tools that would be useful for that API.
 
@@ -1480,9 +2162,7 @@ var PromptGenerator = class extends BaseGenerator {
     logger.title(`Creating ${this.config.name}`);
     const isSafe = await this.checkOutputDir();
     if (!isSafe) {
-      throw new Error(
-        `Directory ${this.outputDir} already exists and is not empty.`
-      );
+      throw new Error(`Directory ${this.outputDir} already exists and is not empty.`);
     }
     await withSpinner(
       "Creating project structure...",
@@ -1502,11 +2182,11 @@ var PromptGenerator = class extends BaseGenerator {
     await this.initializeGit();
     logger.success(`Project ${this.config.name} created successfully!`);
     logger.info(`Generated ${this.config.tools.length} tools from your description`);
-    logger.nextSteps(this.config.name, this.config.language);
+    logger.nextSteps(this.config.name, this.config.language, this.config.javaBuildTool);
   }
 };
 async function generateFromPrompt(baseConfig) {
-  const { description } = await inquirer9.prompt([
+  const { description } = await inquirer11.prompt([
     {
       type: "editor",
       name: "description",
@@ -1562,7 +2242,7 @@ async function generateFromPrompt(baseConfig) {
     logger.list([`${index + 1}. ${tool.name} - ${tool.description}`]);
   });
   logger.blank();
-  const { confirm } = await inquirer9.prompt([
+  const { confirm } = await inquirer11.prompt([
     {
       type: "confirm",
       name: "confirm",
@@ -1582,7 +2262,8 @@ async function generateFromPrompt(baseConfig) {
     resources: [],
     includeExampleTool: false,
     skipInstall: baseConfig.skipInstall || false,
-    initGit: baseConfig.initGit !== false
+    initGit: baseConfig.initGit !== false,
+    javaBuildTool: baseConfig.javaBuildTool
   };
   const context = createGeneratorContext(config);
   const generator = new PromptGenerator(context);
@@ -1623,17 +2304,32 @@ var PresetGenerator = class extends BaseGenerator {
     logger.success(`Project ${this.config.name} created successfully!`);
     logger.info(`Preset: ${this.presetName}`);
     logger.info(`Tools included: ${this.config.tools.map((t) => t.name).join(", ")}`);
-    logger.nextSteps(this.config.name, this.config.language);
+    logger.nextSteps(this.config.name, this.config.language, this.config.javaBuildTool);
   }
 };
 async function generateFromPreset(options) {
-  const preset = getPreset(options.presetId);
-  if (!preset) {
-    throw new Error(`Invalid preset: ${options.presetId}`);
+  let preset;
+  if (isExternalPreset(options.presetId)) {
+    logger.info(`Fetching external preset: ${options.presetId}...`);
+    preset = await withSpinner(
+      "Resolving external preset...",
+      async () => await getPresetByIdentifier(options.presetId),
+      "Preset resolved",
+      "Failed to resolve preset"
+    );
+  } else {
+    preset = getPreset(options.presetId);
+    if (!preset) {
+      throw new Error(`Invalid preset: ${options.presetId}`);
+    }
   }
   const name = options.projectName || await promptProjectName();
   const description = options.useDefaults ? "" : await promptProjectDescription();
   const language = options.language || (options.useDefaults ? "typescript" : await promptLanguage());
+  let javaBuildTool;
+  if (language === "java" || language === "kotlin") {
+    javaBuildTool = options.javaBuildTool || (options.useDefaults ? "maven" : await promptJavaBuildTool());
+  }
   const transport = options.useDefaults ? "stdio" : await promptTransport();
   const config = {
     name,
@@ -1644,24 +2340,221 @@ async function generateFromPreset(options) {
     resources: [],
     includeExampleTool: false,
     skipInstall: options.skipInstall || false,
-    initGit: true
+    initGit: true,
+    javaBuildTool
   };
   const context = createGeneratorContext(config);
   const generator = new PresetGenerator(context, preset.name);
   await generator.generate();
+  return config;
 }
 function validatePresetId(presetId) {
   if (!isValidPresetId(presetId)) {
     const validPresets = ["database", "rest-api", "filesystem"];
-    throw new Error(
-      `Invalid preset "${presetId}". Valid presets are: ${validPresets.join(", ")}`
-    );
+    throw new Error(`Invalid preset "${presetId}". Valid presets are: ${validPresets.join(", ")}`);
   }
   return true;
 }
 
 // src/commands/create.ts
-import path4 from "path";
+import path8 from "path";
+
+// src/types/ci.ts
+import { z as z4 } from "zod";
+var CIProviderSchema = z4.enum(["github", "gitlab", "circleci"]);
+var CI_PROVIDERS = ["github", "gitlab", "circleci"];
+function isValidCIProvider(provider) {
+  return CI_PROVIDERS.includes(provider);
+}
+
+// src/generators/ci.ts
+import path7 from "path";
+
+// src/ci/language-config.ts
+var LANGUAGE_CI_CONFIG = {
+  typescript: {
+    installCommand: "npm ci",
+    buildCommand: "npm run build",
+    testCommand: "npm test",
+    nodeVersion: "20"
+  },
+  python: {
+    installCommand: "pip install -r requirements.txt",
+    testCommand: "pytest",
+    pythonVersion: "3.11"
+  },
+  go: {
+    installCommand: "go mod download",
+    buildCommand: "go build ./...",
+    testCommand: "go test ./...",
+    goVersion: "1.21"
+  },
+  rust: {
+    installCommand: "cargo fetch",
+    buildCommand: "cargo build --release",
+    testCommand: "cargo test",
+    rustVersion: "stable"
+  },
+  java: {
+    installCommand: "mvn install -DskipTests",
+    buildCommand: "mvn package -DskipTests",
+    testCommand: "mvn test",
+    javaVersion: "21"
+  },
+  kotlin: {
+    installCommand: "mvn install -DskipTests",
+    buildCommand: "mvn package -DskipTests",
+    testCommand: "mvn test",
+    javaVersion: "21"
+  },
+  csharp: {
+    installCommand: "dotnet restore",
+    buildCommand: "dotnet build --configuration Release",
+    testCommand: "dotnet test",
+    dotnetVersion: "8.0"
+  },
+  elixir: {
+    installCommand: "mix deps.get",
+    buildCommand: "mix compile",
+    testCommand: "mix test",
+    elixirVersion: "1.15"
+  }
+};
+function getJavaCIConfig(buildTool) {
+  if (buildTool === "gradle") {
+    return {
+      installCommand: "./gradlew dependencies",
+      buildCommand: "./gradlew build -x test",
+      testCommand: "./gradlew test",
+      javaVersion: "21"
+    };
+  }
+  return LANGUAGE_CI_CONFIG.java;
+}
+function getCITemplateContext(projectName, language, javaBuildTool) {
+  const config = (language === "java" || language === "kotlin") && javaBuildTool === "gradle" ? getJavaCIConfig("gradle") : LANGUAGE_CI_CONFIG[language];
+  return {
+    projectName,
+    language,
+    ...config
+  };
+}
+
+// src/generators/ci.ts
+var CIGenerator = class {
+  options;
+  templateDir;
+  context;
+  constructor(options) {
+    this.options = options;
+    this.templateDir = path7.join(getTemplateDir(), "ci", options.provider);
+    this.context = getCITemplateContext(
+      options.projectName || path7.basename(options.projectDir),
+      options.language,
+      options.javaBuildTool
+    );
+  }
+  async generate() {
+    await withSpinner(
+      `Generating ${this.getProviderName()} CI configuration...`,
+      async () => {
+        switch (this.options.provider) {
+          case "github":
+            await this.generateGitHubActions();
+            break;
+          case "gitlab":
+            await this.generateGitLabCI();
+            break;
+          case "circleci":
+            await this.generateCircleCI();
+            break;
+        }
+      },
+      `${this.getProviderName()} CI configuration generated`,
+      `Failed to generate ${this.getProviderName()} CI configuration`
+    );
+  }
+  async generateGitHubActions() {
+    const workflowDir = path7.join(this.options.projectDir, ".github", "workflows");
+    await ensureDir(workflowDir);
+    const templatePath = path7.join(this.templateDir, "ci.yml.ejs");
+    const outputPath = path7.join(workflowDir, "ci.yml");
+    await renderTemplateToFile(templatePath, outputPath, this.context);
+  }
+  async generateGitLabCI() {
+    const templatePath = path7.join(this.templateDir, ".gitlab-ci.yml.ejs");
+    const outputPath = path7.join(this.options.projectDir, ".gitlab-ci.yml");
+    await renderTemplateToFile(templatePath, outputPath, this.context);
+  }
+  async generateCircleCI() {
+    const circleDir = path7.join(this.options.projectDir, ".circleci");
+    await ensureDir(circleDir);
+    const templatePath = path7.join(this.templateDir, "config.yml.ejs");
+    const outputPath = path7.join(circleDir, "config.yml");
+    await renderTemplateToFile(templatePath, outputPath, this.context);
+  }
+  getProviderName() {
+    switch (this.options.provider) {
+      case "github":
+        return "GitHub Actions";
+      case "gitlab":
+        return "GitLab CI";
+      case "circleci":
+        return "CircleCI";
+    }
+  }
+};
+async function generateCI(options) {
+  const generator = new CIGenerator(options);
+  await generator.generate();
+}
+async function detectLanguageFromProject(projectDir) {
+  const checks = [
+    { file: "package.json", language: "typescript" },
+    { file: "pyproject.toml", language: "python" },
+    { file: "requirements.txt", language: "python" },
+    { file: "go.mod", language: "go" },
+    { file: "Cargo.toml", language: "rust" },
+    { file: "pom.xml", language: "java" },
+    { file: "build.gradle", language: "java" },
+    { file: "build.gradle.kts", language: "kotlin" },
+    { file: "*.csproj", language: "csharp" },
+    { file: "mix.exs", language: "elixir" }
+  ];
+  for (const check of checks) {
+    if (await exists(path7.join(projectDir, check.file))) {
+      return check.language;
+    }
+  }
+  return void 0;
+}
+async function detectJavaBuildTool(projectDir) {
+  if (await exists(path7.join(projectDir, "build.gradle")) || await exists(path7.join(projectDir, "build.gradle.kts"))) {
+    return "gradle";
+  }
+  if (await exists(path7.join(projectDir, "pom.xml"))) {
+    return "maven";
+  }
+  return void 0;
+}
+
+// src/commands/create.ts
+function getLanguageFromOptions(options) {
+  if (options.typescript) return "typescript";
+  if (options.python) return "python";
+  if (options.go) return "go";
+  if (options.rust) return "rust";
+  if (options.java) return "java";
+  if (options.kotlin) return "kotlin";
+  if (options.csharp) return "csharp";
+  if (options.elixir) return "elixir";
+  return void 0;
+}
+function getJavaBuildToolFromOptions(options) {
+  if (options.maven) return "maven";
+  if (options.gradle) return "gradle";
+  return void 0;
+}
 async function createCommand(projectName, options) {
   try {
     if (options.preset) {
@@ -1688,16 +2581,17 @@ async function createCommand(projectName, options) {
 }
 async function handleWizardGeneration(projectName, options) {
   let config;
-  const presetLanguage = options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0;
+  const presetLanguage = getLanguageFromOptions(options);
+  const presetJavaBuildTool = getJavaBuildToolFromOptions(options);
   if (options.yes) {
-    config = await runQuickWizard(projectName, presetLanguage);
+    config = await runQuickWizard(projectName, presetLanguage, presetJavaBuildTool);
   } else {
-    config = await runWizard({ defaultName: projectName, presetLanguage });
+    config = await runWizard({ defaultName: projectName, presetLanguage, presetJavaBuildTool });
   }
   if (options.skipInstall) {
     config.skipInstall = true;
   }
-  const outputPath = path4.resolve(process.cwd(), config.name);
+  const outputPath = path8.resolve(process.cwd(), config.name);
   if (await exists(outputPath)) {
     const files = await import("fs-extra").then((m) => m.readdir(outputPath));
     if (files.length > 0) {
@@ -1706,6 +2600,9 @@ async function handleWizardGeneration(projectName, options) {
     }
   }
   await generateFromWizard(config);
+  if (options.ci) {
+    await handleCIGeneration(config.name, config.language, config.javaBuildTool, options.ci);
+  }
 }
 async function handleOpenAPIGeneration(projectName, options) {
   const specPath = options.fromOpenapi;
@@ -1713,45 +2610,71 @@ async function handleOpenAPIGeneration(projectName, options) {
     logger.error(`OpenAPI specification file not found: ${specPath}`);
     process.exit(1);
   }
-  const name = projectName || path4.basename(specPath, path4.extname(specPath)) + "-mcp";
+  const name = projectName || path8.basename(specPath, path8.extname(specPath)) + "-mcp";
   await generateFromOpenAPI(specPath, {
     name,
-    language: options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0,
-    skipInstall: options.skipInstall
+    language: getLanguageFromOptions(options),
+    skipInstall: options.skipInstall,
+    javaBuildTool: getJavaBuildToolFromOptions(options)
   });
 }
 async function handlePromptGeneration(projectName, options) {
   await generateFromPrompt({
     name: projectName,
-    language: options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0,
-    skipInstall: options.skipInstall
+    language: getLanguageFromOptions(options),
+    skipInstall: options.skipInstall,
+    javaBuildTool: getJavaBuildToolFromOptions(options)
   });
 }
 async function handlePresetGeneration(projectName, options) {
   const presetId = options.preset;
-  validatePresetId(presetId);
-  await generateFromPreset({
+  if (!isExternalPreset(presetId) && !isValidPresetId(presetId)) {
+    logger.error(
+      `Invalid preset "${presetId}". Valid local presets: ${PRESET_IDS.join(", ")}
+For external presets use: @org/package or github:user/repo`
+    );
+    process.exit(1);
+  }
+  const result = await generateFromPreset({
     projectName,
     presetId,
-    language: options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0,
+    language: getLanguageFromOptions(options),
     skipInstall: options.skipInstall,
-    useDefaults: options.yes
+    useDefaults: options.yes,
+    javaBuildTool: getJavaBuildToolFromOptions(options)
+  });
+  if (options.ci && result) {
+    await handleCIGeneration(result.name, result.language, result.javaBuildTool, options.ci);
+  }
+}
+async function handleCIGeneration(projectName, language, javaBuildTool, ciProvider) {
+  if (!isValidCIProvider(ciProvider)) {
+    logger.error(`Invalid CI provider: ${ciProvider}. Valid options: github, gitlab, circleci`);
+    return;
+  }
+  const projectDir = path8.resolve(process.cwd(), projectName);
+  await generateCI({
+    projectDir,
+    provider: ciProvider,
+    language,
+    javaBuildTool,
+    projectName
   });
 }
 
 // src/commands/init.ts
-import path5 from "path";
-import inquirer10 from "inquirer";
+import path9 from "path";
+import inquirer12 from "inquirer";
 async function initCommand(options) {
   try {
     const currentDir = process.cwd();
-    const dirName = path5.basename(currentDir);
-    const hasPackageJson = await exists(path5.join(currentDir, "package.json"));
-    const hasPyproject = await exists(path5.join(currentDir, "pyproject.toml"));
-    const hasGoMod = await exists(path5.join(currentDir, "go.mod"));
-    const hasCargoToml = await exists(path5.join(currentDir, "Cargo.toml"));
+    const dirName = path9.basename(currentDir);
+    const hasPackageJson = await exists(path9.join(currentDir, "package.json"));
+    const hasPyproject = await exists(path9.join(currentDir, "pyproject.toml"));
+    const hasGoMod = await exists(path9.join(currentDir, "go.mod"));
+    const hasCargoToml = await exists(path9.join(currentDir, "Cargo.toml"));
     if ((hasPackageJson || hasPyproject || hasGoMod || hasCargoToml) && !options.force) {
-      const { proceed } = await inquirer10.prompt([
+      const { proceed } = await inquirer12.prompt([
         {
           type: "confirm",
           name: "proceed",
@@ -1793,7 +2716,7 @@ async function initCommand(options) {
     let projectName = dirName;
     if (hasPackageJson) {
       try {
-        const pkgContent = await readFile(path5.join(currentDir, "package.json"));
+        const pkgContent = await readFile(path9.join(currentDir, "package.json"));
         const pkg = JSON.parse(pkgContent);
         projectName = pkg.name || dirName;
       } catch {
@@ -1823,14 +2746,14 @@ async function initCommand(options) {
 }
 
 // src/commands/add-tool.ts
-import path6 from "path";
+import path10 from "path";
 async function addToolCommand(options) {
   try {
     const currentDir = process.cwd();
-    const isTypeScript = await exists(path6.join(currentDir, "package.json"));
-    const isPython = await exists(path6.join(currentDir, "pyproject.toml"));
-    const isGo = await exists(path6.join(currentDir, "go.mod"));
-    const isRust = await exists(path6.join(currentDir, "Cargo.toml"));
+    const isTypeScript = await exists(path10.join(currentDir, "package.json"));
+    const isPython = await exists(path10.join(currentDir, "pyproject.toml"));
+    const isGo = await exists(path10.join(currentDir, "go.mod"));
+    const isRust = await exists(path10.join(currentDir, "Cargo.toml"));
     if (!isTypeScript && !isPython && !isGo && !isRust) {
       logger.error("No MCP server project found in current directory.");
       logger.info("Run this command from the root of your MCP server project.");
@@ -1868,9 +2791,9 @@ async function addToolCommand(options) {
   }
 }
 async function addToolToTypeScript(projectDir, tool) {
-  const toolsDir = path6.join(projectDir, "src", "tools");
+  const toolsDir = path10.join(projectDir, "src", "tools");
   const toolFileName = `${tool.name.replace(/_/g, "-")}.ts`;
-  const toolFilePath = path6.join(toolsDir, toolFileName);
+  const toolFilePath = path10.join(toolsDir, toolFileName);
   if (await exists(toolFilePath)) {
     logger.error(`Tool file already exists: ${toolFilePath}`);
     process.exit(1);
@@ -1886,9 +2809,9 @@ async function addToolToTypeScript(projectDir, tool) {
   ]);
 }
 async function addToolToPython(projectDir, tool) {
-  const toolsDir = path6.join(projectDir, "src", "tools");
+  const toolsDir = path10.join(projectDir, "src", "tools");
   const toolFileName = `${tool.name}.py`;
-  const toolFilePath = path6.join(toolsDir, toolFileName);
+  const toolFilePath = path10.join(toolsDir, toolFileName);
   if (await exists(toolFilePath)) {
     logger.error(`Tool file already exists: ${toolFilePath}`);
     process.exit(1);
@@ -2032,9 +2955,9 @@ function mapTypeToPython(type) {
   }
 }
 async function addToolToGo(projectDir, tool) {
-  const toolsDir = path6.join(projectDir, "internal", "tools");
+  const toolsDir = path10.join(projectDir, "internal", "tools");
   const toolFileName = `${tool.name}.go`;
-  const toolFilePath = path6.join(toolsDir, toolFileName);
+  const toolFilePath = path10.join(toolsDir, toolFileName);
   if (await exists(toolFilePath)) {
     logger.error(`Tool file already exists: ${toolFilePath}`);
     process.exit(1);
@@ -2050,9 +2973,9 @@ async function addToolToGo(projectDir, tool) {
   ]);
 }
 async function addToolToRust(projectDir, tool) {
-  const srcDir = path6.join(projectDir, "src");
+  const srcDir = path10.join(projectDir, "src");
   const toolFileName = `${tool.name}.rs`;
-  const toolFilePath = path6.join(srcDir, toolFileName);
+  const toolFilePath = path10.join(srcDir, toolFileName);
   if (await exists(toolFilePath)) {
     logger.error(`Tool file already exists: ${toolFilePath}`);
     process.exit(1);
@@ -2200,6 +3123,7 @@ function mapTypeToRust(type) {
 }
 
 export {
+  isValidCIProvider,
   projectNameRegex,
   validateProjectName,
   validateToolName,
@@ -2209,20 +3133,6 @@ export {
   safeParseAndValidate,
   promptProjectName,
   promptProjectDescription,
-  promptLanguage,
-  promptTransport,
-  promptIncludeExampleTool,
-  promptAddTools,
-  promptToolConfig,
-  promptMultipleTools,
-  promptAddResources,
-  promptResourceConfig,
-  promptMultipleResources,
-  promptGenerationMethod,
-  PRESETS,
-  promptPreset,
-  runWizard,
-  runQuickWizard,
   ensureDir,
   writeFile,
   readFile,
@@ -2236,7 +3146,39 @@ export {
   renderTemplateToFile,
   walkDir,
   getTemplateDir,
+  getTemplateDirForLanguage,
   resolveOutputPath,
+  pluginRegistry,
+  promptLanguage,
+  promptTransport,
+  promptIncludeExampleTool,
+  promptAddTools,
+  promptToolConfig,
+  promptMultipleTools,
+  promptAddResources,
+  promptResourceConfig,
+  promptMultipleResources,
+  promptJavaBuildTool,
+  promptGenerationMethod,
+  BuiltinLanguageSchema,
+  LanguageSchema,
+  BUILTIN_LANGUAGES,
+  isBuiltinLanguage,
+  JavaBuildToolSchema,
+  TransportSchema,
+  ToolParameterSchema,
+  ToolConfigSchema,
+  ResourceConfigSchema,
+  ProjectConfigSchema,
+  PresetIdSchema,
+  clearPresetCache,
+  listCachedPresets,
+  getCacheDir,
+  PRESETS,
+  promptPreset,
+  promptCIProvider,
+  runWizard,
+  runQuickWizard,
   isGitInstalled,
   initGitRepository,
   createInitialCommit,
@@ -2259,6 +3201,9 @@ export {
   PresetGenerator,
   generateFromPreset,
   validatePresetId,
+  generateCI,
+  detectLanguageFromProject,
+  detectJavaBuildTool,
   createCommand,
   initCommand,
   addToolCommand