it-tools-mcp 3.2.10 → 3.2.12

package/README.dockerhub.md

@@ -11,7 +11,7 @@
 [![Docker Platform](https://img.shields.io/badge/platform-linux%2Famd64%20%7C%20linux%2Farm64-blue)](https://hub.docker.com/r/wrenchpilot/it-tools-mcp)
 [![GitHub Stars](https://img.shields.io/github/stars/wrenchpilot/it-tools-mcp?style=social)](https://github.com/wrenchpilot/it-tools-mcp/stargazers)
 
-A comprehensive Model Context Protocol (MCP) server that provides access to **112 IT tools and utilities** commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
+A comprehensive Model Context Protocol (MCP) server that provides access to over **100 IT tools and utilities** commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
 
 ## Using with VS Code
 
@@ -62,7 +62,7 @@ Add to your VS Code `settings.json`:
 }
 ```
 
-See the complete list of all 112 tools with detailed parameters on [GitHub](https://github.com/wrenchpilot/it-tools-mcp#available-tools)
+See the complete list of tools with detailed parameters on [GitHub](https://github.com/wrenchpilot/it-tools-mcp#available-tools)
 
 ## 📸 Examples in Action
 

package/README.md

@@ -14,17 +14,24 @@
 
 > **📝 Note**: A condensed version of this README is automatically synced to [Docker Hub](https://hub.docker.com/r/wrenchpilot/it-tools-mcp) due to character limits.
 
-A comprehensive Model Context Protocol (MCP) server that provides access to 112 IT tools and utilities commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
+A comprehensive Model Context Protocol (MCP) server that provides access to over 100 IT tools and utilities commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
 
 ## 📦 Installation & Setup
 
 ### Using with VS Code
 
-**[Install IT Tools MCP in VS Code](vscode:mcp/install?%7B%22name%22%3A%22it-tools-mcp%22%2C%22gallery%22%3Atrue%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22it-tools-mcp%22%5D%7D)**
+**Quick Install:**
 
-*Click the link above in VS Code to install the IT Tools MCP server.*
+[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=it-tools&config=%7B%22command%22%3A%20%22npx%22%2C%22args%22%3A%20%5B%22it-tools-mcp%22%5D%7D) [![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_Server-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=it-tools&config=%7B%22command%22%3A%20%22npx%22%2C%22args%22%3A%20%5B%22it-tools-mcp%22%5D%7D&quality=insiders)
 
-Add to your VS Code `settings.json`:
+**Install:**
+
+1. Open VS Code
+2. Press `Ctrl+Shift+P` (or `Cmd+Shift+P` on Mac)
+3. Type "MCP" and select "MCP: Add Server"
+4. Choose "NPM Package" and enter: `it-tools-mcp`
+
+**Or manually add to your VS Code `settings.json`:**
 
 #### Node
 
@@ -89,7 +96,7 @@ echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"base64-enc
 
 ## 🛠️ Tool Categories
 
-This MCP server provides **112 tools** across **14 categories**:
+This MCP server provides over **100 tools** across **14 categories**:
 
 - **� Ansible Tools** (5 tools): Vault encryption/decryption, inventory parser, playbook validator, reference
 - **🎨 Color Tools** (2 tools): Hex ↔ RGB conversion
@@ -258,14 +265,14 @@ Built with **TypeScript**, **Zod** validation, and **MCP SDK** for robust, type-
 This project was developed using **VS Code**, **Copilot Chat Agent**, **Playwright MCP**, and the **Claude Sonnet 4 Model**, demonstrating the power of AI-assisted software development:
 
 - **Intelligent Code Generation**: Claude Sonnet analyzed requirements and generated comprehensive tool implementations
-- **Schema Validation**: Automatically identified and resolved JSON schema validation issues across 112 tools
+- **Schema Validation**: Automatically identified and resolved JSON schema validation issues across tools
 - **Docker Optimization**: Created production-ready Docker workflows and multi-stage builds
 - **Documentation**: Generated comprehensive README with examples and tool reference tables
 - **Testing**: Implemented robust error handling and validation throughout the codebase
 
 **Key AI Contributions:**
 
-- 🔧 **Tool Implementation**: All 112 tools designed and implemented with AI assistance
+- 🔧 **Tool Implementation**: All tools designed and implemented with AI assistance
 - 📦 **Docker Setup**: Complete containerization with GitHub Actions CI/CD pipeline
 - 🔍 **Schema Cleanup**: Systematic removal of unsupported Zod keywords from all tool definitions
 - 📚 **Documentation**: Comprehensive README with usage examples and tool catalogs

package/build/index.js

@@ -208,17 +208,27 @@ export const SECURITY_HEADERS = {
     'Referrer-Policy': 'strict-origin-when-cross-origin',
 };
 // Helper to read version from package.json at runtime (ESM compatible)
-function getPackageVersion() {
-    // Use import.meta.url to get the directory in ESM
+// Get package metadata for enhanced server info
+function getPackageMetadata() {
     const __dirname = path.dirname(new URL(import.meta.url).pathname);
     const pkgPath = path.resolve(__dirname, '../package.json');
     const pkgRaw = fs.readFileSync(pkgPath, 'utf-8');
-    return JSON.parse(pkgRaw).version;
+    const pkg = JSON.parse(pkgRaw);
+    return {
+        name: pkg.name,
+        version: pkg.version,
+        description: pkg.description,
+        keywords: pkg.keywords,
+        author: pkg.author,
+        repository: pkg.repository,
+        homepage: pkg.homepage
+    };
 }
-// Create server instance
+// Create server instance with enhanced metadata
+const packageInfo = getPackageMetadata();
 const server = new McpServer({
     name: "it-tools-mcp",
-    version: getPackageVersion(),
+    version: packageInfo.version,
     capabilities: {
         resources: {},
         tools: {},
@@ -257,14 +267,181 @@ async function loadModularTools(server, category) {
         }
     }
 }
-// Register all tool modules (dynamically for faster startup, with per-module timing)
+// Dynamic tool discovery and metadata generation
+async function discoverTools() {
+    const toolsBaseDir = path.join(__dirname, 'tools');
+    if (!fs.existsSync(toolsBaseDir)) {
+        return { toolCategories: {}, totalToolCount: 0 };
+    }
+    // Discover categories dynamically from the filesystem
+    const categories = fs.readdirSync(toolsBaseDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+        .sort(); // Sort for consistent ordering
+    const toolCategories = {};
+    let totalToolCount = 0;
+    for (const category of categories) {
+        const toolsDir = path.join(toolsBaseDir, category);
+        const toolDirs = fs.readdirSync(toolsDir, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name)
+            .sort(); // Sort tools within category
+        if (toolDirs.length > 0) {
+            toolCategories[category] = {
+                description: await getCategoryDescription(category, toolDirs),
+                tools: toolDirs
+            };
+            totalToolCount += toolDirs.length;
+        }
+    }
+    return { toolCategories, totalToolCount };
+}
+// Generate category description by examining actual tool metadata
+async function getCategoryDescription(category, toolNames) {
+    const toolsDir = path.join(__dirname, 'tools', category);
+    const toolDescriptions = [];
+    // Try to extract descriptions from a few sample tools in the category
+    const samplesToCheck = Math.min(3, toolNames.length); // Check up to 3 tools for description
+    for (let i = 0; i < samplesToCheck; i++) {
+        const toolDir = toolNames[i];
+        const toolPath = path.join(toolsDir, toolDir, 'index.js');
+        if (fs.existsSync(toolPath)) {
+            try {
+                const toolModule = await import(`./${path.relative(__dirname, toolPath).replace(/\\/g, '/')}`);
+                // Look for description in the tool registration
+                const registerFunction = Object.values(toolModule).find((fn) => typeof fn === 'function' && fn.name.startsWith('register'));
+                if (registerFunction) {
+                    // Create a mock server to capture the tool registration
+                    const mockServer = {
+                        registerTool: (name, config) => {
+                            if (config.description && typeof config.description === 'string') {
+                                toolDescriptions.push(config.description);
+                            }
+                        }
+                    };
+                    try {
+                        registerFunction(mockServer);
+                    }
+                    catch (error) {
+                        // Ignore errors in mock registration
+                    }
+                }
+            }
+            catch (error) {
+                // Continue if we can't load a tool
+            }
+        }
+    }
+    // Generate category description based on collected tool descriptions
+    if (toolDescriptions.length > 0) {
+        // Create a summary from the actual tool descriptions
+        const uniqueDescriptions = [...new Set(toolDescriptions)];
+        if (uniqueDescriptions.length === 1) {
+            // If all tools have the same description, use it directly
+            return uniqueDescriptions[0];
+        }
+        else if (uniqueDescriptions.length <= 3) {
+            // If we have 2-3 unique descriptions, combine them
+            return `${category.charAt(0).toUpperCase() + category.slice(1)} tools: ${uniqueDescriptions.join(', ')}`;
+        }
+        else {
+            // If we have many descriptions, provide a generic summary
+            return `${category.charAt(0).toUpperCase() + category.slice(1)} category with ${toolNames.length} tools including: ${uniqueDescriptions.slice(0, 2).join(', ')} and more`;
+        }
+    }
+    // Fallback: generate description from category name and tool count
+    const categoryTitle = category.charAt(0).toUpperCase() + category.slice(1);
+    return `${categoryTitle} tools and utilities (${toolNames.length} tools available)`;
+}
+// Register server info tool with dynamic metadata
+server.registerTool("server-info", {
+    description: "Get comprehensive information about the IT Tools MCP server, including available tool categories, version, and capabilities",
+    inputSchema: {
+        include_tools: z.boolean().optional().describe("Include detailed information about all available tools"),
+        category: z.string().optional().describe("Get information about a specific category (dynamically discovered)")
+    }
+}, async (args) => {
+    const { include_tools = false, category } = args;
+    // Discover tools dynamically
+    const { toolCategories, totalToolCount } = await discoverTools();
+    // Get system info
+    const systemInfo = {
+        timestamp: new Date().toISOString(),
+        platform: process.platform,
+        nodeVersion: process.version,
+        memoryUsage: process.memoryUsage(),
+        uptime: process.uptime()
+    };
+    // Server metadata from package.json
+    const serverMetadata = {
+        name: "IT Tools MCP Server",
+        version: packageInfo.version,
+        description: packageInfo.description,
+        author: packageInfo.author,
+        repository: packageInfo.repository?.url,
+        homepage: packageInfo.homepage,
+        keywords: packageInfo.keywords,
+        protocol: "Model Context Protocol (MCP)",
+        transport: "stdio"
+    };
+    const baseResult = {
+        server: serverMetadata,
+        system: systemInfo,
+        categories: Object.keys(toolCategories).length,
+        totalTools: totalToolCount,
+        installation: {
+            vscode: "Use VS Code install button in README or manual configuration",
+            claude: "Add to claude_desktop_config.json",
+            npm: `npm install -g ${packageInfo.name}`
+        }
+    };
+    let result = baseResult;
+    // Add category-specific information
+    if (category && toolCategories[category]) {
+        result = {
+            ...result,
+            categoryDetails: {
+                name: category,
+                ...toolCategories[category]
+            }
+        };
+    }
+    else if (!category) {
+        result = {
+            ...result,
+            availableCategories: toolCategories
+        };
+    }
+    // Include detailed tool information if requested
+    if (include_tools) {
+        result = {
+            ...result,
+            toolsBreakdown: Object.entries(toolCategories).map(([cat, info]) => ({
+                category: cat,
+                count: info.tools.length,
+                tools: info.tools
+            }))
+        };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }]
+    };
+});
+// Register all tools dynamically by discovering categories from filesystem
 async function registerAllTools(server) {
-    // All categories to load modularly
-    const categories = [
-        'docker', 'ansible', 'color', 'encoding', 'idGenerators',
-        'crypto', 'dataFormat', 'text', 'network', 'math',
-        'utility', 'development', 'forensic', 'physics'
-    ];
+    const toolsBaseDir = path.join(__dirname, 'tools');
+    if (!fs.existsSync(toolsBaseDir)) {
+        console.warn('Tools directory does not exist:', toolsBaseDir);
+        return;
+    }
+    // Discover categories dynamically from the filesystem
+    const categories = fs.readdirSync(toolsBaseDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+        .sort(); // Sort for consistent ordering
     for (const category of categories) {
         await loadModularTools(server, category);
     }
@@ -278,7 +455,7 @@ server.tool("system-info", "Get system resource usage and server information", {
                 type: "text",
                 text: JSON.stringify({
                     server: "IT Tools MCP Server",
-                    version: getPackageVersion(),
+                    version: packageInfo.version,
                     uptime: `${Math.floor(usage.uptimeSeconds)} seconds`,
                     memory: usage.memory,
                     timestamp: new Date().toISOString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "it-tools-mcp",
-  "version": "3.2.10",
+  "version": "3.2.12",
   "description": "MCP server providing access to various IT tools and utilities for developers",
   "type": "module",
   "main": "./build/index.js",