mcp-new 1.5.0 → 1.6.0

package/dist/{chunk-YISSMIHU.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,24 +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" },
-        { name: "Java", value: "java" },
-        { name: "Kotlin", value: "kotlin" },
-        { name: "C# (.NET)", value: "csharp" },
-        { name: "Elixir", value: "elixir" }
-      ],
+      choices,
       default: "typescript"
     }
   ]);
@@ -368,6 +614,65 @@ 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 inquirer8 from "inquirer";
 
@@ -679,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,
@@ -692,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() {
@@ -711,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);
@@ -773,98 +1342,28 @@ async function runQuickWizard(defaultName, presetLanguage, presetJavaBuildTool)
   };
 }
 
-// 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 {
@@ -873,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,
@@ -886,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;
@@ -939,44 +1438,51 @@ var logger = {
     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;
-      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";
+    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:", [
       "",
@@ -1045,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;
@@ -1058,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 {
@@ -1096,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();
@@ -1121,11 +1631,27 @@ var BaseGenerator = class {
         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"
@@ -1143,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
         });
       },
@@ -1161,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
         });
       },
@@ -1182,7 +1708,7 @@ var BaseGenerator = class {
     await withSpinner(
       "Building Rust project...",
       async () => {
-        await execa2("cargo", ["build"], {
+        await execa3("cargo", ["build"], {
           cwd: this.outputDir
         });
       },
@@ -1202,7 +1728,7 @@ var BaseGenerator = class {
       await withSpinner(
         "Installing Maven dependencies...",
         async () => {
-          await execa2("mvn", ["install", "-DskipTests"], {
+          await execa3("mvn", ["install", "-DskipTests"], {
             cwd: this.outputDir
           });
         },
@@ -1211,7 +1737,7 @@ var BaseGenerator = class {
       );
     } else {
       const hasGradle = await this.checkCommand("gradle");
-      const hasGradlew = await exists(path3.join(this.outputDir, "gradlew"));
+      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");
@@ -1221,7 +1747,7 @@ var BaseGenerator = class {
       await withSpinner(
         "Installing Gradle dependencies...",
         async () => {
-          await execa2(gradleCmd, ["build", "-x", "test"], {
+          await execa3(gradleCmd, ["build", "-x", "test"], {
             cwd: this.outputDir
           });
         },
@@ -1240,10 +1766,10 @@ var BaseGenerator = class {
     await withSpinner(
       "Restoring .NET dependencies...",
       async () => {
-        await execa2("dotnet", ["restore"], {
+        await execa3("dotnet", ["restore"], {
           cwd: this.outputDir
         });
-        await execa2("dotnet", ["build"], {
+        await execa3("dotnet", ["build"], {
           cwd: this.outputDir
         });
       },
@@ -1261,10 +1787,10 @@ var BaseGenerator = class {
     await withSpinner(
       "Installing Elixir dependencies...",
       async () => {
-        await execa2("mix", ["deps.get"], {
+        await execa3("mix", ["deps.get"], {
           cwd: this.outputDir
         });
-        await execa2("mix", ["compile"], {
+        await execa3("mix", ["compile"], {
           cwd: this.outputDir
         });
       },
@@ -1275,7 +1801,7 @@ var BaseGenerator = class {
   async checkCommand(command) {
     try {
       const checkCmd = process.platform === "win32" ? "where" : "which";
-      await execa2(checkCmd, [command]);
+      await execa3(checkCmd, [command]);
       return true;
     } catch {
       return false;
@@ -1311,12 +1837,15 @@ var BaseGenerator = class {
   }
 };
 function createGeneratorContext(config, outputPath) {
-  const outputDir = outputPath || path3.resolve(process.cwd(), config.name);
+  const outputDir = outputPath || path6.resolve(process.cwd(), config.name);
   let templateDir;
-  if ((config.language === "java" || config.language === "kotlin") && config.javaBuildTool) {
-    templateDir = path3.join(getTemplateDir(), config.language, config.javaBuildTool);
+  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 = path3.join(getTemplateDir(), config.language);
+    templateDir = path6.join(getTemplateDir(), config.language);
   }
   return {
     config,
@@ -1366,7 +1895,7 @@ async function generateFromWizard(config, outputPath) {
 
 // src/parsers/openapi.ts
 import YAML from "yaml";
-import inquirer9 from "inquirer";
+import inquirer10 from "inquirer";
 async function parseOpenAPISpec(content) {
   let spec;
   try {
@@ -1378,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) {
@@ -1413,7 +1942,7 @@ function parseOperation(path7, method, operation, spec) {
     }
   }
   return {
-    path: path7,
+    path: path11,
     method: method.toUpperCase(),
     operationId: operation.operationId || "",
     summary: operation.summary || "",
@@ -1466,7 +1995,7 @@ async function selectEndpoints(endpoints) {
     value: ep,
     checked: true
   }));
-  const { selected } = await inquirer9.prompt([
+  const { selected } = await inquirer10.prompt([
     {
       type: "checkbox",
       name: "selected",
@@ -1601,7 +2130,7 @@ function mapOpenAPIType(type) {
 
 // src/generators/from-prompt.ts
 import Anthropic from "@anthropic-ai/sdk";
-import inquirer10 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.
 
@@ -1657,7 +2186,7 @@ var PromptGenerator = class extends BaseGenerator {
   }
 };
 async function generateFromPrompt(baseConfig) {
-  const { description } = await inquirer10.prompt([
+  const { description } = await inquirer11.prompt([
     {
       type: "editor",
       name: "description",
@@ -1713,7 +2242,7 @@ async function generateFromPrompt(baseConfig) {
     logger.list([`${index + 1}. ${tool.name} - ${tool.description}`]);
   });
   logger.blank();
-  const { confirm } = await inquirer10.prompt([
+  const { confirm } = await inquirer11.prompt([
     {
       type: "confirm",
       name: "confirm",
@@ -1779,9 +2308,20 @@ var PresetGenerator = class extends BaseGenerator {
   }
 };
 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();
@@ -1806,6 +2346,7 @@ async function generateFromPreset(options) {
   const context = createGeneratorContext(config);
   const generator = new PresetGenerator(context, preset.name);
   await generator.generate();
+  return config;
 }
 function validatePresetId(presetId) {
   if (!isValidPresetId(presetId)) {
@@ -1816,7 +2357,188 @@ function validatePresetId(presetId) {
 }
 
 // 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";
@@ -1869,7 +2591,7 @@ async function handleWizardGeneration(projectName, options) {
   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) {
@@ -1878,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;
@@ -1885,7 +2610,7 @@ 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: getLanguageFromOptions(options),
@@ -1903,8 +2628,14 @@ async function handlePromptGeneration(projectName, 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: getLanguageFromOptions(options),
@@ -1912,21 +2643,38 @@ async function handlePresetGeneration(projectName, options) {
     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 inquirer11 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 inquirer11.prompt([
+      const { proceed } = await inquirer12.prompt([
         {
           type: "confirm",
           name: "proceed",
@@ -1968,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 {
@@ -1998,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.");
@@ -2043,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);
@@ -2061,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);
@@ -2207,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);
@@ -2225,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);
@@ -2375,6 +3123,7 @@ function mapTypeToRust(type) {
 }
 
 export {
+  isValidCIProvider,
   projectNameRegex,
   validateProjectName,
   validateToolName,
@@ -2384,6 +3133,22 @@ export {
   safeParseAndValidate,
   promptProjectName,
   promptProjectDescription,
+  ensureDir,
+  writeFile,
+  readFile,
+  copyFile,
+  copyDir,
+  exists,
+  remove,
+  readDir,
+  isDirectory,
+  renderTemplate,
+  renderTemplateToFile,
+  walkDir,
+  getTemplateDir,
+  getTemplateDirForLanguage,
+  resolveOutputPath,
+  pluginRegistry,
   promptLanguage,
   promptTransport,
   promptIncludeExampleTool,
@@ -2395,24 +3160,25 @@ export {
   promptMultipleResources,
   promptJavaBuildTool,
   promptGenerationMethod,
+  BuiltinLanguageSchema,
+  LanguageSchema,
+  BUILTIN_LANGUAGES,
+  isBuiltinLanguage,
+  JavaBuildToolSchema,
+  TransportSchema,
+  ToolParameterSchema,
+  ToolConfigSchema,
+  ResourceConfigSchema,
+  ProjectConfigSchema,
+  PresetIdSchema,
+  clearPresetCache,
+  listCachedPresets,
+  getCacheDir,
   PRESETS,
   promptPreset,
+  promptCIProvider,
   runWizard,
   runQuickWizard,
-  ensureDir,
-  writeFile,
-  readFile,
-  copyFile,
-  copyDir,
-  exists,
-  remove,
-  readDir,
-  isDirectory,
-  renderTemplate,
-  renderTemplateToFile,
-  walkDir,
-  getTemplateDir,
-  resolveOutputPath,
   isGitInstalled,
   initGitRepository,
   createInitialCommit,
@@ -2435,6 +3201,9 @@ export {
   PresetGenerator,
   generateFromPreset,
   validatePresetId,
+  generateCI,
+  detectLanguageFromProject,
+  detectJavaBuildTool,
   createCommand,
   initCommand,
   addToolCommand