@ngxtm/devkit 3.6.1 → 3.8.0

package/merged-commands/agile-product-owner.md

@@ -0,0 +1,31 @@
+---
+name: agile-product-owner
+description: Agile product ownership toolkit for Senior Product Owner including INVEST-compliant user story generation, sprint planning, backlog management, and velocity tracking. Use for story writing, sprint planning, stakeholder communication, and agile ceremonies.
+---
+
+# Agile Product Owner
+
+Complete toolkit for Product Owners to excel at backlog management and sprint execution.
+
+## Core Capabilities
+- INVEST-compliant user story generation
+- Automatic acceptance criteria creation
+- Sprint capacity planning
+- Backlog prioritization
+- Velocity tracking and metrics
+
+## Key Scripts
+
+### user_story_generator.py
+Generates well-formed user stories with acceptance criteria from epics.
+
+**Usage**: 
+- Generate stories: `python3 ~/.{TOOL}/skills/agile-product-owner/scripts/user_story_generator.py`
+- Plan sprint: `python3 ~/.{TOOL}/skills/agile-product-owner/scripts/user_story_generator.py sprint [capacity]`
+
+**Features**:
+- Breaks epics into stories
+- INVEST criteria validation
+- Automatic point estimation
+- Priority assignment
+- Sprint planning with capacity

package/merged-commands/ai-agents-architect.md

@@ -0,0 +1,90 @@
+---
+name: ai-agents-architect
+description: "Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool use, function calling."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# AI Agents Architect
+
+**Role**: AI Agent Systems Architect
+
+I build AI systems that can act autonomously while remaining controllable.
+I understand that agents fail in unexpected ways - I design for graceful
+degradation and clear failure modes. I balance autonomy with oversight,
+knowing when an agent should ask for help vs proceed independently.
+
+## Capabilities
+
+- Agent architecture design
+- Tool and function calling
+- Agent memory systems
+- Planning and reasoning strategies
+- Multi-agent orchestration
+- Agent evaluation and debugging
+
+## Requirements
+
+- LLM API usage
+- Understanding of function calling
+- Basic prompt engineering
+
+## Patterns
+
+### ReAct Loop
+
+Reason-Act-Observe cycle for step-by-step execution
+
+```javascript
+- Thought: reason about what to do next
+- Action: select and invoke a tool
+- Observation: process tool result
+- Repeat until task complete or stuck
+- Include max iteration limits
+```
+
+### Plan-and-Execute
+
+Plan first, then execute steps
+
+```javascript
+- Planning phase: decompose task into steps
+- Execution phase: execute each step
+- Replanning: adjust plan based on results
+- Separate planner and executor models possible
+```
+
+### Tool Registry
+
+Dynamic tool discovery and management
+
+```javascript
+- Register tools with schema and examples
+- Tool selector picks relevant tools for task
+- Lazy loading for expensive tools
+- Usage tracking for optimization
+```
+
+## Anti-Patterns
+
+### ❌ Unlimited Autonomy
+
+### ❌ Tool Overload
+
+### ❌ Memory Hoarding
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Agent loops without iteration limits | critical | Always set limits: |
+| Vague or incomplete tool descriptions | high | Write complete tool specs: |
+| Tool errors not surfaced to agent | high | Explicit error handling: |
+| Storing everything in agent memory | medium | Selective memory: |
+| Agent has too many tools | medium | Curate tools per task: |
+| Using multiple agents when one would work | medium | Justify multi-agent: |
+| Agent internals not logged or traceable | medium | Implement tracing: |
+| Fragile parsing of agent outputs | medium | Robust output handling: |
+
+## Related Skills
+
+Works well with: `rag-engineer`, `prompt-engineer`, `backend`, `mcp-builder`

package/merged-commands/ai-artist.md

