@leanmcp/core 0.4.5 → 0.4.7

package/dist/index.js

@@ -185,6 +185,186 @@ var init_decorators = __esm({
   }
 });
 
+// src/type-parser.ts
+function loadTsMorph() {
+  if (tsMorphLoaded) {
+    return tsMorphProject !== null;
+  }
+  tsMorphLoaded = true;
+  try {
+    const customRequire = (0, import_node_module.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;
+  }
+}
+function registerClassSource(className, sourceFile) {
+  classSourceMap.set(className, sourceFile);
+}
+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 (import_fs.default.existsSync(tsPath)) {
+      filePath = tsPath;
+    }
+  }
+  const cacheKey = `${filePath}:${className}`;
+  if (typeCache.has(cacheKey)) {
+    return typeCache.get(cacheKey);
+  }
+  if (!import_fs.default.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();
+  }
+}
+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"
+  };
+}
+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 (import_fs.default.existsSync(tsPath)) {
+            return tsPath;
+          }
+        }
+        return fileName;
+      }
+    }
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
+  }
+  return null;
+}
+function clearTypeCache() {
+  typeCache.clear();
+}
+var import_fs, import_node_module, import_meta, typeCache, classSourceMap, tsMorphProject, tsMorphNode, tsMorphLoaded;
+var init_type_parser = __esm({
+  "src/type-parser.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_node_module = require("module");
+    import_meta = {};
+    typeCache = /* @__PURE__ */ new Map();
+    classSourceMap = /* @__PURE__ */ new Map();
+    tsMorphProject = null;
+    tsMorphNode = null;
+    tsMorphLoaded = false;
+    __name(loadTsMorph, "loadTsMorph");
+    __name(registerClassSource, "registerClassSource");
+    __name(parseClassTypesSync, "parseClassTypesSync");
+    __name(typeTextToJsonSchema, "typeTextToJsonSchema");
+    __name(findSourceFile, "findSourceFile");
+    __name(clearTypeCache, "clearTypeCache");
+  }
+});
+
 // src/schema-generator.ts
 function classToJsonSchema(classConstructor) {
   const instance = new classConstructor();
@@ -240,19 +420,51 @@ function 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;
+    }
   };
 }
-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";
@@ -272,8 +484,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";
@@ -287,12 +507,25 @@ function classToJsonSchemaWithConstraints(classConstructor) {
           jsonSchemaType = "string";
         }
       }
+      propertySchema = {
+        type: jsonSchemaType
+      };
+    } else {
+      propertySchema = {
+        type: "string"
+      };
+    }
+    if (constraints) {
+      const parsedItems = propertySchema.items;
+      propertySchema = {
+        ...propertySchema,
+        ...constraints
+      };
+      if (parsedItems && !constraints.items) {
+        propertySchema.items = parsedItems;
+      }
     }
