@leanmcp/core 0.4.5 → 0.4.7

package/dist/index.mjs

@@ -10,8 +10,8 @@ import {
 
 // src/index.ts
 import "reflect-metadata";
-import fs from "fs";
-import path from "path";
+import fs3 from "fs";
+import path2 from "path";
 import { pathToFileURL } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -168,6 +168,191 @@ __name(getDecoratedMethods, "getDecoratedMethods");
 
 // src/schema-generator.ts
 import "reflect-metadata";
+
+// src/type-parser.ts
+import fs from "fs";
+import { createRequire } from "module";
+var typeCache = /* @__PURE__ */ new Map();
+var classSourceMap = /* @__PURE__ */ new Map();
+var tsMorphProject = null;
+var tsMorphNode = null;
+var tsMorphLoaded = false;
+function loadTsMorph() {
+  if (tsMorphLoaded) {
+    return tsMorphProject !== null;
+  }
+  tsMorphLoaded = true;
+  try {
+    const customRequire = createRequire(import.meta.url);
+    const tsMorph = customRequire("ts-morph");
+    tsMorphProject = tsMorph.Project;
+    tsMorphNode = tsMorph.Node;
+    return true;
+  } catch (error) {
+    console.warn(`[type-parser] ts-morph not available: ${error.message}`);
+    return false;
+  }
+}
+__name(loadTsMorph, "loadTsMorph");
+function registerClassSource(className, sourceFile) {
+  classSourceMap.set(className, sourceFile);
+}
+__name(registerClassSource, "registerClassSource");
+function parseClassTypesSync(classConstructor, sourceFilePath) {
+  if (!loadTsMorph()) {
+    return /* @__PURE__ */ new Map();
+  }
+  const className = classConstructor.name;
+  let filePath = sourceFilePath || classSourceMap.get(className) || findSourceFile();
+  if (!filePath) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (filePath.endsWith(".js")) {
+    const tsPath = filePath.replace(/\.js$/, ".ts");
+    if (fs.existsSync(tsPath)) {
+      filePath = tsPath;
+    }
+  }
+  const cacheKey = `${filePath}:${className}`;
+  if (typeCache.has(cacheKey)) {
+    return typeCache.get(cacheKey);
+  }
+  if (!fs.existsSync(filePath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const project = new tsMorphProject({
+      skipAddingFilesFromTsConfig: true,
+      skipFileDependencyResolution: true,
+      useInMemoryFileSystem: false
+    });
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    const classDecl = sourceFile.getClass(className);
+    if (!classDecl) {
+      return /* @__PURE__ */ new Map();
+    }
+    const propertyTypes = /* @__PURE__ */ new Map();
+    for (const prop of classDecl.getInstanceProperties()) {
+      if (tsMorphNode.isPropertyDeclaration(prop)) {
+        const propName = prop.getName();
+        const typeNode = prop.getTypeNode();
+        if (typeNode) {
+          const typeText = typeNode.getText();
+          const jsonSchemaType = typeTextToJsonSchema(typeText);
+          propertyTypes.set(propName, jsonSchemaType);
+        }
+      }
+    }
+    typeCache.set(cacheKey, propertyTypes);
+    return propertyTypes;
+  } catch (error) {
+    console.warn(`[type-parser] Failed to parse ${filePath}: ${error.message}`);
+    return /* @__PURE__ */ new Map();
+  }
+}
+__name(parseClassTypesSync, "parseClassTypesSync");
+function typeTextToJsonSchema(typeText) {
+  const type = typeText.trim().replace(/\?$/, "");
+  if (type.endsWith("[]")) {
+    const elementType = type.slice(0, -2);
+    return {
+      type: "array",
+      items: typeTextToJsonSchema(elementType)
+    };
+  }
+  const arrayMatch = type.match(/^Array<(.+)>$/);
+  if (arrayMatch) {
+    return {
+      type: "array",
+      items: typeTextToJsonSchema(arrayMatch[1])
+    };
+  }
+  const lowerType = type.toLowerCase();
+  switch (lowerType) {
+    case "string":
+      return {
+        type: "string"
+      };
+    case "number":
+      return {
+        type: "number"
+      };
+    case "integer":
+      return {
+        type: "integer"
+      };
+    case "boolean":
+      return {
+        type: "boolean"
+      };
+    case "object":
+      return {
+        type: "object"
+      };
+    case "any":
+    case "unknown":
+      return {};
+    // No constraints
+    case "null":
+      return {
+        type: "null"
+      };
+  }
+  if (type.includes("|")) {
+    const parts = type.split("|").map((p) => p.trim());
+    const nonNullParts = parts.filter((p) => p.toLowerCase() !== "null");
+    if (nonNullParts.length === 1) {
+      return typeTextToJsonSchema(nonNullParts[0]);
+    }
+    return {
+      anyOf: nonNullParts.map((p) => typeTextToJsonSchema(p))
+    };
+  }
+  return {
+    type: "object"
+  };
+}
+__name(typeTextToJsonSchema, "typeTextToJsonSchema");
+function findSourceFile() {
+  const originalPrepareStackTrace = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack2) => stack2;
+    const err = new Error();
+    const stack = err.stack;
+    for (const site of stack) {
+      const fileName = site.getFileName();
+      if (fileName && !fileName.includes("node_modules") && !fileName.includes("type-parser") && !fileName.includes("schema-generator") && (fileName.endsWith(".ts") || fileName.endsWith(".js"))) {
+        if (fileName.endsWith(".js")) {
+          const tsPath = fileName.replace(/\.js$/, ".ts");
+          if (fs.existsSync(tsPath)) {
+            return tsPath;
+          }
+        }
+        return fileName;
+      }
+    }
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
+  }
+  return null;
+}
+__name(findSourceFile, "findSourceFile");
+function clearTypeCache() {
+  typeCache.clear();
+}
+__name(clearTypeCache, "clearTypeCache");
+
+// src/schema-generator.ts
+import path from "path";
+import fs2 from "fs";
+var schemaMetadata = null;
+try {
+  const metadataPath = path.join(process.cwd(), "dist", "schema-metadata.json");
+  if (fs2.existsSync(metadataPath)) {
+    schemaMetadata = JSON.parse(fs2.readFileSync(metadataPath, "utf-8"));
+  }
+} catch {
+}
 function classToJsonSchema(classConstructor) {
   const instance = new classConstructor();
   const properties = {};
@@ -224,20 +409,52 @@ __name(Optional, "Optional");
 function SchemaConstraint(constraints) {
   return (target, propertyKey) => {
     Reflect.defineMetadata("schema:constraints", constraints, target, propertyKey);
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      Error.prepareStackTrace = (_, stack2) => stack2;
+      const err = new Error();
+      const stack = err.stack;
+      for (const site of stack) {
+        const fileName = site.getFileName();
+        if (fileName && !fileName.includes("node_modules") && !fileName.includes("schema-generator") && (fileName.endsWith(".ts") || fileName.endsWith(".js"))) {
+          const className = target.constructor.name;
+          if (className && className !== "Object") {
+            registerClassSource(className, fileName);
+          }
+          break;
+        }
+      }
+    } finally {
+      Error.prepareStackTrace = originalPrepareStackTrace;
+    }
   };
 }
 __name(SchemaConstraint, "SchemaConstraint");
