open-index/open-npm huggingface dataset:
npm package: @roflsec/dice-coefficient
Description: Sørensen–Dice coefficient for strings with CLI
Author: roflsec
Latest version: 1.0.1

# dice-coefficient

Sørensen–Dice coefficient for strings, with CLI and Node.js export.

## Usage CLI
dice-coefficient "string1" "string2" [--raw|-r] [--percent|-p]

## Usage Node.js
const { diceCoefficient } = require('dice-coefficient');
console.log(diceCoefficient("Context","Contact"));
npm package: @roflsec/dnspoofer
Description: DNSpoofer est un module Node.js pour effectuer du DNS spoofing en batch ou continu, avec multicores et stats live. Utile pour solidifier une infrastructure. ---
Author: roflsec
Latest version: 1.0.3

# DNSpoofer CLI

DNSpoofer est un module Node.js pour effectuer du DNS spoofing en batch ou continu, avec multicores et stats live.
Utile pour solidifier une infrastructure.
---

## Installation depuis npm
```
npm i -g @roflsec/dnspoofer
```

ou

## Installation depuis github

```
git clone <repo>
cd DNSpoofer
npm install
npm link
```

> La commande CLI globale \`dnspoofer\` est maintenant disponible.

---

## Commandes

### Spoof simple
```
dnspoofer -server=192.168.0.1 -domain=example.com --test
```

### Spoof avec custom DNS
```
dnspoofer -server=192.168.0.1 -domain=example.com -dns=custom.json
```

### Options avancées
- `--workers=N` : nombre de workers (par défaut = nombre de cores CPU)
- `--interval=ms` : délai entre cycles de spoof pour chaque worker (par défaut = 0)
- `--test` : mode test !

Exemple :
```
dnspoofer -server=192.168.0.1 -domain=example.com -dns=custom.json --workers=4 --interval=1000 --test
```

---

## Fonctionnalités en test

- Multicores continu et stats live toutes les 5 secondes  
- Queue circulaire pour chaque DNS, pas de répétition avant utilisation de tous  
- Fusion automatique `freeDNS.json` + custom
- Compatible Termux, Debian, Ubuntu, Windows

Lulz
npm package: @roflsec/fail2scan
Description: Fail2Scan daemon - watches fail2ban logs and scans banned IPs using nmap, dig and whois.
Author: RoflSecurity
Latest version: 0.0.23



---

Fail2Scan

Fail2Scan is a Node.js daemon that watches your Fail2Ban logs for banned IP addresses and automatically scans them using system tools (nmap, dig, whois). All results are saved in a structured folder for easy review.


---

Features

Watches Fail2Ban logs in real time.

Detects new banned IPs automatically.

Runs nmap for full port scanning.

Runs dig for reverse DNS lookup.

Runs whois for IP ownership and ASN info.

Saves output in /var/log/fail2scan/<YYYY-MM-DD>/<IP>_<timestamp>/.

Pure Node.js, no external dependencies, works with Node 18+.

Compatible with PM2 or any process manager.



---

Installation

# Install globally
sudo npm install -g @roflsec/fail2scan


---

Usage

# Start daemon (default settings)
fail2scan-daemon

# Custom log file, output directory, concurrency, nmap arguments, quiet mode
fail2scan-daemon --log /var/log/fail2ban.log --out /var/log/fail2scan --concurrency 2 --nmap-args "-sS -Pn -p- -T4 -sV" --quiet

CLI Options

Option	Default	Description

--log	/var/log/fail2ban.log	Path to your Fail2Ban log file.
--out	/var/log/fail2scan	Output directory for scan results.
--concurrency	1	Number of scans to run in parallel.
--nmap-args	-sS -Pn -p- -T4 -sV	Arguments to pass to nmap.
--quiet	false	Suppress console output.
--help / -h		Show usage info.



---

Output Structure

Results are saved in this format:

/var/log/fail2scan/
└─ 2025-10-12/
   └─ 192.168.1.100_2025-10-12T14-30-00Z/
      ├─ nmap.txt      # raw nmap output
      ├─ dig.txt       # raw dig output
      ├─ whois.txt     # raw whois output
      └─ summary.json  # JSON summary of scan results

summary.json includes:

ip – scanned IP

timestamp – ISO timestamp of scan

commands – details of each scan (nmap, dig, whois)

open_ports – array of open ports detected by nmap



---

Requirements

Node.js 18+

System tools installed: nmap, dig, whois

Permissions to read Fail2Ban logs and write to the output directory


# Debian/Ubuntu example
sudo apt install nmap dnsutils whois


---

Running with PM2

# Start daemon with PM2
pm2 start $(which fail2scan-daemon) -- --log /var/log/fail2ban.log --out /var/log/fail2scan
pm2 save
pm2 status


---

License

MIT © RoflSec
npm package: @roflsec/splitit
Description: CLI pour télécharger et séparer les pistes audio de vidéos YouTube (plug-n-play, multi-OS, Termux supporté)
Author: RoflSecurity
Latest version: 1.0.30

# ![SplitIt Logo](./misc/logo.png) SplitIt 🎵💥

**Author:** RoflSec  
**Version:** `0.0.10`  <!-- dynamically updated by clean.sh -->

---
<!-- project size: 63.60 MB -->

## Installation 🌍

**From NPM (global):**
```bash
npm install -g @roflsec/splitit
```
**From GitHub:**
```
git clone https://github.com/RoflSecurity/Splitit
cd Splitit
npm i -g .
```
> ✅ Now splitit is globally available, wherever you run it.




---

What is this? 🤔

SplitIt is your ultimate music tool to separate audio tracks from any YouTube URL.

🎹 Stems (vocals & instrumental) for Windows/Linux/Mac

📱 Termux-friendly: just MP3 + WAV to avoid headaches


No more fuss with Spleeter, Docker, or broken paths.


---

Usage 🚀
```
splitit "<YouTube URL>"
```
Example:
```
splitit "https://youtu.be/SJjBXzSc-IA?feature=shared"
```
Termux → MP3 download + WAV conversion only

Windows/Linux/Mac → Full Spleeter separation (2–3 stems depending on mode)


Output: 0 files in output/
The output folder is created in the current working directory and contains your processed audio files.


---

Architecture 🏗️

splitit/
├─ bin/                     # CLI wrapper
│  └─ splitit
├─ scripts/                 # Main scripts
│  ├─ cli.js                # Node CLI
│  ├─ download.sh           # Download + convert audio
│  ├─ spleeter-launcher.py  # Spleeter wrapper
│  ├─ install-binaries.js   # Install necessary binaries
│  └─ clean.sh              # Dev cleanup & README version bump
├─ output/                  # Audio output
├─ misc/                    # Logo etc.
├─ package.json
└─ README.md


---

Tips & Tricks 💡

npm run clean → cleans the repo & updates README version automatically

chmod +x bin/splitit if you get permission errors

Spleeter is optional on Termux → no errors if missing



---

Lulz Status 😎

Plug’n’play for Windows/Linux/Mac

Termux supported without Spleeter

Author: RoflSec, the reference for robust infra protection & testing


---
npm package: @rog0x/mcp-a11y-tools
Description: Web accessibility analysis tools for AI agents via MCP
Latest version: 1.0.2

# mcp-a11y-tools

Web accessibility analysis tools for AI agents, served over the Model Context Protocol (MCP).

## Tools

### check_alt_text
Analyze images in HTML for missing, empty, or low-quality alt text.
- Detects missing `alt` attributes
- Identifies decorative images (`alt=""` with `role="presentation"`)
- Flags low-quality alt text (e.g., "image", "photo", filenames)
- Checks linked images, `<input type="image">`, and `<area>` elements

### check_heading_hierarchy
Validate heading structure for proper nesting and content quality.
- Verifies h1-h6 order with no skipped levels
- Ensures a single `<h1>` per page
- Detects empty, too-short, or too-long headings
- Supports `role="heading"` with `aria-level`
- Returns a visual tree of the heading outline

### check_color_contrast
Check WCAG 2.x contrast ratio for foreground/background color pairs.
- Calculates precise contrast ratio per WCAG relative luminance formula
- Reports AA and AAA compliance for normal and large text
- Accepts hex (`#fff`, `#ffffff`), `rgb(r,g,b)`, and named colors

