mcp-new 1.5.0 → 1.6.0

package/dist/cli.js

@@ -2,23 +2,32 @@
 import {
   PRESETS,
   addToolCommand,
+  clearPresetCache,
   createCommand,
   createInitialCommit,
   createSpinner,
+  detectJavaBuildTool,
+  detectLanguageFromProject,
   ensureDir,
   exists,
+  generateCI,
   generateFromWizard,
+  getCacheDir,
   initCommand,
   initGitRepository,
   isGitInstalled,
+  isValidCIProvider,
+  listCachedPresets,
   logger,
+  pluginRegistry,
+  promptCIProvider,
   promptJavaBuildTool,
   promptLanguage,
   readDir,
   readFile,
   withSpinner,
   writeFile
-} from "./chunk-YISSMIHU.js";
+} from "./chunk-LJNMSDBU.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -687,6 +696,876 @@ async function monorepoListCommand() {
   }
 }
 
+// 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 = `
@@ -741,7 +1620,7 @@ ${chalk4.bold("Learn More:")}
   MCP Spec:       ${chalk4.underline("https://spec.modelcontextprotocol.io")}
 `;
 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)").option("-y, --yes", "Skip prompts and use defaults").action(createCommand);
+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",
   `
@@ -811,6 +1690,70 @@ ${chalk4.bold("Supported languages:")}
   \u2022 Rust (cargo)
 `
 ).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",
@@ -845,7 +1788,14 @@ ${chalk4.bold("Examples:")}
   monorepoAddCommand(serverName, opts);
 });
 monorepo.command("list").description("List all packages in the workspace").action(monorepoListCommand);
-program.parse();
-if (process.argv.length === 2) {
-  program.help();
+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);
+});