dktcli 1.0.0__tar.gz

dktcli-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 <your name>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dktcli-1.0.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: dktcli
+Version: 1.0.0
+Summary: devkittools: the developer's swiss army knife - 35+ zero-dependency CLI tools (ports, serve, json, git helpers, secrets scan, cron, and more) under one command: dkt
+License: MIT
+Keywords: cli,developer-tools,devtools,git,changelog,ollama,productivity,utilities,toolbox
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# dkt - the developer's swiss army knife
+
+**35+ small, sharp CLI tools under one command: `dkt`.**
+Pure Python, **zero dependencies**, Windows / macOS / Linux. Colored output, spinners, aligned tables,
+typo suggestions ("did you mean..."), tab-completion, and an interactive menu.
+
+```text
+  ____  _  _______
+ |  _ \| |/ /_   _|   devkittools
+ | | | | ' /  | |     the developer's swiss army knife
+ | |_| | . \  | |
+ |____/|_|\_\ |_|
+```
+
+## Install
+
+```bash
+pip install dktcli
+dkt                # see every tool
+```
+
+No PyPI? From this folder: `pip install .` - or on Windows just double-click **`install.bat`**
+(it also fixes your PATH). If `dkt` isn't found, `python -m devkittools` always works.
+
+**Update:** `dkt update` (PyPI installs) or double-click **`update.bat`** (does `git pull` if this is a clone).
+**Uninstall:** `uninstall.bat` or `pip uninstall dktcli`.
+
+## The tools
+
+Run `dkt` for the list, `dkt <tool> -h` for examples of any tool, or `dkt menu` for an interactive launcher.
+
+### Servers & Network
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt portkiller` | `pk` | what's using port 3000? kill it |
+| `dkt serve` | `sv` | static server with CORS, SPA mode, LAN URL, `--open` |
+| `dkt http` | `req` | HTTP requests with pretty JSON, timing, headers, downloads |
+| `dkt net` | | `ip` (local/public), `dns`, `check host:port` |
+
+### Project & Code
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt repostats` | `rs` | lines per language, biggest files, git activity, health check |
+| `dkt tree` | `tr` | pretty tree, respects .gitignore, `--sizes`, `--copy` |
+| `dkt find` | `fd` | project-wide search (regex, context lines) + find files + safe find & replace |
+| `dkt todo` | `td` | every TODO / FIXME / HACK with file:line |
+| `dkt secrets` | `sec` | scan for leaked API keys / tokens / private keys (CI-friendly exit code) |
+| `dkt clean` | `cl` | delete node_modules, `__pycache__`, caches with sizes + confirmation |
+| `dkt du` | | what's eating my disk, with bars |
+| `dkt watch` | `w` | re-run any command when files change |
+| `dkt bench` | `bn` | benchmark / compare commands |
+| `dkt env` | | env vars (secrets masked), PATH doctor, `.env` vs `.env.example` |
+| `dkt ignore` | `gi` | .gitignore generator (python, node, unity, minecraft, godot...) |
+| `dkt license` | `lic` | LICENSE file (MIT, ISC, BSD, Unlicense) |
+| `dkt init` | `new` | scaffold python / node / web projects with git + license |
+
+### Git
+| Command | What it does |
+|---|---|
+| `dkt gx log` | compact colored graph |
+| `dkt gx branches [--prune]` | branch overview, delete merged branches |
+| `dkt gx undo` / `wip` / `amend` / `sync` / `who` | everyday shortcuts |
+| `dkt changeloggen` (`clg`) | CHANGELOG.md from conventional commits |
+
+### AI helpers
+| Command | What it does |
+|---|---|
+| `dkt projectcontextpacker` (`pcp`) | pack a project into one AI-prompt file, with token counts |
+| `dkt commitwriter` (`cw`) | commit messages from your diff using local Ollama |
+
+### Generate & Convert
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt gen` | `g` | `uuid` (v4/v7), `ulid`, `password`, `token`, `id`, `lorem`, `slug` |
+| `dkt enc` | `e` | base64 / url / hex / html encode & decode |
+| `dkt jwt` | | decode a JWT, shows expiry |
+| `dkt hash` | `h` | md5/sha*/blake2, files, `--verify`, `--hmac` |
+| `dkt time` | `tm` | epoch <-> date, date math, differences |
+| `dkt color` | `col` | hex/rgb/hsl, live swatches, contrast ratio, palettes |
+
+### Data & Text
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt json` | `js` | `fmt`, `min`, `get a.b[0]`, `keys`, `flat`, `csv`, `validate` (forgives comments / trailing commas) |
+| `dkt regex` | `rx` | highlighted matches, named groups, `--replace` |
+| `dkt cron` | | explain a cron expression + next runs |
+| `dkt snip` | | personal snippet notebook (`add` / `get --copy` / `ls` / `rm`) |
+
+### System & dkt itself
+`dkt doctor` (system info + which dev tools you have), `dkt update`, `dkt config`, `dkt completion`, `dkt menu`, `dkt about`.
+
+## Handy patterns
+```bash
+dkt js fmt --paste --copy          # clean up JSON from your clipboard
+cat resp.json | dkt js get data.items[0].id
+dkt sv --open --spa                # serve the folder, SPA fallback, open browser
+dkt w -c "pytest -q" --clear       # tests on every save
+dkt sec --json || echo "secrets found"   # CI gate
+dkt tr --copy                      # paste a project tree into docs / AI chats
+dkt new python mytool              # new project, ready to go
+```
+
+## Tab completion
+```powershell
+dkt completion powershell | Out-String | Add-Content $PROFILE   # PowerShell
+```
+```bash
+eval "$(dkt completion bash)"      # add to ~/.bashrc (zsh: dkt completion zsh)
+```
+
+## Settings
+`dkt config set author "Your Name"` (used by `license` / `init`), `dkt config set model qwen2.5-coder:7b` (commit writer).
+Env vars `DKT_<KEY>` override the file. `NO_COLOR=1` disables colors, `DKT_ASCII=1` disables unicode symbols.
+
+## Publishing to PyPI (maintainers)
+1. The PyPI package is called **`dktcli`** (set in `pyproject.toml`); the command you type is still `dkt`.
+2. Run **`publish.bat`** (builds, checks, uploads with your API token) - or use the included GitHub Action
+   (`.github/workflows/publish.yml`, trusted publishing) and just create a Release.
+3. Bump `__version__` in `src/devkittools/__init__.py` for every release.
+
+## Development
+```bash
+pip install -e .
+python -m unittest discover -s tests
+```
+Adding a tool = one file in `src/devkittools/tools/` with a `META` tuple and a `register()` function, then add it to `MODULES` in `cli.py`.
+
+## License
+MIT

