claude-code-kit 0.18.0__tar.gz → 0.19.0__tar.gz

{claude_code_kit-0.18.0 → claude_code_kit-0.19.0}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "claude-kit",
       "source": "./",
       "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker): install CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json, then run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.",
-      "version": "0.18.0",
+      "version": "0.19.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.18.0 → claude_code_kit-0.19.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker). `claude-kit init` asks ordered questions and installs CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates with working memory and a self-improving learnings loop.",
   "author": {
     "name": "Arjunsingh Yadav",

{claude_code_kit-0.18.0 → claude_code_kit-0.19.0}/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to claude-kit are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project uses
 [semantic versioning](https://semver.org/).
 
+## [0.19.0] — 2026-06-20
+
+**Add four granular Docker skills (backend/frontend Dockerfiles, shared building blocks, compose).**
+
+### Added
+
+- **4 granular Docker skills** under `skills/`, complementing the broader `containerization-and-deployment`
+  skill with focused deep-dives derived from real production Python/FastAPI + React services:
+  - **`dockerfile-backend`** — multi-stage Python/FastAPI Dockerfiles: builder/runtime split, slim vs
+    alpine trade-offs, system deps (libpq/librdkafka/krb5), layer-cache ordering, venv copy, non-root
+    user, multi-mode entrypoint, gunicorn+uvicorn, `HEALTHCHECK`.
+  - **`dockerfile-frontend`** — React/Vite multi-stage builds: node(alpine) build → nginx runtime,
+    lockfile-first caching, `VITE_*`/`REACT_APP_*` build args, runtime `envsubst`, nginx SPA history fallback.
+  - **`docker-shared`** — shared base images from a private registry (tag vs `@sha256` digest pinning),
+    `.dockerignore` conventions, shared compose fragments (YAML anchors, `x-` fields, external
+    networks/volumes), and the build-arg-secret anti-pattern + BuildKit `--mount=type=secret` fix.
+  - **`docker-compose`** — local-dev/orchestration: postgres/redis/kafka/temporal healthchecks wired to
+    `depends_on: condition: service_healthy`, one-image-many-roles (MODE), env-specific compose files.
+  Each ships `SKILL.md` + `README.md` + `references/`, cross-links `containerization-and-deployment`,
+  and is fully genericized (no internal service/registry/org names, paths, or secrets) — verified by a
+  scrub gate + adversarial critic. Like the 0.18.0 set, these are intentionally stack-specific and not
+  wired into the catalog/scaffold, so `claude-kit init` output is unchanged. The `docs/stack-skills/`
+  index is updated (22 skills).
+
 ## [0.18.0] — 2026-06-20
 
 **Add a stack-specific skill collection (Python/FastAPI + React) and refine the secret guard.**

{claude_code_kit-0.18.0 → claude_code_kit-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.18.0
+Version: 0.19.0
 Summary: Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.
 Project-URL: Homepage, https://github.com/ajyadav013/claude-kit
 Project-URL: Repository, https://github.com/ajyadav013/claude-kit

{claude_code_kit-0.18.0 → claude_code_kit-0.19.0}/docs/stack-skills/README.md

@@ -1,6 +1,6 @@
 # Production Engineering Skills Collection
 
-These eighteen Claude Code skills encode production-proven engineering conventions derived from real-world Python/FastAPI and React services. Each skill was extracted from analyzing patterns across multiple production backend and frontend services, capturing canonical patterns for FastAPI microservices, async Python, Kafka/Temporal integration, multi-tenancy, database access, React frontends, observability, authentication, containerization, testing, data pipelines, and modernization strategies. Use them to align new projects with established patterns, audit existing services, or onboard engineers to modern Python and React development practices.
+These twenty-two Claude Code skills encode production-proven engineering conventions derived from real-world Python/FastAPI and React services. Each skill was extracted from analyzing patterns across multiple production backend and frontend services, capturing canonical patterns for FastAPI microservices, async Python, Kafka/Temporal integration, multi-tenancy, database access, React frontends, observability, authentication, containerization (with granular Dockerfile/compose deep-dives), testing, data pipelines, and modernization strategies. Use them to align new projects with established patterns, audit existing services, or onboard engineers to modern Python and React development practices.
 
 > **Where these live in this repo:** the skill folders are under [`skills/`](../../skills/) (auto-discovered by the claude-kit plugin). The links below point there.
 
@@ -21,6 +21,10 @@ These eighteen Claude Code skills encode production-proven engineering conventio
 | **observability-and-logging** | Structured logging, OpenTelemetry tracing, Sentry error tracking, Prometheus metrics, NewRelic, request/correlation IDs, /health and /readiness endpoints | [SKILL.md](../../skills/observability-and-logging/SKILL.md) |
 | **auth-and-rbac** | Authentication dependency chain (get_current_client / x-user-data header), JWT verification, RBAC role/permission enforcement, password hashing (argon2), OTP (pyotp), tenant-scoped authorization | [SKILL.md](../../skills/auth-and-rbac/SKILL.md) |
 | **containerization-and-deployment** | Multi-stage Dockerfiles, docker-compose for local infra, one-image-many-roles pattern (entrypoint.py MODE dispatch), cert/keytab writing from env + kinit bootstrap, k8s health/readiness probes, CI pipelines, secrets/env hygiene | [SKILL.md](../../skills/containerization-and-deployment/SKILL.md) |
+| **dockerfile-backend** | Granular multi-stage Python/FastAPI Dockerfile deep-dive — builder/runtime split, slim vs alpine trade-offs, system deps (libpq/librdkafka/krb5), layer-cache ordering, venv copy, non-root user, gunicorn+uvicorn, HEALTHCHECK | [SKILL.md](../../skills/dockerfile-backend/SKILL.md) |
+| **dockerfile-frontend** | Granular React/Vite multi-stage Dockerfile deep-dive — node(alpine) build → nginx runtime, lockfile-first caching, `VITE_*`/`REACT_APP_*` build args, runtime `envsubst`, nginx SPA history fallback, security headers | [SKILL.md](../../skills/dockerfile-frontend/SKILL.md) |
+| **docker-shared** | Shared Docker building blocks — base images from a private registry (tag vs `@sha256` digest pinning), `.dockerignore` conventions, shared compose fragments (YAML anchors, `x-` fields, external networks/volumes), build-arg-secret anti-pattern + BuildKit `--mount=type=secret` | [SKILL.md](../../skills/docker-shared/SKILL.md) |
+| **docker-compose** | docker-compose for local dev + orchestration — postgres/redis/kafka/temporal healthchecks wired to `depends_on: condition: service_healthy`, one-image-many-roles (MODE), env-specific compose files (`.dev`/`.prod-test`/`.override`), profiles, migrator pattern | [SKILL.md](../../skills/docker-compose/SKILL.md) |
 | **testing-conventions** | pytest + pytest-asyncio + conftest fixtures, async test DB setup, mocking external services (Kafka/Temporal/HTTP), Playwright/allure E2E, honest account of coverage gaps with recommended baseline | [SKILL.md](../../skills/testing-conventions/SKILL.md) |
 | **alembic-migrations** | Alembic migration setup for async SQLAlchemy — alembic.ini, env.py (async engine + target_metadata), versions/ naming, autogenerate workflow, multi-tenant/multi-schema migrations | [SKILL.md](../../skills/alembic-migrations/SKILL.md) |
 | **data-engineering-bigquery-gcs** | BigQuery / GCS / pandas batch data pipelines, medallion (bronze/silver/gold) layering, ETL executed inside Temporal activities (not workflows), Vertex usage, schema/partitioning conventions | [SKILL.md](../../skills/data-engineering-bigquery-gcs/SKILL.md) |
@@ -44,6 +48,10 @@ These eighteen Claude Code skills encode production-proven engineering conventio
    - "add observability / structured logging / tracing" → **observability-and-logging**
    - "implement authentication / RBAC / JWT verification" → **auth-and-rbac**
    - "create Dockerfile / docker-compose / k8s probes" → **containerization-and-deployment**
+   - "write a Python/FastAPI backend Dockerfile / optimize image size / multi-stage build" → **dockerfile-backend**
+   - "write a React/Vite frontend Dockerfile / node build + nginx serve / VITE_* build args" → **dockerfile-frontend**
+   - "set up a shared base image / .dockerignore / private registry auth / compose YAML anchors" → **docker-shared**
+   - "write docker-compose for local dev / healthchecks / postgres+redis+kafka+temporal" → **docker-compose**
    - "set up pytest fixtures / test DB / E2E tests" → **testing-conventions**
    - "configure Alembic / autogenerate migrations" → **alembic-migrations**
    - "build BigQuery ETL / GCS pipeline / medallion architecture" → **data-engineering-bigquery-gcs**

{claude_code_kit-0.18.0 → claude_code_kit-0.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.18.0"
+version = "0.19.0"
 description = "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop."
 readme = "README.md"
 requires-python = ">=3.9"

claude_code_kit-0.19.0/skills/docker-compose/README.md

@@ -0,0 +1,36 @@
+# docker-compose Skill
+
+Docker Compose patterns for local development and multi-service orchestration, derived from real-world production microservices.
+
+## What this skill covers
+
+- **Service dependencies with health checks**: postgres (pg_isready), redis (redis-cli ping), kafka (kafka-topics.sh --list), zookeeper (zkServer.sh status), wired to `depends_on` with `condition: service_healthy`
+- **One image, many containers**: Build once, deploy as server/worker/consumer/cron by varying MODE env var
+- **Environment-specific compose files**: Base docker-compose.yml, .dev (bind mounts + debug ports), .prod-test (local Cloud Run simulation), .override (personal gitignored config)
+- **YAML anchors for shared environment variables**: Define once with `x-environment: &common-env`, reference with `<<: *common-env`
+- **Profiles for optional infrastructure**: Gate monitoring/kafka/temporal services with profiles (activate with --profile flag)
+- **Hot-reload development**: Bind mounts for source code, named volumes for data persistence, debug ports per container
+- **Kafka + Zookeeper setup**: Conditional startup, health checks, listener configuration, KRaft mode alternative
+- **Temporal orchestration**: Auto-setup image with postgres backend, Temporal UI
+- **Host connectivity for dev mode**: host.docker.internal for connecting to host-native services
+- **Migration service pattern**: One-shot migrator service that runs database migrations then exits
+
+## Source
+
+This skill is grounded in production compose files from real backend microservices (FastAPI/Python), frontend applications (React/Next.js), and infrastructure services. All examples are genericized and sanitized — no internal service names, registries, credentials, or organization-specific details.
+
+## Cross-references
+
+- **containerization-and-deployment**: Multi-stage Dockerfile, MODE dispatch entrypoint.py, cert/keytab writing, Cloud Run deployment (this skill focuses on compose orchestration; containerization-and-deployment covers the broader containerization lifecycle)
+
+## When to use
+
+Use this skill when:
+- Setting up local dev infrastructure (postgres/redis/kafka/zookeeper/temporal)
+- Implementing one-image-many-containers for different roles (server/worker/consumer/cron)
+- Configuring environment-specific compose files (.dev/.prod-test/.override)
+- Wiring service dependencies with health checks and conditional startup
+- Testing production-like deployments locally before Cloud Run/k8s deploy
+- Orchestrating multi-service applications with docker-compose
+
+Cross-link to containerization-and-deployment for Dockerfile patterns, entrypoint MODE dispatch, and deployment strategies.