mcp-devutils 1.3.0 → 1.4.0

package/README.md

@@ -1,70 +1,8 @@
 # mcp-devutils
 
-An MCP (Model Context Protocol) server with developer utilities. Use it directly with Claude Desktop, Cursor, or any MCP-compatible client.
+MCP server with **30 developer utilities** for Claude Desktop, Cursor, and any MCP-compatible AI assistant.
 
-## Tools
-
-| Tool | Description |
-|------|-------------|
-| `uuid` | Generate UUID v4 (up to 10 at once) |
-| `hash` | Hash text with md5, sha1, or sha256 |
-| `base64` | Encode or decode base64 |
-| `timestamp` | Convert between Unix timestamps and ISO 8601 |
-| `jwt_decode` | Decode JWT token payload (no verification) |
-| `random_string` | Generate random strings/passwords |
-| `url_encode` | URL encode or decode strings |
-| `json_format` | Pretty-print or minify JSON |
-| `regex_test` | Test regex patterns against strings |
-| `cron_explain` | Explain cron expressions in plain English + next 5 runs |
-| `hmac` | Generate HMAC signatures (SHA-256, SHA-512, etc.) |
-| `color_convert` | Convert colors between hex, RGB, and HSL |
-| `semver_compare` | Compare two semantic versions |
-| `http_status` | Look up HTTP status code meaning and usage |
-| `slug` | Generate URL-safe slugs from text |
-| `escape_html` | Escape or unescape HTML entities |
-| `chmod_calc` | Convert between numeric and symbolic Unix permissions |
-| `diff` | Compare two texts and show differences line by line |
-| `number_base` | Convert numbers between decimal, hex, octal, and binary |
-| `lorem_ipsum` | Generate placeholder lorem ipsum text |
-| `word_count` | Count characters, words, lines, and bytes in text |
-| `cidr` | Parse CIDR notation — network, broadcast, host range |
-| `case_convert` | Convert between camelCase, snake_case, PascalCase, kebab-case, CONSTANT_CASE, Title Case |
-| `markdown_toc` | Generate table of contents from markdown headings |
-
-## Installation
-
-```bash
-npm install -g mcp-devutils
-```
-
-Or use directly with `npx`:
-
-```json
-{
-  "mcpServers": {
-    "devutils": {
-      "command": "npx",
-      "args": ["-y", "mcp-devutils"]
-    }
-  }
-}
-```
-
-## Usage with Claude Desktop
-
-Add to your `claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "devutils": {
-      "command": "mcp-devutils"
-    }
-  }
-}
-```
-
-Or with npx (no install needed):
+## Install
 
 ```json
 {
@@ -77,162 +15,51 @@ Or with npx (no install needed):
 }
 ```
 
-## Usage with Cursor
+## Tools (30)
 
