• If

  $ARGUMENTS

  is not empty,

  SERVICE=$ARGUMENTS

  (normalize to lowercase).
• If

  $ARGUMENTS

  is empty, skip to Step 3 to ask the user to select a service.

test -f .devtools/${SERVICE}.compose.yml

• If the file does not exist → continue to Step 2.
• If the file exists → go to Step 1a.

"

${SERVICE}

is already installed in

.devtools/

."

"Add another instance with an alias, or cancel? [alias/cancel]"

• If user answers cancel → output

  "Nothing written. Exiting."

  and stop.
• If user provides an alias (e.g.

  cache

  ,

  session

  ):
  • Set

    ALIAS=<alias>

    (lowercase, letters/numbers/hyphens only).
  • Set

    SERVICE_SLUG=${SERVICE}-${ALIAS}

    (e.g.

    redis-cache

    ).
  • Set

    SERVICE_SNAKE=${SERVICE}_${ALIAS}

    (e.g.

    redis_cache

    ) — used for YAML service keys, volume keys, network keys.
  • Set

    ENV_PREFIX=<SERVICE_UPPER>_<ALIAS_UPPER>

    (e.g.

    REDIS_CACHE

    ) — used for env var names.
  • Check if alias already installed:
    bash

    test -f .devtools/${SERVICE_SLUG}.compose.yml

  • If file exists → output

    "${SERVICE_SLUG} is already installed — nothing to do."

    and stop. (MERGE-04)
  • If file does not exist → set

    MODE=alias

    and continue to Step 3.
• No alias set and no existing file → set

  MODE=standard

  and continue to Step 2.

.devtools/

test -d .devtools

• If

  .devtools/

  exists → skip to Step 3.
• If

  .devtools/

  does not exist → proceed:
  1. Announce:

     "Creating .devtools/ directory..."

     .
  2. Create the directory:
     bash

     mkdir -p .devtools

  3. Write

     .devtools/.gitignore

     with exactly this content (do not add any other entries):

     .env

  4. Ask:

     "Project name for Docker namespacing? [default: <derive from git remote or pwd>]"

     • Derive the default: run

       basename $(git remote get-url origin 2>/dev/null || echo $(pwd)) | sed 's/\.git$//'

     • Set

       COMPOSE_PROJECT_NAME=<user answer or default>

       .
  5. Continue to Step 3.
  If

  .devtools/.env

  already exists and contains

  COMPOSE_PROJECT_NAME

  , skip the project name question entirely (D-20).

SERVICE

$ARGUMENTS

"Which service would you like to add? (redis / rabbitmq / postgres / mysql / mongodb)"

• Set

  SERVICE=<user answer>

  (normalize to lowercase).
• If the answer is not one of the five supported services, respond:

  "Service '<answer>' is not supported. Supported: redis, rabbitmq, postgres, mysql, mongodb."

  and stop.

curl -fsSL "${SKILL_RAW_BASE}/compose-templates/${SERVICE}/metadata.json"

• parameters[]

  — list of

  { name, default, env_var, token }

  entries

• ui_companion

  — present or absent

• exporter

  — present or absent (used later for monitoring)

1. Port?

   [default: <port from metadata>]

   • Store answer as

     ANSWERS[port]

     .
2. Image version/tag?

   [default: <version from metadata>]

   • Store answer as

     ANSWERS[version]

     .

[default: 6379]

"Password? [optional — press enter to skip]"

• If user presses enter →

  ANSWERS[password]=""

  (empty string — Redis runs without auth).
• Otherwise →

  ANSWERS[password]=<user input>

  .

rabbitmq

ui_companion

"Enable UI companion? [y/N]"

• If No → set

  ANSWERS[ui_enabled]=false

  and skip to Step 7.
• If Yes → set

  ANSWERS[ui_enabled]=true

  .
  Ask:

  "Enable auth on UI? [y/N]"

  (default: N) →

  ANSWERS[ui_auth]=<true/false>

  Service-specific follow-ups when UI is enabled:

  postgres (pgAdmin credentials)

  Ask:

  "pgAdmin login email? [default: admin@local.dev]"

  →

  ANSWERS[pgadmin_email]

  Ask:

  "pgAdmin login password? (required)"

  →

  ANSWERS[pgadmin_password]

  (re-ask if blank)

  mysql (phpMyAdmin — no extra credentials needed beyond service creds)

  (No additional questions — phpMyAdmin connects using MYSQL_USER / MYSQL_PASSWORD.)

  mongodb (Mongo Express auth)

  If

  ANSWERS[ui_auth]=true

  : Ask:

  "Mongo Express username? [default: admin]"

  →

  ANSWERS[me_username]

  Ask:

  "Mongo Express password? (required)"

  →

  ANSWERS[me_password]

  (re-ask if blank)

  redis (RedisInsight — no extra credentials needed)

  (RedisInsight authenticates via the Redis password already captured in Step 5.)

****