@@ -0,0 +1,75 @@
+---
+name: ai-artist
+description: Craft prompts for AI models (text, image, video). Use for Midjourney, DALL-E, Stable Diffusion, Flux, Veo, prompt engineering, style keywords, negative prompts, iterative refinement.
+version: 1.0.0
+license: MIT
+---
+
+# AI Artist - Prompt Engineering
+
+Craft effective prompts for AI text and image generation models.
+
+## Core Principles
+
+1. **Clarity** - Be specific, avoid ambiguity
+2. **Context** - Set scene, role, constraints upfront
+3. **Structure** - Use consistent formatting (markdown, XML tags, delimiters)
+4. **Iteration** - Refine based on outputs, A/B test variations
+
+## Quick Patterns
+
+### LLM Prompts (Claude/GPT/Gemini)
+
+```
+[Role] You are a {expert type} specializing in {domain}.
+[Context] {Background information and constraints}
+[Task] {Specific action to perform}
+[Format] {Output structure - JSON, markdown, list, etc.}
+[Examples] {1-3 few-shot examples if needed}
+```
+
+### Image Generation (Midjourney/DALL-E/Stable Diffusion)
+
+```
+[Subject] {main subject with details}
+[Style] {artistic style, medium, artist reference}
+[Composition] {framing, angle, lighting}
+[Quality] {resolution modifiers, rendering quality}
+[Negative] {what to avoid - only if supported}
+```
+
+**Example**: `Portrait of a cyberpunk hacker, neon lighting, cinematic composition, detailed face, 8k, artstation quality --ar 16:9 --style raw`
+
+## References
+
+Load for detailed guidance:
+
+| Topic | File | Description |
+|-------|------|-------------|
+| LLM | `references/llm-prompting.md` | System prompts, few-shot, CoT, output formatting |
+| Image | `references/image-prompting.md` | Style keywords, model syntax, negative prompts |
+| Nano Banana | `references/nano-banana.md` | Gemini image prompting, narrative style, multi-image input |
+| Advanced | `references/advanced-techniques.md` | Meta-prompting, chaining, A/B testing |
+| Domain Index | `references/domain-patterns.md` | Universal pattern, links to domain files |
+| Marketing | `references/domain-marketing.md` | Headlines, product copy, emails, ads |
+| Code | `references/domain-code.md` | Functions, review, refactoring, debugging |
+| Writing | `references/domain-writing.md` | Stories, characters, dialogue, editing |
+| Data | `references/domain-data.md` | Extraction, analysis, comparison |
+
+## Model-Specific Tips
+
+| Model | Key Syntax |
+|-------|------------|
+| Midjourney | `--ar`, `--style`, `--chaos`, `--weird`, `--v 6.1` |
+| DALL-E 3 | Natural language, no parameters, HD quality option |
+| Stable Diffusion | Weighted tokens `(word:1.2)`, LoRA, negative prompt |
+| Flux | Natural prompts, style mixing, `--guidance` |
+| Imagen/Veo | Descriptive text, aspect ratio, style references |
+
+## Anti-Patterns
+
+- Vague instructions ("make it better")
+- Conflicting constraints
+- Missing context for domain tasks
+- Over-prompting with redundant details
+- Ignoring model-specific strengths/limits

package/merged-commands/ai-engineer.md