### validate_aria
Validate ARIA attributes on HTML elements.
- Detects invalid ARIA roles
- Checks for missing required ARIA properties per role
- Flags redundant ARIA roles that match native semantics
- Warns about `aria-label` on non-interactive elements
- Catches `aria-hidden="true"` on focusable elements

### check_form_accessibility
Audit form elements for accessibility compliance.
- Verifies every input has an associated label (explicit, implicit, or ARIA)
- Checks radio/checkbox groups for `<fieldset>` and `<legend>`
- Flags placeholder text used as the only label
- Suggests `autocomplete` attributes for personal info fields
- Detects duplicate IDs that break label association

## Setup

```bash
npm install
npm run build
```

## Usage with Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "a11y-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-a11y-tools/dist/index.js"]
    }
  }
}
```

## License

MIT
npm package: @rog0x/mcp-api-tools
Description: HTTP/API testing tools for AI agents via MCP
Latest version: 1.0.2

# @rog0x/mcp-api-tools

HTTP/API testing tools for AI agents, built on the [Model Context Protocol](https://modelcontextprotocol.io).

## Tools

### `http_request`
Make any HTTP request (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS) with full control over headers, body, authentication, and timeouts. Returns status code, response headers, body, and timing information.

### `api_health`
Check the health of multiple API endpoints in parallel. Returns HTTP status, response time, SSL certificate validity and expiry, and optional response body validation. Includes a summary with counts of healthy, unhealthy, and errored endpoints.

### `jwt_decode`
Decode a JWT token without cryptographic verification. Returns the decoded header and payload, issued-at time, expiry time, and whether the token is currently expired.

### `url_parse`
Parse a URL into its component parts (protocol, host, port, path, query parameters, hash) or build a URL from individual parts.

### `header_analyzer`
Analyze HTTP response headers for security posture (HSTS, CSP, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy), caching directives, CORS configuration, and cookie attributes. Provides a letter grade for security. Can fetch headers from a live URL or analyze a provided headers object.

## Installation

```bash
npm install
npm run build
```

## Configuration

### Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "api-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-api-tools/dist/index.js"]
    }
  }
}
```

### Claude Code

```bash
claude mcp add api-tools node D:/products/mcp-servers/mcp-api-tools/dist/index.js
```

## Examples

**Make a POST request:**
```
Use http_request to POST to https://httpbin.org/post with JSON body {"key": "value"}
```

**Check API health:**
```
Use api_health to check these endpoints: https://api.github.com, https://httpbin.org/get
```

**Decode a JWT:**
```
Use jwt_decode to decode this token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
```

**Parse a URL:**
```
Use url_parse to break down https://example.com:8080/api/v1?key=value&debug=true#section
```

**Analyze security headers:**
```
Use header_analyzer to check security headers for https://github.com
```

## License

MIT
npm package: @rog0x/mcp-cache-tools
Description: Caching and memoization tools for AI agents — MCP server #30
Latest version: 1.0.2