dktcli-1.0.0/README.md

@@ -0,0 +1,129 @@
+# dkt - the developer's swiss army knife
+
+**35+ small, sharp CLI tools under one command: `dkt`.**
+Pure Python, **zero dependencies**, Windows / macOS / Linux. Colored output, spinners, aligned tables,
+typo suggestions ("did you mean..."), tab-completion, and an interactive menu.
+
+```text
+  ____  _  _______
+ |  _ \| |/ /_   _|   devkittools
+ | | | | ' /  | |     the developer's swiss army knife
+ | |_| | . \  | |
+ |____/|_|\_\ |_|
+```
+
+## Install
+
+```bash
+pip install dktcli
+dkt                # see every tool
+```
+
+No PyPI? From this folder: `pip install .` - or on Windows just double-click **`install.bat`**
+(it also fixes your PATH). If `dkt` isn't found, `python -m devkittools` always works.
+
+**Update:** `dkt update` (PyPI installs) or double-click **`update.bat`** (does `git pull` if this is a clone).
+**Uninstall:** `uninstall.bat` or `pip uninstall dktcli`.
+
+## The tools
+
+Run `dkt` for the list, `dkt <tool> -h` for examples of any tool, or `dkt menu` for an interactive launcher.
+
+### Servers & Network
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt portkiller` | `pk` | what's using port 3000? kill it |
+| `dkt serve` | `sv` | static server with CORS, SPA mode, LAN URL, `--open` |
+| `dkt http` | `req` | HTTP requests with pretty JSON, timing, headers, downloads |
+| `dkt net` | | `ip` (local/public), `dns`, `check host:port` |
+
+### Project & Code
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt repostats` | `rs` | lines per language, biggest files, git activity, health check |
+| `dkt tree` | `tr` | pretty tree, respects .gitignore, `--sizes`, `--copy` |
+| `dkt find` | `fd` | project-wide search (regex, context lines) + find files + safe find & replace |
+| `dkt todo` | `td` | every TODO / FIXME / HACK with file:line |
+| `dkt secrets` | `sec` | scan for leaked API keys / tokens / private keys (CI-friendly exit code) |
+| `dkt clean` | `cl` | delete node_modules, `__pycache__`, caches with sizes + confirmation |
+| `dkt du` | | what's eating my disk, with bars |
+| `dkt watch` | `w` | re-run any command when files change |
+| `dkt bench` | `bn` | benchmark / compare commands |
+| `dkt env` | | env vars (secrets masked), PATH doctor, `.env` vs `.env.example` |
+| `dkt ignore` | `gi` | .gitignore generator (python, node, unity, minecraft, godot...) |
+| `dkt license` | `lic` | LICENSE file (MIT, ISC, BSD, Unlicense) |
+| `dkt init` | `new` | scaffold python / node / web projects with git + license |
+
+### Git
+| Command | What it does |
+|---|---|
+| `dkt gx log` | compact colored graph |
+| `dkt gx branches [--prune]` | branch overview, delete merged branches |
+| `dkt gx undo` / `wip` / `amend` / `sync` / `who` | everyday shortcuts |
+| `dkt changeloggen` (`clg`) | CHANGELOG.md from conventional commits |
+
+### AI helpers
+| Command | What it does |
+|---|---|
+| `dkt projectcontextpacker` (`pcp`) | pack a project into one AI-prompt file, with token counts |
+| `dkt commitwriter` (`cw`) | commit messages from your diff using local Ollama |
+
+### Generate & Convert
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt gen` | `g` | `uuid` (v4/v7), `ulid`, `password`, `token`, `id`, `lorem`, `slug` |
+| `dkt enc` | `e` | base64 / url / hex / html encode & decode |
+| `dkt jwt` | | decode a JWT, shows expiry |
+| `dkt hash` | `h` | md5/sha*/blake2, files, `--verify`, `--hmac` |
+| `dkt time` | `tm` | epoch <-> date, date math, differences |
+| `dkt color` | `col` | hex/rgb/hsl, live swatches, contrast ratio, palettes |
+
+### Data & Text
+| Command | Alias | What it does |
+|---|---|---|
+| `dkt json` | `js` | `fmt`, `min`, `get a.b[0]`, `keys`, `flat`, `csv`, `validate` (forgives comments / trailing commas) |
+| `dkt regex` | `rx` | highlighted matches, named groups, `--replace` |
+| `dkt cron` | | explain a cron expression + next runs |
+| `dkt snip` | | personal snippet notebook (`add` / `get --copy` / `ls` / `rm`) |
+
+### System & dkt itself
+`dkt doctor` (system info + which dev tools you have), `dkt update`, `dkt config`, `dkt completion`, `dkt menu`, `dkt about`.
+
+## Handy patterns
+```bash
+dkt js fmt --paste --copy          # clean up JSON from your clipboard
+cat resp.json | dkt js get data.items[0].id
+dkt sv --open --spa                # serve the folder, SPA fallback, open browser
+dkt w -c "pytest -q" --clear       # tests on every save
+dkt sec --json || echo "secrets found"   # CI gate
+dkt tr --copy                      # paste a project tree into docs / AI chats
+dkt new python mytool              # new project, ready to go
+```
+
+## Tab completion
+```powershell
+dkt completion powershell | Out-String | Add-Content $PROFILE   # PowerShell
+```
+```bash
+eval "$(dkt completion bash)"      # add to ~/.bashrc (zsh: dkt completion zsh)
+```
+
+## Settings
+`dkt config set author "Your Name"` (used by `license` / `init`), `dkt config set model qwen2.5-coder:7b` (commit writer).
+Env vars `DKT_<KEY>` override the file. `NO_COLOR=1` disables colors, `DKT_ASCII=1` disables unicode symbols.
+
+## Publishing to PyPI (maintainers)
+1. The PyPI package is called **`dktcli`** (set in `pyproject.toml`); the command you type is still `dkt`.
+2. Run **`publish.bat`** (builds, checks, uploads with your API token) - or use the included GitHub Action
+   (`.github/workflows/publish.yml`, trusted publishing) and just create a Release.
+3. Bump `__version__` in `src/devkittools/__init__.py` for every release.
+
+## Development
+```bash
+pip install -e .
+python -m unittest discover -s tests
+```
+Adding a tool = one file in `src/devkittools/tools/` with a `META` tuple and a `register()` function, then add it to `MODULES` in `cli.py`.
+
+## License
+MIT

dktcli-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dktcli"
+dynamic = ["version"]
+description = "devkittools: the developer's swiss army knife - 35+ zero-dependency CLI tools (ports, serve, json, git helpers, secrets scan, cron, and more) under one command: dkt"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["cli", "developer-tools", "devtools", "git", "changelog", "ollama", "productivity", "utilities", "toolbox"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Utilities",
+]
+dependencies = []
+
+[project.scripts]
+dkt = "devkittools.cli:main"
+devkittools = "devkittools.cli:main"
+
+[tool.setuptools.dynamic]
+version = { attr = "devkittools.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

dktcli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dktcli-1.0.0/src/devkittools/__init__.py

@@ -0,0 +1,3 @@
+"""devkittools - a suite of small developer CLI tools (command: dkt)."""
+
+__version__ = "1.0.0"

dktcli-1.0.0/src/devkittools/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

dktcli-1.0.0/src/devkittools/cli.py

@@ -0,0 +1,179 @@
+"""Entry point for the `dkt` command."""
+from __future__ import annotations
+
+import argparse
+import difflib
+import re
+import shlex
+import sys
+from typing import List, Optional
+
+from . import __version__
+from .tools import (bench, changeloggen, clean, colortool, commitwriter, contextpacker, cron, doctor, du, enc,
+                    envtool, findtool, gen, gx, hashtool, httptool, ignore, initproj, jsontool, net, portkiller,
+                    regextool, repostats, secrets_scan, serve, snip, system, timetool, todo, tree, watch)
+from .utils import DktError, banner, c, is_interactive, ask, setup_console, sym, term_width
+
+VERSION_STR = "devkittools %s" % __version__
+
+# Order here = order in the help screen.
+MODULES = [
+    portkiller, serve, httptool, net,
+    repostats, tree, findtool, todo, secrets_scan, clean, du, watch, bench, envtool, ignore, initproj,
+    gx, changeloggen,
+    contextpacker, commitwriter,
+    gen, enc, hashtool, timetool, colortool,
+    jsontool, regextool, cron, snip,
+    doctor,
+]
+CATEGORY_ORDER = ["Servers & Network", "Project & Code", "Git", "AI Helpers", "Generate & Convert",
+                  "Data & Text", "System"]
+EXTRA = [  # (category, name, alias, summary) for commands without a META of their own
+    ("Generate & Convert", "jwt", "", "decode JSON Web Tokens"),
+    ("Project & Code", "license", "lic", "write a LICENSE file"),
+    ("dkt itself", "update", "", "upgrade dkt to the newest version"),
+    ("dkt itself", "config", "", "view / change settings"),
+    ("dkt itself", "completion", "", "shell tab-completion script"),
+    ("dkt itself", "menu", "", "interactive launcher"),
+    ("dkt itself", "about", "", "logo, version and tips"),
+]
+CATEGORY_ORDER.append("dkt itself")
+
+
+def all_tools():
+    rows = [m.META for m in MODULES] + EXTRA
+    return rows
+
+
+def grouped_help() -> str:
+    lines = []
+    cats = {}
+    for cat, name, alias, summary in all_tools():
+        cats.setdefault(cat, []).append((name, alias, summary))
+    for cat in CATEGORY_ORDER:
+        items = cats.get(cat)
+        if not items:
+            continue
+        lines.append("")
+        lines.append("  " + c(cat, "bold bmagenta"))
+        for name, alias, summary in items:
+            if len(name) > 12 and alias:
+                name, alias = alias, name
+            short = ("(%s)" % alias) if alias else ""
+            lines.append("    %s %s  %s" % (c(name.ljust(10), "bold bcyan"), c(short.ljust(6), "gray"), summary))
+    return "\n".join(lines)
+
+
+def print_overview() -> None:
+    banner()
+    print(grouped_help())
+    print()
+    print("  " + c("usage:", "bold") + " dkt <tool> [options]     " + c("dkt <tool> -h for examples", "gray"))
+    print("  " + c("tip:", "bold") + "   dkt menu for an interactive launcher, dkt completion for tab-complete")
+    print()
+
+
+class OverviewAction(argparse.Action):
+    def __init__(self, option_strings, dest, **kw):
+        super().__init__(option_strings, dest, nargs=0, **kw)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        print_overview()
+        parser.exit(0)
+
+
+class DktParser(argparse.ArgumentParser):
+    tool_names: List[str] = []
+
+    def error(self, message):
+        m = re.search(r"invalid choice: '([^']*)'", message)
+        if m and self.prog == "dkt":
+            bad = m.group(1)
+            guess = difflib.get_close_matches(bad, self.tool_names, n=3, cutoff=0.5)
+            sys.stderr.write("%s unknown tool '%s'\n" % (c("error:", "red"), bad))
+            if guess:
+                sys.stderr.write("  did you mean: %s ?\n" % ", ".join(c(g, "bold bcyan") for g in guess))
+            sys.stderr.write("  run 'dkt' to see all tools\n")
+            self.exit(2)
+        super().error(message)
+
+
+def build_parser():
+    parser = DktParser(prog="dkt", description="devkittools - the developer's swiss army knife.",
+                       add_help=False, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("-h", "--help", action=OverviewAction, help="show all tools")
+    parser.add_argument("-v", "-V", "--version", action="version", version=VERSION_STR, help="show version")
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("-v", "-V", "--version", action="version", version=VERSION_STR, help="show version and exit")
+    sub = parser.add_subparsers(dest="command", metavar="<tool>", title="tools")
+    for m in MODULES:
+        m.register(sub, common)
+    system.register(sub, common)
+    menu = sub.add_parser("menu", aliases=["m"], parents=[common], help="interactive launcher")
+    menu.set_defaults(func=lambda a: run_menu())
+    DktParser.tool_names = sorted(sub.choices)
+    return parser
+
+
+def run_menu() -> int:
+    if not is_interactive():
+        print_overview()
+        return 0
+    banner()
+    tools = []
+    cats = {}
+    for cat, name, alias, summary in all_tools():
+        if name in ("menu",):
+            continue
+        cats.setdefault(cat, []).append((name, alias, summary))
+    n = 0
+    for cat in CATEGORY_ORDER:
+        if cat not in cats:
+            continue
+        print("  " + c(cat, "bold bmagenta"))
+        for name, alias, summary in cats[cat]:
+            n += 1
+            tools.append(name)
+            print("   %s %s  %s" % (c(str(n).rjust(2), "gray"), c(name.ljust(10), "bold bcyan"), summary))
+        print()
+    while True:
+        pick = ask("pick a tool by number or name (q to quit)")
+        if pick.lower() in ("", "q", "quit", "exit"):
+            return 0
+        name = tools[int(pick) - 1] if pick.isdigit() and 0 < int(pick) <= len(tools) else pick
+        print()
+        main([name, "--help"] if True else [])
+        line = ask("arguments (blank = run with none, 'b' = back)")
+        if line.lower() == "b":
+            continue
+        try:
+            argv = [name] + shlex.split(line)
+        except ValueError as e:
+            print(c("bad quoting: %s" % e, "red"))
+            continue
+        print()
+        main(argv)
+        print()
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    setup_console()
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "func", None):
+        print_overview()
+        return 0
+    try:
+        return int(args.func(args) or 0)
+    except DktError as e:
+        print(c("error:", "red"), e, file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print(file=sys.stderr)
+        return 130
+    except BrokenPipeError:
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dktcli-1.0.0/src/devkittools/tools/__init__.py

@@ -0,0 +1 @@
+"""Individual dkt tools. Each module exposes register(subparsers, common) and run(args)."""

dktcli-1.0.0/src/devkittools/tools/bench.py

@@ -0,0 +1,73 @@
+"""dkt bench (bn) - time a command over several runs."""
+from __future__ import annotations
+
+import argparse
+import statistics
+import subprocess
+import time
+
+from ..utils import DktError, Spinner, bar, c, kv
+
+META = ("Project & Code", "bench", "bn", "benchmark any command: min/mean/max over N runs")
+
+EPILOG = """\
+examples:
+  dkt bn "python script.py"
+  dkt bn "node a.js" "node b.js" -n 20      compare two commands
+  dkt bn "make build" --warmup 2 --runs 5
+"""
+
+
+def fmt(s: float) -> str:
+    return "%.0f ms" % (s * 1000) if s < 1 else "%.2f s" % s
+
+
+def time_cmd(cmd: str, runs: int, warmup: int):
+    times = []
+    fails = 0
+    for i in range(warmup + runs):
+        t0 = time.perf_counter()
+        rc = subprocess.call(cmd, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        dt = time.perf_counter() - t0
+        if i >= warmup:
+            times.append(dt)
+            fails += rc != 0
+    return times, fails
+
+
+def run(args) -> int:
+    if not args.commands:
+        raise DktError('Give at least one command, e.g. dkt bn "python script.py"')
+    results = []
+    for cmd in args.commands:
+        with Spinner("benchmarking: %s" % cmd):
+            times, fails = time_cmd(cmd, args.runs, args.warmup)
+        results.append((cmd, times, fails))
+    best = min(statistics.mean(t) for _, t, _ in results)
+    for cmd, times, fails in results:
+        mean = statistics.mean(times)
+        print("\n  " + c(cmd, "bold bcyan"))
+        rows = [("mean", c(fmt(mean), "bold") + (" " + c("± " + fmt(statistics.stdev(times)), "gray") if len(times) > 1 else "")),
+                ("range", "%s … %s" % (fmt(min(times)), fmt(max(times)))),
+                ("runs", "%d%s" % (len(times), c("  (%d failed)" % fails, "red") if fails else ""))]
+        if len(results) > 1:
+            rows.append(("vs best", "%.2fx" % (mean / best) if mean > best else c("fastest", "bgreen")))
+        kv(rows)
+    if len(results) > 1:
+        print()
+        mx = max(statistics.mean(t) for _, t, _ in results)
+        for cmd, times, _ in results:
+            m = statistics.mean(times)
+            print("  %s %s  %s" % (c(bar(m, mx, 24), "bmagenta"), fmt(m).rjust(8), cmd))
+    print()
+    return 0
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("bench", aliases=["bn"], parents=[common], help=META[3],
+                       description="Benchmark shell commands.", epilog=EPILOG,
+                       formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("commands", nargs="*", metavar="CMD")
+    p.add_argument("-n", "--runs", type=int, default=10)
+    p.add_argument("--warmup", type=int, default=1)
+    p.set_defaults(func=run)