Merge pull request #3 from QuantGeekDev/feature/automatic-resource-detection

featL add resource autodiscovery

Author: QuantGeekDev

src/core/MCPServer.ts

@@ -13,45 +13,68 @@ import { logger } from "./Logger.js";
 export interface MCPServerConfig {
   name?: string;
   version?: string;
+  basePath?: string;
 }
 
+export type ServerCapabilities = {
+  tools?: {
+    enabled: true;
+  };
+  schemas?: {
+    enabled: true;
+  };
+  prompts?: {
+    enabled: true;
+  };
+};
+
 export class MCPServer {
   private server: Server;
   private toolsMap: Map<string, ToolProtocol> = new Map();
   private toolLoader: ToolLoader;
   private serverName: string;
   private serverVersion: string;
+  private basePath: string;
 
   constructor(config: MCPServerConfig = {}) {
+    this.basePath = this.resolveBasePath(config.basePath);
     this.serverName = config.name ?? this.getDefaultName();
     this.serverVersion = config.version ?? this.getDefaultVersion();
 
     logger.info(
       `Initializing MCP Server: ${this.serverName}@${this.serverVersion}`
     );
 
+    this.toolLoader = new ToolLoader(this.basePath);
+
     this.server = new Server(
       {
         name: this.serverName,
         version: this.serverVersion,
       },
       {
         capabilities: {
-          tools: {
-            enabled: true,
-          },
+          tools: { enabled: true },
         },
       }
     );
 
-    this.toolLoader = new ToolLoader();
     this.setupHandlers();
   }
 
+  private resolveBasePath(configPath?: string): string {
+    if (configPath) {
+      return configPath;
+    }
+    if (process.argv[1]) {
+      return process.argv[1];
+    }
+    return process.cwd();
+  }
+
   private readPackageJson(): any {
     try {
-      const mainModulePath = process.argv[1];
-      const packagePath = join(dirname(mainModulePath), "..", "package.json");
+      const packagePath = join(dirname(this.basePath), "package.json");
       const packageContent = readFileSync(packagePath, "utf-8");
       const packageJson = JSON.parse(packageContent);
       logger.debug(`Successfully read package.json from: ${packagePath}`);
@@ -63,27 +86,19 @@ export class MCPServer {
   }
 
   private getDefaultName(): string {
-    try {
-      const packageJson = this.readPackageJson();
-      if (packageJson?.name) {
-        logger.info(`Using name from package.json: ${packageJson.name}`);
-        return packageJson.name;
-      }
-    } catch (error) {
-      logger.warn(`Error getting name from package.json: ${error}`);
+    const packageJson = this.readPackageJson();
+    if (packageJson?.name) {
+      logger.info(`Using name from package.json: ${packageJson.name}`);
+      return packageJson.name;
     }
     return "unnamed-mcp-server";
   }
 
   private getDefaultVersion(): string {
-    try {
-      const packageJson = this.readPackageJson();
-      if (packageJson?.version) {
-        logger.info(`Using version from package.json: ${packageJson.version}`);
-        return packageJson.version;
-      }
-    } catch (error) {
-      logger.warn(`Error getting version from package.json: ${error}`);
+    const packageJson = this.readPackageJson();
+    if (packageJson?.version) {
+      logger.info(`Using version from package.json: ${packageJson.version}`);
+      return packageJson.version;
     }
     return "0.0.0";
   }
@@ -116,6 +131,21 @@ export class MCPServer {
     });
   }
 
+  private async detectCapabilities(): Promise<ServerCapabilities> {
+    const capabilities: ServerCapabilities = {};
+
+    //IK this is unecessary but it'll guide future schema and prompt capability autodiscovery
+
+    if (await this.toolLoader.hasTools()) {
+      capabilities.tools = { enabled: true };
+      logger.debug("Tools capability enabled");
+    } else {
+      logger.debug("No tools found, tools capability disabled");
+    }
+
+    return capabilities;
+  }
+
   async start() {
     try {
       const tools = await this.toolLoader.loadTools();
@@ -126,12 +156,18 @@ export class MCPServer {
       const transport = new StdioServerTransport();
       await this.server.connect(transport);
 
-      logger.info(
-        `Started ${this.serverName}@${this.serverVersion} with ${tools.length} tools`
-      );
-      logger.info(
-        `Available tools: ${Array.from(this.toolsMap.keys()).join(", ")}`
-      );
+      if (tools.length > 0) {
+        logger.info(
+          `Started ${this.serverName}@${this.serverVersion} with ${tools.length} tools`
+        );
+        logger.info(
+          `Available tools: ${Array.from(this.toolsMap.keys()).join(", ")}`
+        );
+      } else {
+        logger.info(
+          `Started ${this.serverName}@${this.serverVersion} with no tools`
+        );
+      }
     } catch (error) {
       logger.error(`Server initialization error: ${error}`);
       throw error;

src/core/toolLoader.ts

@@ -7,12 +7,30 @@ export class ToolLoader {
   private readonly TOOLS_DIR: string;
   private readonly EXCLUDED_FILES = ["BaseTool.js", "*.test.js", "*.spec.js"];
 
-  constructor() {
-    const mainModulePath = process.argv[1];
+  constructor(basePath?: string) {
+    const mainModulePath = basePath || process.argv[1];
     this.TOOLS_DIR = join(dirname(mainModulePath), "tools");
     logger.debug(`Initialized ToolLoader with directory: ${this.TOOLS_DIR}`);
   }
 
+  async hasTools(): Promise<boolean> {
+    try {
+      const stats = await fs.stat(this.TOOLS_DIR);
+      if (!stats.isDirectory()) {
+        logger.debug("Tools path exists but is not a directory");
+        return false;
+      }
+
+      const files = await fs.readdir(this.TOOLS_DIR);
+      const hasValidFiles = files.some((file) => this.isToolFile(file));
+      logger.debug(`Tools directory has valid files: ${hasValidFiles}`);
+      return hasValidFiles;
+    } catch (error) {
+      logger.debug("No tools directory found");
+      return false;
+    }
+  }
+
   private isToolFile(file: string): boolean {
     if (!file.endsWith(".js")) return false;
     const isExcluded = this.EXCLUDED_FILES.some((pattern) => {
@@ -54,7 +72,7 @@ export class ToolLoader {
       try {
         stats = await fs.stat(this.TOOLS_DIR);
       } catch (error) {
-        logger.error(`Error accessing tools directory: ${error}`);
+        logger.debug("No tools directory found");
         return [];
       }