feat: make toolLoader load tools automatically

Author: QuantGeekDev

package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-framework",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Framework for building Model Context Protocol (MCP) servers in Typescript",
   "type": "module",
   "author": "Alex Andru <alex@andru.codes>",

src/core/Logger.ts

@@ -11,15 +11,13 @@ export class Logger {
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     const logDir = "logs";
 
-    // Ensure logs directory exists
     mkdir(logDir, { recursive: true }).catch((err) => {
       process.stderr.write(`Failed to create logs directory: ${err}\n`);
     });
 
     this.logFilePath = join(logDir, `mcp-server-${timestamp}.log`);
     this.logStream = createWriteStream(this.logFilePath, { flags: "a" });
 
-    // Handle process termination
     process.on("exit", () => this.close());
     process.on("SIGINT", () => this.close());
     process.on("SIGTERM", () => this.close());
@@ -47,7 +45,7 @@ export class Logger {
   }
 
   public log(message: string): void {
-    this.info(message); // Alias for info
+    this.info(message);
   }
 
   public error(message: string): void {

src/core/MCPServer.ts

@@ -4,14 +4,12 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import { ToolLoader, ToolLoaderOptions } from "./toolLoader.js";
+import { ToolLoader } from "./toolLoader.js";
 import { BaseTool } from "../tools/BaseTool.js";
 
 export interface MCPServerConfig {
   name: string;
   version: string;
-  toolsDir?: string;
-  excludeTools?: string[];
 }
 
 export class MCPServer {
@@ -34,11 +32,7 @@ export class MCPServer {
       }
     );
 
-    this.toolLoader = new ToolLoader({
-      toolsDir: config.toolsDir,
-      exclude: config.excludeTools,
-    });
-
+    this.toolLoader = new ToolLoader();
     this.setupHandlers();
   }
 
@@ -72,7 +66,6 @@ export class MCPServer {
       const transport = new StdioServerTransport();
       await this.server.connect(transport);
 
-      // Write errors to stderr instead of stdout
       process.stderr.write(`Server started with ${tools.length} tools\n`);
     } catch (error) {
       process.stderr.write(`Server initialization error: ${error}\n`);

src/core/toolLoader.ts

@@ -1,67 +1,21 @@
 import { BaseTool } from "../tools/BaseTool.js";
-import { dirname, join } from "path";
+import { join, dirname } from "path";
 import { promises as fs } from "fs";
-import { statSync } from "fs";
-import { fileURLToPath } from "url";
-import { cwd } from "process";
 import { logger } from "./Logger.js";
 
-export interface ToolLoaderOptions {
-  toolsDir?: string;
-  exclude?: string[];
-}
-
 export class ToolLoader {
-  private toolsDir: string;
-  private exclude: string[];
+  private readonly TOOLS_DIR: string;
+  private readonly EXCLUDED_FILES = ["BaseTool.js", "*.test.js", "*.spec.js"];
 
-  constructor(options: ToolLoaderOptions = {}) {
-    this.exclude = options.exclude || ["BaseTool.js", "*.test.js", "*.spec.js"];
-    this.toolsDir = this.resolveToolsDir(options.toolsDir);
-    logger.debug(`Initialized ToolLoader with directory: ${this.toolsDir}`);
-  }
-
-  private resolveToolsDir(toolsDir?: string): string {
-    if (toolsDir) {
-      logger.debug(`Using provided tools directory: ${toolsDir}`);
-      return toolsDir;
-    }
-
-    const currentFilePath = fileURLToPath(import.meta.url);
-    const currentDir = dirname(currentFilePath);
-    const possiblePaths = [
-      join(currentDir, "..", "tools"),
-      join(currentDir, "..", "..", "tools"),
-      join(cwd(), "dist", "tools"),
-      join(cwd(), "build", "tools"),
-      join(cwd(), "tools"),
-    ];
-
-    logger.debug(
-      `Searching for tools in possible paths:\n${possiblePaths.join("\n")}`
-    );
-
-    for (const path of possiblePaths) {
-      try {
-        if (statSync(path).isDirectory()) {
-          logger.debug(`Found existing tools directory: ${path}`);
-          return path;
-        }
-      } catch (e) {
-        logger.debug(`Path ${path} not accessible`);
-      }
-    }
-
-    const fallbackPath = join(cwd(), "dist", "tools");
-    logger.debug(
-      `No valid tools directory found, falling back to: ${fallbackPath}`
-    );
-    return fallbackPath;
+  constructor() {
+    const mainModulePath = process.argv[1];
+    this.TOOLS_DIR = join(dirname(mainModulePath), "tools");
+    logger.debug(`Initialized ToolLoader with directory: ${this.TOOLS_DIR}`);
   }
 
   private isToolFile(file: string): boolean {
     if (!file.endsWith(".js")) return false;
-    const isExcluded = this.exclude.some((pattern) => {
+    const isExcluded = this.EXCLUDED_FILES.some((pattern) => {
       if (pattern.includes("*")) {
         const regex = new RegExp(pattern.replace("*", ".*"));
         return regex.test(file);
@@ -94,22 +48,22 @@ export class ToolLoader {
 
   async loadTools(): Promise<BaseTool[]> {
     try {
-      logger.debug(`Attempting to load tools from: ${this.toolsDir}`);
+      logger.debug(`Attempting to load tools from: ${this.TOOLS_DIR}`);
 
       let stats;
       try {
-        stats = await fs.stat(this.toolsDir);
+        stats = await fs.stat(this.TOOLS_DIR);
       } catch (error) {
         logger.error(`Error accessing tools directory: ${error}`);
         return [];
       }
 
       if (!stats.isDirectory()) {
-        logger.error(`Path is not a directory: ${this.toolsDir}`);
+        logger.error(`Path is not a directory: ${this.TOOLS_DIR}`);
         return [];
       }
 
-      const files = await fs.readdir(this.toolsDir);
+      const files = await fs.readdir(this.TOOLS_DIR);
       logger.debug(`Found files in directory: ${files.join(", ")}`);
 
       const tools: BaseTool[] = [];
@@ -120,7 +74,7 @@ export class ToolLoader {
         }
 
         try {
-          const fullPath = join(this.toolsDir, file);
+          const fullPath = join(this.TOOLS_DIR, file);
           logger.debug(`Attempting to load tool from: ${fullPath}`);
 
           const importPath = `file://${fullPath}`;

src/index.ts

@@ -1,3 +1,3 @@
 export { MCPServer, type MCPServerConfig } from "./core/MCPServer.js";
 export { BaseTool, BaseToolImplementation } from "./tools/BaseTool.js";
-export { ToolLoader, type ToolLoaderOptions } from "./core/toolLoader.js";
+export { ToolLoader } from "./core/toolLoader.js";