agent-notes 2.19.0__tar.gz → 2.20.0__tar.gz

{agent_notes-2.19.0 → agent_notes-2.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.19.0
+Version: 2.20.0
 Summary: AI agent configuration manager for Claude Code, OpenCode, and Copilot
 Author-email: Eugene Naumov <min.verkligheten@gmail.com>
 License-Expression: MIT

agent_notes-2.20.0/agent_notes/VERSION

@@ -0,0 +1 @@
+2.20.0

{agent_notes-2.19.0 → agent_notes-2.20.0}/agent_notes/commands/wizard.py

@@ -259,28 +259,28 @@ def _select_skills(step: int = 0, total: int = 0, version: str = '') -> List[str
     selected_skills = list(process_skills)
 
     if tech_groups:
+        # Build one option per individual skill so users pick by name, not group label.
         options = []
+        all_skill_names = set()
         for group_name, skills in tech_groups.items():
-            desc = descriptions.get(group_name, group_name.lower())
-            count = len(skills)
-            label = f"{group_name.capitalize()} — {desc} ({count} {'skill' if count == 1 else 'skills'})"
-            options.append((label, group_name))
-
-        all_group_names = set(tech_groups.keys())
+            for skill_name in skills:
+                desc = descriptions.get(skill_name, skill_name)
+                label = f"{skill_name.capitalize()} — {desc}"
+                options.append((label, skill_name))
+                all_skill_names.add(skill_name)
 
         title = "Which domain skills to include?\n  (process skills are always included)"
         if _can_interactive():
-            selected_groups = _checkbox_select(title, options, defaults=all_group_names,
-                                               step=step, total=total, version=version)
+            selected_domain_skills = _checkbox_select(title, options, defaults=all_skill_names,
+                                                      step=step, total=total, version=version)
         else:
-            selected_groups = _checkbox_select_fallback(title, options, defaults=all_group_names,
-                                                        step=step, total=total, version=version)
+            selected_domain_skills = _checkbox_select_fallback(title, options, defaults=all_skill_names,
+                                                               step=step, total=total, version=version)
 
         skill_summary_parts = [f"process ({len(process_skills)})"] if process_skills else []
-        for group_name, skills in tech_groups.items():
-            if group_name in selected_groups:
-                selected_skills.extend(skills)
-                skill_summary_parts.append(f"{group_name.capitalize()} ({len(skills)})")
+        for skill_name in selected_domain_skills:
+            selected_skills.append(skill_name)
+            skill_summary_parts.append(skill_name.capitalize())
     else:
         skill_summary_parts = [f"process ({len(process_skills)})"] if process_skills else []
 

agent_notes-2.20.0/agent_notes/data/skills/docker/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: docker
+group: domain
+description: "Docker development: Dockerfiles, Compose, multi-stage builds, and service patterns. Context7-style: loads only the relevant reference on demand."
+triggers:
+  - docker
+  - Dockerfile
+  - docker-compose
+  - container
+  - multi-stage build
+  - health check
+  - Docker Compose
+---
+
+# Docker Reference
+
+Based on the user's current task, use the Read tool to load the relevant reference file from this skill's directory. Only load the file(s) you need — do not load all of them.
+
+| Topic | File | Use when |
+|---|---|---|
+| Dockerfile | dockerfile.md | Writing or editing Dockerfiles, multi-stage builds, layer optimization, language-specific patterns |
+| Compose | compose.md | Writing docker-compose.yml, service definitions, health checks, dev/prod configs |
+
+The reference files are in the same directory as this skill file. After reading, apply the patterns and conventions to the user's code.

agent_notes-2.19.0/agent_notes/data/skills/docker-compose-advanced/SKILL.md → agent_notes-2.20.0/agent_notes/data/skills/docker/compose.md

@@ -1,10 +1,317 @@
+# Docker Compose
+
+## Docker Compose Patterns
+
+Production-ready Docker Compose configurations for multi-container applications based on official Docker Compose Specification and current best practices.
+
+> **Sources**: This guide is based on [Docker Compose Specification](https://docs.docker.com/reference/compose-file/), [Docker Compose Services Reference](https://docs.docker.com/reference/compose-file/services/), and Docker Compose v2 (2022+) best practices.
+
+---
+
+## Important: Version Field is Obsolete
+
+**The `version:` field is obsolete** as of Docker Compose v2 (2022). Docker Compose now ignores this field entirely. Modern compose files should **NOT include** a `version:` field.
+
+**Why**: Docker Compose v1.27.0+ (2020) introduced the Compose Specification, making the version field optional. The Compose Specification is now the recommended version.
+
+**Source**: [Docker Compose Specification](https://docs.docker.com/reference/compose-file/)
+
+---
+
+## Compose File Structure Template
+
+```yaml
+services:
+  # Application service
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: production
+      args:
+        NODE_ENV: production
+    image: myapp:latest
+    container_name: myapp
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - DATABASE_URL=postgresql://postgres:password@db:5432/myapp
+      - REDIS_URL=redis://redis:6379
+    env_file:
+      - .env
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    volumes:
+      - ./uploads:/app/uploads
+      - app_logs:/app/logs
+    networks:
+      - app_network
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # Database service
+  db:
+    image: postgres:16-alpine
+    container_name: myapp_db
+    restart: unless-stopped
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=password
+      - POSTGRES_DB=myapp
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro
+    networks:
+      - app_network
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  # Redis service
+  redis:
+    image: redis:7-alpine
+    container_name: myapp_redis
+    restart: unless-stopped
+    command: redis-server --appendonly yes
+    volumes:
+      - redis_data:/data
+    networks:
+      - app_network
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  postgres_data:
+    driver: local
+  redis_data:
+    driver: local
+  app_logs:
+    driver: local
+
+networks:
+  app_network:
+    driver: bridge
+```
+
+---
+
+## Health Checks in Compose
+
+Health checks work the same way as Dockerfile HEALTHCHECK and use the same default values. Your Compose file can override values set in the Dockerfile.
+
+```yaml
+services:
+  web:
+    image: myapp:latest
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+```
+
+**Health check attributes**:
+- `test`: Command to run (can be string or array)
+- `interval`: Time between checks (default: 30s)
+- `timeout`: Maximum time for check to complete (default: 30s)
+- `retries`: Consecutive failures before marking unhealthy (default: 3)
+- `start_period`: Grace period for container initialization (default: 0s)
+
+**Source**: [Docker Compose Health Checks](https://docs.docker.com/reference/compose-file/services/#healthcheck)
+
 ---
-name: docker-compose-advanced
-description: "Docker Compose advanced: database services, caches, proxies, dev/prod configs, and full stack examples. Use when user needs multi-service compose setups or environment-specific overrides."
-group: docker
+
+## Depends_on with Conditions
+
+Use `condition` to wait for services to be healthy before starting dependent services.
+
+```yaml
+services:
+  app:
+    depends_on:
+      db:
+        condition: service_healthy  # Wait for health check to pass
+      redis:
+        condition: service_started  # Just wait for container to start
+```
+
+**Available conditions**:
+- `service_started`: Default, just waits for container to start
+- `service_healthy`: Waits for health check to pass
+- `service_completed_successfully`: Waits for one-time task to complete
+
+**Source**: [Docker Compose depends_on](https://docs.docker.com/reference/compose-file/services/#depends_on)
+
 ---
 
-# Docker Compose (Advanced)
+## Common Service Patterns
+
+### Node.js Application
+
+```yaml
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: ${BUILD_TARGET:-production}
+    image: ${APP_NAME}:${VERSION:-latest}
+    restart: unless-stopped
+    ports:
+      - "${APP_PORT:-3000}:3000"
+    environment:
+      NODE_ENV: ${NODE_ENV:-production}
+      DATABASE_URL: ${DATABASE_URL}
+      REDIS_URL: redis://redis:6379
+    env_file:
+      - .env
+    depends_on:
+      db:
+        condition: service_healthy
+    volumes:
+      # Development: mount source code
+      - ./src:/app/src:ro
+      # Production: named volumes for data
+      - uploads:/app/uploads
+      - logs:/app/logs
+    networks:
+      - app_network
+    healthcheck:
+      test: ["CMD", "node", "healthcheck.js"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    deploy:
+      resources:
+        limits:
+          cpus: '1'
+          memory: 1G
+        reservations:
+          cpus: '0.5'
+          memory: 512M
+```
+
+### Rails with Background Workers
+
+```yaml
+services:
+  web:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: bundle exec rails server -b 0.0.0.0
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      RAILS_ENV: ${RAILS_ENV:-production}
+      DATABASE_URL: postgresql://postgres:password@db:5432/myapp
+      REDIS_URL: redis://redis:6379/0
+      SECRET_KEY_BASE: ${SECRET_KEY_BASE}
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_started
+    volumes:
+      - ./storage:/app/storage
+      - ./log:/app/log
+    networks:
+      - app_network
+
+  sidekiq:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: bundle exec sidekiq
+    restart: unless-stopped
+    environment:
+      RAILS_ENV: ${RAILS_ENV:-production}
+      DATABASE_URL: postgresql://postgres:password@db:5432/myapp
+      REDIS_URL: redis://redis:6379/0
+    depends_on:
+      - db
+      - redis
+    volumes:
+      - ./storage:/app/storage
+      - ./log:/app/log
+    networks:
+      - app_network
+```
+
+### Python/Django with Celery
+
+```yaml
+services:
+  web:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: gunicorn myapp.wsgi:application --bind 0.0.0.0:8000 --workers 4
+    restart: unless-stopped
+    ports:
+      - "8000:8000"
+    environment:
+      DJANGO_SETTINGS_MODULE: myapp.settings.production
+      DATABASE_URL: postgresql://postgres:password@db:5432/myapp
+      REDIS_URL: redis://redis:6379/0
+      SECRET_KEY: ${SECRET_KEY}
+    depends_on:
+      db:
+        condition: service_healthy
+    volumes:
+      - ./media:/app/media
+      - ./static:/app/static
+    networks:
+      - app_network
+
+  celery_worker:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: celery -A myapp worker -l info
+    restart: unless-stopped
+    environment:
+      DJANGO_SETTINGS_MODULE: myapp.settings.production
+      DATABASE_URL: postgresql://postgres:password@db:5432/myapp
+      REDIS_URL: redis://redis:6379/0
+    depends_on:
+      - db
+      - redis
+    networks:
+      - app_network
+
+  celery_beat:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: celery -A myapp beat -l info
+    restart: unless-stopped
+    environment:
+      DJANGO_SETTINGS_MODULE: myapp.settings.production
+      REDIS_URL: redis://redis:6379/0
+    depends_on:
+      - redis
+    networks:
+      - app_network
+```
+
+---
 
 ## Database Services
 
@@ -494,7 +801,7 @@ networks:
 
 ## Best Practices
 
-### ✅ DO
+### DO
 
 1. **Remove version field** - It's obsolete in Compose v2
 2. **Use health checks** - Essential for orchestration
@@ -507,7 +814,7 @@ networks:
 9. **Separate dev/prod configs** - Different requirements
 10. **Use depends_on conditions** - Proper startup order
 
-### ❌ DON'T
+### DON'T
 
 1. **Include version field** - Generates warnings in Compose v2
 2. **Use :latest in production** - Unpredictable