release: v0.15.0 — shimkit db redis

Sixth engine in the db registry: Redis. Container-first, port
:16379, AUTH via --requirepass, AOF persistence on by default.

Why Redis: standard cache + queue backend for Laravel
(CACHE_DRIVER=redis), Symfony (CacheItemPool), Django (Channels)
etc. With this release a developer can:

  shimkit db postgres up
  shimkit db redis up
  shimkit framework symfony env --yes --db postgres ./my-app

and have a full SQL + cache dev stack with one apt-install-free
flow.

New Engine ABC method:

  def up_command(self, *, password: str) -> list[str] | None: ...

Default returns None (use image's default CMD). Redis overrides
to return `["redis-server", "--requirepass", PW, "--appendonly",
"yes"]`. Available to any future engine that needs argv-passed
config the image doesn't expose as env vars.

`DbManager._EngineBound.up` plumbs the new method through to
`docker.containers.run` via a `command=` kwarg, conditionally
when up_command returns non-None.

Redis specifics — what we don't do:

- **`dump` is unsupported.** Redis backups are RDB snapshots
  (binary, server-version-tied). The right backup story is
  volume-level (`/data/dump.rdb` inside the managed volume),
  not a stream piped to stdout. Users wanting a dump:
  `shimkit db redis shell` then `SAVE` or `BGSAVE`.

- **`--on-host` is unsupported.** Same charter as mongo +
  phpmyadmin: shimkit doesn't install host packages. Users
  wanting host Redis run `brew install redis` / `apt install
  redis-server` themselves.

stack lemp interaction:

`stack lemp` is SQL-class only. The recipe now rejects non-SQL
backing DBs with a clearer error pointing the user at
`shimkit db <engine> up` for cache / non-relational backends.
Two pre-existing tests that used `redis` as the "unknown engine"
placeholder are updated to use `elasticsearch` (still
genuinely unknown).

Tests: 16 new in test_tools_db_redis.py (1070 → 1086 total).
Registry membership + insertion order, pure engine driver
(environment_for_up empty / up_command argv shape with
--requirepass + --appendonly / shell_argv uses --no-auth-warning
+ -a / no-password fallback / supports_dump=False /
supports_on_host=False / data_dir=/data / container_port=6379 /
name=redis), manager plumbing (up passes command= through
docker.containers.run / dump refused / on-host refused), config
defaults present.

Gates: pytest 1086 passed, ruff clean, mypy strict clean. No new
optional dependency extras.

Author: imanimanyara

CHANGELOG.md

@@ -6,6 +6,57 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+## [0.15.0] — 2026-05-16
+
+### Added
+
+- **`shimkit db redis`** — sixth engine in the `db` registry.
+  Image `redis:7-alpine`, host port `:16379`, container port 6379.
+  AUTH via `--requirepass` (Redis's official image doesn't read
+  a `REDIS_PASSWORD` env var), AOF persistence on by default.
+- **`Engine.up_command(password)`** — new method on the engine
+  ABC. Default returns `None` (use image's default CMD). Redis
+  overrides to return `["redis-server", "--requirepass", PW,
+  "--appendonly", "yes"]`. Available to any future engine that
+  needs argv-passed config the image doesn't expose as env vars.
+- `Redis` engine driver in `tools/db/engines/redis.py`. Marks
+  `supports_dump=False` (Redis backups are volume-level RDB
+  snapshots, not logical dumps) and `supports_on_host=False`
+  (same charter as mongo / phpmyadmin — shimkit doesn't manage
+  host-installed Redis).
+
+### Changed
+
+- `stack lemp` rejects non-SQL backing DBs with a clearer error
+  (mongo / redis / phpmyadmin can run alongside via the per-
+  engine `shimkit db <engine> up` but don't fit the L-E-M-P role).
+- `DbManager._EngineBound.up` plumbs `Engine.up_command` through
+  to `docker run` via the new optional `command=` kwarg.
+
+### Tests
+
+- 16 new tests in `tests/test_tools_db_redis.py` (1070 → 1086
+  total). Registry membership + insertion order, pure engine
+  driver shape (environment_for_up empty / up_command argv /
+  shell_argv with --no-auth-warning / no-password fallback /
+  supports_dump=False / supports_on_host=False / data_dir /
+  container_port), manager plumbing (up passes command= through
+  docker.containers.run / dump refused / on-host refused),
+  config defaults present.
+- Adjusted two pre-existing tests that used `redis` as an "unknown
+  engine" placeholder (now a valid name).
+
+### Notes
+
+`shimkit db redis up` gives Laravel / Symfony / Django users a
+local Redis cache and queue backend without touching the host
+package manager. Pairs with the framework recipes — set
+`REDIS_URL=redis://default:shimkit-dev@127.0.0.1:16379/0` in
+your `.env` / `.env.local` / `settings.py`.
+
+Gates: pytest 1086 passed, ruff clean, mypy strict clean. No new
+optional dependency extras.
+
 ## [0.14.0] — 2026-05-16
 
 ### Added

docs/README.md

@@ -94,6 +94,8 @@ Top-level utilities (not tools):
 
 Per-version, user-facing summaries (newest first):
 
+- **[`v0.15.0`](release-notes/v0.15.0.md)** — `shimkit db redis`
+  sixth engine. `Engine.up_command()` for argv-passed config.
 - **[`v0.14.0`](release-notes/v0.14.0.md)** — `shimkit framework
   symfony` sibling recipe under the `framework` parent.
 - **[`v0.13.0`](release-notes/v0.13.0.md)** — `shimkit tls --method

docs/release-notes/v0.15.0.md

@@ -0,0 +1,142 @@
+# shimkit 0.15.0
+
+Sixth engine in the `shimkit db` registry: Redis. For the full
+machine-readable changelog, see [`CHANGELOG.md`](../../CHANGELOG.md).
+
+---
+
+## TL;DR
+
+```
+shimkit db redis up         # redis:7-alpine on 127.0.0.1:16379
+shimkit db redis shell      # redis-cli with AUTH
+shimkit db redis down       # stop + remove the container
+shimkit db redis status     # state + port
+shimkit db redis reset      # SEVERE — drop the container AND its volume
+```
+
+`dump` and `--on-host` are intentionally **not** supported on
+Redis (see below).
+
+---
+
+## Why Redis
+
+Local Redis is the standard cache + queue backend for Laravel
+(`CACHE_DRIVER=redis` / queue worker), Symfony (`CacheItemPool` via
+Redis), Django (Channels), and just about everything else. Adding
+it to the `db` registry means one command brings up an authed
+Redis container alongside your SQL DB:
+
+```bash
+shimkit db postgres up
+shimkit db redis up
+shimkit framework symfony env --yes --db postgres ./my-app
+echo "REDIS_URL=redis://default:shimkit-dev@127.0.0.1:16379/0" >> ./my-app/.env.local
+```
+
+No `apt install redis-server`, no systemd config, no AUTH file
+to maintain — same lifecycle as the other engines.
+
+---
+
+## What's new
+
+### `Engine.up_command(password)` (new ABC method)
+
+Default returns `None` (use image's default `CMD`). Redis overrides
+to return:
+
+```python
+["redis-server", "--requirepass", PASSWORD, "--appendonly", "yes"]
+```
+
+The official `redis:7-alpine` image doesn't read a `REDIS_PASSWORD`
+env var (that's a Bitnami convention). The clean way to configure
+AUTH is to pass `--requirepass` as the container command. The new
+ABC method is available to any future engine that needs argv-passed
+config.
+
+### Redis specifics
+
+- **Port**: `127.0.0.1:16379` (shimkit's `:1` prefix on the
+  upstream port — keeps a system-installed Redis from colliding).
+- **Volume**: `~/.shimkit/data/db/redis-dev/` mounts at `/data`
+  inside. AOF + RDB live here.
+- **Persistence**: AOF enabled by default (`--appendonly yes`).
+- **AUTH**: mandatory. Default password `shimkit-dev`; override
+  via `--password` or `tools.db.default_password`.
+- **Image**: `redis:7-alpine` (~30 MB).
+
+### Why no `dump`
+
+Redis dumps are RDB snapshots — binary, version-tied to the
+server. The right backup story is volume-level (just `cp` the
+`/data/dump.rdb` file inside the managed volume), not a stream
+piped to stdout. shimkit returns `supports_dump=False` rather
+than emitting half-broken bytes.
+
+To trigger an RDB write:
+
+```bash
+shimkit db redis shell
+# 127.0.0.1:16379> SAVE       (synchronous, blocks)
+# 127.0.0.1:16379> BGSAVE     (background)
+```
+
+The file lands at `~/.shimkit/data/db/redis-dev/dump.rdb` on the
+host.
+
+### Why no `--on-host`
+
+Same charter as mongo and phpmyadmin: shimkit doesn't install host
+packages. Users wanting host Redis run `brew install redis` /
+`apt install redis-server` themselves and manage it via systemd
+/ brew services directly. The `--on-host` mode for mysql /
+mariadb / postgres (v0.9.0) exists because those are the engines
+where users frequently switch between host + container; Redis
+isn't.
+
+---
+
+## `stack lemp` interaction
+
+The LEMP recipe is SQL-only. Trying to use `--db redis` now
+returns a clear error:
+
+```
+✗ `stack lemp` only supports SQL backing DBs (mariadb, mysql,
+  postgres); got 'redis'. Run `shimkit db redis up` separately
+  to add a cache / non-relational backend.
+```
+
+Run them side-by-side:
+
+```bash
+shimkit stack lemp up --db postgres --project myapp
+shimkit db redis up
+```
+
+Both bind 127.0.0.1; the framework container reaches Redis via
+`host.docker.internal:16379` on Docker Desktop or
+`172.17.0.1:16379` on Linux (`host-gateway`).
+
+---
+
+## Stats
+
+- Tests: 1070 → 1086 (+16)
+- Gates: pytest, ruff, mypy strict — all green
+- New optional extras: 0
+
+---
+
+## Upgrading
+
+```bash
+uv tool upgrade shimkit
+pipx upgrade shimkit
+```
+
+Existing db engines see no behavioural change. To start using
+Redis, `shimkit db redis up`.

docs/tools/db.md

@@ -1,7 +1,7 @@
 # shimkit db
 
-Container-first database orchestration. Five engines today
-(`mysql`, `mariadb`, `postgres`, `mongo`, `phpmyadmin`); every one
+Container-first database orchestration. Six engines today
+(`mysql`, `mariadb`, `postgres`, `mongo`, `redis`, `phpmyadmin`); every one
 runs as a Docker container, bound to `127.0.0.1` by default,
 backed by a host volume at `~/.shimkit/data/db/<engine>-<id>/`.
 
@@ -73,12 +73,31 @@ Limits:
 | mariadb    | `mariadb:10.11`  | `:13307` | `3306`  | `root` |
 | postgres   | `postgres:16`    | `:15432` | `5432`  | `postgres` |
 | mongo      | `mongo:7`        | `:17017` | `27017` | `admin` |
+| redis      | `redis:7-alpine` | `:16379` | `6379`  | n/a (`--requirepass`) |
 | phpmyadmin | `phpmyadmin:5`   | `:18080` | `80`    | n/a (web UI) |
 
 Shimkit-prefixed host ports keep a system-installed engine
 (if any) from colliding. Override per-invocation with `--port` or
 project-wide via `tools.db.engines.<engine>.default_port`.
 
+### Redis (v0.15.0)
+
+Redis is the odd engine: no admin user, no SQL, no dump. The
+official `redis:7-alpine` image doesn't read a `REDIS_PASSWORD`
+env var, so shimkit configures AUTH by passing `--requirepass`
+as the container command. AOF persistence (`--appendonly yes`) is
+on by default — that's the recommended dev posture.
+
+- **`dump` is unsupported** — Redis backups are volume-level
+  (the `/data/dump.rdb` file inside the managed volume), not
+  logical dumps. Trigger one from the shell:
+  `shimkit db redis shell` then `SAVE` (synchronous) or `BGSAVE`
+  (background).
+- **`--on-host` is unsupported** — same reason as mongo /
+  phpmyadmin: shimkit doesn't install host packages. Users
+  wanting host Redis run `brew install redis` /
+  `apt install redis-server` themselves.
+
 Default bind is **`127.0.0.1`** (loopback only). Override with
 `--bind 0.0.0.0` if you really want to expose the port on the LAN —
 and pair that with a sensible `--password`.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shimkit"
-version = "0.14.0"
+version = "0.15.0"
 description = "A toolkit of developer utilities — Java version manager, shell upgrader, and more. Python tools, shimmed by bash."
 readme = "README.md"
 license = { file = "LICENSE" }

src/shimkit/__init__.py

@@ -3,5 +3,5 @@
 Python tools, shimmed by bash.
 """
 
-__version__ = "0.14.0"
+__version__ = "0.15.0"
 __all__ = ["__version__"]

src/shimkit/config/defaults.json

@@ -156,6 +156,7 @@
         "mariadb":    {"image": "mariadb:10.11", "default_port": 13307},
         "postgres":   {"image": "postgres:16",   "default_port": 15432},
         "mongo":      {"image": "mongo:7",       "default_port": 17017},
+        "redis":      {"image": "redis:7-alpine","default_port": 16379},
         "phpmyadmin": {"image": "phpmyadmin:5",  "default_port": 18080}
       },
       "host_services": {

src/shimkit/config/schema.py

@@ -304,6 +304,7 @@ class DbConfig(_StrictModel):
             "mariadb": DbEngineEntry(image="mariadb:10.11", default_port=13307),
             "postgres": DbEngineEntry(image="postgres:16", default_port=15432),
             "mongo": DbEngineEntry(image="mongo:7", default_port=17017),
+            "redis": DbEngineEntry(image="redis:7-alpine", default_port=16379),
             "phpmyadmin": DbEngineEntry(image="phpmyadmin:5", default_port=18080),
         }
     )

src/shimkit/tools/db/engines/__init__.py

@@ -16,13 +16,15 @@
 from .mysql import MySQL
 from .phpmyadmin import PhpMyAdmin
 from .postgres import Postgres
+from .redis import Redis
 
 # Insertion order is preserved so `db ls` / help output is stable.
 REGISTRY: dict[str, Engine] = {
     "mysql": MySQL(),
     "mariadb": MariaDB(),
     "postgres": Postgres(),
     "mongo": Mongo(),
+    "redis": Redis(),
     "phpmyadmin": PhpMyAdmin(),
 }
 
@@ -42,6 +44,7 @@ def get(name: str) -> Engine | None:
     "MySQL",
     "PhpMyAdmin",
     "Postgres",
+    "Redis",
     "UnsupportedEngineOperationError",
     "get",
 ]

src/shimkit/tools/db/engines/base.py

@@ -104,6 +104,16 @@ def requires_link(self) -> bool:
         """
         return False
 
+    def up_command(self, *, password: str) -> list[str] | None:
+        """Override the image's default ``CMD``.
+
+        Default is ``None`` — use the image's built-in entrypoint /
+        cmd. Engines that need argv-passed config (e.g. Redis's
+        ``--requirepass``, which isn't exposed as an env var by the
+        official image) override and return the full argv.
+        """
+        return None
+
     # ---- --on-host mode -------------------------------------------------
 
     def supports_on_host(self) -> bool: