Dev Tools

A growing collection of developer utility tools — available as a CLI, REST API, and MCP server, all powered by a single .NET library.

Dev Tools is built around one idea: write a tool once, expose it everywhere. Every tool is a single C# class decorated with [ToolDefinition]. At build time, Roslyn source generators automatically produce a CLI command, an API endpoint, and an MCP tool definition - no boilerplate, no duplication.

The library covers everyday developer tasks: encoding and decoding (Base64, URL, case formats), cryptographic operations (hashing, encryption, JWT parsing), identifier generation (UUID v3-v7, ULID, tokens, passphrases), data formatting (JSON, XML), and more. Tools are independently installable and usable across all four frontends:

• CLI: a dotnet global tool, fully pipeable
• REST API: an ASP.NET Core service with interactive Scalar docs
• Web UI: a Blazor WebAssembly app (MudBlazor)
• MCP Server: plugs directly into Claude, Cursor, and other AI assistants
• NuGet: embed the tools directly in your .NET application

Tools are localized (English and Ukrainian), multi-arch Docker images are published on every release.

Try the live demo - no installation needed.

---

Table of Contents

• Dev Tools
  • Table of Contents
  • Features
  • Available Tools
  • Usage
    • Web UI
    • CLI
    • REST API
    • MCP Server (AI assistants)
      • Run via DotNet Tool
      • Run via Docker
    • NuGet Library
    • All-in-one Docker Image
  • Building Locally
    • Prerequisites
    • Clone And Build
    • Make Targets
  • License

---

Features

• Write once, expose everywhere — CLI, REST API, and MCP server all auto-generated from a single [ToolDefinition] attribute via Roslyn source generators
• Growing tool library — encoding, hashing, encryption, UUID/ULID generation, JWT parsing, formatters, and more
• Pipeable CLI — compose tools with Unix pipes: echo "hello" | dev-tools base64-encoder
• AI assistant integration — MCP server works with Claude, Cursor, and any MCP-compatible host
• Localization — English and Ukrainian
• Multi-arch Docker images — linux/amd64 and linux/arm64, published on every release
• Extensible — add a new tool in a single .cs file and UI component; the rest is wired up at build time

---

Available Tools

See docs/tools.md for the full categorized reference with aliases and descriptions.

---

Usage

Web UI

Run locally with Docker:

docker run -p 8080:8080 ghcr.io/dobermanch/dev-tools-web

Open http://localhost:8080 in your browser.

---

CLI

Install as a dotnet global tool:

dotnet tool install --global Dev.Tools.Console

# Encode to Base64
dev-tools base64-encoder "Hello, World!"
# → SGVsbG8sIFdvcmxkIQ==

# Pipe tools together
echo "Hello, World!" | dev-tools base64-encoder | dev-tools base64-decoder

# Format JSON (sort keys)
echo '{"b":2,"a":1}' | dev-tools json-formatter --sort-keys Ascending

# Get help
dev-tools --help
dev-tools hash --help

Or run without installing via Docker:

docker run --rm ghcr.io/dobermanch/dev-tools-console base64-encoder "Hello, World!"
# → SGVsbG8sIFdvcmxkIQ==

# Pipe into the container
echo "Hello, World!" | docker run --rm -i ghcr.io/dobermanch/dev-tools-console base64-encoder

---

REST API

Run as a Docker container:

docker run -p 8080:8080 ghcr.io/dobermanch/dev-tools-api

Call an endpoint:

# Encode to Base64
curl -X POST http://localhost:8080/tools/base64-encoder \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello, World!"}'

Interactive API documentation (Scalar UI) is available at http://localhost:8080/ui.

---

MCP Server (AI assistants)

Once registered, your assistant can use any tool directly — e.g., "hash this text with SHA-256" or "generate 5 UUIDs".

Run via DotNet Tool

Install the MCP server as a global tool and register it in your AI assistant configuration.

dotnet tool install --global Dev.Tools.Mcp

Add to AI agent MCP config

"dev-tools": {
  "type": "stdio",
  "command": "dev-tools-mcp"
}

Run via Docker

Use Docker dev-tools-mcp image and register it in your AI assistant configuration.

Using stdio transport:

"dev-tools": {
  "type": "stdio",
  "command": "docker",
  "args": ["run", "--rm", "-i", "-e", "MCP_TRANSPORT=stdio", "ghcr.io/dobermanch/dev-tools-mcp"]
}

Using HTTP transport:

"dev-tools": {
  "type": "http",
  "command": "docker",
  "args": ["run", "--rm", "-i", "ghcr.io/dobermanch/dev-tools-mcp"]
}

---

NuGet Library

Embed the tools directly in your .NET application.

dotnet add package Dev.Tools

// Base64 encode
var encoded = await new Base64EncoderTool().RunAsync(
    new Base64EncoderTool.Args("Hello, World!"),
    CancellationToken.None);

Console.WriteLine(encoded.Output); // SGVsbG8sIFdvcmxkIQ==

---

All-in-one Docker Image

The dev-tools image bundles the Web UI, REST API, and MCP server into a single container — useful for self-hosting or quick local demos.

docker run -p 80:80 -p 8080:8080 -p 8081:8081 ghcr.io/dobermanch/dev-tools

Port	Service	Urls
80	Web UI	http://localhost
8080	REST API	http://localhost:8080, http://localhost:8080/ui
8081	MCP server (HTTP transport)	http://localhost:8081

---

Building Locally

Prerequisites

• .NET 10 SDK
• Docker (optional — for container builds)
• Make (optional — for convenience targets)

Clone And Build

git clone https://github.com/dobermanch/dev-tools.git
cd dev-tools

dotnet restore
dotnet build
dotnet test

Run a specific test class:

dotnet test --filter "ClassName=Base64EncoderToolTests"

Make Targets

make tool      # Pack and install Dev.Tools.Console globally
make mcp       # Pack and install Dev.Tools.Mcp globally
make nuget     # Pack the Dev.Tools NuGet package
make docker    # Build all Docker images locally
make clean     # Remove build artifacts and Docker images

---

License

MIT