mcp-devutils 1.1.5 → 1.3.0

package/README.md

@@ -19,6 +19,17 @@ An MCP (Model Context Protocol) server with developer utilities. Use it directly
 | `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
 
@@ -150,6 +161,64 @@ Compare two semantic versions:
 - `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
+
+### 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
+
 ## See Also
 
 - [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

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.1.0" },
+  { name: "mcp-devutils", version: "1.3.0" },
   { capabilities: { tools: {} } }
 );
 
@@ -197,6 +197,144 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ["version1", "version2"]
         }
+      },
+      {
+        name: "http_status",
+        description: "Look up HTTP status code meaning, category, and common usage",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: { type: "number", description: "HTTP status code (e.g. 404, 502)" }
+          },
+          required: ["code"]
+        }
+      },
+      {
+        name: "slug",
+        description: "Generate a URL-safe slug from text",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to slugify" },
+            separator: { type: "string", description: "Word separator (default: '-')" }
+          },
+          required: ["text"]
+        }
+      },
+      {
+        name: "escape_html",
+        description: "Escape or unescape HTML entities",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to escape or unescape" },
+            action: {
+              type: "string",
+              enum: ["escape", "unescape"],
+              description: "Action: escape or unescape (default: escape)"
+            }
+          },
+          required: ["text"]
+        }
+      },
+      {
+        name: "chmod_calc",
+        description: "Convert between numeric and symbolic Unix file permissions (e.g. 755 ↔ rwxr-xr-x)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            permission: { type: "string", description: "Numeric (e.g. '755') or symbolic (e.g. 'rwxr-xr-x') permission" }
+          },
+          required: ["permission"]
+        }
+      },
+      {
+        name: "diff",
+        description: "Compare two text strings and show the differences line by line",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text1: { type: "string", description: "First text (original)" },
+            text2: { type: "string", description: "Second text (modified)" }
+          },
+          required: ["text1", "text2"]
+        }
+      },
+      {
+        name: "number_base",
+        description: "Convert numbers between decimal, hexadecimal, octal, and binary",
+        inputSchema: {
+          type: "object",
+          properties: {
+            value: { type: "string", description: "Number to convert (prefix with 0x for hex, 0o for octal, 0b for binary, or plain decimal)" }
+          },
+          required: ["value"]
+        }
+      },
+      {
+        name: "lorem_ipsum",
+        description: "Generate placeholder lorem ipsum text",
+        inputSchema: {
+          type: "object",
+          properties: {
+            count: { type: "number", description: "Number of units to generate (default: 1)" },
+            unit: {
+              type: "string",
+              enum: ["paragraphs", "sentences", "words"],
+              description: "Unit type (default: paragraphs)"
+            }
+          }
+        }
+      },
+      {
+        name: "word_count",
+        description: "Count characters, words, lines, and bytes in text",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to analyze" }
+          },
+          required: ["text"]
+        }
+      },
+      {
+        name: "cidr",
+        description: "Parse CIDR notation and show network address, broadcast, host range, and number of hosts",
+        inputSchema: {
+          type: "object",
+          properties: {
+            notation: { type: "string", description: "CIDR notation (e.g. '192.168.1.0/24')" }
+          },
+          required: ["notation"]
+        }
+      },
+      {
+        name: "case_convert",
+        description: "Convert text between camelCase, snake_case, PascalCase, kebab-case, CONSTANT_CASE, and Title Case",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to convert (e.g. 'myVariableName' or 'my-variable-name')" },
+            to: {
+              type: "string",
+              enum: ["camel", "snake", "pascal", "kebab", "constant", "title"],
+              description: "Target case format"
+            }
+          },
+          required: ["text", "to"]
+        }
+      },
+      {
+        name: "markdown_toc",
+        description: "Generate a table of contents from markdown headings",
+        inputSchema: {
+          type: "object",
+          properties: {
+            markdown: { type: "string", description: "Markdown text to extract headings from" },
+            max_depth: { type: "number", description: "Maximum heading depth to include (default: 3)" }
+          },
+          required: ["markdown"]
+        }
       }
     ]
   };