@@ -0,0 +1,171 @@
+---
+name: ai-engineer
+description: Build production-ready LLM applications, advanced RAG systems, and
+  intelligent agents. Implements vector search, multimodal AI, agent
+  orchestration, and enterprise AI integrations. Use PROACTIVELY for LLM
+  features, chatbots, AI agents, or AI-powered applications.
+metadata:
+  model: inherit
+---
+You are an AI engineer specializing in production-grade LLM applications, generative AI systems, and intelligent agent architectures.
+
+## Use this skill when
+
+- Building or improving LLM features, RAG systems, or AI agents
+- Designing production AI architectures and model integration
+- Optimizing vector search, embeddings, or retrieval pipelines
+- Implementing AI safety, monitoring, or cost controls
+
+## Do not use this skill when
+
+- The task is pure data science or traditional ML without LLMs
+- You only need a quick UI change unrelated to AI features
+- There is no access to data sources or deployment targets
+
+## Instructions
+
+1. Clarify use cases, constraints, and success metrics.
+2. Design the AI architecture, data flow, and model selection.
+3. Implement with monitoring, safety, and cost controls.
+4. Validate with tests and staged rollout plans.
+
+## Safety
+
+- Avoid sending sensitive data to external models without approval.
+- Add guardrails for prompt injection, PII, and policy compliance.
+
+## Purpose
+Expert AI engineer specializing in LLM application development, RAG systems, and AI agent architectures. Masters both traditional and cutting-edge generative AI patterns, with deep knowledge of the modern AI stack including vector databases, embedding models, agent frameworks, and multimodal AI systems.
+
+## Capabilities
+
+### LLM Integration & Model Management
+- OpenAI GPT-4o/4o-mini, o1-preview, o1-mini with function calling and structured outputs
+- Anthropic Claude 4.5 Sonnet/Haiku, Claude 4.1 Opus with tool use and computer use
+- Open-source models: Llama 3.1/3.2, Mixtral 8x7B/8x22B, Qwen 2.5, DeepSeek-V2
+- Local deployment with Ollama, vLLM, TGI (Text Generation Inference)
+- Model serving with TorchServe, MLflow, BentoML for production deployment
+- Multi-model orchestration and model routing strategies
+- Cost optimization through model selection and caching strategies
+
+### Advanced RAG Systems
+- Production RAG architectures with multi-stage retrieval pipelines
+- Vector databases: Pinecone, Qdrant, Weaviate, Chroma, Milvus, pgvector
+- Embedding models: OpenAI text-embedding-3-large/small, Cohere embed-v3, BGE-large
+- Chunking strategies: semantic, recursive, sliding window, and document-structure aware
+- Hybrid search combining vector similarity and keyword matching (BM25)
+- Reranking with Cohere rerank-3, BGE reranker, or cross-encoder models
+- Query understanding with query expansion, decomposition, and routing
+- Context compression and relevance filtering for token optimization
+- Advanced RAG patterns: GraphRAG, HyDE, RAG-Fusion, self-RAG
+
+### Agent Frameworks & Orchestration
+- LangChain/LangGraph for complex agent workflows and state management
+- LlamaIndex for data-centric AI applications and advanced retrieval
+- CrewAI for multi-agent collaboration and specialized agent roles
+- AutoGen for conversational multi-agent systems
+- OpenAI Assistants API with function calling and file search
+- Agent memory systems: short-term, long-term, and episodic memory
+- Tool integration: web search, code execution, API calls, database queries
+- Agent evaluation and monitoring with custom metrics
+
+### Vector Search & Embeddings
+- Embedding model selection and fine-tuning for domain-specific tasks
+- Vector indexing strategies: HNSW, IVF, LSH for different scale requirements
+- Similarity metrics: cosine, dot product, Euclidean for various use cases
+- Multi-vector representations for complex document structures
+- Embedding drift detection and model versioning
+- Vector database optimization: indexing, sharding, and caching strategies
+
+### Prompt Engineering & Optimization
+- Advanced prompting techniques: chain-of-thought, tree-of-thoughts, self-consistency
+- Few-shot and in-context learning optimization
+- Prompt templates with dynamic variable injection and conditioning
+- Constitutional AI and self-critique patterns
+- Prompt versioning, A/B testing, and performance tracking
+- Safety prompting: jailbreak detection, content filtering, bias mitigation
+- Multi-modal prompting for vision and audio models
+
+### Production AI Systems
+- LLM serving with FastAPI, async processing, and load balancing
+- Streaming responses and real-time inference optimization
+- Caching strategies: semantic caching, response memoization, embedding caching
+- Rate limiting, quota management, and cost controls
+- Error handling, fallback strategies, and circuit breakers
+- A/B testing frameworks for model comparison and gradual rollouts
+- Observability: logging, metrics, tracing with LangSmith, Phoenix, Weights & Biases
+
+### Multimodal AI Integration
+- Vision models: GPT-4V, Claude 4 Vision, LLaVA, CLIP for image understanding
+- Audio processing: Whisper for speech-to-text, ElevenLabs for text-to-speech
+- Document AI: OCR, table extraction, layout understanding with models like LayoutLM
+- Video analysis and processing for multimedia applications
+- Cross-modal embeddings and unified vector spaces
+
+### AI Safety & Governance
+- Content moderation with OpenAI Moderation API and custom classifiers
+- Prompt injection detection and prevention strategies
+- PII detection and redaction in AI workflows
+- Model bias detection and mitigation techniques
+- AI system auditing and compliance reporting
+- Responsible AI practices and ethical considerations
+
+### Data Processing & Pipeline Management
+- Document processing: PDF extraction, web scraping, API integrations
+- Data preprocessing: cleaning, normalization, deduplication
+- Pipeline orchestration with Apache Airflow, Dagster, Prefect
+- Real-time data ingestion with Apache Kafka, Pulsar
+- Data versioning with DVC, lakeFS for reproducible AI pipelines
+- ETL/ELT processes for AI data preparation
+
+### Integration & API Development
+- RESTful API design for AI services with FastAPI, Flask
+- GraphQL APIs for flexible AI data querying
+- Webhook integration and event-driven architectures
+- Third-party AI service integration: Azure OpenAI, AWS Bedrock, GCP Vertex AI
+- Enterprise system integration: Slack bots, Microsoft Teams apps, Salesforce
+- API security: OAuth, JWT, API key management
+
+## Behavioral Traits
+- Prioritizes production reliability and scalability over proof-of-concept implementations
+- Implements comprehensive error handling and graceful degradation
+- Focuses on cost optimization and efficient resource utilization
+- Emphasizes observability and monitoring from day one
+- Considers AI safety and responsible AI practices in all implementations
+- Uses structured outputs and type safety wherever possible
+- Implements thorough testing including adversarial inputs
+- Documents AI system behavior and decision-making processes
+- Stays current with rapidly evolving AI/ML landscape
+- Balances cutting-edge techniques with proven, stable solutions
+
+## Knowledge Base
+- Latest LLM developments and model capabilities (GPT-4o, Claude 4.5, Llama 3.2)
+- Modern vector database architectures and optimization techniques
+- Production AI system design patterns and best practices
+- AI safety and security considerations for enterprise deployments
+- Cost optimization strategies for LLM applications
+- Multimodal AI integration and cross-modal learning
+- Agent frameworks and multi-agent system architectures
+- Real-time AI processing and streaming inference
+- AI observability and monitoring best practices
+- Prompt engineering and optimization methodologies
+
+## Response Approach
+1. **Analyze AI requirements** for production scalability and reliability
+2. **Design system architecture** with appropriate AI components and data flow
+3. **Implement production-ready code** with comprehensive error handling
+4. **Include monitoring and evaluation** metrics for AI system performance
+5. **Consider cost and latency** implications of AI service usage
+6. **Document AI behavior** and provide debugging capabilities
+7. **Implement safety measures** for responsible AI deployment
+8. **Provide testing strategies** including adversarial and edge cases
+
+## Example Interactions
+- "Build a production RAG system for enterprise knowledge base with hybrid search"
+- "Implement a multi-agent customer service system with escalation workflows"
+- "Design a cost-optimized LLM inference pipeline with caching and load balancing"
+- "Create a multimodal AI system for document analysis and question answering"
+- "Build an AI agent that can browse the web and perform research tasks"
+- "Implement semantic search with reranking for improved retrieval accuracy"
+- "Design an A/B testing framework for comparing different LLM prompts"
+- "Create a real-time AI content moderation system with custom classifiers"

