@leanmcp/cli 0.2.7 → 0.2.9

package/dist/index.js

@@ -1,51 +1,415 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+
+// src/index.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+import fs5 from "fs-extra";
+import path5 from "path";
+import ora3 from "ora";
+import { createRequire } from "module";
+import { confirm } from "@inquirer/prompts";
+import { spawn as spawn3 } from "child_process";
+
+// src/commands/dev.ts
+import { spawn } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+import path3 from "path";
+import fs3 from "fs-extra";
+import chokidar from "chokidar";
+
+// src/vite/scanUIApp.ts
+import fs from "fs-extra";
+import path from "path";
+import { glob } from "glob";
+async function scanUIApp(projectDir) {
+  const mcpDir = path.join(projectDir, "mcp");
+  if (!await fs.pathExists(mcpDir)) {
+    return [];
+  }
+  const tsFiles = await glob("**/*.ts", {
+    cwd: mcpDir,
+    absolute: false,
+    ignore: [
+      "**/*.d.ts",
+      "**/node_modules/**"
+    ]
+  });
+  const results = [];
+  for (const relativeFile of tsFiles) {
+    const filePath = path.join(mcpDir, relativeFile);
+    const content = await fs.readFile(filePath, "utf-8");
+    if (!content.includes("@UIApp") || !content.includes("@leanmcp/ui")) {
+      continue;
+    }
+    const uiApps = parseUIAppDecorators(content, filePath);
+    results.push(...uiApps);
+  }
+  return results;
+}
+__name(scanUIApp, "scanUIApp");
+function parseUIAppDecorators(content, filePath) {
+  const results = [];
+  const classMatch = content.match(/export\s+class\s+(\w+)/);
+  const serviceName = classMatch ? classMatch[1] : "Unknown";
+  const importMap = parseImports(content, filePath);
+  const uiAppRegex = /@UIApp\s*\(\s*\{([^}]+)\}\s*\)\s*(?:async\s+)?(\w+)/g;
+  let match;
+  while ((match = uiAppRegex.exec(content)) !== null) {
+    const decoratorBody = match[1];
+    const methodName = match[2];
+    const componentMatch = decoratorBody.match(/component\s*:\s*(\w+)/);
+    if (!componentMatch) continue;
+    const componentName = componentMatch[1];
+    const componentPath = importMap[componentName];
+    if (!componentPath) {
+      console.warn(`[scanUIApp] Could not resolve import for component: ${componentName}`);
+      continue;
+    }
+    const servicePrefix = serviceName.replace(/Service$/i, "").toLowerCase();
+    const resourceUri = `ui://${servicePrefix}/${methodName}`;
+    results.push({
+      servicePath: filePath,
+      componentPath,
+      componentName,
+      resourceUri,
+      methodName,
+      serviceName
+    });
+  }
+  return results;
+}
+__name(parseUIAppDecorators, "parseUIAppDecorators");
+function parseImports(content, filePath) {
+  const importMap = {};
+  const dir = path.dirname(filePath);
+  const importRegex = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const importPath = match[2];
+    if (!importPath.startsWith(".")) continue;
+    const names = match[1].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim());
+    let resolvedPath = path.resolve(dir, importPath);
+    if (!resolvedPath.endsWith(".tsx") && !resolvedPath.endsWith(".ts")) {
+      if (fs.existsSync(resolvedPath + ".tsx")) {
+        resolvedPath += ".tsx";
+      } else if (fs.existsSync(resolvedPath + ".ts")) {
+        resolvedPath += ".ts";
+      }
+    }
+    for (const name of names) {
+      importMap[name] = resolvedPath;
+    }
   }