-function classToJsonSchemaWithConstraints(classConstructor) {
+function classToJsonSchemaWithConstraints(classConstructor, sourceFilePath) {
   const instance = new classConstructor();
   const properties = {};
   const required = [];
+  const className = classConstructor.name;
+  const precomputedTypes = schemaMetadata?.[className];
+  const parsedTypes = precomputedTypes ? null : parseClassTypesSync(classConstructor, sourceFilePath);
   const propertyNames = Object.keys(instance);
   for (const propertyName of propertyNames) {
     const propertyType = Reflect.getMetadata("design:type", instance, propertyName);
     const constraints = Reflect.getMetadata("schema:constraints", instance, propertyName);
     const isOptional = Reflect.getMetadata("optional", instance, propertyName);
-    let jsonSchemaType = "string";
-    if (propertyType) {
+    let parsedType;
+    if (precomputedTypes) {
+      parsedType = precomputedTypes[propertyName];
+    } else if (parsedTypes) {
+      parsedType = parsedTypes.get(propertyName);
+    }
+    let propertySchema;
+    if (parsedType && parsedType.type) {
+      propertySchema = {
+        ...parsedType
+      };
+    } else if (propertyType) {
+      let jsonSchemaType = "string";
       switch (propertyType.name) {
         case "String":
           jsonSchemaType = "string";
@@ -257,8 +474,16 @@ function classToJsonSchemaWithConstraints(classConstructor) {
         default:
           jsonSchemaType = "object";
       }
+      propertySchema = {
+        type: jsonSchemaType
+      };
     } else if (constraints) {
-      if (constraints.minLength !== void 0 || constraints.maxLength !== void 0 || constraints.pattern) {
+      let jsonSchemaType = "string";
+      if (constraints.type) {
+        jsonSchemaType = constraints.type;
+      } else if (constraints.items) {
+        jsonSchemaType = "array";
+      } else if (constraints.minLength !== void 0 || constraints.maxLength !== void 0 || constraints.pattern) {
         jsonSchemaType = "string";
       } else if (constraints.minimum !== void 0 || constraints.maximum !== void 0) {
         jsonSchemaType = "number";
@@ -272,12 +497,25 @@ function classToJsonSchemaWithConstraints(classConstructor) {
           jsonSchemaType = "string";
         }
       }
+      propertySchema = {
+        type: jsonSchemaType
+      };
+    } else {
+      propertySchema = {
+        type: "string"
+      };
     }
-    const propertySchema = {
-      type: jsonSchemaType,
-      ...constraints || {}
-    };
-    if (jsonSchemaType === "array" && !propertySchema.items) {
+    if (constraints) {
+      const parsedItems = propertySchema.items;
+      propertySchema = {
+        ...propertySchema,
+        ...constraints
+      };
+      if (parsedItems && !constraints.items) {
+        propertySchema.items = parsedItems;
+      }
+    }
+    if (propertySchema.type === "array" && !propertySchema.items) {
       propertySchema.items = {
         type: "string"
       };
@@ -305,9 +543,9 @@ function validatePort(port) {
   }
 }
 __name(validatePort, "validatePort");
-function validatePath(path2) {
-  if (path2.includes("..") || path2.includes("~")) {
-    throw new Error(`Invalid path: ${path2}. Path traversal patterns are not allowed`);
+function validatePath(path3) {
+  if (path3.includes("..") || path3.includes("~")) {
+    throw new Error(`Invalid path: ${path3}. Path traversal patterns are not allowed`);
   }
 }
 __name(validatePath, "validatePath");
@@ -396,9 +634,9 @@ async function createHTTPServer(serverInput, options) {
     if (!serverOptions.mcpDir) {
       const callerFile = getCallerFile();
       if (callerFile) {
-        const path2 = await import("path");
-        const callerDir = path2.dirname(callerFile);
-        resolvedMcpDir = path2.join(callerDir, "mcp");
+        const path3 = await import("path");
+        const callerDir = path3.dirname(callerFile);
+        resolvedMcpDir = path3.join(callerDir, "mcp");
       }
     } else {
       resolvedMcpDir = serverOptions.mcpDir;
@@ -1328,13 +1566,13 @@ var MCPServer = class {
       } else {
         const callerFile = this.getCallerFile();
         if (callerFile) {
-          const callerDir = path.dirname(callerFile);
-          mcpDir = path.join(callerDir, "mcp");
+          const callerDir = path2.dirname(callerFile);
+          mcpDir = path2.join(callerDir, "mcp");
         } else {
-          mcpDir = path.join(process.cwd(), "mcp");
+          mcpDir = path2.join(process.cwd(), "mcp");
         }
       }
-      if (fs.existsSync(mcpDir)) {
+      if (fs3.existsSync(mcpDir)) {
         this.logger.debug(`Auto-discovering services from: ${mcpDir}`);
         await this.autoRegisterServices(mcpDir, serviceFactories);
       } else {
@@ -1584,7 +1822,7 @@ var MCPServer = class {
   */
   async autoRegisterServices(mcpDir, serviceFactories) {
     this.logger.debug(`Auto-registering services from: ${mcpDir}`);
-    if (!fs.existsSync(mcpDir)) {
+    if (!fs3.existsSync(mcpDir)) {
       this.logger.warn(`MCP directory not found: ${mcpDir}`);
       return;
     }
@@ -1603,11 +1841,11 @@ var MCPServer = class {
   */
   findServiceFiles(dir) {
     const files = [];
-    const entries = fs.readdirSync(dir, {
+    const entries = fs3.readdirSync(dir, {
       withFileTypes: true
     });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...this.findServiceFiles(fullPath));
       } else if (entry.isFile()) {
@@ -1638,7 +1876,7 @@ var MCPServer = class {
           }
           this.registerService(instance);
           registeredCount++;
-          this.logger.debug(`Registered service: ${exportName} from ${path.basename(filePath)}`);
+          this.logger.debug(`Registered service: ${exportName} from ${path2.basename(filePath)}`);
         } catch (error) {
           this.logger.warn(`Skipped ${exportName}: ${error.message}`);
         }
@@ -1737,8 +1975,8 @@ var MCPServer = class {
       return;
     }
     try {
-      const manifestPath = path.join(process.cwd(), "dist", "ui-manifest.json");
-      if (!fs.existsSync(manifestPath)) {
+      const manifestPath = path2.join(process.cwd(), "dist", "ui-manifest.json");
+      if (!fs3.existsSync(manifestPath)) {
         return;
       }
       if (this.logging) {
@@ -1780,8 +2018,8 @@ var MCPServer = class {
   */
   async reloadUIManifest() {
     try {
-      const manifestPath = path.join(process.cwd(), "dist", "ui-manifest.json");
-      if (!fs.existsSync(manifestPath)) {
+      const manifestPath = path2.join(process.cwd(), "dist", "ui-manifest.json");
+      if (!fs3.existsSync(manifestPath)) {
         const uiResourceUris = Array.from(this.resources.keys()).filter((uri) => uri.startsWith("ui://"));
         for (const uri of uiResourceUris) {
           this.resources.delete(uri);
@@ -1791,7 +2029,7 @@ var MCPServer = class {
         }
         return;
       }
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
       const currentUIUris = new Set(Object.keys(manifest));
       const registeredUIUris = Array.from(this.resources.keys()).filter((uri) => uri.startsWith("ui://"));
       for (const uri of registeredUIUris) {
@@ -1807,7 +2045,7 @@ var MCPServer = class {
         const htmlPath = isString ? entry : entry.htmlPath;
         const isGPTApp = !isString && entry.isGPTApp;
         const gptMeta = !isString ? entry.gptMeta : void 0;
-        if (!fs.existsSync(htmlPath)) {
+        if (!fs3.existsSync(htmlPath)) {
           if (this.logging) {
             this.logger.warn(`UI HTML file not found: ${htmlPath}`);
           }
@@ -1828,8 +2066,8 @@ var MCPServer = class {
           mimeType,
           inputSchema: void 0,
           method: /* @__PURE__ */ __name(async () => {
-            if (fs.existsSync(htmlPath)) {
-              const html = fs.readFileSync(htmlPath, "utf-8");
+            if (fs3.existsSync(htmlPath)) {
+              const html = fs3.readFileSync(htmlPath, "utf-8");
               return {
                 text: html,
                 _meta: Object.keys(_meta).length > 0 ? _meta : void 0
@@ -1857,11 +2095,11 @@ var MCPServer = class {
   */
   async loadUIManifest() {
     try {
-      const manifestPath = path.join(process.cwd(), "dist", "ui-manifest.json");
-      if (!fs.existsSync(manifestPath)) {
+      const manifestPath = path2.join(process.cwd(), "dist", "ui-manifest.json");
+      if (!fs3.existsSync(manifestPath)) {
         return;
       }
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
       for (const [uri, entry] of Object.entries(manifest)) {
         const isString = typeof entry === "string";
         const htmlPath = isString ? entry : entry.htmlPath;
@@ -1873,13 +2111,13 @@ var MCPServer = class {
           }
           continue;
         }
-        if (!fs.existsSync(htmlPath)) {
+        if (!fs3.existsSync(htmlPath)) {
           if (this.logging) {
             this.logger.warn(`UI HTML file not found: ${htmlPath}`);
           }
           continue;
         }
-        const html = fs.readFileSync(htmlPath, "utf-8");
+        const html = fs3.readFileSync(htmlPath, "utf-8");
         const mimeType = isGPTApp ? "text/html+skybridge" : "text/html;profile=mcp-app";
         const _meta = {};
         if (isGPTApp) {
@@ -2130,19 +2368,19 @@ var MCPServerRuntime = class {
     });
   }
   async loadServices() {
-    const absPath = path.resolve(this.options.servicesDir);
-    if (!fs.existsSync(absPath)) {
+    const absPath = path2.resolve(this.options.servicesDir);
+    if (!fs3.existsSync(absPath)) {
       this.logger.error(`Services directory not found: ${absPath}`);
       return;
     }
-    const files = fs.readdirSync(absPath);
+    const files = fs3.readdirSync(absPath);
     let toolCount = 0;
     let promptCount = 0;
     let resourceCount = 0;
     for (const dir of files) {
-      const modulePath = path.join(absPath, dir, "index.ts");
-      const modulePathJs = path.join(absPath, dir, "index.js");
-      const finalPath = fs.existsSync(modulePath) ? modulePath : fs.existsSync(modulePathJs) ? modulePathJs : null;
+      const modulePath = path2.join(absPath, dir, "index.ts");
+      const modulePathJs = path2.join(absPath, dir, "index.js");
+      const finalPath = fs3.existsSync(modulePath) ? modulePath : fs3.existsSync(modulePathJs) ? modulePathJs : null;
       if (finalPath) {
         try {
           const fileUrl = pathToFileURL(finalPath).href;
@@ -2277,6 +2515,7 @@ export {
   UserEnvs,
   classToJsonSchema,
   classToJsonSchemaWithConstraints,
+  clearTypeCache,
   createAuthError,
   createHTTPServer,
   createProtectedResourceMetadata,
@@ -2285,6 +2524,8 @@ export {
   getDecoratedMethods,
   getMethodMetadata,
   isAuthError,
+  parseClassTypesSync,
+  registerClassSource,
   startMCPServer,
   validateNonEmpty,
   validatePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/core",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Core library implementing decorators, reflection, and MCP runtime server",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -32,6 +32,9 @@
     "dotenv": "^16.3.1",
     "reflect-metadata": "^0.2.1"
   },
+  "optionalDependencies": {
+    "ts-morph": "^24.0.0"
+  },
   "peerDependencies": {
     "cors": "^2.8.5",
     "express": "^5.0.0",
@@ -75,4 +78,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}