Service:        redis
Mode:           standard install  (or: alias install as "redis-cache")
─────────────────────────────────────────────
Port:           6379
Version:        7
Password:       ****
UI companion:   disabled
Taskfile tasks: yes
Monitoring:     no
─────────────────────────────────────────────
Files to write:
  .devtools/.gitignore              (first install only)
  .devtools/redis.compose.yml
  .devtools/redis.Taskfile.yml      (if Taskfile=yes)
  .devtools/compose.yml             (created or appended)
  .devtools/Taskfile.yml            (created on first install only)
  .devtools/.env                    (appended)
  .devtools/.env.example            (appended)

"Write these files? [Y/n]"

• If No → output

  "Cancelled. Nothing written."

  and stop.
• If Yes → continue to Step 9.

curl -fsSL "${SKILL_RAW_BASE}/compose-templates/${SERVICE}/${SERVICE}.compose.yml"

MODE=standard

SERVICE=redis

ANSWERS[password]

• Remove the

  --requirepass ${REDIS_PASSWORD}

  argument from the

  command:

  line.
• Remove

  -a "${REDIS_PASSWORD}"

  from the

  healthcheck.test

  command. Write the modified content (not the raw template) to

  .devtools/redis.compose.yml

  .

MODE=alias

.devtools/<filename>.compose.yml

<filename>

${SERVICE}

${SERVICE_SLUG}

redis-cache

1. Fetch and write the compose template:
   bash

   curl -fsSL "${SKILL_RAW_BASE}/compose-templates/monitoring/monitoring.compose.yml"

   Write fetched content to

   .devtools/monitoring.compose.yml

   in the target project.
2. If

   ANSWERS[taskfile]=true

   , fetch and write the Taskfile:
   bash

   curl -fsSL "${SKILL_RAW_BASE}/taskfile-templates/monitoring/monitoring.Taskfile.yml"

   Write fetched content to

   .devtools/monitoring.Taskfile.yml

   in the target project.
3. After writing

   monitoring.compose.yml

   (step 1 above), update

   .devtools/compose.yml

   to add the monitoring include (using the same create-or-append logic as Step 11a):
   yaml

     - ./monitoring.compose.yml

monitoring.compose.yml

compose.yml

• ./<filename>.compose.yml

Where `<filename>` is `${SERVICE}` (standard) or `${SERVICE_SLUG}` (alias).

**If it DOES exist (subsequent service install):**
Read the file, locate the `include:` block, and append a new line:
```yaml
  - ./<filename>.compose.yml

MODE=standard

• SERVICE_SLUG

  =

  ${SERVICE}-${ALIAS}

  (e.g.

  redis-cache

  ) — used in filenames and container names

• SERVICE_SNAKE

  =

  ${SERVICE}_${ALIAS}

  (e.g.

  redis_cache

  ) — used in YAML keys, volumes, networks

• ENV_PREFIX

  =

  <SERVICE_UPPER>_<ALIAS_UPPER>

  (e.g.

  REDIS_CACHE

  ) — used in env var names

• ${SERVICE}.compose.yml

  →

  ${SERVICE_SLUG}.compose.yml

• logs -f ${SERVICE}

  →

  logs -f ${SERVICE_SNAKE}

• restart ${SERVICE}

  →

  restart ${SERVICE_SNAKE}

✓ Done! Files written:

  .devtools/.gitignore              (first install)
  .devtools/redis.compose.yml       (or redis-cache.compose.yml for alias)
  .devtools/redis.Taskfile.yml      (if Taskfile=yes)
  .devtools/compose.yml             (created or updated)
  .devtools/Taskfile.yml            (if first install)
  .devtools/.env                    (appended)
  .devtools/.env.example            (appended)

  Start service:    task redis:up
  With UI:          task redis:up-ui
  With monitoring:  task redis:up-monitoring
  Stop:             task redis:down

  Start service:    task redis-cache:up

## REPLACED

.devtools/.env

⚠ Warning: The following keys were already present in .devtools/.env and have been replaced:
  - REDIS_PORT  (old value marked ## REPLACED)
Review .devtools/.env if this is unexpected.

⚠ Do not commit .devtools/.env — it contains real credentials.
   .devtools/.gitignore already excludes it.

• Service compose file exists at

  .devtools/<service>.compose.yml

  (or

  <service>-<alias>.compose.yml

  )
• Service Taskfile exists at

  .devtools/<service>.Taskfile.yml

  (if Taskfile=yes)

• .devtools/.env

  contains all service env vars with real values

• .devtools/.env.example

  contains all service env var names with dummy/placeholder values

• .devtools/.gitignore

  exists and contains

  .env

• .devtools/compose.yml

  exists and includes the new service's compose file

• .devtools/Taskfile.yml

  exists (created or pre-existing)

• task <service>:up

  starts the service successfully
• Re-running the skill for the same service asks alias-or-cancel (no silent overwrite)
• Re-running with an identical alias produces "already installed — nothing to do" </success_criteria>