composter-cli 1.0.10 → 1.0.11

package/mcp/lib/auth.js

@@ -0,0 +1,78 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// Session path (same as CLI)
+const SESSION_PATH = path.join(os.homedir(), ".config", "composter", "session.json");
+
+// Get base URL - supports both dev and production
+export function getBaseUrl() {
+  // Check for explicit env var first
+  if (process.env.COMPOSTER_API_URL) {
+    return process.env.COMPOSTER_API_URL;
+  }
+  // Check for dev mode
+  if (process.env.COMPOSTER_DEV === "true" || process.env.NODE_ENV === "development") {
+    return "http://localhost:3000/api";
+  }
+  // Default to production
+  return "https://composter.onrender.com/api";
+}
+
+// Load session from CLI's session file
+export function loadSession() {
+  if (!fs.existsSync(SESSION_PATH)) {
+    return null;
+  }
+
+  try {
+    const raw = fs.readFileSync(SESSION_PATH, "utf-8");
+    const session = JSON.parse(raw);
+
+    // Check if session is expired
+    if (session.expiresAt && new Date(session.expiresAt) < new Date()) {
+      return null;
+    }
+
+    return session;
+  } catch {
+    return null;
+  }
+}
+
+// Get JWT token from session
+export function getAuthToken() {
+  const session = loadSession();
+  if (!session) {
+    throw new Error("No session found. Please run 'composter login' first.");
+  }
+
+  const token = session.jwt || session.token || session.accessToken;
+  if (!token) {
+    throw new Error("Session file missing token. Please run 'composter login' again.");
+  }
+
+  return token;
+}
+
+// Verify session is valid by making a test API call
+export async function verifySession() {
+  const token = getAuthToken();
+  const baseUrl = getBaseUrl();
+
+  const res = await fetch(`${baseUrl.replace('/api', '')}/api/me`, {
+    headers: {
+      "Authorization": `Bearer ${token}`,
+    },
+  });
+
+  if (!res.ok) {
+    if (res.status === 401) {
+      throw new Error("Session expired. Please run 'composter login' again.");
+    }
+    throw new Error(`Authentication failed: ${res.statusText}`);
+  }
+
+  const data = await res.json();
+  return data?.user?.id || data?.session?.userId;
+}

package/mcp/lib/factory.js