# @rog0x/mcp-cache-tools

**MCP Server #30** — Caching and memoization tools for AI agents.

Analyze, generate, simulate, and optimize caching strategies across HTTP, CDN, and browser layers.

## Tools

### 1. `analyze_cache_headers`
Analyze HTTP cache headers (Cache-Control, ETag, Last-Modified, Expires, Vary). Grades the overall caching strategy A+ through F and provides actionable improvement suggestions with context-aware advice for static assets, API responses, HTML pages, and media.

### 2. `generate_cache_key`
Generate deterministic cache keys from various inputs:
- **URL mode** — normalizes URL, sorts query params, filters include/exclude params
- **Body mode** — hashes request body with JSON key sorting for consistency
- **Composite mode** — combines multiple key parts into a single deterministic hash

Supports namespacing, versioning, TTL, and outputs ready-to-use Redis/Memcached commands.

### 3. `simulate_cache`
Simulate cache behavior for a sequence of requests. Compare eviction strategies side-by-side:
- **LRU** — Least Recently Used
- **LFU** — Least Frequently Used
- **FIFO** — First In, First Out
- **TTL** — Time-To-Live based expiration

Outputs hit rate, miss rate, eviction count, and step-by-step timeline.

### 4. `check_cdn_headers`
Detect which CDN is serving a resource from response headers. Identifies Cloudflare, Fastly, Akamai, CloudFront, Vercel, Netlify, Google Cloud CDN, Azure CDN, KeyCDN, and Bunny CDN. Reports cache status (HIT/MISS/STALE/BYPASS), edge server, and POP location.

### 5. `analyze_browser_cache`
Analyze what resources a page would cache in the browser. Determines cache type (strong, heuristic, conditional, none), duration, revalidation strategy, and estimates bandwidth/time savings on repeat visits. Groups results by resource type with optimization suggestions.

## Setup

```bash
npm install
npm run build
```

## MCP Configuration

```json
{
  "mcpServers": {
    "mcp-cache-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-cache-tools/dist/index.js"]
    }
  }
}
```

## License

MIT
npm package: @rog0x/mcp-color-tools
Description: MCP server providing color manipulation and design tools for AI agents
Author: rog0x
Latest version: 1.0.1

# mcp-color-tools

MCP server providing color manipulation and design tools for AI agents.

## Tools

### color_convert

Convert a color between HEX, RGB, HSL, HSV, and CMYK. Accepts any format as input and returns all formats.

```json
{ "color": "#ff6b35" }
{ "color": "rgb(255, 107, 53)" }
{ "color": "hsl(16, 100%, 60%)" }
{ "color": "hsv(16, 79%, 100%)" }
{ "color": "cmyk(0, 58, 79, 0)" }
```

### palette_generate

Generate a color palette from a base color.

**Types:** complementary, analogous, triadic, split-complementary, monochromatic

```json
{ "color": "#ff6b35", "type": "triadic" }
```

### contrast_check

Check WCAG contrast ratio between two colors. Reports AA/AAA compliance for normal text, large text, and UI components.

```json
{ "color1": "#ffffff", "color2": "#333333" }
```

### color_mix

Mix, blend, lighten, darken, saturate, or desaturate colors.

```json
{ "operation": "mix", "colors": ["#ff0000", "#0000ff"], "weights": [2, 1] }
{ "operation": "blend", "colors": ["#ff0000", "#0000ff"], "ratio": 0.3 }
{ "operation": "lighten", "colors": ["#ff6b35"], "amount": 20 }
{ "operation": "darken", "colors": ["#ff6b35"], "amount": 15 }
{ "operation": "saturate", "colors": ["#888888"], "amount": 30 }
{ "operation": "desaturate", "colors": ["#ff6b35"], "amount": 25 }
```

### css_gradient

Generate CSS gradient code with direction, stops, and browser prefixes.

```json
{
  "type": "linear",
  "colors": ["#ff6b35", "#ffd700", "#00bcd4"],
  "direction": "135deg"
}
```

```json
{
  "type": "radial",
  "colors": [
    { "color": "#ff6b35", "position": 0 },
    { "color": "#ffd700", "position": 50 },
    { "color": "#00bcd4", "position": 100 }
  ],
  "direction": "circle at center"
}
```

## Setup

```bash
npm install
npm run build
```

## Claude Desktop Configuration

```json
{
  "mcpServers": {
    "color-tools": {
      "command": "node",
      "args": ["path/to/mcp-color-tools/dist/index.js"]
    }
  }
}
```

## License

MIT
npm package: @rog0x/mcp-config-tools
Description: MCP server providing configuration file tools for AI agents
Latest version: 1.0.2

# mcp-config-tools

MCP server providing configuration file tools for AI agents. Parse, validate, merge, convert, and diff configuration files across all common formats.

## Tools

### json_config

Read, validate, deep merge, and diff JSON/JSONC configuration files.

- **parse** — Parse JSONC (JSON with comments and trailing commas)
- **validate** — Check if content is valid JSON/JSONC
- **merge** — Deep merge two JSON configs (overlay wins on conflicts)
- **diff** — Find structural differences between two JSON configs

### yaml_config

Read, validate, and convert YAML configuration files.

- **parse** — Parse YAML content to structured data
- **validate** — Check if content is valid YAML
- **to_json** — Convert YAML to JSON
- **from_json** — Convert JSON to YAML
- **validate_schema** — Validate against docker-compose, GitHub Actions, or Kubernetes schemas

### toml_parser

Parse TOML configuration files (Cargo.toml, pyproject.toml, etc.).

