thanh-kit 2.5.0 → 2.5.2

package/templates/skills/ai-artist/scripts/generate.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+AI Artist Generate - Nano Banana image generation with 3 creative modes
+
+Uses 129 actual prompts from awesome-nano-banana-pro-prompts collection.
+
+Usage:
+    python generate.py "<concept>" --output <path.png> [options]
+
+Modes:
+    --mode search   : Find best matching prompt (default)
+    --mode creative : Remix elements from multiple prompts
+    --mode wild     : AI-enhanced out-of-the-box interpretation
+    --mode all      : Generate all 3 variations
+"""
+
+import argparse
+import sys
+import os
+import re
+import random
+from pathlib import Path
+
+# Add parent for core imports
+sys.path.insert(0, str(Path(__file__).parent))
+from core import search
+
+# Gemini API setup
+CLAUDE_ROOT = Path.home() / '.claude'
+sys.path.insert(0, str(CLAUDE_ROOT / 'scripts'))
+PROJECT_CLAUDE = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(PROJECT_CLAUDE / 'scripts'))
+try:
+    from resolve_env import resolve_env
+    CENTRALIZED_RESOLVER = True
+except ImportError:
+    CENTRALIZED_RESOLVER = False
+    try:
+        from dotenv import load_dotenv
+        load_dotenv(Path.home() / '.claude' / '.env')
+        load_dotenv(Path.home() / '.claude' / 'skills' / '.env')
+    except ImportError:
+        pass
+
+try:
+    from google import genai
+    from google.genai import types
+    GENAI_AVAILABLE = True
+except ImportError:
+    GENAI_AVAILABLE = False
+
+
+# ============ CONFIGURATION ============
+NANO_BANANA_MODELS = {
+    "flash": "gemini-2.5-flash-image",
+    "pro": "gemini-3-pro-image-preview",
+}
+DEFAULT_MODEL = "flash"
+ASPECT_RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"]
+
+
+def get_api_key() -> str:
+    """Get Gemini API key from environment."""
+    if CENTRALIZED_RESOLVER:
+        return resolve_env('GEMINI_API_KEY', skill='ai-multimodal')
+    return os.getenv('GEMINI_API_KEY')
+
+
+def adapt_prompt(template_prompt: str, concept: str, **kwargs) -> str:
+    """Adapt a template prompt to the user's concept.
+
+    Intelligently replaces variables and adapts the prompt while keeping
+    the original structure and Nano Banana narrative style.
+    """
+    prompt = template_prompt
+
+    # Replace common variable patterns
+    replacements = {
+        # Raycast-style arguments
+        r'\{argument name="[^"]*" default="[^"]*"\}': concept,
+        r'\{argument name=[^}]+\}': concept,
+        # Bracket variables
+        r'\[insert [^\]]+\]': concept,
+        r'\[subject\]': concept,
+        r'\[concept\]': concept,
+        r'\[topic\]': concept,
+        r'\[product\]': concept,
+        r'\[scene\]': concept,
+        r'\[description\]': concept,
+        # Generic placeholders
+        r'\{[^}]+\}': lambda m: kwargs.get(m.group(0)[1:-1], concept),
+    }
+
+    for pattern, replacement in replacements.items():
+        if callable(replacement):
+            prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+        else:
+            prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+
+    # Ensure negative constraints exist (Nano Banana style)
+    if "NEVER" not in prompt and "DO NOT" not in prompt:
+        prompt += " NEVER add watermarks or unwanted text. DO NOT include labels."
+
+    return prompt
+
+
+def mode_search(concept: str, verbose: bool = False) -> tuple[str, dict]:
+    """Mode 1: Find best matching prompt from awesome collection."""
+    result = search(concept, "awesome", 1)
+
+    if result.get("count", 0) > 0:
+        match = result["results"][0]
+        prompt = adapt_prompt(match["prompt"], concept)
+
+        if verbose:
+            print(f"  [SEARCH] Matched: {match['title'][:60]}...")
+            print(f"  Author: {match.get('author', 'Unknown')}")
+
+        return prompt, {"mode": "search", "match": match}
+
+    # Fallback to basic prompt
+    prompt = f"A professional image of {concept}. High quality, detailed. Professional photography. NEVER add watermarks."
+    return prompt, {"mode": "search", "match": None}
+
+
+def mode_creative(concept: str, verbose: bool = False) -> tuple[str, dict]:
+    """Mode 2: Creative remix - combine elements from multiple prompts."""
+    # Get top 3 matches
+    result = search(concept, "awesome", 3)
+    matches = result.get("results", [])
+
+    if len(matches) < 2:
+        return mode_search(concept, verbose)
+
+    # Extract key elements from each prompt
+    elements = []
+    for m in matches:
+        prompt = m.get("prompt", "")
+        # Extract style descriptions, lighting, composition hints
+        if "style" in prompt.lower() or "lighting" in prompt.lower():
+            elements.append(prompt[:200])
+
+    if verbose:
+        print(f"  [CREATIVE] Remixing {len(matches)} prompts:")
+        for m in matches:
+            print(f"    - {m['title'][:50]}...")
+
+    # Build creative remix
+    base = matches[0]["prompt"]
+    style_hints = []
+
+    # Extract style from second match
+    if len(matches) > 1:
+        m2 = matches[1]["prompt"]
+        style_match = re.search(r'(style[^.]+\.)', m2, re.IGNORECASE)
+        if style_match:
+            style_hints.append(style_match.group(1))
+
+    # Extract lighting/mood from third match
+    if len(matches) > 2:
+        m3 = matches[2]["prompt"]
+        light_match = re.search(r'(lighting[^.]+\.)', m3, re.IGNORECASE)
+        if light_match:
+            style_hints.append(light_match.group(1))
+
+    # Adapt and enhance
+    prompt = adapt_prompt(base, concept)
+    if style_hints:
+        prompt += " " + " ".join(style_hints)
+
+    return prompt, {"mode": "creative", "matches": [m["title"] for m in matches]}
+
+
+def mode_wild(concept: str, verbose: bool = False) -> tuple[str, dict]:
+    """Mode 3: Wild/Out-of-the-box - AI-enhanced creative interpretation."""
+    result = search(concept, "awesome", 5)
+    matches = result.get("results", [])
+
+    # Creative transformations
+    transformations = [
+        "reimagined as a Japanese Ukiyo-e woodblock print with Prussian blue and vermilion",
+        "transformed into a premium liquid glass Bento grid infographic",
+        "captured as a vintage 1800s patent document with technical drawings",
+        "rendered as a surreal dreamscape with volumetric god rays",
+        "depicted in cyberpunk neon aesthetic with holographic elements",
+        "illustrated as a hand-drawn chalkboard explanation",
+        "visualized as an isometric 3D diorama with miniature figures",
+        "presented as a cinematic movie poster with dramatic lighting",
+        "created as a vaporwave aesthetic with glitch effects and Roman statues",
+        "designed as a premium Apple-style product showcase",
+    ]
+
+    # Pick random transformation
+    transform = random.choice(transformations)
+
+    if matches:
+        # Use structure from a random match but apply wild transformation
+        base = random.choice(matches)
+        prompt = f"{concept}, {transform}. "
+
+        # Extract any technical camera/quality settings from matched prompt
+        tech_match = re.search(r'(\d+mm lens|f/[\d.]+|Canon|Nikon|professional photography)', base["prompt"])
+        if tech_match:
+            prompt += f"Shot with {tech_match.group(1)}. "
+
+        if verbose:
+            print(f"  [WILD] Transform: {transform}")
+            print(f"  Based on: {base['title'][:50]}...")
+    else:
+        prompt = f"{concept}, {transform}. Professional quality."
+
+    prompt += " NEVER add watermarks. DO NOT include unwanted text."
+
+    return prompt, {"mode": "wild", "transformation": transform}
+
+
+def generate_image(
+    prompt: str,
+    output_path: str,
+    model: str = DEFAULT_MODEL,
+    aspect_ratio: str = "1:1",
+    size: str = "2K",
+    verbose: bool = False
+) -> dict:
+    """Generate image using Nano Banana (Gemini image models)."""
+
+    if not GENAI_AVAILABLE:
+        return {"status": "error", "error": "google-genai not installed. Run: pip install google-genai"}
+
+    api_key = get_api_key()
+    if not api_key:
+        return {"status": "error", "error": "GEMINI_API_KEY not found"}
+
+    model_id = NANO_BANANA_MODELS.get(model, model)
+
+    if verbose:
+        print(f"\n[Nano Banana Generation]")
+        print(f"  Model: {model_id}")
+        print(f"  Aspect: {aspect_ratio}")
+        print(f"  Prompt: {prompt[:100]}...")
+
+    try:
+        client = genai.Client(api_key=api_key)
+
+        # Build config
+        image_config_args = {'aspect_ratio': aspect_ratio}
+        if 'pro' in model_id.lower() and size:
+            image_config_args['image_size'] = size
+
+        config = types.GenerateContentConfig(
+            response_modalities=['IMAGE'],
+            image_config=types.ImageConfig(**image_config_args)
+        )
+
+        response = client.models.generate_content(
+            model=model_id,
+            contents=[prompt],
+            config=config
+        )
+
+        output_file = Path(output_path)
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        if hasattr(response, 'candidates') and response.candidates:
+            for part in response.candidates[0].content.parts:
+                if part.inline_data:
+                    with open(output_file, 'wb') as f:
+                        f.write(part.inline_data.data)
+
+                    if verbose:
+                        print(f"  Generated: {output_file}")
+
+                    return {"status": "success", "output": str(output_file), "model": model_id}
+
+        return {"status": "error", "error": "No image in response"}
+
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="AI Artist Generate - Nano Banana with 3 creative modes",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Modes:
+  search   : Find best matching prompt from 129 curated prompts (default)
+  creative : Remix elements from multiple matching prompts
+  wild     : AI-enhanced out-of-the-box creative interpretation
+  all      : Generate all 3 variations
+
+Examples:
+  # Search mode (default)
+  python generate.py "tech conference banner" -o banner.png
+
+  # Creative remix
+  python generate.py "AI workshop" -o workshop.png --mode creative
+
+  # Wild/experimental
+  python generate.py "product showcase" -o product.png --mode wild
+
+  # Generate all 3 variations
+  python generate.py "futuristic city" -o city.png --mode all
+"""
+    )
+
+    parser.add_argument("concept", help="Core concept/subject to generate")
+    parser.add_argument("--output", "-o", required=True, help="Output image path")
+    parser.add_argument("--mode", "-m", choices=["search", "creative", "wild", "all"],
+                       default="search", help="Generation mode")
+    parser.add_argument("--model", choices=list(NANO_BANANA_MODELS.keys()),
+                       default=DEFAULT_MODEL, help="Model: flash or pro")
+    parser.add_argument("--aspect-ratio", "-ar", choices=ASPECT_RATIOS, default="1:1")
+    parser.add_argument("--size", choices=["1K", "2K", "4K"], default="2K")
+    parser.add_argument("--verbose", "-v", action="store_true")
+    parser.add_argument("--show-prompt", action="store_true", help="Print generated prompt")
+    parser.add_argument("--dry-run", action="store_true", help="Build prompt without generating")
+
+    args = parser.parse_args()
+
+    if args.verbose:
+        print(f"[Concept: {args.concept}]")
+
+    # Determine modes to run
+    modes = ["search", "creative", "wild"] if args.mode == "all" else [args.mode]
+
+    for mode in modes:
+        if args.verbose or len(modes) > 1:
+            print(f"\n{'='*50}")
+            print(f"[Mode: {mode.upper()}]")
+
+        # Build prompt based on mode
+        if mode == "search":
+            prompt, meta = mode_search(args.concept, args.verbose)
+        elif mode == "creative":
+            prompt, meta = mode_creative(args.concept, args.verbose)
+        elif mode == "wild":
+            prompt, meta = mode_wild(args.concept, args.verbose)
+
+        if args.show_prompt or args.verbose:
+            print(f"\n[Prompt]\n{prompt}\n")
+
+        if args.dry_run:
+            print("[Dry run - no generation]")
+            continue
+
+        # Generate output path for mode
+        output_path = args.output
+        if len(modes) > 1:
+            base = Path(args.output)
+            output_path = str(base.parent / f"{base.stem}-{mode}{base.suffix}")
+
+        result = generate_image(
+            prompt=prompt,
+            output_path=output_path,
+            model=args.model,
+            aspect_ratio=args.aspect_ratio,
+            size=args.size,
+            verbose=args.verbose
+        )
+
+        if result["status"] == "success":
+            print(f"✓ Generated: {result['output']}")
+        else:
+            print(f"✗ Error: {result['error']}")
+
+
+if __name__ == "__main__":
+    main()

