@leanmcp/cli 0.5.4 → 0.5.5-alpha.28.7306df7

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 LeanMCP Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 LeanMCP Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -3,8 +3,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/index.ts
 import { Command } from "commander";
-import fs10 from "fs-extra";
-import path10 from "path";
+import fs11 from "fs-extra";
+import path11 from "path";
 import ora8 from "ora";
 import { createRequire } from "module";
 import { confirm as confirm4 } from "@inquirer/prompts";
@@ -841,11 +841,194 @@ __name(devCommand, "devCommand");
 // src/commands/build.ts
 import { spawn as spawn2 } from "child_process";
 import ora2 from "ora";
+import path5 from "path";
+import fs5 from "fs-extra";
+
+// src/schema-extractor.ts
 import path4 from "path";
 import fs4 from "fs-extra";
+import { Project, Node } from "ts-morph";
+async function generateSchemaMetadata(projectDir) {
+  const metadata = {};
+  const classesByName = /* @__PURE__ */ new Map();
+  const classesToProcess = /* @__PURE__ */ new Set();
+  const processedClasses = /* @__PURE__ */ new Set();
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true
+  });
+  const tsFiles = await findTsFiles(projectDir);
+  for (const filePath of tsFiles) {
+    try {
+      const sourceFile = project.addSourceFileAtPath(filePath);
+      for (const classDecl of sourceFile.getClasses()) {
+        const className = classDecl.getName();
+        if (className) {
+          classesByName.set(className, classDecl);
+        }
+      }
+      for (const classDecl of sourceFile.getClasses()) {
+        for (const method of classDecl.getInstanceMethods()) {
+          const decorators = method.getDecorators();
+          const isTool = decorators.some((d) => {
+            const name = d.getName();
+            return [
+              "Tool",
+              "Prompt",
+              "Resource"
+            ].includes(name);
+          });
+          if (isTool) {
+            const params = method.getParameters();
+            if (params.length > 0) {
+              const paramToken = params[0];
+              const typeNode = paramToken.getTypeNode();
+              if (typeNode) {
+                const typeName = typeNode.getText().trim();
+                if (!isPrimitive(typeName)) {
+                  classesToProcess.add(extractBaseClassName(typeName));
+                }
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+    }
+  }
+  for (const className of classesToProcess) {
+    if (processedClasses.has(className)) continue;
+    const classDecl = classesByName.get(className);
+    if (!classDecl) continue;
+    const propertyTypes = {};
+    for (const prop of classDecl.getInstanceProperties()) {
+      if (Node.isPropertyDeclaration(prop)) {
+        const propName = prop.getName();
+        const typeNode = prop.getTypeNode();
+        if (typeNode) {
+          const typeText = typeNode.getText();
+          const schemaType = typeTextToSchemaType(typeText);
+          propertyTypes[propName] = schemaType;
+          const baseType = extractBaseClassName(typeText);
+          if (!isPrimitive(baseType) && !processedClasses.has(baseType)) {
+            classesToProcess.add(baseType);
+          }
+        }
+      }
+    }
+    if (Object.keys(propertyTypes).length > 0) {
+      metadata[className] = propertyTypes;
+    }
+    processedClasses.add(className);
+  }
+  const outputPath = path4.join(projectDir, "dist", "schema-metadata.json");
+  await fs4.ensureDir(path4.dirname(outputPath));
+  await fs4.writeJSON(outputPath, metadata, {
+    spaces: 2
+  });
+}
+__name(generateSchemaMetadata, "generateSchemaMetadata");
+function isPrimitive(typeName) {
+  const t = typeName.toLowerCase();
+  return [
+    "string",
+    "number",
+    "boolean",
+    "any",
+    "void",
+    "null",
+    "undefined",
+    "object",
+    "date"
+  ].includes(t);
+}
+__name(isPrimitive, "isPrimitive");
+function extractBaseClassName(typeText) {
+  let name = typeText.trim();
+  if (name.endsWith("[]")) {
+    name = name.slice(0, -2);
+  }
+  const arrayMatch = name.match(/^Array<(.+)>$/i);
+  if (arrayMatch) {
+    name = arrayMatch[1];
+  }
+  return name.trim();
+}
+__name(extractBaseClassName, "extractBaseClassName");
+async function findTsFiles(dir) {
+  const files = [];
+  async function scan(currentDir) {
+    const entries = await fs4.readdir(currentDir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const fullPath = path4.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if ([
+          "node_modules",
+          "dist",
+          ".git",
+          ".leanmcp"
+        ].includes(entry.name)) {
+          continue;
+        }
+        await scan(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  __name(scan, "scan");
+  await scan(dir);
+  return files;
+}
+__name(findTsFiles, "findTsFiles");
+function typeTextToSchemaType(typeText) {
+  const type = typeText.trim().replace(/\?$/, "");
+  if (type.endsWith("[]")) {
+    const elementType = type.slice(0, -2).toLowerCase();
+    return {
+      type: "array",
+      items: {
+        type: mapPrimitiveType(elementType)
+      }
+    };
+  }
+  const arrayMatch = type.match(/^Array<(.+)>$/i);
+  if (arrayMatch) {
+    const elementType = arrayMatch[1].trim().toLowerCase();
+    return {
+      type: "array",
+      items: {
+        type: mapPrimitiveType(elementType)
+      }
+    };
+  }
+  return {
+    type: mapPrimitiveType(type.toLowerCase())
+  };
+}
+__name(typeTextToSchemaType, "typeTextToSchemaType");
+function mapPrimitiveType(tsType) {
+  switch (tsType) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "integer":
+      return "integer";
+    default:
+      return "string";
+  }
+}
+__name(mapPrimitiveType, "mapPrimitiveType");
+
+// src/commands/build.ts
 async function buildCommand() {
   const cwd = process.cwd();
-  if (!await fs4.pathExists(path4.join(cwd, "main.ts"))) {
+  if (!await fs5.pathExists(path5.join(cwd, "main.ts"))) {
     logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
     logger.gray("Run this command from your project root.");
     process.exit(1);
@@ -910,6 +1093,14 @@ async function buildCommand() {
     logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
+  const schemaSpinner = ora2("Generating schema metadata...").start();
+  try {
+    await generateSchemaMetadata(cwd);
+    schemaSpinner.succeed("Schema metadata generated");
+  } catch (error) {
+    schemaSpinner.warn("Schema metadata generation failed (runtime fallback will be used)");
+    logger.gray(`   ${error instanceof Error ? error.message : String(error)}`);
+  }
   logger.success("\nBuild complete!");
   logger.gray("\nTo start the server:");
   logger.info("  npm run start:node\n");
@@ -919,11 +1110,11 @@ __name(buildCommand, "buildCommand");
 // src/commands/start.ts
 import { spawn as spawn3 } from "child_process";
 import ora3 from "ora";
-import path5 from "path";
-import fs5 from "fs-extra";
+import path6 from "path";
+import fs6 from "fs-extra";
 async function startCommand() {
   const cwd = process.cwd();
-  if (!await fs5.pathExists(path5.join(cwd, "main.ts"))) {
+  if (!await fs6.pathExists(path6.join(cwd, "main.ts"))) {
     logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
     logger.gray("Run this command from your project root.");
     process.exit(1);
@@ -1025,8 +1216,8 @@ __name(startCommand, "startCommand");
 
 // src/commands/login.ts
 import ora4 from "ora";
-import path6 from "path";
-import fs6 from "fs-extra";
+import path7 from "path";
+import fs7 from "fs-extra";
 import os2 from "os";
 import { input, confirm } from "@inquirer/prompts";
 var DEBUG_MODE2 = false;
@@ -1040,12 +1231,12 @@ function debug2(message, ...args) {
   }
 }
 __name(debug2, "debug");
-var CONFIG_DIR = path6.join(os2.homedir(), ".leanmcp");
-var CONFIG_FILE = path6.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path7.join(os2.homedir(), ".leanmcp");
+var CONFIG_FILE = path7.join(CONFIG_DIR, "config.json");
 async function loadConfig() {
   try {
-    if (await fs6.pathExists(CONFIG_FILE)) {
-      return await fs6.readJSON(CONFIG_FILE);
+    if (await fs7.pathExists(CONFIG_FILE)) {
+      return await fs7.readJSON(CONFIG_FILE);
     }
   } catch (error) {
   }
@@ -1053,8 +1244,8 @@ async function loadConfig() {
 }
 __name(loadConfig, "loadConfig");
 async function saveConfig(config) {
-  await fs6.ensureDir(CONFIG_DIR);
-  await fs6.writeJSON(CONFIG_FILE, config, {
+  await fs7.ensureDir(CONFIG_DIR);
+  await fs7.writeJSON(CONFIG_FILE, config, {
     spaces: 2
   });
 }
@@ -1261,8 +1452,8 @@ __name(whoamiCommand, "whoamiCommand");
 
 // src/commands/deploy.ts
 import ora5 from "ora";
-import path8 from "path";
-import fs8 from "fs-extra";
+import path9 from "path";
+import fs9 from "fs-extra";
 import os3 from "os";
 import archiver from "archiver";
 import { input as input2, confirm as confirm2, select } from "@inquirer/prompts";
@@ -1445,8 +1636,8 @@ function generateProjectName() {
 __name(generateProjectName, "generateProjectName");
 
 // src/utils/env-parser.ts
-import fs7 from "fs-extra";
-import path7 from "path";
+import fs8 from "fs-extra";
+import path8 from "path";
 var RESERVED_ENV_KEYS = [
   "AWS_REGION",
   "AWS_ACCESS_KEY_ID",
@@ -1509,16 +1700,16 @@ function parseEnvFile(content) {
 }
 __name(parseEnvFile, "parseEnvFile");
 async function loadEnvFile(filePath) {
-  const absolutePath = path7.resolve(filePath);
-  if (!await fs7.pathExists(absolutePath)) {
+  const absolutePath = path8.resolve(filePath);
+  if (!await fs8.pathExists(absolutePath)) {
     throw new Error(`Env file not found: ${absolutePath}`);
   }
-  const content = await fs7.readFile(absolutePath, "utf-8");
+  const content = await fs8.readFile(absolutePath, "utf-8");
   return parseEnvFile(content);
 }
 __name(loadEnvFile, "loadEnvFile");
 async function writeEnvFile(filePath, vars) {
-  const absolutePath = path7.resolve(filePath);
+  const absolutePath = path8.resolve(filePath);
   const lines = [
     "# Environment variables",
     `# Generated by leanmcp CLI at ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -1534,7 +1725,7 @@ async function writeEnvFile(filePath, vars) {
     }
   }
   lines.push("");
-  await fs7.writeFile(absolutePath, lines.join("\n"));
+  await fs8.writeFile(absolutePath, lines.join("\n"));
 }
 __name(writeEnvFile, "writeEnvFile");
 function isValidEnvKey(key) {
@@ -1612,10 +1803,10 @@ var API_ENDPOINTS = {
 var LEANMCP_CONFIG_DIR = ".leanmcp";
 var LEANMCP_CONFIG_FILE = "config.json";
 async function readLeanMCPConfig(projectPath) {
-  const configPath = path8.join(projectPath, LEANMCP_CONFIG_DIR, LEANMCP_CONFIG_FILE);
+  const configPath = path9.join(projectPath, LEANMCP_CONFIG_DIR, LEANMCP_CONFIG_FILE);
   try {
-    if (await fs8.pathExists(configPath)) {
-      const config = await fs8.readJSON(configPath);
+    if (await fs9.pathExists(configPath)) {
+      const config = await fs9.readJSON(configPath);
       debug3("Found existing .leanmcp config:", config);
       return config;
     }
@@ -1626,10 +1817,10 @@ async function readLeanMCPConfig(projectPath) {
 }
 __name(readLeanMCPConfig, "readLeanMCPConfig");
 async function writeLeanMCPConfig(projectPath, config) {
-  const configDir = path8.join(projectPath, LEANMCP_CONFIG_DIR);
-  const configPath = path8.join(configDir, LEANMCP_CONFIG_FILE);
-  await fs8.ensureDir(configDir);
-  await fs8.writeJSON(configPath, config, {
+  const configDir = path9.join(projectPath, LEANMCP_CONFIG_DIR);
+  const configPath = path9.join(configDir, LEANMCP_CONFIG_FILE);
+  await fs9.ensureDir(configDir);
+  await fs9.writeJSON(configPath, config, {
     spaces: 2
   });
   debug3("Saved .leanmcp config:", config);
@@ -1637,7 +1828,7 @@ async function writeLeanMCPConfig(projectPath, config) {
 __name(writeLeanMCPConfig, "writeLeanMCPConfig");
 async function createZipArchive(folderPath, outputPath) {
   return new Promise((resolve, reject) => {
-    const output = fs8.createWriteStream(outputPath);
+    const output = fs9.createWriteStream(outputPath);
     const archive = archiver("zip", {
       zlib: {
         level: 9
@@ -1747,16 +1938,16 @@ async function deployCommand(folderPath, options = {}) {
   }
   const apiUrl = await getApiUrl();
   debug3("API URL:", apiUrl);
-  const absolutePath = path8.resolve(process.cwd(), folderPath);
-  if (!await fs8.pathExists(absolutePath)) {
+  const absolutePath = path9.resolve(process.cwd(), folderPath);
+  if (!await fs9.pathExists(absolutePath)) {
     logger.error(`Folder not found: ${absolutePath}`);
     process.exit(1);
   }
-  const hasMainTs = await fs8.pathExists(path8.join(absolutePath, "main.ts"));
-  const hasPackageJson = await fs8.pathExists(path8.join(absolutePath, "package.json"));
-  const hasMainPy = await fs8.pathExists(path8.join(absolutePath, "main.py"));
-  const hasRequirementsTxt = await fs8.pathExists(path8.join(absolutePath, "requirements.txt"));
-  const hasPyprojectToml = await fs8.pathExists(path8.join(absolutePath, "pyproject.toml"));
+  const hasMainTs = await fs9.pathExists(path9.join(absolutePath, "main.ts"));
+  const hasPackageJson = await fs9.pathExists(path9.join(absolutePath, "package.json"));
+  const hasMainPy = await fs9.pathExists(path9.join(absolutePath, "main.py"));
+  const hasRequirementsTxt = await fs9.pathExists(path9.join(absolutePath, "requirements.txt"));
+  const hasPyprojectToml = await fs9.pathExists(path9.join(absolutePath, "pyproject.toml"));
   const isNodeProject = hasMainTs || hasPackageJson;
   const isPythonProject = hasMainPy || hasRequirementsTxt || hasPyprojectToml;
   if (!isNodeProject && !isPythonProject) {
@@ -1828,10 +2019,10 @@ Generated project name: ${chalk.bold(projectName)}
     } catch (e) {
       debug3("Could not fetch existing projects");
     }
-    let folderName = path8.basename(absolutePath);
+    let folderName = path9.basename(absolutePath);
     if (hasPackageJson) {
       try {
-        const pkg2 = await fs8.readJSON(path8.join(absolutePath, "package.json"));
+        const pkg2 = await fs9.readJSON(path9.join(absolutePath, "package.json"));
         folderName = pkg2.name || folderName;
       } catch (e) {
       }
@@ -1982,7 +2173,7 @@ ${error instanceof Error ? error.message : String(error)}`);
   }
   const uploadSpinner = ora5("Packaging and uploading...").start();
   try {
-    const tempZip = path8.join(os3.tmpdir(), `leanmcp-${Date.now()}.zip`);
+    const tempZip = path9.join(os3.tmpdir(), `leanmcp-${Date.now()}.zip`);
     const zipSize = await createZipArchive(absolutePath, tempZip);
     uploadSpinner.text = `Packaging... (${Math.round(zipSize / 1024)}KB)`;
     debug3("Step 2a: Getting upload URL for project:", projectId);
@@ -2009,7 +2200,7 @@ ${error instanceof Error ? error.message : String(error)}`);
       throw new Error("Backend did not return upload URL");
     }
     debug3("Step 2b: Uploading to S3...");
-    const zipBuffer = await fs8.readFile(tempZip);
+    const zipBuffer = await fs9.readFile(tempZip);
     const s3Response = await fetch(uploadUrl, {
       method: "PUT",
       body: zipBuffer,
@@ -2032,7 +2223,7 @@ ${error instanceof Error ? error.message : String(error)}`);
         s3Location
       })
     });
-    await fs8.remove(tempZip);
+    await fs9.remove(tempZip);
     uploadSpinner.succeed("Project uploaded");
   } catch (error) {
     uploadSpinner.fail("Failed to upload");
@@ -2307,8 +2498,8 @@ __name(projectsDeleteCommand, "projectsDeleteCommand");
 
 // src/commands/env.ts
 import ora7 from "ora";
-import path9 from "path";
-import fs9 from "fs-extra";
+import path10 from "path";
+import fs10 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
 var DEBUG_MODE4 = false;
 function setEnvDebugMode(enabled) {
@@ -2341,10 +2532,10 @@ __name(debugFetch2, "debugFetch");
 var LEANMCP_CONFIG_DIR2 = ".leanmcp";
 var LEANMCP_CONFIG_FILE2 = "config.json";
 async function readLeanMCPConfig2(projectPath) {
-  const configPath = path9.join(projectPath, LEANMCP_CONFIG_DIR2, LEANMCP_CONFIG_FILE2);
+  const configPath = path10.join(projectPath, LEANMCP_CONFIG_DIR2, LEANMCP_CONFIG_FILE2);
   try {
-    if (await fs9.pathExists(configPath)) {
-      const config = await fs9.readJSON(configPath);
+    if (await fs10.pathExists(configPath)) {
+      const config = await fs10.readJSON(configPath);
       debug4("Found existing .leanmcp config:", config);
       return config;
     }
@@ -2362,7 +2553,7 @@ async function getDeploymentContext(folderPath) {
     return null;
   }
   const apiUrl = await getApiUrl();
-  const absolutePath = path9.resolve(process.cwd(), folderPath);
+  const absolutePath = path10.resolve(process.cwd(), folderPath);
   const config = await readLeanMCPConfig2(absolutePath);
   if (!config) {
     logger.error("No deployment found.");
@@ -2987,12 +3178,16 @@ vite.config.ts.timestamp-*
 var getExampleServiceTemplate = /* @__PURE__ */ __name((projectName) => `import { Tool, Resource, Prompt, SchemaConstraint, Optional } from "@leanmcp/core";
 
     /**
-     * Example service demonstrating LeanMCP SDK decorators
+     * ${projectName} - Production-ready MCP server example
      * 
-     * This is a simple example to get you started. Add your own tools, resources, and prompts here!
+     * This example demonstrates LeanMCP's core features:
+     * - Schema validation with decorators
+     * - Type-safe tool definitions
+     * - Resource and prompt capabilities
+     * - Production-ready structure
      */
 
-    // Input schema with validation decorators
+    // Input schemas with validation decorators
     class CalculateInput {
       @SchemaConstraint({ description: "First number" })
       a!: number;
@@ -3017,13 +3212,13 @@ var getExampleServiceTemplate = /* @__PURE__ */ __name((projectName) => `import
       message!: string;
     }
 
-    export class ExampleService {
+    export class ${projectName}Service {
+      // CALCULATION TOOL - Shows schema validation
       @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;
@@ -3052,14 +3247,17 @@ var getExampleServiceTemplate = /* @__PURE__ */ __name((projectName) => `import
             text: JSON.stringify({
               operation: input.operation || "add",
               operands: { a: input.a, b: input.b },
-              result
+              result,
+              timestamp: new Date().toISOString(),
+              server: "${projectName}"
             }, null, 2)
           }]
         };
       }
 
+      // ECHO TOOL - Shows basic functionality
       @Tool({
-        description: "Echo a message back",
+        description: "Echo a message back with timestamp",
         inputClass: EchoInput
       })
       async echo(input: EchoInput) {
@@ -3068,13 +3266,15 @@ var getExampleServiceTemplate = /* @__PURE__ */ __name((projectName) => `import
             type: "text" as const,
             text: JSON.stringify({
               echoed: input.message,
-              timestamp: new Date().toISOString()
+              timestamp: new Date().toISOString(),
+              server: "${projectName}"
             }, null, 2)
           }]
         };
       }
 
-      @Resource({ description: "Get server information" })
+      // SERVER INFO RESOURCE - Shows resource capabilities
+      @Resource({ description: "Get server information and health status" })
       async serverInfo() {
         return {
           contents: [{
@@ -3083,25 +3283,45 @@ var getExampleServiceTemplate = /* @__PURE__ */ __name((projectName) => `import
             text: JSON.stringify({
               name: "${projectName}",
               version: "1.0.0",
-              uptime: process.uptime()
+              status: "healthy",
+              uptime: Math.floor(process.uptime()),
+              memory: {
+                used: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+                total: Math.round(process.memoryUsage().heapTotal / 1024 / 1024)
+              },
+              features: [
+                "Schema validation with decorators",
+                "Type-safe tool definitions", 
+                "Resource endpoints",
+                "Prompt templates"
+              ],
+              timestamp: new Date().toISOString()
             }, null, 2)
           }]
         };
       }
 
-      @Prompt({ description: "Generate a greeting prompt" })
-      async greeting(args: { name?: string }) {
+      // WELCOME PROMPT - Shows prompt capabilities
+      @Prompt({ description: "Generate a welcome prompt for the server" })
+      async welcome(args: { name?: string }) {
         return {
           messages: [{
             role: "user" as const,
             content: {
               type: "text" as const,
-              text: \`Hello \${args.name || 'there'}! Welcome to ${projectName}.\`
-        }
-      }]
-    };
-  }
-}
+              text: \`Welcome \${args.name || 'there'} to ${projectName}! 
+
+Your MCP server is running with these tools:
+- calculate: Perform arithmetic operations
+- echo: Echo messages back
+- serverInfo: Get server status and information
+
+Try calling these tools to see LeanMCP in action!\`
+            }
+          }]
+        };
+      }
+    }
 `, "getExampleServiceTemplate");
 
 // src/templates/main_ts_v1.ts
@@ -3111,6 +3331,14 @@ import { createHTTPServer } from "@leanmcp/core";
 // Load environment variables
 dotenv.config();
 
+console.log("Starting ${projectName} MCP Server...");
+console.log("Features included:");
+console.log("   Schema validation with decorators");
+console.log("   Resource endpoints");
+console.log("   Prompt templates");
+console.log("   Type-safe tool definitions");
+console.log("");
+
 // Services are automatically discovered from ./mcp directory
 await createHTTPServer({
   name: "${projectName}",
@@ -3118,10 +3346,27 @@ await createHTTPServer({
   port: 3001,
   cors: true,
   logging: true${dashboardLine}
-  // stateless: false,  // Enable stateful mode (uses DynamoDB on Lambda for session persistence)
 });
 
-console.log("\\n${projectName} MCP Server");
+console.log("\\n${projectName} MCP Server is running!");
+console.log("\\nTry these commands to test your server:");
+console.log("");
+console.log("# Test calculation tool (schema validation)");
+console.log('curl -X POST http://localhost:3001/mcp \\\\');
+console.log('  -H "Content-Type: application/json" \\\\');
+console.log('  -d '{"method": "tools/call", "params": {"name": "calculate", "arguments": {"a": 10, "b": 5, "operation": "add"}}}'');
+console.log("");
+console.log("# Test echo tool");
+console.log('curl -X POST http://localhost:3001/mcp \\\\');
+console.log('  -H "Content-Type: application/json" \\\\');
+console.log('  -d '{"method": "tools/call", "params": {"name": "echo", "arguments": {"message": "Hello LeanMCP!"}}}'');
+console.log("");
+console.log("# Get server information (resource)");
+console.log('curl -X POST http://localhost:3001/mcp \\\\');
+console.log('  -H "Content-Type: application/json" \\\\');
+console.log('  -d '{"method": "resources/read", "params": {"uri": "server://info"}}'');
+console.log("");
+console.log("Ready to customize - add your own tools, resources, and prompts!");
 `, "getMainTsTemplate");
 
 // src/templates/service_index_v1.ts
@@ -3445,29 +3690,29 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
     ...options
   });
   const spinner = ora8(`Creating project ${projectName}...`).start();
-  const targetDir = path10.join(process.cwd(), projectName);
-  if (fs10.existsSync(targetDir)) {
+  const targetDir = path11.join(process.cwd(), projectName);
+  if (fs11.existsSync(targetDir)) {
     spinner.fail(`Folder ${projectName} already exists.`);
     process.exit(1);
   }
-  await fs10.mkdirp(targetDir);
+  await fs11.mkdirp(targetDir);
   const isPython = options.python === true;
   if (isPython) {
     const requirements = getPythonRequirementsTemplate();
-    await fs10.writeFile(path10.join(targetDir, "requirements.txt"), requirements);
+    await fs11.writeFile(path11.join(targetDir, "requirements.txt"), requirements);
     const mainPy = getPythonMainTemplate(projectName);
-    await fs10.writeFile(path10.join(targetDir, "main.py"), mainPy);
-    await fs10.writeFile(path10.join(targetDir, ".gitignore"), pythonGitignoreTemplate);
+    await fs11.writeFile(path11.join(targetDir, "main.py"), mainPy);
+    await fs11.writeFile(path11.join(targetDir, ".gitignore"), pythonGitignoreTemplate);
     const env = `# Server Configuration
 PORT=3001
 
 # Add your environment variables here
 `;
-    await fs10.writeFile(path10.join(targetDir, ".env"), env);
+    await fs11.writeFile(path11.join(targetDir, ".env"), env);
     const readme = getPythonReadmeTemplate(projectName);
-    await fs10.writeFile(path10.join(targetDir, "README.md"), readme);
+    await fs11.writeFile(path11.join(targetDir, "README.md"), readme);
   } else {
-    await fs10.mkdirp(path10.join(targetDir, "mcp", "example"));
+    await fs11.mkdirp(path11.join(targetDir, "mcp", "example"));
     const pkg2 = {
       name: projectName,
       version: "1.0.0",
@@ -3503,7 +3748,7 @@ PORT=3001
         typescript: "^5.6.3"
       }
     };
-    await fs10.writeJSON(path10.join(targetDir, "package.json"), pkg2, {
+    await fs11.writeJSON(path11.join(targetDir, "package.json"), pkg2, {
       spaces: 2
     });
     const tsconfig = {
@@ -3526,15 +3771,15 @@ PORT=3001
         "dist"
       ]
     };
-    await fs10.writeJSON(path10.join(targetDir, "tsconfig.json"), tsconfig, {
+    await fs11.writeJSON(path11.join(targetDir, "tsconfig.json"), tsconfig, {
       spaces: 2
     });
     const dashboardLine = options.dashboard === false ? `
   dashboard: false,  // Dashboard disabled via --no-dashboard` : "";
     const mainTs = getMainTsTemplate(projectName, dashboardLine);
-    await fs10.writeFile(path10.join(targetDir, "main.ts"), mainTs);
+    await fs11.writeFile(path11.join(targetDir, "main.ts"), mainTs);
     const exampleServiceTs = getExampleServiceTemplate(projectName);
-    await fs10.writeFile(path10.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
+    await fs11.writeFile(path11.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
     const gitignore = gitignoreTemplate;
     const env = `# Server Configuration
 PORT=3001
@@ -3542,10 +3787,10 @@ NODE_ENV=development
 
 # Add your environment variables here
 `;
-    await fs10.writeFile(path10.join(targetDir, ".gitignore"), gitignore);
-    await fs10.writeFile(path10.join(targetDir, ".env"), env);
+    await fs11.writeFile(path11.join(targetDir, ".gitignore"), gitignore);
+    await fs11.writeFile(path11.join(targetDir, ".env"), env);
     const readme = getReadmeTemplate(projectName);
-    await fs10.writeFile(path10.join(targetDir, "README.md"), readme);
+    await fs11.writeFile(path11.join(targetDir, "README.md"), readme);
   }
   spinner.succeed(`Project ${projectName} created!`);
   logger.log("\nSuccess! Your MCP server is ready.\n", chalk.green);
@@ -3669,20 +3914,20 @@ NODE_ENV=development
 });
 program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
   const cwd = process.cwd();
-  const mcpDir = path10.join(cwd, "mcp");
-  if (!fs10.existsSync(path10.join(cwd, "main.ts"))) {
+  const mcpDir = path11.join(cwd, "mcp");
+  if (!fs11.existsSync(path11.join(cwd, "main.ts"))) {
     logger.log("ERROR: Not a LeanMCP project (main.ts missing).", chalk.red);
     process.exit(1);
   }
-  const serviceDir = path10.join(mcpDir, serviceName);
-  const serviceFile = path10.join(serviceDir, "index.ts");
-  if (fs10.existsSync(serviceDir)) {
+  const serviceDir = path11.join(mcpDir, serviceName);
+  const serviceFile = path11.join(serviceDir, "index.ts");
+  if (fs11.existsSync(serviceDir)) {
     logger.log(`ERROR: Service ${serviceName} already exists.`, chalk.red);
     process.exit(1);
   }
-  await fs10.mkdirp(serviceDir);
+  await fs11.mkdirp(serviceDir);
   const indexTs = getServiceIndexTemplate(serviceName, capitalize(serviceName));
-  await fs10.writeFile(serviceFile, indexTs);
+  await fs11.writeFile(serviceFile, indexTs);
   logger.log(`\\nCreated new service: ${chalk.bold(serviceName)}`, chalk.green);
   logger.log(`   File: mcp/${serviceName}/index.ts`, chalk.gray);
   logger.log(`   Tool: greet`, chalk.gray);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/cli",
-  "version": "0.5.4",
+  "version": "0.5.5-alpha.28.7306df7",
   "description": "Command-line interface for scaffolding LeanMCP projects",
   "bin": {
     "leanmcp": "bin/leanmcp.js"
@@ -40,7 +40,8 @@
     "postcss": "^8.4.32",
     "tailwindcss": "^3.4.0",
     "vite": "^5.4.0",
-    "vite-plugin-singlefile": "^2.3.0"
+    "vite-plugin-singlefile": "^2.3.0",
+    "ts-morph": "^24.0.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",
@@ -70,4 +71,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}