- **parse** — Parse TOML content to structured data
- **extract_section** — Extract a specific section by dot-path
- **list_deps** — List dependencies from Cargo.toml or pyproject.toml
- **compare_versions** — Compare two semantic version strings

### ini_parser

Parse INI and properties configuration files.

- **parse** — Parse INI content into sections and key-value pairs
- **get_sections** — List all section names
- **get_value** — Get a specific key from a section
- **to_json** — Convert INI to JSON
- **from_json** — Convert JSON back to INI format

### config_diff

Compare two configuration files in any supported format.

- Auto-detects file format (JSON, YAML, TOML, INI)
- Cross-format comparison (e.g., compare a YAML file against a JSON file)
- Shows additions, removals, and changes with full nested paths

## Setup

```bash
npm install
npm run build
```

## MCP Configuration

```json
{
  "mcpServers": {
    "config-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-config-tools/dist/index.js"]
    }
  }
}
```

## Dependencies

- `@modelcontextprotocol/sdk` — MCP protocol SDK
- `yaml` — YAML parser and serializer
- Built-in TOML and INI parsers (zero extra dependencies)
npm package: @rog0x/mcp-crypto-tools
Description: Cryptography and encoding tools for AI agents via MCP
Latest version: 1.0.2

# mcp-crypto-tools

Cryptography and encoding tools for AI agents, served via the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).

## Tools

### hash

Hash text using MD5, SHA-1, SHA-256, SHA-512, or HMAC. Compare two hash values. Compute all algorithms at once.

**Actions:** `hash`, `hmac`, `compare`, `hash_all`

### encode_decode

Encode and decode text using Base64, URL encoding, HTML entities, hex, or binary. Auto-detect encoding format.

**Actions:** `base64_encode`, `base64_decode`, `url_encode`, `url_decode`, `html_encode`, `html_decode`, `hex_encode`, `hex_decode`, `binary_encode`, `binary_decode`, `detect`

### generate_id

Generate unique identifiers: UUID v4, nanoid, ULID, CUID, or random strings with configurable length and charset.

**Types:** `uuid`, `nanoid`, `ulid`, `cuid`, `random`

### password

Generate secure passwords with configurable character sets, length, and count. Check password strength with entropy calculation and crack time estimation.

**Actions:** `generate`, `check_strength`

### jwt

Decode JWT tokens to inspect header and payload, check expiry status, or create unsigned JWTs for testing.

**Actions:** `decode`, `check_expiry`, `create_unsigned`

## Setup

```bash
npm install
npm run build
```

## MCP Configuration

Add to your MCP client configuration:

```json
{
  "mcpServers": {
    "crypto-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-crypto-tools/dist/index.js"]
    }
  }
}
```

## Dependencies

- `@modelcontextprotocol/sdk` - MCP server framework
- Node.js built-in `crypto` module - all cryptographic operations

No external crypto libraries required.

## License

MIT
npm package: @rog0x/mcp-database-tools
Description: MCP server providing SQL and database tools for AI agents - format, explain, analyze, build, and migrate SQL without a DB connection
Author: rog0x
Latest version: 1.0.1

# mcp-database-tools

MCP server providing SQL and database tools for AI agents. All analysis is performed on SQL text — no actual database connection required.

## Tools

### sql_format
Format and prettify SQL queries with proper indentation, uppercased keywords, and aligned columns. Supports MySQL, PostgreSQL, and SQLite syntax.

### sql_explain
Take a SQL query and explain what it does in plain English, step by step. Identifies query type, tables, columns, conditions, and provides optimization tips.

### schema_analyze
Parse CREATE TABLE statements to extract tables, columns, types, constraints, foreign keys, and indexes. Generates an ER diagram in Mermaid format.

### query_build
Build SQL queries from natural language descriptions. Supports common patterns like filtering by date, aggregation, joins, ordering, and pagination.

### migration_generate
Compare two schemas (old vs new CREATE TABLE statements) and generate ALTER TABLE migration statements. Produces both up (forward) and down (rollback) migrations.

## Installation

```bash
npm install
npm run build
```

## Usage

### With Claude Desktop