-Add to your Cursor MCP settings:
-
-```json
-{
-  "mcpServers": {
-    "devutils": {
-      "command": "npx",
-      "args": ["-y", "mcp-devutils"]
-    }
-  }
-}
-```
-
-## Tool Examples
-
-### uuid
-Generate one or more UUIDs:
-- `count`: Number of UUIDs to generate (1–10, default: 1)
-
-### hash
-Hash text with a chosen algorithm:
-- `text`: Text to hash (required)
-- `algorithm`: `md5`, `sha1`, or `sha256` (default: sha256)
-
-### base64
-Encode or decode base64:
-- `text`: Input text (required)
-- `action`: `encode` or `decode` (default: encode)
-
-### timestamp
-Convert timestamps:
-- `value`: Unix timestamp or ISO date string (leave empty for current time)
-
-### jwt_decode
-Decode a JWT without verifying the signature:
-- `token`: JWT string (required)
-- Returns header, payload, expiry info
-
-### random_string
-Generate random strings:
-- `length`: String length (default: 16, max: 256)
-- `charset`: `alphanumeric`, `alpha`, `numeric`, `hex`, `password`, or `url-safe`
-
-### url_encode
-Encode or decode URLs:
-- `text`: Input text (required)
-- `action`: `encode` or `decode` (default: encode)
-
-### json_format
-Format or minify JSON:
-- `json`: JSON string (required)
-- `action`: `format` or `minify` (default: format)
-- `indent`: Spaces for indentation (default: 2)
-
-### regex_test
-Test regex patterns:
-- `pattern`: Regex pattern (required)
-- `text`: String to test against (required)
-- `flags`: Regex flags like `g`, `i`, `gi` (optional)
-
-### cron_explain
-Explain a cron expression in plain English and show the next 5 scheduled runs:
-- `expression`: 5-field cron expression (required), e.g. `*/15 9-17 * * 1-5`
-
-### hmac
-Generate an HMAC signature:
-- `message`: Message to sign (required)
-- `key`: Secret key (required)
-- `algorithm`: `sha256`, `sha512`, `sha1`, or `md5` (default: sha256)
-- `encoding`: `hex` or `base64` (default: hex)
-
-### color_convert
-Convert colors between formats:
-- `color`: Color string (required) — accepts `#ff5733`, `rgb(255,87,51)`, or `hsl(11,100%,60%)`
-- Returns all three formats
-
-### semver_compare
-Compare two semantic versions:
-- `version1`: First version (required), e.g. `1.2.3`
-- `version2`: Second version (required), e.g. `2.0.0`
-- Returns comparison result and parsed components
-
-### http_status
-Look up HTTP status codes:
-- `code`: HTTP status code (required), e.g. `404`, `502`
-- Returns status name, category, and description
-
-### slug
-Generate URL-safe slugs:
-- `text`: Text to slugify (required)
-- `separator`: Word separator (default: `-`)
-
-### escape_html
-Escape or unescape HTML entities:
-- `text`: Input text (required)
-- `action`: `escape` or `unescape` (default: escape)
-
-### chmod_calc
-Convert Unix file permissions:
-- `permission`: Numeric (e.g. `755`) or symbolic (e.g. `rwxr-xr-x`) (required)
-- Returns both formats plus owner/group/other breakdown
-
-### diff
-Compare two texts:
-- `text1`: Original text (required)
-- `text2`: Modified text (required)
-- Returns line-by-line diff with added/removed/unchanged summary
-
-### number_base
-Convert numbers between bases:
-- `value`: Number string (required) — prefix `0x` for hex, `0o` for octal, `0b` for binary, or plain decimal
-- Returns decimal, hex, octal, and binary representations
-
-### lorem_ipsum
-Generate placeholder text:
-- `count`: Number of units (default: 1, max: 20)
-- `unit`: `paragraphs`, `sentences`, or `words` (default: paragraphs)
-
-### word_count
-Analyze text:
-- `text`: Input text (required)
-- Returns character count, word count, line count, and byte size
-
-### cidr
-Parse CIDR notation:
-- `notation`: CIDR string (required), e.g. `192.168.1.0/24`
-- Returns network, netmask, broadcast, host range, total hosts
-
-### case_convert
-Convert between naming conventions:
-- `text`: Input text (required), e.g. `myVariableName` or `my-variable-name`
-- `to`: Target case (required) — `camel`, `snake`, `pascal`, `kebab`, `constant`, or `title`
-- Returns converted text plus all format variants
+| Tool | Description |
+|------|-------------|
+| `uuid` | Generate UUID v4 (batch support) |
+| `hash` | Hash text (md5, sha1, sha256) |
+| `base64` | Encode/decode base64 |
+| `timestamp` | Convert Unix ↔ ISO 8601 dates |
+| `jwt_decode` | Decode JWT tokens (header + payload) |
+| `random_string` | Generate random strings/passwords |
+| `url_encode` | URL encode/decode |
+| `json_format` | Pretty-print or minify JSON |
+| `regex_test` | Test regex patterns with match details |
+| `cron_explain` | Explain cron expressions + next run times |
+| `hmac` | Generate HMAC signatures |
+| `color_convert` | Convert hex ↔ RGB ↔ HSL colors |
+| `semver_compare` | Compare semantic versions |
+| `http_status` | Look up HTTP status code meanings |
+| `slug` | Generate URL-safe slugs |
+| `escape_html` | Escape/unescape HTML entities |
+| `chmod_calc` | Convert numeric ↔ symbolic permissions |
+| `diff` | Compare two text strings |
+| `number_base` | Convert decimal/hex/octal/binary |
+| `lorem_ipsum` | Generate placeholder text |
+| `word_count` | Count chars, words, lines, bytes |
+| `cidr` | Parse CIDR notation (network, broadcast, hosts) |
+| `case_convert` | Convert camelCase/snake_case/PascalCase/kebab-case |
+| `markdown_toc` | Generate table of contents from markdown |
+| `env_parse` | Parse and validate .env files |
+| `ip_info` | Analyze IP addresses (type, class, private/public) |
+| `password_strength` | Analyze password entropy and strength |
+| `data_size` | Convert between bytes/KB/MB/GB/TB (SI + IEC) |
+| `string_escape` | Escape strings for JSON/CSV/regex/SQL/shell |
+
+## Zero dependencies
+
+Only requires `@modelcontextprotocol/sdk`. All tools use Node.js built-ins.
 