-    const propertySchema = {
-      type: jsonSchemaType,
-      ...constraints || {}
-    };
-    if (jsonSchemaType === "array" && !propertySchema.items) {
+    if (propertySchema.type === "array" && !propertySchema.items) {
       propertySchema.items = {
         type: "string"
       };
@@ -308,11 +541,22 @@ function classToJsonSchemaWithConstraints(classConstructor) {
     required: required.length > 0 ? required : void 0
   };
 }
-var import_reflect_metadata2;
+var import_reflect_metadata2, import_path, import_fs2, schemaMetadata;
 var init_schema_generator = __esm({
   "src/schema-generator.ts"() {
     "use strict";
     import_reflect_metadata2 = require("reflect-metadata");
+    init_type_parser();
+    import_path = __toESM(require("path"));
+    import_fs2 = __toESM(require("fs"));
+    schemaMetadata = null;
+    try {
+      const metadataPath = import_path.default.join(process.cwd(), "dist", "schema-metadata.json");
+      if (import_fs2.default.existsSync(metadataPath)) {
+        schemaMetadata = JSON.parse(import_fs2.default.readFileSync(metadataPath, "utf-8"));
+      }
+    } catch {
+    }
     __name(classToJsonSchema, "classToJsonSchema");
     __name(Optional, "Optional");
     __name(SchemaConstraint, "SchemaConstraint");
@@ -445,9 +689,9 @@ function validatePort(port) {
     throw new Error(`Invalid port: ${port}. Must be an integer between 1-65535`);
   }
 }
-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`);
   }
 }
 function validateServiceName(name) {
@@ -698,9 +942,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;
@@ -1617,6 +1861,7 @@ __export(index_exports, {
   UserEnvs: () => UserEnvs,
   classToJsonSchema: () => classToJsonSchema,
   classToJsonSchemaWithConstraints: () => classToJsonSchemaWithConstraints,
+  clearTypeCache: () => clearTypeCache,
   createAuthError: () => createAuthError,
   createHTTPServer: () => createHTTPServer,
   createProtectedResourceMetadata: () => createProtectedResourceMetadata,
@@ -1625,6 +1870,8 @@ __export(index_exports, {
   getDecoratedMethods: () => getDecoratedMethods,
   getMethodMetadata: () => getMethodMetadata,
   isAuthError: () => isAuthError,
+  parseClassTypesSync: () => parseClassTypesSync,
+  registerClassSource: () => registerClassSource,
   startMCPServer: () => startMCPServer,
   validateNonEmpty: () => validateNonEmpty,
   validatePath: () => validatePath,
@@ -1638,12 +1885,12 @@ async function startMCPServer(options) {
   await runtime.start();
   return runtime;
 }
-var import_reflect_metadata3, import_fs, import_path, import_url, import_server, import_stdio, import_types, import_ajv, ajv, MCPServer, MCPServerRuntime;
+var import_reflect_metadata3, import_fs3, import_path2, import_url, import_server, import_stdio, import_types, import_ajv, ajv, MCPServer, MCPServerRuntime;
 var init_index = __esm({
   "src/index.ts"() {
     import_reflect_metadata3 = require("reflect-metadata");
-    import_fs = __toESM(require("fs"));
-    import_path = __toESM(require("path"));
+    import_fs3 = __toESM(require("fs"));
+    import_path2 = __toESM(require("path"));
     import_url = require("url");
     import_server = require("@modelcontextprotocol/sdk/server/index.js");
     import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -1651,6 +1898,7 @@ var init_index = __esm({
     import_ajv = __toESM(require("ajv"));
     init_decorators();
     init_schema_generator();
+    init_type_parser();
     init_http_server();
     init_logger();
     init_validation();
@@ -1733,13 +1981,13 @@ var init_index = __esm({
           } else {
             const callerFile = this.getCallerFile();
             if (callerFile) {
-              const callerDir = import_path.default.dirname(callerFile);
-              mcpDir = import_path.default.join(callerDir, "mcp");
+              const callerDir = import_path2.default.dirname(callerFile);
+              mcpDir = import_path2.default.join(callerDir, "mcp");
             } else {
-              mcpDir = import_path.default.join(process.cwd(), "mcp");
+              mcpDir = import_path2.default.join(process.cwd(), "mcp");
             }
           }
-          if (import_fs.default.existsSync(mcpDir)) {
+          if (import_fs3.default.existsSync(mcpDir)) {
             this.logger.debug(`Auto-discovering services from: ${mcpDir}`);
             await this.autoRegisterServices(mcpDir, serviceFactories);
           } else {
@@ -1989,7 +2237,7 @@ var init_index = __esm({
       */
       async autoRegisterServices(mcpDir, serviceFactories) {
         this.logger.debug(`Auto-registering services from: ${mcpDir}`);
-        if (!import_fs.default.existsSync(mcpDir)) {
+        if (!import_fs3.default.existsSync(mcpDir)) {
           this.logger.warn(`MCP directory not found: ${mcpDir}`);
           return;
         }
@@ -2008,11 +2256,11 @@ var init_index = __esm({
       */
       findServiceFiles(dir) {
         const files = [];
-        const entries = import_fs.default.readdirSync(dir, {
+        const entries = import_fs3.default.readdirSync(dir, {
           withFileTypes: true
         });
         for (const entry of entries) {
-          const fullPath = import_path.default.join(dir, entry.name);
+          const fullPath = import_path2.default.join(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...this.findServiceFiles(fullPath));
           } else if (entry.isFile()) {
@@ -2043,7 +2291,7 @@ var init_index = __esm({
               }
               this.registerService(instance);
               registeredCount++;
-              this.logger.debug(`Registered service: ${exportName} from ${import_path.default.basename(filePath)}`);
+              this.logger.debug(`Registered service: ${exportName} from ${import_path2.default.basename(filePath)}`);
             } catch (error) {
               this.logger.warn(`Skipped ${exportName}: ${error.message}`);
             }
@@ -2142,8 +2390,8 @@ var init_index = __esm({
           return;
         }
         try {
-          const manifestPath = import_path.default.join(process.cwd(), "dist", "ui-manifest.json");
-          if (!import_fs.default.existsSync(manifestPath)) {
+          const manifestPath = import_path2.default.join(process.cwd(), "dist", "ui-manifest.json");
+          if (!import_fs3.default.existsSync(manifestPath)) {
             return;
           }
           if (this.logging) {
@@ -2185,8 +2433,8 @@ var init_index = __esm({
       */
       async reloadUIManifest() {
         try {
-          const manifestPath = import_path.default.join(process.cwd(), "dist", "ui-manifest.json");
-          if (!import_fs.default.existsSync(manifestPath)) {
+          const manifestPath = import_path2.default.join(process.cwd(), "dist", "ui-manifest.json");
+          if (!import_fs3.default.existsSync(manifestPath)) {
             const uiResourceUris = Array.from(this.resources.keys()).filter((uri) => uri.startsWith("ui://"));
             for (const uri of uiResourceUris) {
               this.resources.delete(uri);
@@ -2196,7 +2444,7 @@ var init_index = __esm({
             }
             return;
           }
-          const manifest = JSON.parse(import_fs.default.readFileSync(manifestPath, "utf-8"));
+          const manifest = JSON.parse(import_fs3.default.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) {
@@ -2212,7 +2460,7 @@ var init_index = __esm({
             const htmlPath = isString ? entry : entry.htmlPath;
             const isGPTApp = !isString && entry.isGPTApp;
             const gptMeta = !isString ? entry.gptMeta : void 0;
-            if (!import_fs.default.existsSync(htmlPath)) {
+            if (!import_fs3.default.existsSync(htmlPath)) {
               if (this.logging) {
                 this.logger.warn(`UI HTML file not found: ${htmlPath}`);
               }
@@ -2233,8 +2481,8 @@ var init_index = __esm({
               mimeType,
               inputSchema: void 0,
               method: /* @__PURE__ */ __name(async () => {
-                if (import_fs.default.existsSync(htmlPath)) {
-                  const html = import_fs.default.readFileSync(htmlPath, "utf-8");
+                if (import_fs3.default.existsSync(htmlPath)) {
+                  const html = import_fs3.default.readFileSync(htmlPath, "utf-8");
                   return {
                     text: html,
                     _meta: Object.keys(_meta).length > 0 ? _meta : void 0
@@ -2262,11 +2510,11 @@ var init_index = __esm({
       */
       async loadUIManifest() {
         try {
-          const manifestPath = import_path.default.join(process.cwd(), "dist", "ui-manifest.json");
-          if (!import_fs.default.existsSync(manifestPath)) {
+          const manifestPath = import_path2.default.join(process.cwd(), "dist", "ui-manifest.json");
+          if (!import_fs3.default.existsSync(manifestPath)) {
             return;
           }
-          const manifest = JSON.parse(import_fs.default.readFileSync(manifestPath, "utf-8"));
+          const manifest = JSON.parse(import_fs3.default.readFileSync(manifestPath, "utf-8"));
           for (const [uri, entry] of Object.entries(manifest)) {
             const isString = typeof entry === "string";
             const htmlPath = isString ? entry : entry.htmlPath;
@@ -2278,13 +2526,13 @@ var init_index = __esm({
               }
               continue;
             }
-            if (!import_fs.default.existsSync(htmlPath)) {
+            if (!import_fs3.default.existsSync(htmlPath)) {
               if (this.logging) {
                 this.logger.warn(`UI HTML file not found: ${htmlPath}`);
               }
               continue;
             }
-            const html = import_fs.default.readFileSync(htmlPath, "utf-8");
+            const html = import_fs3.default.readFileSync(htmlPath, "utf-8");
             const mimeType = isGPTApp ? "text/html+skybridge" : "text/html;profile=mcp-app";
             const _meta = {};
             if (isGPTApp) {
@@ -2535,19 +2783,19 @@ var init_index = __esm({
         });
       }
       async loadServices() {
-        const absPath = import_path.default.resolve(this.options.servicesDir);
-        if (!import_fs.default.existsSync(absPath)) {
+        const absPath = import_path2.default.resolve(this.options.servicesDir);
+        if (!import_fs3.default.existsSync(absPath)) {
           this.logger.error(`Services directory not found: ${absPath}`);
           return;
         }
-        const files = import_fs.default.readdirSync(absPath);
+        const files = import_fs3.default.readdirSync(absPath);
         let toolCount = 0;
         let promptCount = 0;
         let resourceCount = 0;
         for (const dir of files) {
-          const modulePath = import_path.default.join(absPath, dir, "index.ts");
-          const modulePathJs = import_path.default.join(absPath, dir, "index.js");
-          const finalPath = import_fs.default.existsSync(modulePath) ? modulePath : import_fs.default.existsSync(modulePathJs) ? modulePathJs : null;
+          const modulePath = import_path2.default.join(absPath, dir, "index.ts");
+          const modulePathJs = import_path2.default.join(absPath, dir, "index.js");
+          const finalPath = import_fs3.default.existsSync(modulePath) ? modulePath : import_fs3.default.existsSync(modulePathJs) ? modulePathJs : null;
           if (finalPath) {
             try {
               const fileUrl = (0, import_url.pathToFileURL)(finalPath).href;
@@ -2681,6 +2929,7 @@ init_index();
   UserEnvs,
   classToJsonSchema,
   classToJsonSchemaWithConstraints,
+  clearTypeCache,
   createAuthError,
   createHTTPServer,
   createProtectedResourceMetadata,
@@ -2689,6 +2938,8 @@ init_index();
   getDecoratedMethods,
   getMethodMetadata,
   isAuthError,
+  parseClassTypesSync,
+  registerClassSource,
   startMCPServer,
   validateNonEmpty,
   validatePath,