mcp-new 1.2.2 → 1.6.0

package/dist/cli.js

@@ -2,11 +2,32 @@
 import {
   PRESETS,
   addToolCommand,
+  clearPresetCache,
   createCommand,
+  createInitialCommit,
   createSpinner,
+  detectJavaBuildTool,
+  detectLanguageFromProject,
+  ensureDir,
+  exists,
+  generateCI,
+  generateFromWizard,
+  getCacheDir,
   initCommand,
-  logger
-} from "./chunk-3JG4FVS2.js";
+  initGitRepository,
+  isGitInstalled,
+  isValidCIProvider,
+  listCachedPresets,
+  logger,
+  pluginRegistry,
+  promptCIProvider,
+  promptJavaBuildTool,
+  promptLanguage,
+  readDir,
+  readFile,
+  withSpinner,
+  writeFile
+} from "./chunk-LJNMSDBU.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -347,7 +368,7 @@ async function upgradeNodePackage(projectDir, info) {
   await fs2.writeJson(packageJsonPath, packageJson, { spaces: 2 });
   await execa("npm", ["install"], { cwd: projectDir });
 }
-async function checkPythonPackage(projectDir) {
+async function checkPythonPackage(_projectDir) {
   const packageName = "mcp";
   let current = null;
   let latest = null;
@@ -421,6 +442,1130 @@ async function upgradeRustPackage(projectDir, info) {
   await execa("cargo", ["update", "-p", info.packageName], { cwd: projectDir });
 }
 
+// src/commands/monorepo.ts
+import path3 from "path";
+import inquirer from "inquirer";
+async function monorepoInitCommand(workspaceName, options) {
+  try {
+    let name = workspaceName;
+    if (!name) {
+      const { inputName } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "inputName",
+          message: "Workspace name:",
+          default: "mcp-workspace"
+        }
+      ]);
+      name = inputName;
+    }
+    const outputDir = path3.resolve(process.cwd(), name);
+    if (await exists(outputDir)) {
+      const files = await readDir(outputDir);
+      if (files.length > 0 && !options.force) {
+        logger.error(
+          `Directory "${name}" already exists and is not empty. Use --force to override.`
+        );
+        process.exit(1);
+      }
+    }
+    logger.title(`Creating MCP Monorepo: ${name}`);
+    await withSpinner(
+      "Creating workspace structure...",
+      async () => {
+        await ensureDir(outputDir);
+        await ensureDir(path3.join(outputDir, "packages"));
+        await ensureDir(path3.join(outputDir, "shared"));
+      },
+      "Workspace structure created"
+    );
+    const workspaceConfig = {
+      name,
+      packages: []
+    };
+    await withSpinner(
+      "Creating configuration files...",
+      async () => {
+        await writeFile(
+          path3.join(outputDir, "mcp.workspace.json"),
+          JSON.stringify(workspaceConfig, null, 2)
+        );
+        const packageJson = {
+          name,
+          version: "1.0.0",
+          private: true,
+          workspaces: ["packages/*", "shared/*"],
+          scripts: {
+            build: "npm run build --workspaces",
+            dev: "npm run dev --workspaces --if-present",
+            test: "npm run test --workspaces --if-present"
+          }
+        };
+        await writeFile(path3.join(outputDir, "package.json"), JSON.stringify(packageJson, null, 2));
+        const readme = `# ${name}
+
+MCP Monorepo Workspace
+
+## Structure
+
+\`\`\`
+${name}/
+\u251C\u2500\u2500 packages/           # MCP servers
+\u251C\u2500\u2500 shared/             # Shared utilities and types
+\u251C\u2500\u2500 mcp.workspace.json  # Workspace configuration
+\u2514\u2500\u2500 package.json        # Root package.json
+\`\`\`
+
+## Commands
+
+\`\`\`bash
+# Add a new MCP server
+mcp-new monorepo add <server-name>
+
+# Build all packages
+npm run build
+
+# Run all dev servers
+npm run dev
+\`\`\`
+
+## Packages
+
+${workspaceConfig.packages.length === 0 ? "_No packages yet. Run `mcp-new monorepo add <name>` to create one._" : workspaceConfig.packages.map((p) => `- ${p}`).join("\n")}
+`;
+        await writeFile(path3.join(outputDir, "README.md"), readme);
+        const gitignore = `# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+`;
+        await writeFile(path3.join(outputDir, ".gitignore"), gitignore);
+      },
+      "Configuration files created"
+    );
+    const gitInstalled = await isGitInstalled();
+    if (gitInstalled) {
+      await withSpinner(
+        "Initializing git repository...",
+        async () => {
+          await initGitRepository(outputDir);
+          await createInitialCommit(outputDir);
+        },
+        "Git repository initialized"
+      );
+    }
+    logger.success(`Monorepo workspace "${name}" created successfully!`);
+    logger.box("Next steps:", ["", `  cd ${name}`, `  mcp-new monorepo add my-first-server`, ""]);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+async function monorepoAddCommand(serverName, options) {
+  try {
+    const workspaceConfigPath = path3.resolve(process.cwd(), "mcp.workspace.json");
+    if (!await exists(workspaceConfigPath)) {
+      logger.error(
+        "Not in a monorepo workspace. Run `mcp-new monorepo init` first, or cd into an existing workspace."
+      );
+      process.exit(1);
+    }
+    let name = serverName || options.name;
+    if (!name) {
+      const { inputName } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "inputName",
+          message: "Server name:",
+          default: "my-mcp-server"
+        }
+      ]);
+      name = inputName;
+    }
+    let language;
+    const opts = options;
+    if (opts.typescript === true || opts.t === true) language = "typescript";
+    else if (opts.python === true || opts.p === true) language = "python";
+    else if (opts.go === true || opts.g === true) language = "go";
+    else if (opts.rust === true || opts.r === true) language = "rust";
+    else if (opts.java === true || opts.j === true) language = "java";
+    else if (opts.kotlin === true || opts.k === true) language = "kotlin";
+    else if (opts.csharp === true || opts.c === true) language = "csharp";
+    else if (opts.elixir === true || opts.e === true) language = "elixir";
+    if (!language) {
+      language = await promptLanguage();
+    }
+    let javaBuildTool;
+    if (language === "java" || language === "kotlin") {
+      javaBuildTool = options.maven ? "maven" : options.gradle ? "gradle" : await promptJavaBuildTool();
+    }
+    const outputDir = path3.join(process.cwd(), "packages", name);
+    if (await exists(outputDir)) {
+      logger.error(`Server "${name}" already exists in packages/`);
+      process.exit(1);
+    }
+    logger.title(`Adding MCP Server: ${name}`);
+    await generateFromWizard(
+      {
+        name,
+        description: "",
+        language,
+        transport: "stdio",
+        tools: [],
+        resources: [],
+        includeExampleTool: true,
+        skipInstall: options.skipInstall || false,
+        initGit: false,
+        // Don't init git for individual packages
+        javaBuildTool
+      },
+      outputDir
+    );
+    const workspaceConfigContent = await readFile(workspaceConfigPath);
+    const workspaceConfig = JSON.parse(workspaceConfigContent);
+    workspaceConfig.packages.push(name);
+    await writeFile(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2));
+    logger.success(`Server "${name}" added to packages/`);
+    logger.info(`Language: ${language}${javaBuildTool ? ` (${javaBuildTool})` : ""}`);
+    logger.box("Next steps:", [
+      "",
+      `  cd packages/${name}`,
+      "  # Start developing your MCP server",
+      ""
+    ]);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+async function monorepoListCommand() {
+  try {
+    const workspaceConfigPath = path3.resolve(process.cwd(), "mcp.workspace.json");
+    if (!await exists(workspaceConfigPath)) {
+      logger.error("Not in a monorepo workspace.");
+      process.exit(1);
+    }
+    const workspaceConfigContent = await readFile(workspaceConfigPath);
+    const workspaceConfig = JSON.parse(workspaceConfigContent);
+    logger.title(`Workspace: ${workspaceConfig.name}`);
+    if (workspaceConfig.packages.length === 0) {
+      logger.info("No packages yet. Run `mcp-new monorepo add <name>` to create one.");
+    } else {
+      logger.info("Packages:");
+      workspaceConfig.packages.forEach((pkg, index) => {
+        console.log(`  ${index + 1}. ${pkg}`);
+      });
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/add-ci.ts
+import path4 from "path";
+async function addCICommand(provider, options = {}) {
+  const projectDir = process.cwd();
+  try {
+    const hasPackageJson = await exists(path4.join(projectDir, "package.json"));
+    const hasPyproject = await exists(path4.join(projectDir, "pyproject.toml"));
+    const hasGoMod = await exists(path4.join(projectDir, "go.mod"));
+    const hasCargoToml = await exists(path4.join(projectDir, "Cargo.toml"));
+    const hasPomXml = await exists(path4.join(projectDir, "pom.xml"));
+    const hasBuildGradle = await exists(path4.join(projectDir, "build.gradle"));
+    const hasBuildGradleKts = await exists(path4.join(projectDir, "build.gradle.kts"));
+    const hasMixExs = await exists(path4.join(projectDir, "mix.exs"));
+    const hasProjectFile = hasPackageJson || hasPyproject || hasGoMod || hasCargoToml || hasPomXml || hasBuildGradle || hasBuildGradleKts || hasMixExs;
+    if (!hasProjectFile) {
+      logger.error(
+        "No project configuration file found. Please run this command from a project root directory."
+      );
+      process.exit(1);
+    }
+    let ciProvider;
+    const providerArg = provider || options.provider;
+    if (providerArg) {
+      if (!isValidCIProvider(providerArg)) {
+        logger.error(`Invalid CI provider: ${providerArg}. Valid options: github, gitlab, circleci`);
+        process.exit(1);
+      }
+      ciProvider = providerArg;
+    } else {
+      ciProvider = await promptCIProvider();
+    }
+    let language = await detectLanguageFromProject(projectDir);
+    if (!language) {
+      logger.warning("Could not detect project language. Please select manually:");
+      language = await promptLanguage();
+    }
+    let javaBuildTool = await detectJavaBuildTool(projectDir);
+    if ((language === "java" || language === "kotlin") && !javaBuildTool) {
+      javaBuildTool = await promptJavaBuildTool();
+    }
+    await generateCI({
+      projectDir,
+      provider: ciProvider,
+      language,
+      javaBuildTool,
+      projectName: path4.basename(projectDir)
+    });
+    logger.success(`CI/CD configuration added successfully!`);
+    const providerInstructions = {
+      github: [
+        "Your GitHub Actions workflow has been created at .github/workflows/ci.yml",
+        "It will automatically run on push and pull requests to main branch",
+        "Commit and push to see it in action"
+      ],
+      gitlab: [
+        "Your GitLab CI configuration has been created at .gitlab-ci.yml",
+        "It will automatically run on push to any branch",
+        "Push to your GitLab repository to see it in action"
+      ],
+      circleci: [
+        "Your CircleCI configuration has been created at .circleci/config.yml",
+        "Connect your repository to CircleCI to enable the pipeline",
+        "Visit https://circleci.com to set up your project"
+      ]
+    };
+    logger.nextSteps(providerInstructions[ciProvider]);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/docs.ts
+import path8 from "path";
+
+// src/docs-server/server.ts
+import http from "http";
+import path7 from "path";
+
+// src/docs-server/markdown.ts
+import { marked } from "marked";
+marked.setOptions({
+  gfm: true,
+  breaks: true
+});
+function parseMarkdown(content) {
+  const html = marked.parse(content);
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1] : "Untitled";
+  const headings = [];
+  const headingRegex = /^#{1,3}\s+(.+)$/gm;
+  let match;
+  while ((match = headingRegex.exec(content)) !== null) {
+    headings.push(match[1]);
+  }
+  return {
+    title,
+    content: html,
+    headings,
+    rawContent: content
+  };
+}
+function renderMarkdownToHTML(content, title) {
+  const parsed = parseMarkdown(content);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title} - mcp-new Documentation</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      line-height: 1.6;
+      color: #333;
+      background: #f5f5f5;
+    }
+
+    .container {
+      display: flex;
+      min-height: 100vh;
+    }
+
+    .sidebar {
+      width: 280px;
+      background: #1a1a2e;
+      color: #fff;
+      padding: 20px;
+      position: fixed;
+      height: 100vh;
+      overflow-y: auto;
+    }
+
+    .sidebar h1 {
+      font-size: 1.5rem;
+      margin-bottom: 20px;
+      color: #4fc3f7;
+    }
+
+    .sidebar nav ul {
+      list-style: none;
+    }
+
+    .sidebar nav li {
+      margin: 8px 0;
+    }
+
+    .sidebar nav a {
+      color: #b0bec5;
+      text-decoration: none;
+      display: block;
+      padding: 8px 12px;
+      border-radius: 4px;
+      transition: background 0.2s, color 0.2s;
+    }
+
+    .sidebar nav a:hover,
+    .sidebar nav a.active {
+      background: rgba(79, 195, 247, 0.1);
+      color: #4fc3f7;
+    }
+
+    .search-box {
+      margin-bottom: 20px;
+    }
+
+    .search-box input {
+      width: 100%;
+      padding: 10px 12px;
+      border: none;
+      border-radius: 4px;
+      background: rgba(255,255,255,0.1);
+      color: #fff;
+      font-size: 14px;
+    }
+
+    .search-box input::placeholder {
+      color: #78909c;
+    }
+
+    .main {
+      margin-left: 280px;
+      flex: 1;
+      padding: 40px;
+      max-width: 900px;
+    }
+
+    .content {
+      background: #fff;
+      padding: 40px;
+      border-radius: 8px;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+
+    .content h1 {
+      font-size: 2.5rem;
+      margin-bottom: 20px;
+      color: #1a1a2e;
+      border-bottom: 2px solid #4fc3f7;
+      padding-bottom: 10px;
+    }
+
+    .content h2 {
+      font-size: 1.8rem;
+      margin-top: 40px;
+      margin-bottom: 16px;
+      color: #1a1a2e;
+    }
+
+    .content h3 {
+      font-size: 1.4rem;
+      margin-top: 30px;
+      margin-bottom: 12px;
+      color: #333;
+    }
+
+    .content p {
+      margin-bottom: 16px;
+    }
+
+    .content code {
+      background: #f0f0f0;
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-family: 'Fira Code', 'Monaco', monospace;
+      font-size: 0.9em;
+    }
+
+    .content pre {
+      background: #1a1a2e;
+      color: #f0f0f0;
+      padding: 20px;
+      border-radius: 6px;
+      overflow-x: auto;
+      margin: 20px 0;
+    }
+
+    .content pre code {
+      background: none;
+      padding: 0;
+      color: inherit;
+    }
+
+    .content ul, .content ol {
+      margin: 16px 0;
+      padding-left: 30px;
+    }
+
+    .content li {
+      margin: 8px 0;
+    }
+
+    .content a {
+      color: #4fc3f7;
+      text-decoration: none;
+    }
+
+    .content a:hover {
+      text-decoration: underline;
+    }
+
+    .content blockquote {
+      border-left: 4px solid #4fc3f7;
+      padding-left: 20px;
+      margin: 20px 0;
+      color: #666;
+      font-style: italic;
+    }
+
+    .content table {
+      width: 100%;
+      border-collapse: collapse;
+      margin: 20px 0;
+    }
+
+    .content th, .content td {
+      border: 1px solid #ddd;
+      padding: 12px;
+      text-align: left;
+    }
+
+    .content th {
+      background: #f5f5f5;
+    }
+
+    .search-results {
+      display: none;
+      position: absolute;
+      top: 100%;
+      left: 0;
+      right: 0;
+      background: #2a2a3e;
+      border-radius: 4px;
+      max-height: 300px;
+      overflow-y: auto;
+      margin-top: 4px;
+    }
+
+    .search-results.active {
+      display: block;
+    }
+
+    .search-result-item {
+      padding: 10px 12px;
+      border-bottom: 1px solid rgba(255,255,255,0.1);
+      cursor: pointer;
+    }
+
+    .search-result-item:hover {
+      background: rgba(79, 195, 247, 0.1);
+    }
+
+    .search-result-item h4 {
+      color: #fff;
+      font-size: 14px;
+      margin-bottom: 4px;
+    }
+
+    .search-result-item p {
+      color: #78909c;
+      font-size: 12px;
+    }
+
+    @media (max-width: 768px) {
+      .sidebar {
+        display: none;
+      }
+      .main {
+        margin-left: 0;
+        padding: 20px;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <aside class="sidebar">
+      <h1>mcp-new</h1>
+      <div class="search-box" style="position: relative;">
+        <input type="text" id="search" placeholder="Search docs..." autocomplete="off">
+        <div id="search-results" class="search-results"></div>
+      </div>
+      <nav id="nav">
+        <ul>
+          ${parsed.headings.map((h) => `<li><a href="#${slugify(h)}">${h}</a></li>`).join("\n          ")}
+        </ul>
+      </nav>
+    </aside>
+    <main class="main">
+      <article class="content">
+        ${parsed.content}
+      </article>
+    </main>
+  </div>
+
+  <script>
+    // SSE for hot reload
+    const evtSource = new EventSource('/sse');
+    evtSource.onmessage = function(event) {
+      if (event.data === 'reload') {
+        location.reload();
+      }
+    };
+
+    // Search functionality
+    const searchInput = document.getElementById('search');
+    const searchResults = document.getElementById('search-results');
+
+    searchInput.addEventListener('input', async (e) => {
+      const query = e.target.value.trim();
+      if (query.length < 2) {
+        searchResults.classList.remove('active');
+        return;
+      }
+
+      try {
+        const res = await fetch('/api/search?q=' + encodeURIComponent(query));
+        const results = await res.json();
+
+        if (results.length > 0) {
+          searchResults.innerHTML = results.map(r =>
+            '<div class="search-result-item" onclick="location.href=\\'' + r.path + '\\'"><h4>' + r.title + '</h4><p>' + r.snippet + '</p></div>'
+          ).join('');
+          searchResults.classList.add('active');
+        } else {
+          searchResults.classList.remove('active');
+        }
+      } catch (err) {
+        console.error('Search error:', err);
+      }
+    });
+
+    document.addEventListener('click', (e) => {
+      if (!e.target.closest('.search-box')) {
+        searchResults.classList.remove('active');
+      }
+    });
+  </script>
+</body>
+</html>`;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+
+// src/docs-server/search.ts
+import path5 from "path";
+var DocsSearchEngine = class {
+  index = { documents: /* @__PURE__ */ new Map() };
+  docsDir;
+  constructor(docsDir) {
+    this.docsDir = docsDir;
+  }
+  async buildIndex() {
+    this.index.documents.clear();
+    await this.indexDirectory(this.docsDir);
+  }
+  async indexDirectory(dir) {
+    if (!await exists(dir)) {
+      return;
+    }
+    const entries = await readDir(dir);
+    for (const entry of entries) {
+      const fullPath = path5.join(dir, entry);
+      try {
+        const subEntries = await readDir(fullPath);
+        await this.indexDirectory(fullPath);
+      } catch {
+        if (entry.endsWith(".md")) {
+          await this.indexFile(fullPath);
+        }
+      }
+    }
+  }
+  async indexFile(filePath) {
+    try {
+      const content = await readFile(filePath);
+      const parsed = parseMarkdown(content);
+      const relativePath = "/" + path5.relative(this.docsDir, filePath).replace(/\.md$/, "");
+      const words = /* @__PURE__ */ new Set();
+      const textContent = parsed.rawContent.toLowerCase();
+      const wordMatches = textContent.match(/\b[a-z0-9]+\b/g);
+      if (wordMatches) {
+        wordMatches.forEach((w) => words.add(w));
+      }
+      this.index.documents.set(relativePath, {
+        path: relativePath,
+        title: parsed.title,
+        content: parsed.rawContent,
+        words
+      });
+    } catch (error) {
+    }
+  }
+  search(query, limit = 10) {
+    const queryWords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 1);
+    if (queryWords.length === 0) {
+      return [];
+    }
+    const results = [];
+    for (const [docPath, doc] of this.index.documents) {
+      let score = 0;
+      const titleLower = doc.title.toLowerCase();
+      for (const word of queryWords) {
+        if (titleLower.includes(word)) {
+          score += 10;
+        }
+      }
+      const contentLower = doc.content.toLowerCase();
+      for (const word of queryWords) {
+        if (doc.words.has(word)) {
+          score += 1;
+        }
+        if (contentLower.includes(word)) {
+          score += 2;
+        }
+      }
+      if (score > 0) {
+        const snippet = this.extractSnippet(doc.content, queryWords[0]);
+        results.push({
+          path: docPath,
+          title: doc.title,
+          snippet,
+          score
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  extractSnippet(content, query) {
+    const index = content.toLowerCase().indexOf(query.toLowerCase());
+    if (index === -1) {
+      return content.slice(0, 150) + "...";
+    }
+    const start = Math.max(0, index - 50);
+    const end = Math.min(content.length, index + query.length + 100);
+    let snippet = content.slice(start, end);
+    if (start > 0) snippet = "..." + snippet;
+    if (end < content.length) snippet = snippet + "...";
+    return snippet.replace(/\n/g, " ").trim();
+  }
+  getDocuments() {
+    return this.index.documents;
+  }
+};
+
+// src/docs-server/watcher.ts
+import fs3 from "fs";
+import path6 from "path";
+import { EventEmitter } from "events";
+var DocsWatcher = class extends EventEmitter {
+  watchers = /* @__PURE__ */ new Map();
+  debounceTimer = null;
+  docsDir;
+  constructor(docsDir) {
+    super();
+    this.docsDir = docsDir;
+  }
+  async start() {
+    await this.watchDirectory(this.docsDir);
+  }
+  async watchDirectory(dir) {
+    if (!await exists(dir)) {
+      return;
+    }
+    const watcher = fs3.watch(dir, { recursive: false }, (eventType, filename) => {
+      if (filename && filename.endsWith(".md")) {
+        this.debouncedEmit();
+      }
+    });
+    this.watchers.set(dir, watcher);
+    try {
+      const entries = await readDir(dir);
+      for (const entry of entries) {
+        const fullPath = path6.join(dir, entry);
+        try {
+          const subEntries = await readDir(fullPath);
+          await this.watchDirectory(fullPath);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  debouncedEmit() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.emit("change");
+    }, 100);
+  }
+  stop() {
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+  }
+};
+
+// src/docs-server/server.ts
+var DocsServer = class {
+  server = null;
+  searchEngine;
+  watcher;
+  sseClients = /* @__PURE__ */ new Set();
+  options;
+  constructor(options) {
+    this.options = options;
+    this.searchEngine = new DocsSearchEngine(options.docsDir);
+    this.watcher = new DocsWatcher(options.docsDir);
+  }
+  async start() {
+    await this.searchEngine.buildIndex();
+    await this.watcher.start();
+    this.watcher.on("change", async () => {
+      await this.searchEngine.buildIndex();
+      this.notifyClients();
+    });
+    this.server = http.createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+    return new Promise((resolve) => {
+      this.server.listen(this.options.port, () => {
+        resolve();
+      });
+    });
+  }
+  stop() {
+    if (this.server) {
+      this.server.close();
+    }
+    this.watcher.stop();
+    for (const client of this.sseClients) {
+      client.end();
+    }
+    this.sseClients.clear();
+  }
+  async handleRequest(req, res) {
+    const url = new URL(req.url || "/", `http://localhost:${this.options.port}`);
+    const pathname = url.pathname;
+    try {
+      if (pathname === "/sse") {
+        this.handleSSE(res);
+        return;
+      }
+      if (pathname === "/api/search") {
+        const query = url.searchParams.get("q") || "";
+        const results = this.searchEngine.search(query);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(results));
+        return;
+      }
+      if (pathname.startsWith("/static/")) {
+        await this.serveStatic(pathname, res);
+        return;
+      }
+      await this.serveMarkdown(pathname, res);
+    } catch (error) {
+      this.serveError(res, 500, "Internal Server Error");
+    }
+  }
+  handleSSE(res) {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    this.sseClients.add(res);
+    res.on("close", () => {
+      this.sseClients.delete(res);
+    });
+  }
+  notifyClients() {
+    for (const client of this.sseClients) {
+      client.write("data: reload\n\n");
+    }
+  }
+  async serveMarkdown(pathname, res) {
+    let filePath = pathname === "/" ? "/index" : pathname;
+    if (!filePath.endsWith(".md")) {
+      filePath += ".md";
+    }
+    const fullPath = path7.join(this.options.docsDir, filePath);
+    if (await exists(fullPath)) {
+      const content = await readFile(fullPath);
+      const title = path7.basename(filePath, ".md");
+      const html = renderMarkdownToHTML(content, title);
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+      return;
+    }
+    const indexPath = path7.join(this.options.docsDir, pathname, "index.md");
+    if (await exists(indexPath)) {
+      const content = await readFile(indexPath);
+      const title = path7.basename(pathname) || "Home";
+      const html = renderMarkdownToHTML(content, title);
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+      return;
+    }
+    const dirPath = path7.join(this.options.docsDir, pathname);
+    if (await exists(dirPath)) {
+      const indexHtml = await this.generateDirectoryIndex(pathname);
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(indexHtml);
+      return;
+    }
+    this.serveError(res, 404, "Page Not Found");
+  }
+  async generateDirectoryIndex(pathname) {
+    const docs = this.searchEngine.getDocuments();
+    const prefix = pathname === "/" ? "" : pathname;
+    const links = [];
+    for (const [docPath, doc] of docs) {
+      if (docPath.startsWith(prefix) || prefix === "") {
+        links.push(`- [${doc.title}](${docPath})`);
+      }
+    }
+    const content = `# Documentation
+
+${links.join("\n")}`;
+    return renderMarkdownToHTML(content, "Documentation");
+  }
+  async serveStatic(pathname, res) {
+    const ext = path7.extname(pathname);
+    const contentTypes = {
+      ".css": "text/css",
+      ".js": "application/javascript",
+      ".png": "image/png",
+      ".svg": "image/svg+xml"
+    };
+    const contentType = contentTypes[ext] || "application/octet-stream";
+    const fullPath = path7.join(this.options.docsDir, pathname);
+    if (await exists(fullPath)) {
+      const content = await readFile(fullPath);
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content);
+    } else {
+      this.serveError(res, 404, "Not Found");
+    }
+  }
+  serveError(res, status, message) {
+    const html = renderMarkdownToHTML(`# ${status}
+
+${message}`, `${status} Error`);
+    res.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(html);
+  }
+};
+
+// src/commands/docs.ts
+async function docsCommand(options = {}) {
+  const port = parseInt(options.port || "3000", 10);
+  if (isNaN(port) || port < 1 || port > 65535) {
+    logger.error("Invalid port number. Please provide a port between 1 and 65535.");
+    process.exit(1);
+  }
+  const possibleDocsDirs = [
+    path8.join(process.cwd(), "docs"),
+    path8.join(process.cwd(), "documentation"),
+    path8.join(process.cwd(), "doc"),
+    process.cwd()
+    // Use current directory if it contains markdown files
+  ];
+  let docsDir = null;
+  for (const dir of possibleDocsDirs) {
+    if (await exists(dir)) {
+      const hasMarkdown = await hasMarkdownFiles(dir);
+      if (hasMarkdown) {
+        docsDir = dir;
+        break;
+      }
+    }
+  }
+  if (!docsDir) {
+    logger.error("No documentation directory found.");
+    logger.info('Create a "docs" directory with .md files to use this command.');
+    process.exit(1);
+  }
+  logger.title("mcp-new Documentation Server");
+  logger.info(`Serving docs from: ${docsDir}`);
+  const server = new DocsServer({
+    port,
+    docsDir
+  });
+  try {
+    await server.start();
+    logger.success(`Documentation server running at http://localhost:${port}`);
+    logger.info("Hot reload enabled - changes will refresh automatically");
+    logger.info("Press Ctrl+C to stop");
+    process.on("SIGINT", () => {
+      logger.info("\nShutting down...");
+      server.stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      server.stop();
+      process.exit(0);
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("EADDRINUSE")) {
+        logger.error(`Port ${port} is already in use. Try a different port with --port.`);
+      } else {
+        logger.error(error.message);
+      }
+    } else {
+      logger.error("Failed to start documentation server");
+    }
+    process.exit(1);
+  }
+}
+async function hasMarkdownFiles(dir) {
+  try {
+    const { readdir } = await import("fs/promises");
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        return true;
+      }
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        const subDir = path8.join(dir, entry.name);
+        if (await hasMarkdownFiles(subDir)) {
+          return true;
+        }
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+// src/commands/preset-cache.ts
+async function presetCacheCommand(action) {
+  try {
+    if (!action) {
+      action = "list";
+    }
+    switch (action) {
+      case "clear":
+        await handleClear();
+        break;
+      case "list":
+        await handleList();
+        break;
+      case "path":
+        handlePath();
+        break;
+      default:
+        logger.error(`Unknown action: ${action}. Valid actions: clear, list, path`);
+        process.exit(1);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+async function handleClear() {
+  const count = await clearPresetCache();
+  if (count > 0) {
+    logger.success(`Cleared ${count} cached preset(s)`);
+  } else {
+    logger.info("No cached presets to clear");
+  }
+}
+async function handleList() {
+  const presets = await listCachedPresets();
+  if (presets.length === 0) {
+    logger.info("No presets cached");
+    logger.info(`Cache directory: ${getCacheDir()}`);
+    return;
+  }
+  logger.title("Cached Presets");
+  for (const preset of presets) {
+    const age = Date.now() - preset.cachedAt;
+    const hoursAgo = Math.round(age / (1e3 * 60 * 60));
+    const ageStr = hoursAgo < 1 ? "less than an hour ago" : `${hoursAgo} hour(s) ago`;
+    console.log(`
+  ${preset.manifest.name} (${preset.manifest.version})`);
+    console.log(`    Source: ${preset.source.type}:${preset.source.identifier}`);
+    console.log(`    Cached: ${ageStr}`);
+    console.log(`    Tools: ${preset.manifest.tools.map((t) => t.name).join(", ")}`);
+  }
+  console.log(`
+  Cache directory: ${getCacheDir()}`);
+}
+function handlePath() {
+  console.log(getCacheDir());
+}
+
 // src/cli.ts
 var program = new Command();
 var logo = `
@@ -464,15 +1609,21 @@ ${chalk4.bold("Supported Languages:")}
   ${chalk4.green("-p, --python")}       Python with pip
   ${chalk4.green("-g, --go")}           Go with go modules
   ${chalk4.green("-r, --rust")}         Rust with cargo
+  ${chalk4.green("-j, --java")}         Java with Maven/Gradle
+  ${chalk4.green("-k, --kotlin")}       Kotlin with Maven/Gradle
+  ${chalk4.green("-c, --csharp")}       C# with .NET
+  ${chalk4.green("-e, --elixir")}       Elixir with Mix
 
 ${chalk4.bold("Learn More:")}
 
   Documentation:  ${chalk4.underline("https://github.com/d1maash/mcp-new")}
   MCP Spec:       ${chalk4.underline("https://spec.modelcontextprotocol.io")}
 `;
-program.name("mcp-new").description("CLI tool for generating MCP (Model Context Protocol) servers").version("1.2.2").addHelpText("beforeAll", logo).addHelpText("after", examples);
-program.argument("[project-name]", "Name of the project to create").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("-g, --go", "Use Go template").option("-r, --rust", "Use Rust template").option("--skip-install", "Skip dependency installation").option("--from-openapi <path>", "Generate from OpenAPI/Swagger specification").option("--from-prompt", "Generate tools using AI from text description").option("--preset <name>", "Use a preset template (database, rest-api, filesystem)").option("-y, --yes", "Skip prompts and use defaults").action(createCommand);
-program.command("init").description("Initialize MCP server in the current directory").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("-g, --go", "Use Go template").option("-r, --rust", "Use Rust template").option("--skip-install", "Skip dependency installation").option("-f, --force", "Initialize even if directory contains files").addHelpText("after", `
+program.name("mcp-new").description("CLI tool for generating MCP (Model Context Protocol) servers").version("1.5.0").addHelpText("beforeAll", logo).addHelpText("after", examples);
+program.argument("[project-name]", "Name of the project to create").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("-g, --go", "Use Go template").option("-r, --rust", "Use Rust template").option("-j, --java", "Use Java template").option("-k, --kotlin", "Use Kotlin template").option("-c, --csharp", "Use C# (.NET) template").option("-e, --elixir", "Use Elixir template").option("--maven", "Use Maven build tool (for Java/Kotlin)").option("--gradle", "Use Gradle build tool (for Java/Kotlin)").option("--skip-install", "Skip dependency installation").option("--from-openapi <path>", "Generate from OpenAPI/Swagger specification").option("--from-prompt", "Generate tools using AI from text description").option("--preset <name>", "Use a preset template (database, rest-api, filesystem, or @org/package, github:user/repo)").option("--ci <provider>", "Add CI/CD configuration (github, gitlab, circleci)").option("-y, --yes", "Skip prompts and use defaults").action(createCommand);
+program.command("init").description("Initialize MCP server in the current directory").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("-g, --go", "Use Go template").option("-r, --rust", "Use Rust template").option("-j, --java", "Use Java template").option("-k, --kotlin", "Use Kotlin template").option("-c, --csharp", "Use C# (.NET) template").option("-e, --elixir", "Use Elixir template").option("--maven", "Use Maven build tool (for Java/Kotlin)").option("--gradle", "Use Gradle build tool (for Java/Kotlin)").option("--skip-install", "Skip dependency installation").option("-f, --force", "Initialize even if directory contains files").addHelpText(
+  "after",
+  `
 ${chalk4.bold("Examples:")}
 
   ${chalk4.gray("# Initialize in current directory")}
@@ -483,8 +1634,11 @@ ${chalk4.bold("Examples:")}
 
   ${chalk4.gray("# Force initialize (overwrite existing files)")}
   ${chalk4.cyan("$")} mcp-new init -f
-`).action(initCommand);
-program.command("add-tool").description("Add a new tool to an existing MCP server").option("-n, --name <name>", "Tool name (snake_case)").addHelpText("after", `
+`
+).action(initCommand);
+program.command("add-tool").description("Add a new tool to an existing MCP server").option("-n, --name <name>", "Tool name (snake_case)").addHelpText(
+  "after",
+  `
 ${chalk4.bold("Examples:")}
 
   ${chalk4.gray("# Add tool interactively")}
@@ -492,14 +1646,20 @@ ${chalk4.bold("Examples:")}
 
   ${chalk4.gray("# Add tool with name")}
   ${chalk4.cyan("$")} mcp-new add-tool -n my_new_tool
-`).action(addToolCommand);
-program.command("list-presets").description("List all available preset templates").addHelpText("after", `
+`
+).action(addToolCommand);
+program.command("list-presets").description("List all available preset templates").addHelpText(
+  "after",
+  `
 ${chalk4.bold("Examples:")}
 
   ${chalk4.gray("# Show all presets with their tools")}
   ${chalk4.cyan("$")} mcp-new list-presets
-`).action(listPresetsCommand);
-program.command("validate").description("Validate the current MCP server project").addHelpText("after", `
+`
+).action(listPresetsCommand);
+program.command("validate").description("Validate the current MCP server project").addHelpText(
+  "after",
+  `
 ${chalk4.bold("Examples:")}
 
   ${chalk4.gray("# Validate current project")}
@@ -510,8 +1670,11 @@ ${chalk4.bold("Checks:")}
   \u2022 MCP SDK dependency presence and version
   \u2022 Entry point file existence
   \u2022 Basic project structure
-`).action(validateCommand);
-program.command("upgrade").description("Upgrade MCP SDK to the latest version").option("-c, --check", "Check for updates without installing").addHelpText("after", `
+`
+).action(validateCommand);
+program.command("upgrade").description("Upgrade MCP SDK to the latest version").option("-c, --check", "Check for updates without installing").addHelpText(
+  "after",
+  `
 ${chalk4.bold("Examples:")}
 
   ${chalk4.gray("# Upgrade MCP SDK to latest version")}
@@ -525,8 +1688,114 @@ ${chalk4.bold("Supported languages:")}
   \u2022 Python (pip)
   \u2022 Go (go modules)
   \u2022 Rust (cargo)
-`).action(upgradeCommand);
-program.parse();
-if (process.argv.length === 2) {
-  program.help();
+`
+).action(upgradeCommand);
+program.command("preset-cache [action]").description("Manage external preset cache").addHelpText(
+  "after",
+  `
+${chalk4.bold("Actions:")}
+
+  ${chalk4.green("list")}     List cached presets (default)
+  ${chalk4.green("clear")}    Clear all cached presets
+  ${chalk4.green("path")}     Show cache directory path
+
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# List cached presets")}
+  ${chalk4.cyan("$")} mcp-new preset-cache list
+
+  ${chalk4.gray("# Clear preset cache")}
+  ${chalk4.cyan("$")} mcp-new preset-cache clear
+
+${chalk4.bold("External Presets:")}
+
+  Use external presets with the --preset flag:
+  ${chalk4.cyan("$")} mcp-new my-project --preset @company/custom-preset
+  ${chalk4.cyan("$")} mcp-new my-project --preset github:user/repo
+`
+).action(presetCacheCommand);
+program.command("docs").description("Start an interactive documentation server").option("-p, --port <port>", "Port to run the server on", "3000").addHelpText(
+  "after",
+  `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Start docs server on default port (3000)")}
+  ${chalk4.cyan("$")} mcp-new docs
+
+  ${chalk4.gray("# Start docs server on custom port")}
+  ${chalk4.cyan("$")} mcp-new docs --port 4000
+
+${chalk4.bold("Features:")}
+  ${chalk4.green("Hot reload")}    - Changes refresh automatically
+  ${chalk4.green("Search")}        - Full-text search across all docs
+  ${chalk4.green("Markdown")}      - Renders GitHub-flavored markdown
+`
+).action(docsCommand);
+program.command("add-ci [provider]").description("Add CI/CD configuration to an existing project").addHelpText(
+  "after",
+  `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Add CI interactively")}
+  ${chalk4.cyan("$")} mcp-new add-ci
+
+  ${chalk4.gray("# Add GitHub Actions")}
+  ${chalk4.cyan("$")} mcp-new add-ci github
+
+  ${chalk4.gray("# Add GitLab CI")}
+  ${chalk4.cyan("$")} mcp-new add-ci gitlab
+
+  ${chalk4.gray("# Add CircleCI")}
+  ${chalk4.cyan("$")} mcp-new add-ci circleci
+
+${chalk4.bold("Supported providers:")}
+  ${chalk4.green("github")}      GitHub Actions
+  ${chalk4.green("gitlab")}      GitLab CI
+  ${chalk4.green("circleci")}    CircleCI
+`
+).action(addCICommand);
+var monorepo = program.command("monorepo").description("Manage MCP monorepo workspaces");
+monorepo.command("init [workspace-name]").description("Initialize a new MCP monorepo workspace").option("-f, --force", "Initialize even if directory contains files").addHelpText(
+  "after",
+  `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Create a new monorepo workspace")}
+  ${chalk4.cyan("$")} mcp-new monorepo init my-workspace
+
+  ${chalk4.gray("# Create in current directory name")}
+  ${chalk4.cyan("$")} mcp-new monorepo init
+`
+).action((_workspaceName, _options, command) => {
+  const opts = command.optsWithGlobals();
+  const workspaceName = command.args[0];
+  monorepoInitCommand(workspaceName, opts);
+});
+monorepo.command("add [server-name]").description("Add a new MCP server to the workspace").option("-n, --name <name>", "Server name").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("-g, --go", "Use Go template").option("-r, --rust", "Use Rust template").option("-j, --java", "Use Java template").option("-k, --kotlin", "Use Kotlin template").option("-c, --csharp", "Use C# (.NET) template").option("-e, --elixir", "Use Elixir template").option("--maven", "Use Maven build tool (for Java/Kotlin)").option("--gradle", "Use Gradle build tool (for Java/Kotlin)").option("--skip-install", "Skip dependency installation").addHelpText(
+  "after",
+  `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Add a TypeScript server")}
+  ${chalk4.cyan("$")} mcp-new monorepo add my-server -t
+
+  ${chalk4.gray("# Add a Java server with Gradle")}
+  ${chalk4.cyan("$")} mcp-new monorepo add api-server -j --gradle
+`
+).action((_serverName, _options, command) => {
+  const opts = command.optsWithGlobals();
+  const serverName = command.args[0];
+  monorepoAddCommand(serverName, opts);
+});
+monorepo.command("list").description("List all packages in the workspace").action(monorepoListCommand);
+async function main() {
+  await pluginRegistry.initialize();
+  program.parse();
+  if (process.argv.length === 2) {
+    program.help();
+  }
 }
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});