-### markdown_toc
-Generate a table of contents:
-- `markdown`: Markdown text (required)
-- `max_depth`: Maximum heading level to include (default: 3)
-- Returns formatted TOC with anchor links
+## Support
 
-## See Also
+If this tool saves you time, consider supporting development:
 
-- [mcp-apitools](https://www.npmjs.com/package/mcp-apitools) — 8 API & web dev utilities: HTTP status codes, MIME types, JWT creation, mock data, CORS headers, cookie parsing
-- [mcp-texttools](https://www.npmjs.com/package/mcp-texttools) — 10 text transformation tools: case convert, slugify, word count, lorem ipsum, regex replace, markdown strip
-- [mcp-mathtools](https://www.npmjs.com/package/mcp-mathtools) — 12 math & statistics tools: arithmetic, statistics, unit conversion, financial calculations, matrices
-- [mcp-datetime](https://www.npmjs.com/package/mcp-datetime) — 10 date & time tools: timezone conversion, date math, cron explanation, business days
-- [mcp-quick-calc](https://www.npmjs.com/package/mcp-quick-calc) — 5 calculator tools: currency conversion, percentages, compound interest, unit conversion, loan payments
-- **[mcp-all-tools](https://www.npmjs.com/package/mcp-all-tools)** — All 54+ tools in a single MCP server
+- [Buy me a coffee](https://buymeacoffee.com/gl89tu25lp)
+- [Tip via Stripe ($3)](https://buy.stripe.com/dRm8wP8R295Z9VyeN59Zm00)
 
 ## License
 
-MIT — [Hong Teoh](https://github.com/hlteoh37)
-
-## Support
-
-If this tool saves you time, consider buying me a coffee:
-[buymeacoffee.com/gl89tu25lp](https://buymeacoffee.com/gl89tu25lp)
+MIT

package/index.js

@@ -5,7 +5,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprot
 import crypto from "crypto";
 
 const server = new Server(
-  { name: "mcp-devutils", version: "1.3.0" },
+  { name: "mcp-devutils", version: "1.4.0" },
   { capabilities: { tools: {} } }
 );
 
@@ -335,6 +335,76 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ["markdown"]
         }
+      },
+      {
+        name: "env_parse",
+        description: "Parse and validate .env file contents — shows keys, detects issues like missing values, duplicate keys, or invalid lines",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string", description: ".env file content to parse and validate" }
+          },
+          required: ["content"]
+        }
+      },
+      {
+        name: "ip_info",
+        description: "Parse and analyze an IP address — shows type (IPv4/IPv6), class, whether private/public/loopback/link-local",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ip: { type: "string", description: "IP address to analyze (e.g. '192.168.1.1' or '::1')" }
+          },
+          required: ["ip"]
+        }
+      },
+      {
+        name: "password_strength",
+        description: "Analyze password strength — calculates entropy, checks length, character diversity, and common patterns",
+        inputSchema: {
+          type: "object",
+          properties: {
+            password: { type: "string", description: "Password to analyze" }
+          },
+          required: ["password"]
+        }
+      },
+      {
+        name: "data_size",
+        description: "Convert between data size units (bytes, KB, MB, GB, TB, PB) with both decimal (SI) and binary (IEC) representations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            value: { type: "number", description: "Numeric value to convert" },
+            unit: {
+              type: "string",
+              enum: ["B", "KB", "MB", "GB", "TB", "PB", "KiB", "MiB", "GiB", "TiB", "PiB"],
+              description: "Source unit (default: B for bytes)"
+            }
+          },
+          required: ["value"]
+        }
+      },
+      {
+        name: "string_escape",
+        description: "Escape or unescape strings for various contexts: JSON, CSV, regex, SQL, or shell",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to escape or unescape" },
+            format: {
+              type: "string",
+              enum: ["json", "csv", "regex", "sql", "shell"],
+              description: "Target format to escape for"
+            },
+            action: {
+              type: "string",
+              enum: ["escape", "unescape"],
+              description: "Action: escape or unescape (default: escape)"
+            }
+          },
+          required: ["text", "format"]
+        }
       }
     ]
   };