package/templates/skills/ai-artist/scripts/search.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+AI Artist Search - BM25 search engine for prompt engineering resources
+Usage: python search.py "<query>" [--domain <domain>] [--max-results 3]
+       python search.py "<query>" --prompt-system [--platform <platform>]
+
+Domains: use-case, style, platform, technique, lighting
+Platforms: midjourney, dalle, sd, flux, nano-banana
+"""
+
+import argparse
+import sys
+from core import CSV_CONFIG, MAX_RESULTS, search, search_all_domains
+
+# Fix Windows cp1252 encoding: hardcoded emojis can't encode on Windows.
+# Reconfigure stdout to UTF-8 with replacement (Python 3.7+).
+if sys.stdout.encoding and sys.stdout.encoding.lower() != "utf-8":
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+
+def format_output(result):
+    """Format results for Claude consumption (token-optimized)"""
+    if "error" in result:
+        return f"Error: {result['error']}"
+
+    output = []
+    output.append(f"## AI Artist Search Results")
+    output.append(f"**Domain:** {result['domain']} | **Query:** {result['query']}")
+    output.append(f"**Source:** {result['file']} | **Found:** {result['count']} results\n")
+
+    for i, row in enumerate(result['results'], 1):
+        output.append(f"### Result {i}")
+        for key, value in row.items():
+            value_str = str(value)
+            if len(value_str) > 400:
+                value_str = value_str[:400] + "..."
+            output.append(f"- **{key}:** {value_str}")
+        output.append("")
+
+    return "\n".join(output)
+
+
+def generate_prompt_system(query, platform=None):
+    """Generate a comprehensive prompt system for a given concept"""
+    output = []
+    output.append(f"## 🎨 AI Artist Prompt System")
+    output.append(f"**Concept:** {query}")
+    if platform:
+        output.append(f"**Target Platform:** {platform}")
+    output.append("")
+
+    # Search relevant domains
+    use_case = search(query, "use-case", 1)
+    style = search(query, "style", 2)
+    lighting = search(query, "lighting", 1)
+    technique = search(query, "technique", 2)
+
+    # Use case / Template
+    if use_case.get("count", 0) > 0:
+        uc = use_case["results"][0]
+        output.append("### 📋 Use Case Match")
+        output.append(f"**{uc.get('Use Case', 'N/A')}** ({uc.get('Category', '')})")
+        if uc.get("Prompt Template"):
+            output.append(f"**Template:** `{uc.get('Prompt Template')}`")
+        if uc.get("Key Elements"):
+            output.append(f"**Key Elements:** {uc.get('Key Elements')}")
+        if uc.get("Tips"):
+            output.append(f"**Tips:** {uc.get('Tips')}")
+        output.append("")
+
+    # Styles
+    if style.get("count", 0) > 0:
+        output.append("### 🎭 Recommended Styles")
+        for s in style["results"]:
+            output.append(f"**{s.get('Style Name', 'N/A')}** - {s.get('Description', '')}")
+            if s.get("Prompt Keywords"):
+                output.append(f"  Keywords: `{s.get('Prompt Keywords')}`")
+        output.append("")
+
+    # Lighting
+    if lighting.get("count", 0) > 0:
+        lt = lighting["results"][0]
+        output.append("### 💡 Lighting Suggestion")
+        output.append(f"**{lt.get('Lighting Type', 'N/A')}** - {lt.get('Description', '')}")
+        output.append(f"  Mood: {lt.get('Mood', '')} | Keywords: `{lt.get('Prompt Keywords', '')}`")
+        output.append("")
+
+    # Techniques
+    if technique.get("count", 0) > 0:
+        output.append("### 🔧 Relevant Techniques")
+        for t in technique["results"]:
+            output.append(f"**{t.get('Technique', 'N/A')}**: {t.get('Description', '')}")
+            if t.get("Syntax Example"):
+                output.append(f"  Example: `{t.get('Syntax Example')}`")
+        output.append("")
+
+    # Platform-specific tips
+    if platform:
+        plat = search(platform, "platform", 1)
+        if plat.get("count", 0) > 0:
+            p = plat["results"][0]
+            output.append(f"### 🖥️ {p.get('Platform', '')} Tips")
+            output.append(f"**Prompt Style:** {p.get('Prompt Style', '')}")
+            output.append(f"**Key Parameters:** {p.get('Key Parameters', '')}")
+            output.append(f"**Best Practices:** {p.get('Best Practices', '')}")
+            output.append("")
+
+    return "\n".join(output)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="AI Artist Search")
+    parser.add_argument("query", help="Search query")
+    parser.add_argument("--domain", "-d", choices=list(CSV_CONFIG.keys()), help="Search domain")
+    parser.add_argument("--max-results", "-n", type=int, default=MAX_RESULTS, help="Max results (default: 3)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    # Prompt system generation
+    parser.add_argument("--prompt-system", "-ps", action="store_true", help="Generate comprehensive prompt system")
+    parser.add_argument("--platform", "-p", type=str, default=None, help="Target platform for prompt system")
+    parser.add_argument("--all", "-a", action="store_true", help="Search all domains")
+
+    args = parser.parse_args()
+
+    # Prompt system generation
+    if args.prompt_system:
+        result = generate_prompt_system(args.query, args.platform)
+        print(result)
+    # Search all domains
+    elif args.all:
+        results = search_all_domains(args.query, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(results, indent=2, ensure_ascii=False))
+        else:
+            for domain, result in results.items():
+                print(format_output(result))
+                print("---\n")
+    # Domain search
+    else:
+        result = search(args.query, args.domain, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))

package/templates/skills/ai-multimodal/SKILL.md

@@ -1,12 +1,13 @@
 ---
-name: ai-multimodal
-description: Process and generate multimedia content using Google Gemini API for better vision capabilities. Capabilities include analyze audio files (transcription with timestamps, summarization, speech understanding, music/sound analysis up to 9.5 hours), understand images (better image analysis than Claude models, captioning, reasoning, object detection, design extraction, OCR, visual Q&A, segmentation, handle multiple images), process videos (scene detection, Q&A, temporal analysis, YouTube URLs, up to 6 hours), extract from documents (PDF tables, forms, charts, diagrams, multi-page), generate images (text-to-image with Imagen 4, editing, composition, refinement), generate videos (text-to-video with Veo 3, 8-second clips with native audio). Use when working with audio/video files, analyzing images or screenshots (instead of default vision capabilities of Claude, only fallback to Claude's vision capabilities if needed), processing PDF documents, extracting structured data from media, creating images/videos from text prompts, or implementing multimodal AI features. Supports Gemini 3/2.5, Imagen 4, and Veo 3 models with context windows up to 2M tokens.
+name: ck:ai-multimodal
+description: Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.
 license: MIT
 allowed-tools:
   - Bash
   - Read
   - Write
   - Edit
+argument-hint: "[file-path] [prompt]"
 ---
 
 # AI Multimodal
@@ -50,7 +51,7 @@ GEMINI_API_KEY_3=key3
 
 **Verify setup**: `python scripts/check_setup.py`
 **Analyze media**: `python scripts/gemini_batch_process.py --files <file> --task <analyze|transcribe|extract>`
-  - TIP: When you're asked to analyze an image, check if `gemini` command is available, then use `"<prompt to analyze image>" | gemini -y -m gemini-2.5-flash` command. If `gemini` command is not available, use `python scripts/gemini_batch_process.py --files <file> --task analyze` command.
+  - TIP: When you're asked to analyze an image, check if `gemini` command is available, then use `echo "<prompt to analyze image>" | gemini -y -m <gemini.model>` command (read model from `.claude/.ck.json`: `gemini.model`). If `gemini` command is not available, use `python scripts/gemini_batch_process.py --files <file> --task analyze` command.
 **Generate content**: `python scripts/gemini_batch_process.py --task <generate|generate-video> --prompt "description"`
 
 > **Stdin support**: You can pipe files directly via stdin (auto-detects PNG/JPG/PDF/WAV/MP3).

package/templates/skills/ai-multimodal/scripts/check_setup.py

@@ -13,6 +13,14 @@ import os
 import sys
 from pathlib import Path
 
+# Fix Windows cp1252 encoding: Unicode symbols (✓, ⚠, ✗) can't encode on Windows.
+# Reconfigure stdout to UTF-8 with replacement (Python 3.7+).
+if sys.stdout.encoding and sys.stdout.encoding.lower() != "utf-8":
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    if hasattr(sys.stderr, 'reconfigure'):
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+
 # Color codes for terminal output
 GREEN = '\033[92m'
 YELLOW = '\033[93m'
@@ -81,7 +89,8 @@ def check_centralized_resolver():
     """Check if centralized resolver is available."""
     print_header("Checking Centralized Resolver")
 
-    resolver_path = Path.home() / '.claude' / 'scripts' / 'resolve_env.py'
+    claude_root = Path(__file__).parent.parent.parent.parent
+    resolver_path = claude_root / 'scripts' / 'resolve_env.py'
 
     if resolver_path.exists():
         print_success(f"Centralized resolver found: {resolver_path}")
@@ -106,7 +115,8 @@ def find_api_key():
     print_header("Checking API Key Configuration")
 
     # Try to use centralized resolver
-    sys.path.insert(0, str(Path.home() / '.claude' / 'scripts'))
+    claude_root = Path(__file__).parent.parent.parent.parent
+    sys.path.insert(0, str(claude_root / 'scripts'))
     try:
         from resolve_env import resolve_env
 

package/templates/skills/ai-multimodal/scripts/gemini_batch_process.py

@@ -23,8 +23,9 @@ from typing import List, Dict, Any, Optional
 import csv
 import shutil
 
-# Import centralized environment resolver
-sys.path.insert(0, str(Path.home() / '.claude' / 'scripts'))
+# Import centralized environment resolver (works for both local and global installs)
+CLAUDE_ROOT = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(CLAUDE_ROOT / 'scripts'))
 try:
     from resolve_env import resolve_env
     CENTRALIZED_RESOLVER_AVAILABLE = True

package/templates/skills/ask/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: ck:ask
+description: "Answer technical and architectural questions with expert consultation."
+argument-hint: "[technical-question]"
+---
+
+# Technical Consultation
+
+Technical question or architecture challenge:
+<questions>$ARGUMENTS</questions>
+
+Current development workflows, system constraints, scale requirements, and business context will be considered:
+- Primary workflow: `./.claude/rules/primary-workflow.md`
+- Development rules: `./.claude/rules/development-rules.md`
+- Orchestration protocols: `./.claude/rules/orchestration-protocol.md`
+- Documentation management: `./.claude/rules/documentation-management.md`
+
+**Project Documentation:**
+```
+./docs
+├── project-overview-pdr.md
+├── code-standards.md
+├── codebase-summary.md
+├── design-guidelines.md
+├── deployment-guide.md
+├── system-architecture.md
+└── project-roadmap.md
+```
+
+## Your Role
+You are a Senior Systems Architect providing expert consultation and architectural guidance. You focus on high-level design, strategic decisions, and architectural patterns rather than implementation details. You orchestrate four specialized architectural advisors:
+1. **Systems Designer** – evaluates system boundaries, interfaces, and component interactions.
+2. **Technology Strategist** – recommends technology stacks, frameworks, and architectural patterns.
+3. **Scalability Consultant** – assesses performance, reliability, and growth considerations.
+4. **Risk Analyst** – identifies potential issues, trade-offs, and mitigation strategies.
+You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
+
+## Process
+1. **Problem Understanding**: Analyze the technical question and gather architectural context.
+   - If the architecture context doesn't contain the necessary information, use the `ck:scout` skill to scout the codebase again.
+2. **Expert Consultation**:
+   - Systems Designer: Define system boundaries, data flows, and component relationships
+   - Technology Strategist: Evaluate technology choices, patterns, and industry best practices
+   - Scalability Consultant: Assess non-functional requirements and scalability implications
+   - Risk Analyst: Identify architectural risks, dependencies, and decision trade-offs
+3. **Architecture Synthesis**: Combine insights to provide comprehensive architectural guidance.
+4. **Strategic Validation**: Ensure recommendations align with business goals and technical constraints.
+
+## Output Format
+**Be honest, be brutal, straight to the point, and be concise.**
+1. **Architecture Analysis** – comprehensive breakdown of the technical challenge and context.
+2. **Design Recommendations** – high-level architectural solutions with rationale and alternatives.
+3. **Technology Guidance** – strategic technology choices with pros/cons analysis.
+4. **Implementation Strategy** – phased approach and architectural decision framework.
+5. **Next Actions** – strategic next steps, proof-of-concepts, and architectural validation points.
+
+## Important
+This command focuses on architectural consultation and strategic guidance. Do not start implementing anything.

package/templates/skills/backend-development/SKILL.md

@@ -1,8 +1,9 @@
 ---
-name: backend-development
-description: Build robust backend systems with modern technologies (Node.js, Python, Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB, Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies, security best practices (OWASP Top 10), performance optimization, scalability patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes, CI/CD), and monitoring. Use when designing APIs, implementing authentication, optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities, building microservices, or developing production-ready backend systems.
+name: ck:backend-development
+description: Build backends with Node.js, Python, Go (NestJS, FastAPI, Django). Use for REST/GraphQL/gRPC APIs, auth (OAuth, JWT), databases, microservices, security (OWASP), Docker/K8s.
 license: MIT
 version: 1.0.0
+argument-hint: "[framework] [task]"
 ---
 
 # Backend Development Skill