Add to your Claude Desktop config (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "database-tools": {
      "command": "node",
      "args": ["path/to/mcp-database-tools/dist/index.js"]
    }
  }
}
```

### Standalone

```bash
npm start
```

## Development

```bash
npm run build    # Compile TypeScript
npm start        # Run the server
```

## License

MIT
npm package: @rog0x/mcp-dep-tools
Description: MCP server providing dependency and package management tools for AI agents
Author: rog0x
Latest version: 1.0.1

# mcp-dep-tools

MCP server providing dependency and package management tools for AI agents. Analyze licenses, find outdated packages, visualize dependency trees, estimate bundle sizes, and audit security vulnerabilities — all from your AI assistant.

## Tools

### dep_check_licenses
Analyze licenses of all dependencies in a project. Lists each dependency's license type, flags copyleft (GPL) and unknown licenses, and checks for compatibility issues.

### dep_find_outdated
Check which dependencies are outdated. Compares installed or specified versions against the latest on npm, categorizes updates as major/minor/patch, and shows how many days since the latest version was published.

### dep_analyze_tree
Build and display the dependency tree. Shows direct dependencies and their transitive sub-dependencies, calculates maximum depth, detects circular dependencies, and counts total transitive packages.

### dep_analyze_size
Estimate total bundle size from package.json without installing node_modules. Queries the Bundlephobia API for each production dependency to get minified and gzipped sizes.

### dep_security_audit
Check dependencies for known security vulnerabilities. Runs `npm audit` when a lockfile is present, otherwise queries the npm registry advisory API directly. Reports severity levels, affected version ranges, and fix recommendations.

## Setup

```bash
npm install
npm run build
```

## Usage with Claude Desktop

Add to your Claude Desktop config:

```json
{
  "mcpServers": {
    "dep-tools": {
      "command": "node",
      "args": ["path/to/mcp-dep-tools/dist/index.js"]
    }
  }
}
```

## All tools accept a single parameter

- **project_dir** (string, required): Absolute path to the project directory containing a `package.json`.

## License

MIT
npm package: @rog0x/mcp-docker-tools
Description: Docker management tools for AI agents via MCP
Latest version: 1.0.1

# mcp-docker-tools

Docker management tools for AI agents, built on the [Model Context Protocol](https://modelcontextprotocol.io).

Provides five tools for inspecting containers, images, Dockerfiles, and Compose configurations — all accessible to LLMs through MCP.

## Tools

| Tool | Description |
|------|-------------|
| `docker_container_list` | List running or all containers with status, ports, image, created time, and resource usage (CPU, memory, network/block I/O) |
| `docker_image_list` | List Docker images with size, tags, created date, and layer count |
| `docker_dockerfile_analyze` | Analyze a Dockerfile for best practices: multi-stage builds, non-root user, layer caching, image size, security |
| `docker_compose_analyze` | Analyze docker-compose.yml: services, ports, volumes, networks, health checks, dependencies, and improvement suggestions |
| `docker_container_logs` | Get container logs with tail, keyword filter, time range, and timestamp support |

## Prerequisites

- **Node.js** >= 18
- **Docker** CLI installed and accessible in PATH
- Docker daemon running (for container/image tools)

## Installation

```bash
git clone <repo-url>
cd mcp-docker-tools
npm install
npm run build
```

## Usage with Claude Desktop

Add to your Claude Desktop configuration (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "docker-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-docker-tools/dist/index.js"]
    }
  }
}
```

## Usage with Claude Code

```bash
claude mcp add docker-tools node D:/products/mcp-servers/mcp-docker-tools/dist/index.js
```

Or add to `.claude/settings.json`:

```json
{
  "mcpServers": {
    "docker-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-docker-tools/dist/index.js"]
    }
  }
}
```

## Tool Examples

### List running containers
```json
{ "tool": "docker_container_list" }
```

### List all containers including stopped
```json
{ "tool": "docker_container_list", "args": { "all": true, "format": "table" } }
```

### List images filtered by name
```json
{ "tool": "docker_image_list", "args": { "filter": "node" } }
```

### Analyze a Dockerfile
```json
{
  "tool": "docker_dockerfile_analyze",
  "args": {
    "content": "FROM node:20\nCOPY . .\nRUN npm install\nCMD [\"node\", \"index.js\"]"
  }
}
```

### Analyze docker-compose.yml
```json
{
  "tool": "docker_compose_analyze",
  "args": {
    "content": "services:\n  web:\n    image: nginx\n    ports:\n      - 80:80"
  }
}
```

### Get container logs
```json
{
  "tool": "docker_container_logs",
  "args": { "container": "my-app", "tail": 50, "filter": "error" }
}
```

## License

MIT
npm package: @rog0x/mcp-docs-tools
Description: Documentation generation tools for AI agents via MCP
Latest version: 1.0.2

# mcp-docs-tools

Documentation generation tools for AI agents, served via the Model Context Protocol (MCP).

## Overview

`mcp-docs-tools` provides five specialized documentation tools accessible through MCP:

| Tool | Description |
|------|-------------|
| `generate_jsdoc` | Generate JSDoc/TSDoc comments from function signatures |
| `analyze_readme` | Analyze README completeness and suggest improvements |
| `generate_changelog` | Generate CHANGELOG entries from commit messages |
| `generate_api_docs` | Generate REST API documentation from endpoint definitions |
| `analyze_code_comments` | Analyze comment coverage, find TODOs, detect undocumented functions |

## Installation

```bash
npm install
npm run build
```

## Usage

### As an MCP Server

Add to your MCP client configuration:

```json
{
  "mcpServers": {
    "docs-tools": {
      "command": "node",
      "args": ["path/to/mcp-docs-tools/dist/index.js"]
    }
  }
}
```

### Tools

#### generate_jsdoc

Parses a function signature and generates JSDoc/TSDoc with `@param`, `@returns`, `@throws`, and `@example` tags.

**Parameters:**
- `functionSignature` (string, required) - The function signature to document
- `description` (string, optional) - Description of the function
- `includeExample` (boolean, optional, default: true) - Whether to include an `@example` tag

#### analyze_readme

Analyzes README content for required sections (Installation, Usage, License, etc.), rates completeness from 0-100, and suggests missing sections.

**Parameters:**
- `content` (string, required) - Full text content of the README file

#### generate_changelog

Generates CHANGELOG entries from git-style commit messages following the Keep a Changelog format. Categorizes commits as Added, Changed, Fixed, Removed, Deprecated, or Security.

**Parameters:**
- `versions` (array, required) - Array of `{ version, date, commits }` objects
- `projectName` (string, optional) - Project name for the header

#### generate_api_docs

Generates REST API documentation in Markdown from endpoint descriptions including method, URL, parameters, request/response examples, and status codes.

**Parameters:**
- `apiTitle` (string, required) - Title for the API documentation
- `baseUrl` (string, optional) - Base URL for the API
- `apiDescription` (string, optional) - General API description
- `endpoints` (array, required) - Array of endpoint definitions

#### analyze_code_comments

Analyzes source code comment coverage: computes comment-to-code ratio, finds TODO/FIXME/HACK markers, detects functions without documentation, and suggests where docs are needed.