@@ -0,0 +1,389 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getAuthToken, getBaseUrl } from "./auth.js";
+
+// API request helper with JWT auth
+async function apiRequest(path, options = {}) {
+  const token = getAuthToken();
+  const baseUrl = getBaseUrl();
+
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${token}`,
+    ...options.headers,
+  };
+
+  const res = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers,
+  });
+
+  return res;
+}
+
+// Shared helpers
+async function fetchCategories() {
+  const res = await apiRequest("/categories", { method: "GET" });
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({}));
+    throw new Error(error.message || error.error || res.statusText);
+  }
+  const data = await res.json();
+  return data.categories || [];
+}
+
+async function fetchComponentsByCategory(category) {
+  const res = await apiRequest(`/components/list-by-category?category=${encodeURIComponent(category)}`, { method: "GET" });
+  if (res.status === 404) throw new Error(`Category "${category}" not found.`);
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({}));
+    throw new Error(error.message || error.error || res.statusText);
+  }
+  const data = await res.json();
+  return data.components || [];
+}
+
+async function fetchComponent(category, title) {
+  const res = await apiRequest(
+    `/components?category=${encodeURIComponent(category)}&title=${encodeURIComponent(title)}`,
+    { method: "GET" }
+  );
+  if (res.status === 404) throw new Error(`Component "${title}" not found in category "${category}".`);
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({}));
+    throw new Error(error.message || error.error || res.statusText);
+  }
+  const data = await res.json();
+  return data.component;
+}
+
+async function searchComponents(query) {
+  const res = await apiRequest(`/components/search?q=${encodeURIComponent(query)}`, { method: "GET" });
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({}));
+    throw new Error(error.message || error.error || res.statusText);
+  }
+  const data = await res.json();
+  return data.components || [];
+}
+
+function renderComponent(category, component) {
+  if (!component) return "Component not found.";
+
+  let codeOutput = "";
+  try {
+    const files = JSON.parse(component.code);
+    codeOutput = Object.entries(files)
+      .map(([path, content]) => `### ${path}\n\`\`\`tsx\n${content}\n\`\`\``)
+      .join("\n\n");
+  } catch {
+    codeOutput = `\`\`\`tsx\n${component.code}\n\`\`\``;
+  }
+
+  let depsOutput = "";
+  if (component.dependencies && Object.keys(component.dependencies).length > 0) {
+    const deps = Object.entries(component.dependencies)
+      .map(([pkg, ver]) => `- ${pkg}: ${ver}`)
+      .join("\n");
+    depsOutput = `\n\n**Dependencies:**\n${deps}`;
+  }
+
+  return `# ${component.title}
+
+**Category:** ${category}
+**Created:** ${new Date(component.createdAt).toLocaleDateString()}${depsOutput}
+
+## Source Code
+
+${codeOutput}`;
+}
+
+export function createMcpServer() {
+  const server = new McpServer({
+    name: "Composter",
+    version: "1.0.0",
+  });
+
+  // Tool: Search components
+  server.tool(
+    "search_components",
+    "Search vault components by name or topic. Triggers on queries like 'find button components', 'search cards', 'look up forms'. Returns matches with IDs and categories.",
+    {
+      query: z.string().describe("Search term for component title or category name"),
+    },
+    async ({ query }) => {
+      try {
+        const res = await apiRequest(`/components/search?q=${encodeURIComponent(query)}`, { method: "GET" });
+
+        if (!res.ok) {
+          const error = await res.json().catch(() => ({}));
+          return {
+            content: [{ type: "text", text: `Error searching: ${error.message || error.error || res.statusText}` }],
+          };
+        }
+
+        const data = await res.json();
+        const components = data.components || [];
+
+        if (components.length === 0) {
+          return {
+            content: [{ type: "text", text: "No components found matching that query." }],
+          };
+        }
+
+        const formatted = components.map((c) =>
+          `- **${c.title}** (Category: ${c.category?.name || "unknown"}) [ID: ${c.id}]`
+        ).join("\n");
+
+        return {
+          content: [{ type: "text", text: `Found ${components.length} component(s):\n\n${formatted}` }],
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  // Tool: Natural language helper (catch-all)
+  server.tool(
+    "ask_composter",
+    "Ask in plain English to list categories, show components in a category, search components, or read a component (e.g., 'list categories', 'show components in ui', 'read Simple Card from ui', 'find button components').",
+    {
+      query: z.string().describe("e.g. 'list categories', 'show components in ui', 'read Simple Card from ui', 'find button components'"),
+    },
+    async ({ query }) => {
+      const q = query.trim();
+      const qLower = q.toLowerCase();
+      const respond = (text) => ({ content: [{ type: "text", text }] });
+
+      try {
+        // List categories
+        if (/\b(list|show|what)\b.*\bcategories\b/.test(qLower)) {
+          const categories = await fetchCategories();
+          if (!categories.length) return respond("No categories found. Create one with 'composter mkcat <name>'.");
+          const formatted = categories.map((c) => `- ${c.name}`).join("\n");
+          return respond(`Your categories:\n\n${formatted}`);
+        }
+
+        // List components in a category
+        const listCatMatch = qLower.match(/(?:list|show|what).*(?:components|items).*(?:in|for)\s+([a-z0-9_-]+)/);
+        if (listCatMatch) {
+          const cat = listCatMatch[1];
+          const components = await fetchComponentsByCategory(cat);
+          if (!components.length) return respond(`No components found in category "${cat}".`);
+          const formatted = components
+            .map((c) => `- ${c.title} (created: ${new Date(c.createdAt).toLocaleDateString()})`)
+            .join("\n");
+          return respond(`Components in "${cat}":\n\n${formatted}`);
+        }
+
+        // Read component with optional category
+        const readMatch = q.match(/(?:read|show|get|open|fetch)\s+(.+?)(?:\s+from\s+([a-z0-9_-]+))?$/i);
+        if (readMatch) {
+          const titleRaw = readMatch[1].trim();
+          const categoryRaw = readMatch[2]?.trim();
+
+          if (!categoryRaw) {
+            const hits = await searchComponents(titleRaw);
+            if (!hits.length) return respond(`No components found matching "${titleRaw}".`);
+            if (hits.length > 1) {
+              const list = hits
+                .slice(0, 5)
+                .map((c) => `- ${c.title} (category: ${c.category?.name || "unknown"})`)
+                .join("\n");
+              return respond(
+                `Found multiple components matching "${titleRaw}". Please specify a category:\n\n${list}${
+                  hits.length > 5 ? "\n(and more...)" : ""
+                }`
+              );
+            }
+            const hit = hits[0];
+            const comp = await fetchComponent(hit.category?.name, hit.title);
+            return respond(renderComponent(hit.category?.name, comp));
+          }
+
+          const comp = await fetchComponent(categoryRaw, titleRaw);
+          return respond(renderComponent(categoryRaw, comp));
+        }
+
+        // Fallback: search
+        const hits = await searchComponents(q);
+        if (!hits.length) return respond("No components found matching that query.");
+        const formatted = hits
+          .map((c) => `- **${c.title}** (Category: ${c.category?.name || "unknown"}) [ID: ${c.id}]`)
+          .join("\n");
+        return respond(`Found ${hits.length} component(s):\n\n${formatted}`);
+      } catch (err) {
+        return respond(`Error: ${err.message}`);
+      }
+    }
+  );
+
+  // Tool: List categories
+  server.tool(
+    "list_categories",
+    "List all categories in the vault. Trigger when user asks 'what categories do I have', 'show my categories', 'list vault categories'.",
+    {},
+    async () => {
+      try {
+        const res = await apiRequest("/categories", { method: "GET" });
+
+        if (!res.ok) {
+          const error = await res.json().catch(() => ({}));
+          return {
+            content: [{ type: "text", text: `Error: ${error.message || error.error || res.statusText}` }],
+          };
+        }
+
+        const data = await res.json();
+        const categories = data.categories || [];
+
+        if (categories.length === 0) {
+          return {
+            content: [{ type: "text", text: "No categories found. Create one with 'composter mkcat <name>'." }],
+          };
+        }
+
+        const formatted = categories.map((c) => `- ${c.name}`).join("\n");
+
+        return {
+          content: [{ type: "text", text: `Your categories:\n\n${formatted}` }],
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  // Tool: List components in category
+  server.tool(
+    "list_components",
+    "List components inside a given category. Trigger on requests like 'show components in ui', 'what's in forms', 'list items in buttons'.",
+    {
+      category: z.string().describe("The category name to list components from"),
+    },
+    async ({ category }) => {
+      try {
+        const res = await apiRequest(`/components/list-by-category?category=${encodeURIComponent(category)}`, { method: "GET" });
+
+        if (res.status === 404) {
+          return {
+            content: [{ type: "text", text: `Category "${category}" not found.` }],
+          };
+        }
+
+        if (!res.ok) {
+          const error = await res.json().catch(() => ({}));
+          return {
+            content: [{ type: "text", text: `Error: ${error.message || error.error || res.statusText}` }],
+          };
+        }
+
+        const data = await res.json();
+        const components = data.components || [];
+
+        if (components.length === 0) {
+          return {
+            content: [{ type: "text", text: `No components found in category "${category}".` }],
+          };
+        }
+
+        const formatted = components.map((c) =>
+          `- **${c.title}** (created: ${new Date(c.createdAt).toLocaleDateString()})`
+        ).join("\n");
+
+        return {
+          content: [{ type: "text", text: `Components in "${category}":\n\n${formatted}` }],
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  // Tool: Read component
+  server.tool(
+    "read_component",
+    "Read a component's full source. Trigger on 'read/open/show/get <component> from <category>' or similar. Returns code, category, dependencies, and creation date.",
+    {
+      category: z.string().describe("The category name the component belongs to"),
+      title: z.string().describe("The title/name of the component to read"),
+    },
+    async ({ category, title }) => {
+      try {
+        const res = await apiRequest(
+          `/components?category=${encodeURIComponent(category)}&title=${encodeURIComponent(title)}`,
+          { method: "GET" }
+        );
+
+        if (res.status === 404) {
+          return {
+            content: [{ type: "text", text: `Component "${title}" not found in category "${category}".` }],
+          };
+        }
+
+        if (!res.ok) {
+          const error = await res.json().catch(() => ({}));
+          return {
+            content: [{ type: "text", text: `Error: ${error.message || error.error || res.statusText}` }],
+          };
+        }
+
+        const data = await res.json();
+        const component = data.component;
+
+        if (!component) {
+          return {
+            content: [{ type: "text", text: `Component "${title}" not found.` }],
+          };
+        }
+
+        // Parse code - could be JSON (multi-file) or string (single file)
+        let codeOutput = "";
+        try {
+          const files = JSON.parse(component.code);
+          codeOutput = Object.entries(files)
+            .map(([path, content]) => `### ${path}\n\`\`\`tsx\n${content}\n\`\`\``)
+            .join("\n\n");
+        } catch {
+          codeOutput = `\`\`\`tsx\n${component.code}\n\`\`\``;
+        }
+
+        // Format dependencies
+        let depsOutput = "";
+        if (component.dependencies && Object.keys(component.dependencies).length > 0) {
+          const deps = Object.entries(component.dependencies)
+            .map(([pkg, ver]) => `- ${pkg}: ${ver}`)
+            .join("\n");
+          depsOutput = `\n\n**Dependencies:**\n${deps}`;
+        }
+
+        const output = `# ${component.title}
+
+**Category:** ${category}
+**Created:** ${new Date(component.createdAt).toLocaleDateString()}
+${depsOutput}
+
+## Source Code
+
+${codeOutput}`;
+
+        return {
+          content: [{ type: "text", text: output }],
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+        };
+      }
+    }
+  );
+
+  return server;
+}

package/mcp/src/init.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// Client configuration templates
+const CLIENT_CONFIGS = {
+  claude: {
+    name: "Claude Desktop",
+    configPath: () => {
+      if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+      } else if (process.platform === "win32") {
+        return path.join(process.env.APPDATA, "Claude", "claude_desktop_config.json");
+      } else {
+        return path.join(os.homedir(), ".config", "claude", "claude_desktop_config.json");
+      }
+    },
+    generateConfig: () => ({
+      mcpServers: {
+        composter: {
+          command: "npx",
+          args: ["composter-mcp"],
+        },
+      },
+    }),
+    mergeKey: "mcpServers",
+  },
+  cursor: {
+    name: "Cursor",
+    configPath: () => path.join(process.cwd(), ".cursor", "mcp.json"),
+    generateConfig: () => ({
+      mcpServers: {
+        composter: {
+          command: "npx",
+          args: ["composter-mcp"],
+        },
+      },
+    }),
+    mergeKey: "mcpServers",
+  },
+  vscode: {
+    name: "VS Code (Copilot)",
+    configPath: () => path.join(process.cwd(), ".vscode", "mcp.json"),
+    generateConfig: () => ({
+      mcpServers: {
+        composter: {
+          command: "npx",
+          args: ["composter-mcp"],
+        },
+      },
+    }),
+    mergeKey: "mcpServers",
+  },
+  windsurf: {
+    name: "Windsurf",
+    configPath: () => {
+      if (process.platform === "darwin") {
+        return path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
+      } else if (process.platform === "win32") {
+        return path.join(process.env.APPDATA, "Codeium", "windsurf", "mcp_config.json");
+      } else {
+        return path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
+      }
+    },
+    generateConfig: () => ({
+      mcpServers: {
+        composter: {
+          command: "npx",
+          args: ["composter-mcp"],
+        },
+      },
+    }),
+    mergeKey: "mcpServers",
+  },
+};
+
+function printUsage() {
+  console.log(`
+🤖 Composter MCP - Setup Tool
+
+Usage:
+  npx composter-mcp init <client>
+
+Supported clients:
+  claude    - Claude Desktop
+  cursor    - Cursor IDE
+  vscode    - VS Code with Copilot
+  windsurf  - Windsurf IDE
+
+Examples:
+  npx composter-mcp init claude
+  npx composter-mcp init cursor
+`);
+}
+
+function initClient(clientName) {
+  const client = CLIENT_CONFIGS[clientName?.toLowerCase()];
+  
+  if (!client) {
+    console.log(`❌ Unknown client: ${clientName}`);
+    console.log(`\nSupported clients: ${Object.keys(CLIENT_CONFIGS).join(", ")}`);
+    process.exit(1);
+  }
+
+  const configPath = client.configPath();
+  const configDir = path.dirname(configPath);
+
+  console.log(`\n🔧 Setting up Composter MCP for ${client.name}...\n`);
+
+  // Read existing config if it exists
+  let existingConfig = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      existingConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      console.log(`📄 Found existing config at: ${configPath}`);
+    } catch {
+      console.log(`⚠️  Existing config is invalid JSON, will create new one.`);
+    }
+  }
+
+  // Generate new config
+  const newConfig = client.generateConfig();
+
+  // Merge configs
+  let mergedConfig;
+  if (client.mergeKey) {
+    mergedConfig = {
+      ...existingConfig,
+      [client.mergeKey]: {
+        ...existingConfig[client.mergeKey],
+        ...newConfig[client.mergeKey],
+      },
+    };
+  } else {
+    // Direct merge at root (e.g., Cursor)
+    mergedConfig = {
+      ...existingConfig,
+      ...newConfig,
+    };
+  }
+
+  // Create directory if needed
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+    console.log(`📁 Created directory: ${configDir}`);
+  }
+
+  // Write config
+  fs.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+  console.log(`✅ Config written to: ${configPath}`);
+
+  // Print success message
+  console.log(`
+╔═══════════════════════════════════════════════════════════════════╗
+║                     🎉 Setup Complete!                            ║
+╠═══════════════════════════════════════════════════════════════════╣
+║                                                                   ║
+║  Composter MCP has been configured for ${client.name.padEnd(24)}  ║
+║                                                                   ║
+║  Next steps:                                                      ║
+║  1. Make sure you're logged in: composter login                   ║
+║  2. Restart ${client.name.padEnd(47)}  ║
+║  3. Look for "Composter" in your MCP tools                        ║
+║                                                                   ║
+║  Available tools:                                                 ║
+║  • search_components - Search your component vault                ║
+║  • list_categories   - List all your categories                   ║
+║  • list_components   - List components in a category              ║
+║  • read_component    - Read full source code                      ║
+║                                                                   ║
+╚═══════════════════════════════════════════════════════════════════╝
+`);
+}
+
+// Main
+const args = process.argv.slice(2);
+const command = args[0];
+const clientArg = args[1];
+
+if (command === "init") {
+  if (!clientArg) {
+    console.log("❌ Please specify a client to configure.");
+    printUsage();
+    process.exit(1);
+  }
+  initClient(clientArg);
+} else if (command === "--help" || command === "-h" || !command) {
+  printUsage();
+} else {
+  console.log(`❌ Unknown command: ${command}`);
+  printUsage();
+  process.exit(1);
+}
+

package/mcp/src/server.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createMcpServer } from "../lib/factory.js";
+import { loadSession, getBaseUrl } from "../lib/auth.js";
+
+// Redirect console.log to stderr (MCP uses stdout for protocol communication)
+console.log = (...args) => console.error(...args);
+
+async function main() {
+  try {
+    // Check if user is logged in via CLI
+    const session = loadSession();
+    if (!session) {
+      console.error("❌ No session found. Please run 'composter login' first.");
+      process.exit(1);
+    }
+
+    const baseUrl = getBaseUrl();
+    console.error(`🚀 Composter MCP Server starting...`);
+    console.error(`📡 API: ${baseUrl}`);
+
+    // Create and start MCP server
+    const server = createMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+
+    console.error("✅ Composter MCP server running on stdio");
+  } catch (error) {
+    console.error("❌ Fatal Error:", error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "composter-cli",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "type": "module",
   "description": "Your personal vault for React components. Push, pull, and sync reusable components across projects — like shadcn/ui but for YOUR code.",
   "main": "src/index.js",
@@ -36,9 +36,15 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.3",
     "commander": "^14.0.2",
     "dotenv": "^16.4.5",
     "inquirer": "^13.0.1",
     "node-fetch": "^3.3.2"
-  }
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "mcp/"
+  ]
 }

package/src/commands/init.js

@@ -0,0 +1,47 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export async function initVscode() {
+  const cwd = process.cwd();
+  const vscodeDir = path.join(cwd, ".vscode");
+  const mcpConfigPath = path.join(vscodeDir, "mcp.json");
+
+  // Find the globally installed composter-cli MCP server
+  // When installed globally, the MCP server is in: 
+  // /usr/local/lib/node_modules/composter-cli/mcp/src/server.js
+  const globalMcpServerPath = path.join(
+    path.dirname(path.dirname(path.dirname(__dirname))), 
+    "mcp",
+    "src", 
+    "server.js"
+  );
+
+  const mcpConfig = {
+    servers: {
+      "composter-mcp": {
+        type: "stdio",
+        command: "node",
+        args: [globalMcpServerPath],
+      }
+    },
+    inputs: []
+  };
+
+  // Create .vscode directory if it doesn't exist
+  if (!fs.existsSync(vscodeDir)) {
+    fs.mkdirSync(vscodeDir, { recursive: true });
+    console.log("✓ Created .vscode directory");
+  }
+
+  // Write mcp.json
+  fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+  console.log("✓ Created .vscode/mcp.json");
+  console.log("\n📝 MCP Server configured for this project!");
+  console.log("🔄 Reload VS Code window to activate the MCP server");
+  console.log("   Press: Ctrl+Shift+P → 'Developer: Reload Window'");
+}

package/src/index.js

@@ -6,6 +6,7 @@ import { mkcat } from "./commands/mkcat.js";
 import { listCategories } from "./commands/listCat.js";
 import { pushComponent } from "./commands/push.js";
 import { pullComponent } from "./commands/pull.js";
+import { initVscode } from "./commands/init.js";
 import { createRequire } from "module";
 
 const require = createRequire(import.meta.url);
@@ -23,6 +24,18 @@ program
   .description("Log into your Composter account")
   .action(login);
 
+program
+  .command("init <editor>")
+  .description("Initialize MCP configuration for your editor (vscode)")
+  .action((editor) => {
+    if (editor.toLowerCase() === "vscode") {
+      initVscode();
+    } else {
+      console.error("❌ Only 'vscode' is supported currently");
+      process.exit(1);
+    }
+  });
+
 program
   .command("mkcat <category-name>")
   .description("Create a new category")