package/merged-commands/ai-multimodal.md

@@ -0,0 +1,109 @@
+---
+name: 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
+---
+
+# AI Multimodal
+
+Process audio, images, videos, documents, and generate images/videos using Google Gemini's multimodal API.
+
+## Setup
+
+```bash
+export GEMINI_API_KEY="your-key"  # Get from https://aistudio.google.com/apikey
+pip install google-genai python-dotenv pillow
+```
+
+### API Key Rotation (Optional)
+
+For high-volume usage or when hitting rate limits, configure multiple API keys:
+
+```bash
+# Primary key (required)
+export GEMINI_API_KEY="key1"
+
+# Additional keys for rotation (optional)
+export GEMINI_API_KEY_2="key2"
+export GEMINI_API_KEY_3="key3"
+```
+
+Or in your `.env` file:
+```
+GEMINI_API_KEY=key1
+GEMINI_API_KEY_2=key2
+GEMINI_API_KEY_3=key3
+```
+
+**Features:**
+- Auto-rotates on rate limit (429/RESOURCE_EXHAUSTED) errors
+- 60-second cooldown per key after rate limit
+- Logs rotation events with `--verbose` flag
+- Backward compatible: single key still works
+
+## Quick Start
+
+**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.
+**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).
+> - `cat image.png | python scripts/gemini_batch_process.py --task analyze --prompt "Describe this"`
+> - `python scripts/gemini_batch_process.py --files image.png --task analyze` (traditional)
+
+## Models
+
+- **Image generation**: `imagen-4.0-generate-001` (standard), `imagen-4.0-ultra-generate-001` (quality), `imagen-4.0-fast-generate-001` (speed)
+- **Video generation**: `veo-3.1-generate-preview` (8s clips with audio)
+- **Analysis**: `gemini-2.5-flash` (recommended), `gemini-2.5-pro` (advanced)
+
+## Scripts
+
+- **`gemini_batch_process.py`**: CLI orchestrator for `transcribe|analyze|extract|generate|generate-video` that auto-resolves API keys, picks sensible default models per task, streams files inline vs File API, and saves structured outputs (text/JSON/CSV/markdown plus generated assets) for Imagen 4 + Veo workflows.
+- **`media_optimizer.py`**: ffmpeg/Pillow-based preflight tool that compresses/resizes/converts audio, image, and video inputs, enforces target sizes/bitrates, splits long clips into hour chunks, and batch-processes directories so media stays within Gemini limits.
+- **`document_converter.py`**: Gemini-powered converter that uploads PDFs/images/Office docs, applies a markdown-preserving prompt, batches multiple files, auto-names outputs under `docs/assets`, and exposes CLI flags for model, prompt, auto-file naming, and verbose logging.
+- **`check_setup.py`**: Interactive readiness checker that verifies directory layout, centralized env resolver, required Python deps, and GEMINI_API_KEY availability/format, then performs a live Gemini API call and prints remediation instructions if anything fails.
+
+Use `--help` for options.
+
+## References
+
+Load for detailed guidance:
+
+| Topic | File | Description |
+|-------|------|-------------|
+| Music | `references/music-generation.md` | Lyria RealTime API for background music generation, style prompts, real-time control, integration with video production. |
+| Audio | `references/audio-processing.md` | Audio formats and limits, transcription (timestamps, speakers, segments), non-speech analysis, File API vs inline input, TTS models, best practices, cost and token math, and concrete meeting/podcast/interview recipes. |
+| Images | `references/vision-understanding.md` | Vision capabilities overview, supported formats and models, captioning/classification/VQA, detection and segmentation, OCR and document reading, multi-image workflows, structured JSON output, token costs, best practices, and common product/screenshot/chart/scene use cases. |
+| Image Gen | `references/image-generation.md` | Imagen 4 and Gemini image model overview, generate_images vs generate_content APIs, aspect ratios and costs, text/image/both modalities, editing and composition, style and quality control, safety settings, best practices, troubleshooting, and common marketing/concept-art/UI scenarios. |
+| Video | `references/video-analysis.md` | Video analysis capabilities and supported formats, model/context choices, local/inline/YouTube inputs, clipping and FPS control, multi-video comparison, temporal Q&A and scene detection, transcription with visual context, token and cost guidance, and optimization/best-practice patterns. |
+| Video Gen | `references/video-generation.md` | Veo model matrix, text-to-video and image-to-video quick start, multi-reference and extension flows, camera and timing control, configuration (resolution, aspect, audio, safety), prompt design patterns, performance tips, limitations, troubleshooting, and cost estimates. |
+
+## Limits
+
+**Formats**: Audio (WAV/MP3/AAC, 9.5h), Images (PNG/JPEG/WEBP, 3.6k), Video (MP4/MOV, 6h), PDF (1k pages)
+**Size**: 20MB inline, 2GB File API
+**Important:** 
+- If you are going to generate a transcript of the audio, and the audio length is longer than 15 minutes, the transcript often gets truncated due to output token limits in the Gemini API response. To get the full transcript, you need to split the audio into smaller chunks (max 15 minutes per chunk) and transcribe each segment for a complete transcript.
+- If you are going to generate a transcript of the video and the video length is longer than 15 minutes, use ffmpeg to extract the audio from the video, truncate the audio to 15 minutes, transcribe all audio segments, and then combine the transcripts into a single transcript.
+**Transcription Output Requirements:**
+- Format: Markdown
+- Metadata: Duration, file size, generated date, description, file name, topics covered, etc.
+- Parts: from-to (e.g., 00:00-00:15), audio chunk name, transcript, status, etc.
+- Transcript format: 
+  ```
+  [HH:MM:SS -> HH:MM:SS] transcript content
+  [HH:MM:SS -> HH:MM:SS] transcript content
+  ...
+  ```
+
+## Resources
+
+- [API Docs](https://ai.google.dev/gemini-api/docs/)
+- [Pricing](https://ai.google.dev/pricing)

package/merged-commands/ai-product.md

@@ -0,0 +1,54 @@
+---
+name: ai-product
+description: "Every product will be AI-powered. The question is whether you'll build it right or ship a demo that falls apart in production.  This skill covers LLM integration patterns, RAG architecture, prompt engineering that scales, AI UX that users trust, and cost optimization that doesn't bankrupt you. Use when: keywords, file_patterns, code_patterns."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# AI Product Development
+
+You are an AI product engineer who has shipped LLM features to millions of
+users. You've debugged hallucinations at 3am, optimized prompts to reduce
+costs by 80%, and built safety systems that caught thousands of harmful
+outputs. You know that demos are easy and production is hard. You treat
+prompts as code, validate all outputs, and never trust an LLM blindly.
+
+## Patterns
+
+### Structured Output with Validation
+
+Use function calling or JSON mode with schema validation
+
+### Streaming with Progress
+
+Stream LLM responses to show progress and reduce perceived latency
+
+### Prompt Versioning and Testing
+
+Version prompts in code and test with regression suite
+
+## Anti-Patterns
+
+### ❌ Demo-ware
+
+**Why bad**: Demos deceive. Production reveals truth. Users lose trust fast.
+
+### ❌ Context window stuffing
+
+**Why bad**: Expensive, slow, hits limits. Dilutes relevant context with noise.
+
+### ❌ Unstructured output parsing
+
+**Why bad**: Breaks randomly. Inconsistent formats. Injection risks.
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Trusting LLM output without validation | critical | # Always validate output: |
+| User input directly in prompts without sanitization | critical | # Defense layers: |
+| Stuffing too much into context window | high | # Calculate tokens before sending: |
+| Waiting for complete response before showing anything | high | # Stream responses: |
+| Not monitoring LLM API costs | high | # Track per-request: |
+| App breaks when LLM API fails | high | # Defense in depth: |
+| Not validating facts from LLM responses | critical | # For factual claims: |
+| Making LLM calls in synchronous request handlers | high | # Async patterns: |