**Parameters:**
- `code` (string, required) - Source code to analyze
- `language` (string, optional, default: "typescript") - Programming language

## Configuration

No additional configuration required. The server runs over stdio.

## License

MIT
npm package: @rog0x/mcp-env-tools
Description: MCP server providing environment and configuration tools for AI agents
Latest version: 1.0.2

# @rog0x/mcp-env-tools

MCP server providing environment and configuration tools for AI agents. Helps with parsing `.env` files, generating templates, checking ports, inspecting system info, and verifying tool dependencies.

## Tools

### Environment Parser
- **env_list_variables** - Parse a `.env` file and list all variable keys (values masked)
- **env_detect_missing** - Check if required environment variables are present and populated
- **env_compare_files** - Compare `.env` vs `.env.example` to find missing or extra variables
- **env_find_duplicates** - Find duplicate variable keys in a `.env` file

### Environment Generator
- **env_generate_example** - Generate `.env.example` from an existing `.env` file (strips values, keeps comments, adds placeholders)
- **env_detect_from_package_json** - Detect environment variables referenced in `package.json` scripts
- **env_detect_from_docker_compose** - Detect environment variables referenced in a `docker-compose.yml` file

### Port Checker
- **port_check** - Check if a specific port is in use and identify the process
- **port_find_available** - Find available ports within a given range
- **port_list_processes** - List processes using specific ports

### System Info
- **system_info** - OS, CPU, memory, disk, Node/npm/Python/Git/Docker versions

### Dependency Checker
- **deps_check_tools** - Check if specified tools are installed and get their versions
- **deps_check_versions** - Verify installed tools meet minimum version requirements
- **deps_verify_path** - Analyze the system PATH for common tool directories

## Setup

```bash
npm install
npm run build
```

## Configuration

Add to your MCP client config:

```json
{
  "mcpServers": {
    "env-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-env-tools/dist/index.js"]
    }
  }
}
```

## License

MIT
npm package: @rog0x/mcp-git-tools
Description: Git repository analysis tools for AI agents via MCP
Latest version: 1.0.1

# mcp-git-tools

Git repository analysis tools for AI agents, served over MCP (Model Context Protocol). Analyzes local repositories using native git commands — no GitHub API required.

## Tools

| Tool | Description |
|------|-------------|
| `git_log` | Get commit history with filtering by author, date range, and file path |
| `git_diff` | Show diff between commits, branches, or tags with change summaries |
| `git_blame` | Show who last modified each line of a file with commit info |
| `git_stats` | Repository statistics: commits, contributors, activity over time, most changed files |
| `git_branch` | List branches with last commit info, ahead/behind counts, merged/unmerged status |

## Prerequisites

- **Node.js** >= 18
- **Git** installed and available in PATH

## Setup

```bash
npm install
npm run build
```

## Configuration

Add to your MCP client configuration:

```json
{
  "mcpServers": {
    "git-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-git-tools/dist/index.js"]
    }
  }
}
```

## Tool Details

### git_log

Retrieve recent commit history with optional filters.

**Parameters:**
- `repoPath` (required) — Absolute path to the Git repository
- `count` — Number of commits to return (default: 20)
- `author` — Filter by author name or email
- `since` / `until` — Date range filters
- `path` — Filter to commits touching a specific file or directory

### git_diff

Compare two refs and get a structured summary of changes.

**Parameters:**
- `repoPath` (required) — Absolute path to the Git repository
- `from` — Start ref (default: HEAD~1)
- `to` — End ref (default: HEAD)
- `path` — Limit diff to a specific file or directory
- `summaryOnly` — Return only stats without full diff text

### git_blame

See line-by-line authorship of a file.

**Parameters:**
- `repoPath` (required) — Absolute path to the Git repository
- `filePath` (required) — File path relative to repo root
- `startLine` / `endLine` — Blame a specific line range
- `ref` — Blame at a specific commit

### git_stats

Get a high-level overview of repository activity.

**Parameters:**
- `repoPath` (required) — Absolute path to the Git repository
- `topAuthors` — Number of top contributors to list (default: 10)
- `topFiles` — Number of most-changed files to list (default: 10)

### git_branch

List and analyze branches.

**Parameters:**
- `repoPath` (required) — Absolute path to the Git repository
- `baseBranch` — Branch to compare against (default: main or master)
- `includeRemote` — Include remote-tracking branches
- `mergedOnly` / `unmergedOnly` — Filter by merge status

## License

MIT
npm package: @rog0x/mcp-i18n-tools
Description: Internationalization and localization tools for AI agents via MCP
Latest version: 1.0.2

# @rog0x/mcp-i18n-tools

Internationalization and localization tools for AI agents, exposed as an MCP (Model Context Protocol) server.

## Tools

### detect_locale

Detect the language and locale of a given text string. Returns the detected language code (BCP 47), language name, writing script, confidence score (0-1), and alternate language candidates.

**Supported languages:** English, Spanish, French, German, Portuguese, Italian, Russian, Japanese, Korean, Chinese, Arabic, Hindi, Thai, Greek, Hebrew.

### extract_i18n_keys

Extract hardcoded user-facing strings from source code that should be internationalized. Finds strings in:

- JSX/TSX attributes (`title`, `placeholder`, `label`, `alt`, `aria-label`, etc.)
- HTML template text and attributes
- `console.log` / `console.warn` / `console.error` calls
- `throw new Error(...)` messages
- `alert()` / `confirm()` / `prompt()` dialogs
- Variable assignments with i18n-relevant names (`message`, `label`, `title`, etc.)

Returns each string with its line/column, surrounding context, pattern type, and a suggested i18n key.