@@ -1032,6 +1102,210 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: [{ type: "text", text: toc.join("\n") }] };
       }
 
+      case "env_parse": {
+        const { content } = args;
+        const lines = content.split("\n");
+        const keys = [];
+        const issues = [];
+        const seen = new Set();
+        lines.forEach((line, i) => {
+          const num = i + 1;
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) return;
+          const eqIdx = trimmed.indexOf("=");
+          if (eqIdx === -1) {
+            issues.push(`Line ${num}: Invalid format (no '=' found): ${trimmed}`);
+            return;
+          }
+          const key = trimmed.substring(0, eqIdx).trim();
+          const val = trimmed.substring(eqIdx + 1).trim();
+          if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+            issues.push(`Line ${num}: Invalid key name '${key}'`);
+          }
+          if (seen.has(key)) {
+            issues.push(`Line ${num}: Duplicate key '${key}'`);
+          }
+          seen.add(key);
+          if (!val) {
+            issues.push(`Line ${num}: Empty value for '${key}'`);
+          }
+          keys.push({ key, value: val.length > 50 ? val.substring(0, 50) + "..." : val, line: num });
+        });
+        const output = [`Parsed ${keys.length} key(s) from ${lines.length} line(s)`];
+        if (keys.length > 0) {
+          output.push("\nKeys:");
+          keys.forEach(k => output.push(`  ${k.key} = ${k.value} (line ${k.line})`));
+        }
+        if (issues.length > 0) {
+          output.push(`\n⚠ ${issues.length} issue(s):`);
+          issues.forEach(i => output.push(`  ${i}`));
+        } else {
+          output.push("\n✓ No issues found");
+        }
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "ip_info": {
+        const { ip } = args;
+        const trimmed = ip.trim();
+        const output = [];
+        if (trimmed.includes(":")) {
+          output.push(`IP: ${trimmed}`);
+          output.push(`Version: IPv6`);
+          if (trimmed === "::1") output.push("Type: Loopback");
+          else if (trimmed.startsWith("fe80:")) output.push("Type: Link-local");
+          else if (trimmed.startsWith("fc") || trimmed.startsWith("fd")) output.push("Type: Unique local (private)");
+          else if (trimmed.startsWith("ff")) output.push("Type: Multicast");
+          else if (trimmed === "::") output.push("Type: Unspecified");
+          else output.push("Type: Global unicast (public)");
+        } else {
+          const parts = trimmed.split(".");
+          if (parts.length !== 4 || parts.some(p => isNaN(p) || +p < 0 || +p > 255)) {
+            throw new Error(`Invalid IPv4 address: ${trimmed}`);
+          }
+          const octets = parts.map(Number);
+          output.push(`IP: ${trimmed}`);
+          output.push(`Version: IPv4`);
+          output.push(`Binary: ${octets.map(o => o.toString(2).padStart(8, "0")).join(".")}`);
+          if (octets[0] === 127) output.push("Type: Loopback");
+          else if (octets[0] === 10) output.push("Type: Private (10.0.0.0/8, Class A)");
+          else if (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) output.push("Type: Private (172.16.0.0/12, Class B)");
+          else if (octets[0] === 192 && octets[1] === 168) output.push("Type: Private (192.168.0.0/16, Class C)");
+          else if (octets[0] === 169 && octets[1] === 254) output.push("Type: Link-local (APIPA)");
+          else if (octets[0] >= 224 && octets[0] <= 239) output.push("Type: Multicast");
+          else if (octets[0] >= 240) output.push("Type: Reserved");
+          else output.push("Type: Public");
+          if (octets[0] < 128) output.push("Class: A");
+          else if (octets[0] < 192) output.push("Class: B");
+          else if (octets[0] < 224) output.push("Class: C");
+          else if (octets[0] < 240) output.push("Class: D (Multicast)");
+          else output.push("Class: E (Reserved)");
+        }
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "password_strength": {
+        const { password } = args;
+        const len = password.length;
+        let charsetSize = 0;
+        if (/[a-z]/.test(password)) charsetSize += 26;
+        if (/[A-Z]/.test(password)) charsetSize += 26;
+        if (/[0-9]/.test(password)) charsetSize += 10;
+        if (/[^a-zA-Z0-9]/.test(password)) charsetSize += 32;
+        const entropy = Math.round(len * Math.log2(charsetSize || 1) * 100) / 100;
+        const issues = [];
+        if (len < 8) issues.push("Too short (< 8 characters)");
+        if (!/[A-Z]/.test(password)) issues.push("No uppercase letters");
+        if (!/[a-z]/.test(password)) issues.push("No lowercase letters");
+        if (!/[0-9]/.test(password)) issues.push("No digits");
+        if (!/[^a-zA-Z0-9]/.test(password)) issues.push("No special characters");
+        if (/(.)\1{2,}/.test(password)) issues.push("Contains repeated characters (3+)");
+        if (/^(123|abc|qwerty|password|admin|letmein)/i.test(password)) issues.push("Starts with common pattern");
+        let strength;
+        if (entropy < 28) strength = "Very Weak";
+        else if (entropy < 36) strength = "Weak";
+        else if (entropy < 60) strength = "Moderate";
+        else if (entropy < 80) strength = "Strong";
+        else strength = "Very Strong";
+        const output = [
+          `Password length: ${len}`,
+          `Charset size: ${charsetSize}`,
+          `Entropy: ${entropy} bits`,
+          `Strength: ${strength}`,
+        ];
+        if (issues.length > 0) {
+          output.push(`\nIssues (${issues.length}):`);
+          issues.forEach(i => output.push(`  - ${i}`));
+        } else {
+          output.push("\n✓ No issues detected");
+        }
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "data_size": {
+        const { value, unit = "B" } = args;
+        const units = {
+          B: 1, KB: 1e3, MB: 1e6, GB: 1e9, TB: 1e12, PB: 1e15,
+          KiB: 1024, MiB: 1048576, GiB: 1073741824, TiB: 1099511627776, PiB: 1125899906842624
+        };
+        if (!units[unit]) throw new Error(`Unknown unit: ${unit}. Use: ${Object.keys(units).join(", ")}`);
+        const bytes = value * units[unit];
+        const fmt = (n) => n < 0.01 ? n.toExponential(2) : (n % 1 === 0 ? n.toString() : n.toFixed(2));
+        const output = [
+          `Input: ${value} ${unit} = ${fmt(bytes)} bytes`,
+          "",
+          "Decimal (SI):",
+          `  ${fmt(bytes)} B`,
+          `  ${fmt(bytes / 1e3)} KB`,
+          `  ${fmt(bytes / 1e6)} MB`,
+          `  ${fmt(bytes / 1e9)} GB`,
+          `  ${fmt(bytes / 1e12)} TB`,
+          `  ${fmt(bytes / 1e15)} PB`,
+          "",
+          "Binary (IEC):",
+          `  ${fmt(bytes)} B`,
+          `  ${fmt(bytes / 1024)} KiB`,
+          `  ${fmt(bytes / 1048576)} MiB`,
+          `  ${fmt(bytes / 1073741824)} GiB`,
+          `  ${fmt(bytes / 1099511627776)} TiB`,
+          `  ${fmt(bytes / 1125899906842624)} PiB`,
+        ];
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "string_escape": {
+        const { text, format, action = "escape" } = args;
+        let result;
+        if (action === "escape") {
+          switch (format) {
+            case "json":
+              result = JSON.stringify(text).slice(1, -1);
+              break;
+            case "csv":
+              result = text.includes(",") || text.includes('"') || text.includes("\n")
+                ? '"' + text.replace(/"/g, '""') + '"'
+                : text;
+              break;
+            case "regex":
+              result = text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+              break;
+            case "sql":
+              result = text.replace(/'/g, "''");
+              break;
+            case "shell":
+              result = "'" + text.replace(/'/g, "'\\''") + "'";
+              break;
+            default:
+              throw new Error(`Unknown format: ${format}`);
+          }
+        } else {
+          switch (format) {
+            case "json":
+              result = JSON.parse(`"${text}"`);
+              break;
+            case "csv":
+              result = text.startsWith('"') && text.endsWith('"')
+                ? text.slice(1, -1).replace(/""/g, '"')
+                : text;
+              break;
+            case "regex":
+              result = text.replace(/\\([.*+?^${}()|[\]\\])/g, "$1");
+              break;
+            case "sql":
+              result = text.replace(/''/g, "'");
+              break;
+            case "shell":
+              result = text.startsWith("'") && text.endsWith("'")
+                ? text.slice(1, -1).replace(/'\\''/g, "'")
+                : text;
+              break;
+            default:
+              throw new Error(`Unknown format: ${format}`);
+          }
+        }
+        return { content: [{ type: "text", text: result }] };
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-devutils",
-  "version": "1.3.0",
-  "description": "MCP server with 25 developer utilities - UUID, hash, HMAC, base64, timestamps, JWT decode, random strings, URL encode/decode, JSON format, regex test, cron explain, color convert, semver compare, HTTP status codes, slugify, HTML escape, chmod calculator, text diff, number base converter, lorem ipsum, word count, CIDR calculator, case converter, markdown TOC",
+  "version": "1.4.0",
+  "description": "MCP server with 30 developer utilities - UUID, hash, HMAC, base64, timestamps, JWT decode, random strings, URL encode/decode, JSON format, regex test, cron explain, color convert, semver compare, HTTP status codes, slugify, HTML escape, chmod calculator, text diff, number base converter, lorem ipsum, word count, CIDR calculator, case converter, markdown TOC, env parser, IP info, password strength, data size converter, string escape",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -36,7 +36,12 @@
     "word-count",
     "cidr",
     "case-convert",
-    "markdown-toc"
+    "markdown-toc",
+    "env-parser",
+    "ip-address",
+    "password-strength",
+    "data-size",
+    "string-escape"
   ],
   "author": "Hong Teoh",
   "license": "MIT",
@@ -46,5 +51,13 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hlteoh37/mcp-devutils.git"
+  },
+  "homepage": "https://github.com/hlteoh37/mcp-devutils#readme",
+  "bugs": {
+    "url": "https://github.com/hlteoh37/mcp-devutils/issues"
   }
 }