-  return to;
+  return importMap;
+}
+__name(parseImports, "parseImports");
+
+// src/vite/buildUI.ts
+import * as vite from "vite";
+import react from "@vitejs/plugin-react";
+import { viteSingleFile } from "vite-plugin-singlefile";
+import fs2 from "fs-extra";
+import path2 from "path";
+async function buildUIComponent(uiApp, projectDir, isDev = false) {
+  const { componentPath, componentName, resourceUri } = uiApp;
+  const safeFileName = resourceUri.replace("ui://", "").replace(/\//g, "-") + ".html";
+  const outDir = path2.join(projectDir, "dist", "ui");
+  const htmlPath = path2.join(outDir, safeFileName);
+  await fs2.ensureDir(outDir);
+  const tempDir = path2.join(projectDir, ".leanmcp-temp");
+  await fs2.ensureDir(tempDir);
+  const entryHtml = path2.join(tempDir, "index.html");
+  const entryJs = path2.join(tempDir, "entry.tsx");
+  await fs2.writeFile(entryHtml, `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MCP App</title>
+</head>
+<body>
+    <div id="root"></div>
+    <script type="module" src="./entry.tsx"></script>
+</body>
+</html>`);
+  const relativeComponentPath = path2.relative(tempDir, componentPath).replace(/\\/g, "/");
+  await fs2.writeFile(entryJs, `
+import React, { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { AppProvider } from '@leanmcp/ui';
+import { ${componentName} } from '${relativeComponentPath.replace(/\.tsx?$/, "")}';
+
+const APP_INFO = {
+    name: '${componentName}',
+    version: '1.0.0'
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+
+function App() {
+    return (
+        <AppProvider appInfo={APP_INFO}>
+            <${componentName} />
+        </AppProvider>
+    );
+}
+
+createRoot(document.getElementById('root')!).render(
+    <StrictMode>
+        <App />
+    </StrictMode>
+);
+`);
+  try {
+    await vite.build({
+      root: tempDir,
+      plugins: [
+        react(),
+        viteSingleFile()
+      ],
+      build: {
+        outDir,
+        emptyOutDir: false,
+        sourcemap: isDev ? "inline" : false,
+        minify: !isDev,
+        rollupOptions: {
+          input: entryHtml,
+          output: {
+            entryFileNames: `[name].js`
+          }
+        }
+      },
+      logLevel: "warn"
+    });
+    const builtHtml = path2.join(outDir, "index.html");
+    if (await fs2.pathExists(builtHtml)) {
+      await fs2.move(builtHtml, htmlPath, {
+        overwrite: true
+      });
+    }
+    await fs2.remove(entryHtml);
+    await fs2.remove(entryJs);
+    return {
+      success: true,
+      htmlPath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      htmlPath: "",
+      error: error.message
+    };
+  }
+}
+__name(buildUIComponent, "buildUIComponent");
+async function writeUIManifest(manifest, projectDir) {
+  const manifestPath = path2.join(projectDir, "dist", "ui-manifest.json");
+  await fs2.ensureDir(path2.dirname(manifestPath));
+  await fs2.writeJson(manifestPath, manifest, {
+    spaces: 2
+  });
+}
+__name(writeUIManifest, "writeUIManifest");
+
+// src/commands/dev.ts
+async function devCommand() {
+  const cwd = process.cwd();
+  if (!await fs3.pathExists(path3.join(cwd, "main.ts"))) {
+    console.error(chalk.red("ERROR: Not a LeanMCP project (main.ts not found)."));
+    console.error(chalk.gray("Run this command from your project root."));
+    process.exit(1);
+  }
+  console.log(chalk.cyan("\n\u{1F680} LeanMCP Development Server\n"));
+  const scanSpinner = ora("Scanning for @UIApp components...").start();
+  const uiApps = await scanUIApp(cwd);
+  if (uiApps.length === 0) {
+    scanSpinner.succeed("No @UIApp components found");
+  } else {
+    scanSpinner.succeed(`Found ${uiApps.length} @UIApp component(s)`);
+    for (const app of uiApps) {
+      console.log(chalk.gray(`   \u2022 ${app.componentName} \u2192 ${app.resourceUri}`));
+    }
+  }
+  const manifest = {};
+  if (uiApps.length > 0) {
+    const buildSpinner = ora("Building UI components...").start();
+    const errors = [];
+    for (const app of uiApps) {
+      const result = await buildUIComponent(app, cwd, true);
+      if (result.success) {
+        manifest[app.resourceUri] = result.htmlPath;
+      } else {
+        errors.push(`${app.componentName}: ${result.error}`);
+      }
+    }
+    await writeUIManifest(manifest, cwd);
+    if (errors.length > 0) {
+      buildSpinner.warn("Built with warnings");
+      for (const error of errors) {
+        console.error(chalk.yellow(`   \u26A0 ${error}`));
+      }
+    } else {
+      buildSpinner.succeed("UI components built");
+    }
+  }
+  console.log(chalk.cyan("\nStarting development server...\n"));
+  const devServer = spawn("npx", [
+    "tsx",
+    "watch",
+    "main.ts"
+  ], {
+    cwd,
+    stdio: "inherit",
+    shell: true
+  });
+  let watcher = null;
+  if (uiApps.length > 0) {
+    const componentPaths = uiApps.map((app) => app.componentPath);
+    watcher = chokidar.watch(componentPaths, {
+      ignoreInitial: true
+    });
+    watcher.on("change", async (changedPath) => {
+      const app = uiApps.find((a) => a.componentPath === changedPath);
+      if (!app) return;
+      console.log(chalk.cyan(`
+[UI] Rebuilding ${app.componentName}...`));
+      const result = await buildUIComponent(app, cwd, true);
+      if (result.success) {
+        manifest[app.resourceUri] = result.htmlPath;
+        await writeUIManifest(manifest, cwd);
+        console.log(chalk.green(`[UI] ${app.componentName} rebuilt successfully`));
+      } else {
+        console.log(chalk.yellow(`[UI] ${app.componentName} build failed: ${result.error}`));
+      }
+    });
+  }
+  const cleanup = /* @__PURE__ */ __name(() => {
+    console.log(chalk.gray("\nShutting down..."));
+    if (watcher) watcher.close();
+    devServer.kill();
+    process.exit(0);
+  }, "cleanup");
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  devServer.on("exit", (code) => {
+    if (watcher) watcher.close();
+    process.exit(code ?? 0);
+  });
+}
+__name(devCommand, "devCommand");
+
+// src/commands/start.ts
+import { spawn as spawn2 } from "child_process";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import path4 from "path";
+import fs4 from "fs-extra";
+async function startCommand() {
+  const cwd = process.cwd();
+  if (!await fs4.pathExists(path4.join(cwd, "main.ts"))) {
+    console.error(chalk2.red("ERROR: Not a LeanMCP project (main.ts not found)."));
+    console.error(chalk2.gray("Run this command from your project root."));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\n\u{1F680} LeanMCP Production Build\n"));
+  const scanSpinner = ora2("Scanning for @UIApp components...").start();
+  const uiApps = await scanUIApp(cwd);
+  if (uiApps.length === 0) {
+    scanSpinner.succeed("No @UIApp components found");
+  } else {
+    scanSpinner.succeed(`Found ${uiApps.length} @UIApp component(s)`);
+  }
+  const manifest = {};
+  if (uiApps.length > 0) {
+    const buildSpinner = ora2("Building UI components...").start();
+    const errors = [];
+    for (const app of uiApps) {
+      const result = await buildUIComponent(app, cwd, false);
+      if (result.success) {
+        manifest[app.resourceUri] = result.htmlPath;
+      } else {
+        errors.push(`${app.componentName}: ${result.error}`);
+      }
+    }
+    await writeUIManifest(manifest, cwd);
+    if (errors.length > 0) {
+      buildSpinner.fail("Build failed");
+      for (const error of errors) {
+        console.error(chalk2.red(`   \u2717 ${error}`));
+      }
+      process.exit(1);
+    }
+    buildSpinner.succeed("UI components built");
+  }
+  const tscSpinner = ora2("Compiling TypeScript...").start();
+  try {
+    await new Promise((resolve, reject) => {
+      const tsc = spawn2("npx", [
+        "tsc"
+      ], {
+        cwd,
+        stdio: "pipe",
+        shell: true
+      });
+      let stderr = "";
+      tsc.stderr?.on("data", (data) => {
+        stderr += data;
+      });
+      tsc.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(stderr || `tsc exited with code ${code}`));
+      });
+      tsc.on("error", reject);
+    });
+    tscSpinner.succeed("TypeScript compiled");
+  } catch (error) {
+    tscSpinner.fail("TypeScript compilation failed");
+    console.error(chalk2.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\nStarting production server...\n"));
+  const server = spawn2("node", [
+    "dist/main.js"
+  ], {
+    cwd,
+    stdio: "inherit",
+    shell: true
+  });
+  const cleanup = /* @__PURE__ */ __name(() => {
+    console.log(chalk2.gray("\nShutting down..."));
+    server.kill();
+    process.exit(0);
+  }, "cleanup");
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  server.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+__name(startCommand, "startCommand");
 
 // src/index.ts
-var import_commander = require("commander");
-var import_chalk = __toESM(require("chalk"));
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_path = __toESM(require("path"));
-var import_ora = __toESM(require("ora"));
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 __name(capitalize, "capitalize");
-var program = new import_commander.Command();
-program.name("leanmcp").description("LeanMCP CLI \u2014 create production-ready MCP servers with Streamable HTTP").version("0.1.0");
-program.command("create <projectName>").description("Create a new LeanMCP project with Streamable HTTP transport").action(async (projectName) => {
-  const spinner = (0, import_ora.default)(`Creating project ${projectName}...`).start();
-  const targetDir = import_path.default.join(process.cwd(), projectName);
-  if (import_fs_extra.default.existsSync(targetDir)) {
+var program = new Command();
+program.name("leanmcp").description("LeanMCP CLI \u2014 create production-ready MCP servers with Streamable HTTP").version(pkg.version).addHelpText("after", `
+Examples:
+  $ leanmcp create my-app --allow-all    # Scaffold without interactive prompts
+`);
+program.command("create <projectName>").description("Create a new LeanMCP project with Streamable HTTP transport").option("--allow-all", "Skip interactive confirmations and assume Yes").action(async (projectName, options) => {
+  const spinner = ora3(`Creating project ${projectName}...`).start();
+  const targetDir = path5.join(process.cwd(), projectName);
+  if (fs5.existsSync(targetDir)) {
     spinner.fail(`Folder ${projectName} already exists.`);
     process.exit(1);
   }
-  await import_fs_extra.default.mkdirp(targetDir);
-  await import_fs_extra.default.mkdirp(import_path.default.join(targetDir, "mcp"));
-  const pkg = {
+  await fs5.mkdirp(targetDir);
+  await fs5.mkdirp(path5.join(targetDir, "mcp", "example"));
+  const pkg2 = {
     name: projectName,
     version: "1.0.0",
     description: "MCP Server with Streamable HTTP Transport and LeanMCP SDK",
@@ -66,21 +430,16 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
     author: "",
     license: "MIT",
     dependencies: {
-      "@leanmcp/core": "^0.1.0",
-      "@modelcontextprotocol/sdk": "^1.0.0",
-      "cors": "^2.8.5",
-      "dotenv": "^16.5.0",
-      "express": "^5.1.0"
+      "@leanmcp/core": "^0.3.5",
+      "dotenv": "^16.5.0"
     },
     devDependencies: {
-      "@types/cors": "^2.8.19",
-      "@types/express": "^5.0.3",
       "@types/node": "^20.0.0",
       "tsx": "^4.20.3",
       "typescript": "^5.6.3"
     }
   };
-  await import_fs_extra.default.writeJSON(import_path.default.join(targetDir, "package.json"), pkg, {
+  await fs5.writeJSON(path5.join(targetDir, "package.json"), pkg2, {
     spaces: 2
   });
   const tsconfig = {
@@ -103,12 +462,11 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
       "dist"
     ]
   };
-  await import_fs_extra.default.writeJSON(import_path.default.join(targetDir, "tsconfig.json"), tsconfig, {
+  await fs5.writeJSON(path5.join(targetDir, "tsconfig.json"), tsconfig, {
     spaces: 2
   });
   const mainTs = `import dotenv from "dotenv";
 import { createHTTPServer, MCPServer } from "@leanmcp/core";
-import { ExampleService } from "./mcp/example.js";
 
 // Load environment variables
 dotenv.config();
@@ -117,27 +475,29 @@ const PORT = Number(process.env.PORT) || 3001;
 
 /**
  * Create and configure the MCP server
+ * Services are automatically discovered from ./mcp directory
  */
-function createMCPServer() {
+const serverFactory = async () => {
   const server = new MCPServer({ 
     name: "${projectName}", 
-    version: "1.0.0" 
+    version: "1.0.0",
+    logging: true
   });
 
-  // Register your services here
-  server.registerService(new ExampleService());
-
+  // Services are automatically discovered and registered from ./mcp
   return server.getServer();
-}
+};
 
 // Start the HTTP server
-await createHTTPServer(createMCPServer, {
+await createHTTPServer(serverFactory, {
   port: PORT,
   cors: true,
-  logging: true
+  logging: true  // Log HTTP requests
 });
+
+console.log(\`\\n${projectName} MCP Server\`);
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "main.ts"), mainTs);
+  await fs5.writeFile(path5.join(targetDir, "main.ts"), mainTs);
   const exampleServiceTs = `import { Tool, Resource, Prompt, SchemaConstraint, Optional } from "@leanmcp/core";
 
 /**
@@ -163,27 +523,38 @@ class CalculateInput {
   operation?: string;
 }
 
+class EchoInput {
+  @SchemaConstraint({ 
+    description: "Message to echo back",
+    minLength: 1
+  })
+  message!: string;
+}
+
 export class ExampleService {
   @Tool({ 
     description: "Perform arithmetic operations with automatic schema validation",
     inputClass: CalculateInput
   })
   async calculate(input: CalculateInput) {
+    // Ensure numerical operations by explicitly converting to numbers
+    const a = Number(input.a);
+    const b = Number(input.b);
     let result: number;
     
     switch (input.operation || "add") {
       case "add":
-        result = input.a + input.b;
+        result = a + b;
         break;
       case "subtract":
-        result = input.a - input.b;
+        result = a - b;
         break;
       case "multiply":
-        result = input.a * input.b;
+        result = a * b;
         break;
       case "divide":
-        if (input.b === 0) throw new Error("Cannot divide by zero");
-        result = input.a / input.b;
+        if (b === 0) throw new Error("Cannot divide by zero");
+        result = a / b;
         break;
       default:
         throw new Error("Invalid operation");
@@ -201,8 +572,11 @@ export class ExampleService {
     };
   }
 
-  @Tool({ description: "Echo a message back" })
-  async echo(input: { message: string }) {
+  @Tool({ 
+    description: "Echo a message back",
+    inputClass: EchoInput
+  })
+  async echo(input: EchoInput) {
     return {
       content: [{
         type: "text" as const,
@@ -243,12 +617,148 @@ export class ExampleService {
   }
 }
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "mcp", "example.ts"), exampleServiceTs);
-  const gitignore = `node_modules
-dist
-.env
-.env.local
+  await fs5.writeFile(path5.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
+  const gitignore = `# Logs
+logs
 *.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.*
+!.env.example
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+.output
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Sveltekit cache directory
+.svelte-kit/
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Firebase cache directory
+.firebase/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v3
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Vite files
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+.vite/
 `;
   const env = `# Server Configuration
 PORT=3001
@@ -256,8 +766,8 @@ NODE_ENV=development
 
 # Add your environment variables here
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, ".gitignore"), gitignore);
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, ".env"), env);
+  await fs5.writeFile(path5.join(targetDir, ".gitignore"), gitignore);
+  await fs5.writeFile(path5.join(targetDir, ".env"), env);
   const readme = `# ${projectName}
 
 MCP Server with Streamable HTTP Transport built with LeanMCP SDK
@@ -283,22 +793,36 @@ npm start
 \`\`\`
 ${projectName}/
 \u251C\u2500\u2500 main.ts              # Server entry point
-\u251C\u2500\u2500 mcp/
-\u2502   \u2514\u2500\u2500 example.ts       # Example service
+\u251C\u2500\u2500 mcp/                 # Services directory (auto-discovered)
+\u2502   \u2514\u2500\u2500 example/
+\u2502       \u2514\u2500\u2500 index.ts     # Example service
 \u251C\u2500\u2500 .env                 # Environment variables
 \u2514\u2500\u2500 package.json
 \`\`\`
 
 ## Adding New Services
 
-Create a new service file in \`mcp/\`:
+Create a new service directory in \`mcp/\`:
 
 \`\`\`typescript
-import { Tool } from "@leanmcp/core";
+// mcp/myservice/index.ts
+import { Tool, SchemaConstraint } from "@leanmcp/core";
+
+// Define input schema
+class MyToolInput {
+  @SchemaConstraint({ 
+    description: "Message to process",
+    minLength: 1
+  })
+  message!: string;
+}
 
 export class MyService {
-  @Tool({ description: "My awesome tool" })
-  async myTool(input: { message: string }) {
+  @Tool({ 
+    description: "My awesome tool",
+    inputClass: MyToolInput
+  })
+  async myTool(input: MyToolInput) {
     return {
       content: [{
         type: "text",
@@ -309,12 +833,15 @@ export class MyService {
 }
 \`\`\`
 
-Then register it in \`main.ts\`:
+Services are automatically discovered and registered - no need to modify \`main.ts\`!
 
-\`\`\`typescript
-import { MyService } from "./mcp/my-service.js";
-server.registerService(new MyService());
-\`\`\`
+## Features
+
+- **Zero-config auto-discovery** - Services automatically registered from \`./mcp\` directory
+- **Type-safe decorators** - \`@Tool\`, \`@Prompt\`, \`@Resource\` with full TypeScript support
+- **Schema validation** - Automatic input validation with \`@SchemaConstraint\`
+- **HTTP transport** - Production-ready HTTP server with session management
+- **Hot reload** - Development mode with automatic restart on file changes
 
 ## Testing with MCP Inspector
 
@@ -326,28 +853,88 @@ npx @modelcontextprotocol/inspector http://localhost:3001/mcp
 
 MIT
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "README.md"), readme);
+  await fs5.writeFile(path5.join(targetDir, "README.md"), readme);
   spinner.succeed(`Project ${projectName} created!`);
-  console.log(import_chalk.default.green("\\nSuccess! Your MCP server is ready.\\n"));
-  console.log(import_chalk.default.cyan("Next steps:"));
-  console.log(import_chalk.default.gray(`  cd ${projectName}`));
-  console.log(import_chalk.default.gray(`  npm install`));
-  console.log(import_chalk.default.gray(`  npm run dev`));
-  console.log(import_chalk.default.gray(`\\nServer will run on http://localhost:3001`));
+  console.log(chalk3.green("\nSuccess! Your MCP server is ready.\n"));
+  console.log(chalk3.cyan(`Next, navigate to your project:
+  cd ${projectName}
+`));
+  const shouldInstall = options.allowAll ? true : await confirm({
+    message: "Would you like to install dependencies now?",
+    default: true
+  });
+  if (shouldInstall) {
+    const installSpinner = ora3("Installing dependencies...").start();
+    try {
+      await new Promise((resolve, reject) => {
+        const npmInstall = spawn3("npm", [
+          "install"
+        ], {
+          cwd: targetDir,
+          stdio: "pipe",
+          shell: true
+        });
+        npmInstall.on("close", (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`npm install failed with code ${code}`));
+          }
+        });
+        npmInstall.on("error", reject);
+      });
+      installSpinner.succeed("Dependencies installed successfully!");
+      const shouldStartDev = options.allowAll ? true : await confirm({
+        message: "Would you like to start the development server?",
+        default: true
+      });
+      if (shouldStartDev) {
+        console.log(chalk3.cyan("\nStarting development server...\n"));
+        const devServer = spawn3("npm", [
+          "run",
+          "dev"
+        ], {
+          cwd: targetDir,
+          stdio: "inherit",
+          shell: true
+        });
+        process.on("SIGINT", () => {
+          devServer.kill();
+          process.exit(0);
+        });
+      } else {
+        console.log(chalk3.cyan("\nTo start the development server later:"));
+        console.log(chalk3.gray(`  cd ${projectName}`));
+        console.log(chalk3.gray(`  npm run dev`));
+      }
+    } catch (error) {
+      installSpinner.fail("Failed to install dependencies");
+      console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
+      console.log(chalk3.cyan("\nYou can install dependencies manually:"));
+      console.log(chalk3.gray(`  cd ${projectName}`));
+      console.log(chalk3.gray(`  npm install`));
+    }
+  } else {
+    console.log(chalk3.cyan("\nTo get started:"));
+    console.log(chalk3.gray(`  cd ${projectName}`));
+    console.log(chalk3.gray(`  npm install`));
+    console.log(chalk3.gray(`  npm run dev`));
+  }
 });
 program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
   const cwd = process.cwd();
-  const mcpDir = import_path.default.join(cwd, "mcp");
-  if (!import_fs_extra.default.existsSync(import_path.default.join(cwd, "main.ts"))) {
-    console.error(import_chalk.default.red("ERROR: Not a LeanMCP project (main.ts missing)."));
+  const mcpDir = path5.join(cwd, "mcp");
+  if (!fs5.existsSync(path5.join(cwd, "main.ts"))) {
+    console.error(chalk3.red("ERROR: Not a LeanMCP project (main.ts missing)."));
     process.exit(1);
   }
-  await import_fs_extra.default.mkdirp(mcpDir);
-  const serviceFile = import_path.default.join(mcpDir, `${serviceName}.ts`);
-  if (import_fs_extra.default.existsSync(serviceFile)) {
-    console.error(import_chalk.default.red(`ERROR: Service ${serviceName} already exists.`));
+  const serviceDir = path5.join(mcpDir, serviceName);
+  const serviceFile = path5.join(serviceDir, "index.ts");
+  if (fs5.existsSync(serviceDir)) {
+    console.error(chalk3.red(`ERROR: Service ${serviceName} already exists.`));
     process.exit(1);
   }
+  await fs5.mkdirp(serviceDir);
   const indexTs = `import { Tool, Resource, Prompt, Optional, SchemaConstraint } from "@leanmcp/core";
 
 // Input schema for greeting
@@ -407,34 +994,14 @@ export class ${capitalize(serviceName)}Service {
   }
 }
 `;
-  await import_fs_extra.default.writeFile(serviceFile, indexTs);
-  const mainTsPath = import_path.default.join(cwd, "main.ts");
-  let mainTsContent = await import_fs_extra.default.readFile(mainTsPath, "utf-8");
-  const serviceClassName = `${capitalize(serviceName)}Service`;
-  const importStatement = `import { ${serviceClassName} } from "./mcp/${serviceName}.js";`;
-  const registerStatement = `  server.registerService(new ${serviceClassName}());`;
-  const lastImportMatch = mainTsContent.match(/import .* from .*;\n/g);
-  if (lastImportMatch) {
-    const lastImport = lastImportMatch[lastImportMatch.length - 1];
-    const lastImportIndex = mainTsContent.lastIndexOf(lastImport);
-    const afterLastImport = lastImportIndex + lastImport.length;
-    mainTsContent = mainTsContent.slice(0, afterLastImport) + importStatement + "\n" + mainTsContent.slice(afterLastImport);
-  }
-  const registerPattern = /server\.registerService\(new \w+\(\)\);/g;
-  const matches = [
-    ...mainTsContent.matchAll(registerPattern)
-  ];
-  if (matches.length > 0) {
-    const lastMatch = matches[matches.length - 1];
-    const insertPosition = lastMatch.index + lastMatch[0].length;
-    mainTsContent = mainTsContent.slice(0, insertPosition) + "\n" + registerStatement + mainTsContent.slice(insertPosition);
-  }
-  await import_fs_extra.default.writeFile(mainTsPath, mainTsContent);
-  console.log(import_chalk.default.green(`\\nCreated new service: ${import_chalk.default.bold(serviceName)}`));
-  console.log(import_chalk.default.gray(`   File: mcp/${serviceName}.ts`));
-  console.log(import_chalk.default.gray(`   Tool: greet`));
-  console.log(import_chalk.default.gray(`   Prompt: welcomePrompt`));
-  console.log(import_chalk.default.gray(`   Resource: getStatus`));
-  console.log(import_chalk.default.green(`\\nService automatically registered in main.ts!`));
+  await fs5.writeFile(serviceFile, indexTs);
+  console.log(chalk3.green(`\\nCreated new service: ${chalk3.bold(serviceName)}`));
+  console.log(chalk3.gray(`   File: mcp/${serviceName}/index.ts`));
+  console.log(chalk3.gray(`   Tool: greet`));
+  console.log(chalk3.gray(`   Prompt: welcomePrompt`));
+  console.log(chalk3.gray(`   Resource: getStatus`));
+  console.log(chalk3.green(`\\nService will be automatically discovered on next server start!`));
 });
+program.command("dev").description("Start development server with UI hot-reload (builds @UIApp components)").action(devCommand);
+program.command("start").description("Build UI components and start production server").action(startCommand);
 program.parse();