@@ -578,6 +716,322 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      case "http_status": {
+        const { code } = args;
+        const statuses = {
+          100: ["Continue", "Informational", "The server has received the request headers and the client should proceed to send the request body."],
+          101: ["Switching Protocols", "Informational", "The server is switching protocols as requested by the client (e.g. to WebSocket)."],
+          200: ["OK", "Success", "The request succeeded. Standard response for successful HTTP requests."],
+          201: ["Created", "Success", "The request succeeded and a new resource was created. Typical for POST requests."],
+          202: ["Accepted", "Success", "The request has been accepted for processing, but processing is not complete."],
+          204: ["No Content", "Success", "The request succeeded but there is no content to return. Common for DELETE requests."],
+          301: ["Moved Permanently", "Redirection", "The resource has been permanently moved to a new URL. Clients should update bookmarks."],
+          302: ["Found", "Redirection", "The resource temporarily resides at a different URL. Client should continue using the original URL."],
+          304: ["Not Modified", "Redirection", "The resource has not been modified since the last request. Used for caching."],
+          307: ["Temporary Redirect", "Redirection", "The request should be repeated with the same method at a different URL."],
+          308: ["Permanent Redirect", "Redirection", "The resource has permanently moved. The request method should not change."],
+          400: ["Bad Request", "Client Error", "The server cannot process the request due to malformed syntax or invalid parameters."],
+          401: ["Unauthorized", "Client Error", "Authentication is required. The client must provide valid credentials."],
+          403: ["Forbidden", "Client Error", "The server understood the request but refuses to authorize it. Authentication won't help."],
+          404: ["Not Found", "Client Error", "The requested resource could not be found on the server."],
+          405: ["Method Not Allowed", "Client Error", "The HTTP method is not allowed for the requested resource."],
+          408: ["Request Timeout", "Client Error", "The server timed out waiting for the request from the client."],
+          409: ["Conflict", "Client Error", "The request conflicts with the current state of the resource. Common in concurrent updates."],
+          410: ["Gone", "Client Error", "The resource is no longer available and no forwarding address is known."],
+          413: ["Payload Too Large", "Client Error", "The request body exceeds the server's size limit."],
+          415: ["Unsupported Media Type", "Client Error", "The server does not support the media type of the request body."],
+          422: ["Unprocessable Entity", "Client Error", "The request was well-formed but semantically invalid. Common in validation errors."],
+          429: ["Too Many Requests", "Client Error", "The client has sent too many requests in a given time period (rate limiting)."],
+          500: ["Internal Server Error", "Server Error", "An unexpected condition was encountered on the server."],
+          501: ["Not Implemented", "Server Error", "The server does not support the functionality required to fulfill the request."],
+          502: ["Bad Gateway", "Server Error", "The server received an invalid response from an upstream server."],
+          503: ["Service Unavailable", "Server Error", "The server is temporarily unable to handle the request (overload or maintenance)."],
+          504: ["Gateway Timeout", "Server Error", "The server did not receive a timely response from an upstream server."]
+        };
+        const info = statuses[code];
+        if (!info) {
+          const category = code >= 100 && code < 200 ? "Informational" : code < 300 ? "Success" : code < 400 ? "Redirection" : code < 500 ? "Client Error" : code < 600 ? "Server Error" : "Unknown";
+          return { content: [{ type: "text", text: `${code}: Unknown status code\nCategory: ${category}` }] };
+        }
+        return {
+          content: [{ type: "text", text: `${code} ${info[0]}\nCategory: ${info[1]}\nDescription: ${info[2]}` }]
+        };
+      }
+
+      case "slug": {
+        const { text, separator = "-" } = args;
+        const slug = text.toLowerCase()
+          .normalize("NFD").replace(/[\u0300-\u036f]/g, "")
+          .replace(/[^a-z0-9\s-]/g, "")
+          .trim()
+          .replace(/[\s-]+/g, separator);
+        return { content: [{ type: "text", text: slug }] };
+      }
+
+      case "escape_html": {
+        const { text, action = "escape" } = args;
+        let result;
+        if (action === "escape") {
+          result = text
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#39;");
+        } else {
+          result = text
+            .replace(/&#39;/g, "'")
+            .replace(/&quot;/g, '"')
+            .replace(/&gt;/g, ">")
+            .replace(/&lt;/g, "<")
+            .replace(/&amp;/g, "&");
+        }
+        return { content: [{ type: "text", text: result }] };
+      }
+
+      case "chmod_calc": {
+        const { permission } = args;
+        const numericMatch = permission.match(/^[0-7]{3,4}$/);
+        const symbolicMatch = permission.match(/^([r-][w-][xsS-])([r-][w-][xsS-])([r-][w-][xtT-])$/);
+
+        if (numericMatch) {
+          const digits = permission.length === 4 ? permission : "0" + permission;
+          const special = parseInt(digits[0]);
+          const owner = parseInt(digits[1]);
+          const group = parseInt(digits[2]);
+          const other = parseInt(digits[3]);
+
+          function toSymbolic(val, pos, specialBit) {
+            let r = (val & 4) ? "r" : "-";
+            let w = (val & 2) ? "w" : "-";
+            let x = (val & 1) ? "x" : "-";
+            if (specialBit) {
+              if (pos === "owner" && (special & 4)) x = (val & 1) ? "s" : "S";
+              if (pos === "group" && (special & 2)) x = (val & 1) ? "s" : "S";
+              if (pos === "other" && (special & 1)) x = (val & 1) ? "t" : "T";
+            }
+            return r + w + x;
+          }
+
+          const sym = toSymbolic(owner, "owner", true) + toSymbolic(group, "group", true) + toSymbolic(other, "other", true);
+          const desc = [];
+          desc.push(`Numeric: ${permission}`);
+          desc.push(`Symbolic: ${sym}`);
+          desc.push(`Owner: ${["---","--x","-w-","-wx","r--","r-x","rw-","rwx"][owner]} (${owner})`);
+          desc.push(`Group: ${["---","--x","-w-","-wx","r--","r-x","rw-","rwx"][group]} (${group})`);
+          desc.push(`Other: ${["---","--x","-w-","-wx","r--","r-x","rw-","rwx"][other]} (${other})`);
+          return { content: [{ type: "text", text: desc.join("\n") }] };
+        } else if (symbolicMatch) {
+          function fromSymbolic(s) {
+            let val = 0;
+            if (s[0] === "r") val += 4;
+            if (s[1] === "w") val += 2;
+            if (s[2] === "x" || s[2] === "s" || s[2] === "t") val += 1;
+            return val;
+          }
+          const o = fromSymbolic(symbolicMatch[1]);
+          const g = fromSymbolic(symbolicMatch[2]);
+          const t = fromSymbolic(symbolicMatch[3]);
+          const numeric = `${o}${g}${t}`;
+          return { content: [{ type: "text", text: `Symbolic: ${permission}\nNumeric: ${numeric}\nOwner: ${o}, Group: ${g}, Other: ${t}` }] };
+        } else {
+          throw new Error("Invalid permission. Use numeric (e.g. '755') or symbolic (e.g. 'rwxr-xr-x')");
+        }
+      }
+
+      case "diff": {
+        const { text1, text2 } = args;
+        const lines1 = text1.split("\n");
+        const lines2 = text2.split("\n");
+        const output = [];
+        const maxLen = Math.max(lines1.length, lines2.length);
+
+        // Simple line-by-line diff
+        let added = 0, removed = 0, unchanged = 0;
+        for (let i = 0; i < maxLen; i++) {
+          const l1 = i < lines1.length ? lines1[i] : undefined;
+          const l2 = i < lines2.length ? lines2[i] : undefined;
+          if (l1 === l2) {
+            output.push(`  ${l1}`);
+            unchanged++;
+          } else {
+            if (l1 !== undefined) { output.push(`- ${l1}`); removed++; }
+            if (l2 !== undefined) { output.push(`+ ${l2}`); added++; }
+          }
+        }
+
+        const summary = `\n--- Summary: ${added} added, ${removed} removed, ${unchanged} unchanged`;
+        return { content: [{ type: "text", text: output.join("\n") + summary }] };
+      }
+
+      case "number_base": {
+        const { value } = args;
+        let num;
+        const v = value.trim();
+        if (v.startsWith("0x") || v.startsWith("0X")) num = parseInt(v, 16);
+        else if (v.startsWith("0o") || v.startsWith("0O")) num = parseInt(v.slice(2), 8);
+        else if (v.startsWith("0b") || v.startsWith("0B")) num = parseInt(v.slice(2), 2);
+        else num = parseInt(v, 10);
+        if (isNaN(num)) throw new Error(`Invalid number: ${value}`);
+        const output = [
+          `Decimal:     ${num}`,
+          `Hexadecimal: 0x${num.toString(16).toUpperCase()}`,
+          `Octal:       0o${num.toString(8)}`,
+          `Binary:      0b${num.toString(2)}`
+        ];
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "lorem_ipsum": {
+        const { count = 1, unit = "paragraphs" } = args || {};
+        const sentences = [
+          "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+          "Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+          "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris.",
+          "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore.",
+          "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia.",
+          "Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit.",
+          "Neque porro quisquam est qui dolorem ipsum quia dolor sit amet.",
+          "Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit.",
+          "Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse.",
+          "At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis."
+        ];
+        const n = Math.min(Math.max(1, count), 20);
+        let result;
+        if (unit === "words") {
+          const allWords = sentences.join(" ").split(/\s+/);
+          const words = [];
+          for (let i = 0; i < n; i++) words.push(allWords[i % allWords.length]);
+          result = words.join(" ");
+        } else if (unit === "sentences") {
+          const out = [];
+          for (let i = 0; i < n; i++) out.push(sentences[i % sentences.length]);
+          result = out.join(" ");
+        } else {
+          const paras = [];
+          for (let i = 0; i < n; i++) {
+            const start = (i * 3) % sentences.length;
+            const para = [];
+            for (let j = 0; j < 5; j++) para.push(sentences[(start + j) % sentences.length]);
+            paras.push(para.join(" "));
+          }
+          result = paras.join("\n\n");
+        }
+        return { content: [{ type: "text", text: result }] };
+      }
+
+      case "word_count": {
+        const { text } = args;
+        const chars = text.length;
+        const charsNoSpaces = text.replace(/\s/g, "").length;
+        const words = text.trim() === "" ? 0 : text.trim().split(/\s+/).length;
+        const lines = text.split("\n").length;
+        const bytes = Buffer.byteLength(text, "utf8");
+        const output = [
+          `Characters: ${chars}`,
+          `Characters (no spaces): ${charsNoSpaces}`,
+          `Words: ${words}`,
+          `Lines: ${lines}`,
+          `Bytes (UTF-8): ${bytes}`
+        ];
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "cidr": {
+        const { notation } = args;
+        const match = notation.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)\/(\d+)$/);
+        if (!match) throw new Error("Invalid CIDR notation. Use format: 192.168.1.0/24");
+        const octets = [parseInt(match[1]), parseInt(match[2]), parseInt(match[3]), parseInt(match[4])];
+        const prefix = parseInt(match[5]);
+        if (octets.some(o => o < 0 || o > 255) || prefix < 0 || prefix > 32) {
+          throw new Error("Invalid IP address or prefix length");
+        }
+        const ip = ((octets[0] << 24) | (octets[1] << 16) | (octets[2] << 8) | octets[3]) >>> 0;
+        const mask = prefix === 0 ? 0 : (~0 << (32 - prefix)) >>> 0;
+        const network = (ip & mask) >>> 0;
+        const broadcast = (network | ~mask) >>> 0;
+        const firstHost = prefix >= 31 ? network : (network + 1) >>> 0;
+        const lastHost = prefix >= 31 ? broadcast : (broadcast - 1) >>> 0;
+        const hostCount = prefix >= 31 ? (prefix === 32 ? 1 : 2) : Math.pow(2, 32 - prefix) - 2;
+        const toIP = (n) => `${(n >>> 24) & 255}.${(n >>> 16) & 255}.${(n >>> 8) & 255}.${n & 255}`;
+        const output = [
+          `CIDR: ${notation}`,
+          `Network: ${toIP(network)}`,
+          `Netmask: ${toIP(mask)}`,
+          `Broadcast: ${toIP(broadcast)}`,
+          `First host: ${toIP(firstHost)}`,
+          `Last host: ${toIP(lastHost)}`,
+          `Total hosts: ${hostCount}`,
+          `Prefix length: /${prefix}`
+        ];
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "case_convert": {
+        const { text, to } = args;
+        // Split input into words regardless of input format
+        const words = text
+          .replace(/([a-z])([A-Z])/g, "$1 $2") // camelCase splits
+          .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2") // ABCDef -> ABC Def
+          .replace(/[-_]/g, " ")
+          .split(/\s+/)
+          .filter(w => w.length > 0)
+          .map(w => w.toLowerCase());
+        let result;
+        switch (to) {
+          case "camel":
+            result = words[0] + words.slice(1).map(w => w[0].toUpperCase() + w.slice(1)).join("");
+            break;
+          case "pascal":
+            result = words.map(w => w[0].toUpperCase() + w.slice(1)).join("");
+            break;
+          case "snake":
+            result = words.join("_");
+            break;
+          case "kebab":
+            result = words.join("-");
+            break;
+          case "constant":
+            result = words.map(w => w.toUpperCase()).join("_");
+            break;
+          case "title":
+            result = words.map(w => w[0].toUpperCase() + w.slice(1)).join(" ");
+            break;
+          default:
+            throw new Error(`Unknown case: ${to}`);
+        }
+        const all = {
+          camelCase: words[0] + words.slice(1).map(w => w[0].toUpperCase() + w.slice(1)).join(""),
+          PascalCase: words.map(w => w[0].toUpperCase() + w.slice(1)).join(""),
+          snake_case: words.join("_"),
+          "kebab-case": words.join("-"),
+          CONSTANT_CASE: words.map(w => w.toUpperCase()).join("_"),
+          "Title Case": words.map(w => w[0].toUpperCase() + w.slice(1)).join(" ")
+        };
+        const output = [`Result: ${result}`, "", "All formats:"];
+        for (const [k, v] of Object.entries(all)) output.push(`  ${k}: ${v}`);
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "markdown_toc": {
+        const { markdown, max_depth = 3 } = args;
+        const lines = markdown.split("\n");
+        const toc = [];
+        for (const line of lines) {
+          const match = line.match(/^(#{1,6})\s+(.+)$/);
+          if (match) {
+            const level = match[1].length;
+            if (level > max_depth) continue;
+            const text = match[2].replace(/[*_`\[\]]/g, "").trim();
+            const anchor = text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-");
+            const indent = "  ".repeat(level - 1);
+            toc.push(`${indent}- [${text}](#${anchor})`);
+          }
+        }
+        if (toc.length === 0) return { content: [{ type: "text", text: "No headings found." }] };
+        return { content: [{ type: "text", text: toc.join("\n") }] };
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-devutils",
-  "version": "1.1.5",
-  "description": "MCP server with 13 developer utilities - UUID, hash, HMAC, base64, timestamps, JWT decode, random strings, URL encode/decode, JSON format, regex test, cron explain, color convert, semver compare",
+  "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",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -24,7 +24,19 @@
     "cursor",
     "cron",
     "color-convert",
-    "semver"
+    "semver",
+    "http-status",
+    "slugify",
+    "html-escape",
+    "chmod",
+    "diff",
+    "permissions",
+    "number-base",
+    "lorem-ipsum",
+    "word-count",
+    "cidr",
+    "case-convert",
+    "markdown-toc"
   ],
   "author": "Hong Teoh",
   "license": "MIT",