Zero Dependencies: The Architecture

How 260 CLI tools run on pure import — no pip, no npm, no cargo

Every tool is built using only Python's standard library. Not "mostly" — entirely. From CSV parsing to network requests, JSON processing to terminal graphics, the entire toolkit runs on modules that ship with every Python installation since 3.8.

Why Zero Dependencies Matters

Most Python packages depend on a web of transitive dependencies. A simple CLI tool often pulls in 20-50 packages. This creates real problems:

Problem	Traditional Package	evolver-tools
Install time	30-120s (compiling native extensions)	2-5s
Disk usage	50-500 MB (with deps)	<1 MB
pip list entries	20-50 transitive packages	1
CI/CD cache	Must cache venv + dependencies	No cache needed
Air-gapped install	Requires private PyPI mirror	Works directly
Container image	100+ MB base + deps	12 MB slim image
Security surface	100+ package versions to audit	One package to audit
Supply chain risk	Any dep could be compromised	Stdlib only — no supply chain

What Makes This Possible

Python's standard library is uniquely capable among mainstream languages. It includes modules that cover almost every computing need:

Behind the Scenes: Stdlib Modules Used

Here's a partial map of which Python stdlib modules power each tool category:

The Hard Parts: What Stdlib Doesn't Give You

Building on stdlib-only isn't always easy. Here are the trade-offs:

1. Terminal Colors Without colorama

On Windows, ANSI escape codes don't work by default. colorama is the standard fix. Our approach:

# Check if ANSI is supported, fall back to plain text
import os, sys

def supports_color():
    if sys.platform == "win32":
        # Enable VT processing on Windows 10+
        os.system("")
    return hasattr(sys.stdout, "isatty") and sys.stdout.isatty()

2. Progress Bars Without tqdm

tqdm is everyone's go-to. We built a 40-line progress bar using sys.stdout.write() + \r carriage returns:

def progress_bar(current, total, width=40):
    pct = current / total
    filled = int(width * pct)
    bar = "█" * filled + "░" * (width - filled)
    sys.stdout.write(f"\r{bar} {pct:.1%}")
    sys.stdout.flush()

3. Tabular Output Without tabulate/rich

# Dynamic column-width table formatting with pure string ops
def format_table(headers, rows):
    widths = [len(h) for h in headers]
    for row in rows:
        for i, cell in enumerate(row):
            widths[i] = max(widths[i], len(str(cell)))
    # ... build format string from calculated widths

4. No argparse? Use argparse!

Surprisingly, argparse is stdlib — so CLI argument parsing is fully covered. No need for click or typer.

Architecture: Single File Tools

Each tool is a single Python file in src/evolver_tools/tools/. The discovery system reads tool metadata from embedded docstrings:

# Tool metadata from docstring convention
# Every tool has: name, description, args, examples embedded in its module
TOOLS = {}  # populated at import time by scanning the tools directory

def discover_tools():
    """Auto-discover all tool modules from tools/ directory."""
    tools_dir = Path(__file__).parent / "tools"
    for f in tools_dir.glob("*.py"):
        if f.name == "__init__.py":
            continue
        spec = importlib.util.spec_from_file_location("tool", f)
        mod = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(mod)
        TOOLS[mod.NAME] = mod

Real-World Impact

The zero-dependency approach isn't just academic — it creates real practical benefits:

CI/CD Pipelines

# .github/workflows/data-pipeline.yml
- name: Install and run data pipeline
  run: |
    pip install evolver-tools
    evtool csv-stats data.csv
    evtool csv-chart data.csv

No pip cache, no actions/setup-python with extra args, no venv restoration. Just install and go.

Docker Images

FROM python:3.12-slim
RUN pip install evolver-tools
CMD ["evtool", "list"]

Final image size: ~130 MB (Python slim base) + ~250 KB (our code) = basically the same as Python alone.

Air-Gapped Environments

No PyPI mirror needed. Just copy the .whl file to the target machine. Python stdlib is already there.

The Trade-off

Zero-dependency development has real costs that are worth being honest about:

Trade-off	With Stdlib Only	With External Deps
Development speed	Slower — must reimplement basic patterns	Fast — install what you need
Feature depth	Limited to what stdlib provides	Rich — battle-tested libraries
Edge cases	Must handle manually (e.g., encoding, timezones)	Often handled by the library
Code size	~250KB for 260 tools	Would be much smaller per tool
Learning curve	Requires stdlib expertise	Requires library API knowledge

The key is choosing the right tools for the right job. For quick data tasks in CI/CD, server-side automation, and air-gapped deployments, zero-dependency CLI tools shine. For complex data science or web scraping, purpose-built libraries like pandas or requests are better.

Further Reading

• CLI Cookbook — 100 real-world one-liners
• evolver-tools vs jq, ripgrep, httpie — Honest Comparison
• The Story: How an AI Built 260 CLI Tools
• Architecture Deep-Dive — Full Technical Article