### analyze_translations

Analyze translation JSON files for consistency across locales. Detects:

- **Missing keys** — present in reference locale but absent in others
- **Extra keys** — present in a locale but not in the reference
- **Structure mismatches** — a key is a string in one locale but an object in another
- **Interpolation mismatches** — `{variable}` placeholders differ between locales
- **Empty values** — keys with blank translations
- **Unused keys** — keys not referenced in source code (requires a list of used keys)

### plural_rules

Generate plural form categories for a given locale following CLDR rules. Shows which plural categories the language uses and classifies any test numbers you provide.

| Language   | Categories                          |
| ---------- | ----------------------------------- |
| English    | one, other                          |
| French     | one, other                          |
| Russian    | one, few, many, other               |
| Arabic     | zero, one, two, few, many, other    |
| Polish     | one, few, many, other               |
| Japanese   | other                               |
| Chinese    | other                               |

### format_locale

Format numbers, currencies, dates, and relative times for any locale using the `Intl` APIs. Supports:

- **Numbers** — decimal, percent, unit; compact/scientific/engineering notation
- **Currency** — symbol, narrowSymbol, code, and name displays
- **Dates** — short, medium, long, full styles with date parts breakdown
- **Relative time** — long, short, narrow styles with auto-numeric formatting

## Setup

```bash
npm install
npm run build
```

## MCP Configuration

```json
{
  "mcpServers": {
    "i18n-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-i18n-tools/dist/index.js"]
    }
  }
}
```

## License

MIT
npm package: @rog0x/mcp-image-tools
Description: MCP server providing image analysis tools for AI agents - metadata, favicons, OG images, placeholders, responsive markup
Author: rog0x
Latest version: 1.0.1

# mcp-image-tools

MCP server providing image analysis tools for AI agents. Metadata inspection only -- no image processing or manipulation.

## Tools

### image_metadata
Read image metadata from a URL using HTTP headers. Returns content-type, file size, last-modified, etag, and cache info without downloading the full image.

### find_favicons
Find all favicons for any website. Checks `/favicon.ico`, parses HTML `<link>` tags, and inspects `manifest.json`. Returns all discovered favicons with sizes and types.

### extract_og_image
Extract Open Graph image, Twitter card image, and Apple touch icon from any URL. Useful for generating link previews.

### generate_placeholder
Generate placeholder image URLs via the placehold.co API. Supports custom dimensions, colors, text, format, and font. Returns the URL plus ready-to-use HTML and Markdown markup. Can generate multiple sizes at once.

### responsive_images
Generate `srcset` and `<picture>` element HTML for responsive images. Given a base image URL, produces multiple size variants with proper markup for responsive design, including multi-format `<source>` elements.

## Setup

```bash
npm install
npm run build
```

## Usage with Claude Desktop

Add to your Claude Desktop config:

```json
{
  "mcpServers": {
    "image-tools": {
      "command": "node",
      "args": ["path/to/mcp-image-tools/dist/index.js"]
    }
  }
}
```

## License

MIT
npm package: @rog0x/mcp-lint-tools
Description: Code linting and style checking tools for AI agents via MCP
Latest version: 1.0.2

# @rog0x/mcp-lint-tools

Code linting and style checking tools for AI agents, exposed as an MCP (Model Context Protocol) server.

All analysis is performed via regex and text parsing — no AST libraries required.

## Tools

### check_code_style

Check code style issues with configurable rules:

- **Indentation** — tabs vs spaces, configurable indent size
- **Line length** — flag lines exceeding a maximum length
- **Trailing whitespace** — detect trailing spaces/tabs
- **Final newline** — require a newline at end of file
- **Quotes** — enforce single or double quote consistency
- **Semicolons** — enforce always or never semicolon usage

### check_naming_conventions

Analyze identifier naming conventions:

- Detect **camelCase**, **PascalCase**, **snake_case**, **UPPER_CASE**
- Language-aware rules for TypeScript, JavaScript, Python, Go
- Flag **mixed conventions** within the same identifier kind
- **Suggest fixes** with automatic name conversion

### analyze_complexity

Measure code complexity metrics:

- **Cyclomatic complexity** per function
- **Lines per function** count
- **Nesting depth** measurement
- Configurable thresholds for flagging

### find_dead_code

Detect potential dead code:

- **Unused variables** — declared but never referenced
- **Unreachable code** — statements after return/throw/break
- **Empty catch blocks** — silently swallowed errors
- **Commented-out code** — blocks of commented code
- **TODO/FIXME/HACK** — annotation comments

### analyze_imports

Analyze import statements:

- **Unused imports** — imported names not referenced in code
- **Import ordering** — enforce group ordering (builtin > external > internal > relative)
- **Duplicate imports** — same module imported multiple times
- **Circular dependency hints** — basic detection of potential cycles

## Installation

```bash
npm install
npm run build
```

## Usage with Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "lint-tools": {
      "command": "node",
      "args": ["path/to/mcp-lint-tools/dist/index.js"]
    }
  }
}
```

## Development

```bash
npm install
npm run build
npm start
```

## License

MIT
npm package: @rog0x/mcp-log-tools
Description: Log analysis and processing tools for AI agents via MCP
Latest version: 1.0.2

# @rog0x/mcp-log-tools

Log analysis and processing tools for AI agents, exposed via the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/).

## Tools

### parse_logs

Parse log content in common formats: JSON logs, Apache/Nginx access logs, syslog, and structured logs. Supports custom regex patterns with named capture groups. Extracts timestamp, level, message, source, and additional structured fields.

### filter_logs

Filter parsed log entries by:

- Log level (ERROR, WARN, INFO, DEBUG)
- Date range (ISO 8601)
- Keyword search (case-insensitive)
- Regex pattern matching
- Source/logger name

Returns matched entries along with level occurrence counts.

### analyze_logs

Analyze log patterns to surface operational insights:

- Top 10 most frequent errors (normalized)
- Error rate over time (hourly buckets)
- Request volume per hour
- Slowest endpoints (from HTTP access logs)
- Anomaly detection (sudden spikes or drops using standard deviation)

### format_logs

Convert between log formats and produce reports:

- JSON to plain text, plain to JSON, CSV, or table
- ANSI colorization by log level
- Structured field extraction
- Summary report generation

### log_stats

Compute comprehensive log statistics:

- Total and non-empty line counts
- Level distribution with percentages
- Date range coverage
- Unique IP addresses and request counts
- Top user agents
- HTTP status code distribution
- Throughput (entries per second)

## Setup

```bash
npm install
npm run build
```

## Usage with Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "log-tools": {
      "command": "node",
      "args": ["path/to/mcp-log-tools/dist/index.js"]
    }
  }
}
```

## Supported Log Formats

| Format | Example |
|--------|---------|
| JSON | `{"timestamp":"2024-01-15T10:30:00Z","level":"ERROR","message":"Connection failed"}` |
| Apache/Nginx | `127.0.0.1 - frank [10/Oct/2000:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326` |
| Syslog | `Jan  1 00:00:00 hostname process[1234]: Something happened` |
| Structured | `2024-01-15T10:30:00.000Z [ERROR] [ModuleName] Something failed` |
| Custom | Any format using a regex with named capture groups |

## License

MIT
npm package: @rog0x/mcp-markdown-tools
Description: MCP server providing tools for working with Markdown content
Latest version: 1.0.2

# mcp-markdown-tools

An MCP (Model Context Protocol) server that provides tools for working with Markdown content. Analyze, lint, format, and generate Markdown programmatically through any MCP-compatible client.

## Tools

### generate_toc

Generate a table of contents from markdown headings. Configure minimum/maximum heading depth and choose between ordered or unordered list output.

### lint_markdown

Check markdown for common issues including broken link syntax, heading hierarchy violations, trailing whitespace, missing image alt text, inconsistent list markers, and excessive blank lines.

### format_markdown

Format and prettify markdown content. Normalizes heading styles (converts setext to ATX), fixes spacing around headings and blocks, aligns table columns, and wraps long lines at configurable width.

### markdown_stats

Compute detailed statistics from markdown content: word count, character count, estimated reading time, headings by level, link count, image count, code block count with language distribution, list items, blockquotes, and paragraph count.

### generate_table

Generate formatted markdown tables from JSON data. Supports column selection, custom header labels, and per-column alignment (left, center, right).

## Installation

```bash
npm install
npm run build
```

## Usage with Claude Desktop

Add the following to your Claude Desktop configuration file:

- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`

```json
{
  "mcpServers": {
    "markdown-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-markdown-tools/dist/index.js"]
    }
  }
}
```

## Usage with Claude Code

Add the server using the Claude Code CLI:

```bash
claude mcp add markdown-tools node D:/products/mcp-servers/mcp-markdown-tools/dist/index.js
```

Or add it to your `.mcp.json` configuration:

```json
{
  "mcpServers": {
    "markdown-tools": {
      "command": "node",
      "args": ["D:/products/mcp-servers/mcp-markdown-tools/dist/index.js"]
    }
  }
}
```

## Development

```bash
npm install
npm run build
npm start
```

## License

MIT
npm package: @rog0x/mcp-math-tools
Description: Math and calculation tools for AI agents via MCP
Latest version: 1.0.1

# mcp-math-tools

Math and calculation tools for AI agents, exposed via the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).

## Tools

### `calculate`
Evaluate math expressions safely (no `eval`). Supports arithmetic operators (`+`, `-`, `*`, `/`, `^`, `%`), parentheses, functions (`sqrt`, `abs`, `floor`, `ceil`, `round`, `log`, `ln`, `sin`, `cos`, `tan`, `min`, `max`, `pow`), constants (`pi`, `e`), and named variables.

### `convert_units`
Convert between units across six categories:
- **Length**: m, km, cm, mm, mi, yd, ft, in
- **Weight**: kg, g, mg, lb, oz, ton
- **Temperature**: C, F, K
- **Data**: B, KB, MB, GB, TB
- **Time**: s, min, h, d, week
- **Speed**: m/s, km/h, mph, knots

### `statistics`
Statistical analysis on datasets: mean, median, mode, variance, standard deviation, min, max, range, percentile, correlation between two arrays, and a full summary mode.

### `format_number`
Format numbers as: currency (`$1,234.56`), percentage, scientific notation, binary, octal, hexadecimal, significant figures, or with thousands separators.

### `percentage_calc`
Common percentage operations: X% of Y, what percent X is of Y, percentage change between two values, tip calculator, discount calculator, and markup calculator.

## Installation

```bash
npm install
npm run build
```

## Usage with Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "math-tools": {
      "command": "node",
      "args": ["path/to/mcp-math-tools/dist/index.js"]
    }
  }
}
```

## Examples

**Calculate**: `2 * (3 + 4) ^ 2` returns `98`

**Convert**: `100` from `km/h` to `mph` returns `62.137...`

**Statistics**: summary of `[1, 2, 3, 4, 5]` returns mean, median, mode, variance, etc.

**Format**: `1234567.89` as `currency` returns `$1,234,567.89`

**Percentage**: `15%` tip on `85.50` bill split 3 ways

## License

MIT