agcel 1.0.1

package/skills/qa-engineer/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: qa-engineer
+description: Define testing strategies, write test plans, and implementation end-to-end automation
+---
+
+# QA Engineer
+
+## Overview
+
+Your role is to prevent bugs from reaching production. You verify that the software meets requirements and behaves correctly under various conditions.
+
+## When to Use This Skill
+
+- Creating comprehensive test plans
+- Writing End-to-End (E2E) tests
+- Performing regression testing
+- Validating bug fixes
+
+## Core Responsibilities
+
+1.  **Test Planning**: Identifying what needs to be tested and how.
+2.  **E2E Automation**: Writing scripts (Playwright, Cypress) to simulate user behavior.
+3.  **Manual Testing**: Exploratory testing for edge cases hard to automate.
+4.  **Bug Reporting**: Creating clear, reproducible bug reports.
+
+## Testing Pyramid
+
+1.  **Unit Tests** (Dev responsibility): Fast, isolated.
+2.  **Integration Tests**: Check how modules work together.
+3.  **E2E Tests** (QA focus): Simulate real user flows in a browser environment.
+
+### Bug Report Template
+- **Title**: Concise description of the issue.
+- **Severity**: Critical / High / Medium / Low.
+- **Steps to Reproduce**: 1. Go to... 2. Click...
+- **Expected Result**: What should happen.
+- **Actual Result**: What actually happened.
+- **Screenshots/Logs**: Evidence.
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/skills/rag-engineer/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: rag-engineer
+description: "Expert in building Retrieval-Augmented Generation systems. Masters embedding models, vector databases, chunking strategies, and retrieval optimization for LLM applications. Use when: building RAG, vector search, embeddings, semantic search, document retrieval."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# RAG Engineer
+
+**Role**: RAG Systems Architect
+
+I bridge the gap between raw documents and LLM understanding. I know that
+retrieval quality determines generation quality - garbage in, garbage out.
+I obsess over chunking boundaries, embedding dimensions, and similarity
+metrics because they make the difference between helpful and hallucinating.
+
+## Capabilities
+
+- Vector embeddings and similarity search
+- Document chunking and preprocessing
+- Retrieval pipeline design
+- Semantic search implementation
+- Context window optimization
+- Hybrid search (keyword + semantic)
+
+## Requirements
+
+- LLM fundamentals
+- Understanding of embeddings
+- Basic NLP concepts
+
+## Patterns
+
+### Semantic Chunking
+
+Chunk by meaning, not arbitrary token counts
+
+```javascript
+- Use sentence boundaries, not token limits
+- Detect topic shifts with embedding similarity
+- Preserve document structure (headers, paragraphs)
+- Include overlap for context continuity
+- Add metadata for filtering
+```
+
+### Hierarchical Retrieval
+
+Multi-level retrieval for better precision
+
+```javascript
+- Index at multiple chunk sizes (paragraph, section, document)
+- First pass: coarse retrieval for candidates
+- Second pass: fine-grained retrieval for precision
+- Use parent-child relationships for context
+```
+
+### Hybrid Search
+
+Combine semantic and keyword search
+
+```javascript
+- BM25/TF-IDF for keyword matching
+- Vector similarity for semantic matching
+- Reciprocal Rank Fusion for combining scores
+- Weight tuning based on query type
+```
+
+## Anti-Patterns
+
+### ❌ Fixed Chunk Size
+
+### ❌ Embedding Everything
+
+### ❌ Ignoring Evaluation
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Fixed-size chunking breaks sentences and context | high | Use semantic chunking that respects document structure: |
+| Pure semantic search without metadata pre-filtering | medium | Implement hybrid filtering: |
+| Using same embedding model for different content types | medium | Evaluate embeddings per content type: |
+| Using first-stage retrieval results directly | medium | Add reranking step: |
+| Cramming maximum context into LLM prompt | medium | Use relevance thresholds: |
+| Not measuring retrieval quality separately from generation | high | Separate retrieval evaluation: |
+| Not updating embeddings when source documents change | medium | Implement embedding refresh: |
+| Same retrieval strategy for all query types | medium | Implement hybrid search: |
+
+## Related Skills
+
+Works well with: `ai-agents-architect`, `prompt-engineer`, `database-architect`, `backend`
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/skills/react-patterns/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: react-patterns
+description: Modern React patterns and principles. Hooks, composition, performance, TypeScript best practices.
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# React Patterns
+
+> Principles for building production-ready React applications.
+
+---
+
+## 1. Component Design Principles
+
+### Component Types
+
+| Type | Use | State |
+|------|-----|-------|
+| **Server** | Data fetching, static | None |
+| **Client** | Interactivity | useState, effects |
+| **Presentational** | UI display | Props only |
+| **Container** | Logic/state | Heavy state |
+
+### Design Rules
+
+- One responsibility per component
+- Props down, events up
+- Composition over inheritance
+- Prefer small, focused components
+
+---
+
+## 2. Hook Patterns
+
+### When to Extract Hooks
+
+| Pattern | Extract When |
+|---------|-------------|
+| **useLocalStorage** | Same storage logic needed |
+| **useDebounce** | Multiple debounced values |
+| **useFetch** | Repeated fetch patterns |
+| **useForm** | Complex form state |
+
+### Hook Rules
+
+- Hooks at top level only
+- Same order every render
+- Custom hooks start with "use"
+- Clean up effects on unmount
+
+---
+
+## 3. State Management Selection
+
+| Complexity | Solution |
+|------------|----------|
+| Simple | useState, useReducer |
+| Shared local | Context |
+| Server state | React Query, SWR |
+| Complex global | Zustand, Redux Toolkit |
+
+### State Placement
+
+| Scope | Where |
+|-------|-------|
+| Single component | useState |
+| Parent-child | Lift state up |
+| Subtree | Context |
+| App-wide | Global store |
+
+---
+
+## 4. React 19 Patterns
+
+### New Hooks
+
+| Hook | Purpose |
+|------|---------|
+| **useActionState** | Form submission state |
+| **useOptimistic** | Optimistic UI updates |
+| **use** | Read resources in render |
+
+### Compiler Benefits
+
+- Automatic memoization
+- Less manual useMemo/useCallback
+- Focus on pure components
+
+---
+
+## 5. Composition Patterns
+
+### Compound Components
+
+- Parent provides context
+- Children consume context
+- Flexible slot-based composition
+- Example: Tabs, Accordion, Dropdown
+
+### Render Props vs Hooks
+
+| Use Case | Prefer |
+|----------|--------|
+| Reusable logic | Custom hook |
+| Render flexibility | Render props |
+| Cross-cutting | Higher-order component |
+
+---
+
+## 6. Performance Principles
+
+### When to Optimize
+
+| Signal | Action |
+|--------|--------|
+| Slow renders | Profile first |
+| Large lists | Virtualize |
+| Expensive calc | useMemo |
+| Stable callbacks | useCallback |
+
+### Optimization Order
+
+1. Check if actually slow
+2. Profile with DevTools
+3. Identify bottleneck
+4. Apply targeted fix
+
+---
+
+## 7. Error Handling
+
+### Error Boundary Usage
+
+| Scope | Placement |
+|-------|-----------|
+| App-wide | Root level |
+| Feature | Route/feature level |
+| Component | Around risky component |
+
+### Error Recovery
+
+- Show fallback UI
+- Log error
+- Offer retry option
+- Preserve user data
+
+---
+
+## 8. TypeScript Patterns
+
+### Props Typing
+
+| Pattern | Use |
+|---------|-----|
+| Interface | Component props |
+| Type | Unions, complex |
+| Generic | Reusable components |
+
+### Common Types
+
+| Need | Type |
+|------|------|
+| Children | ReactNode |
+| Event handler | MouseEventHandler |
+| Ref | RefObject<Element> |
+
+---
+
+## 9. Testing Principles
+
+| Level | Focus |
+|-------|-------|
+| Unit | Pure functions, hooks |
+| Integration | Component behavior |
+| E2E | User flows |
+
+### Test Priorities
+
+- User-visible behavior
+- Edge cases
+- Error states
+- Accessibility
+
+---
+
+## 10. Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Prop drilling deep | Use context |
+| Giant components | Split smaller |
+| useEffect for everything | Server components |
+| Premature optimization | Profile first |
+| Index as key | Stable unique ID |
+
+---
+
+> **Remember:** React is about composition. Build small, combine thoughtfully.
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/skills/secure-refactoring/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: secure-refactoring
+description: Rewrite code to adhere to OWASP standards and best practices. Use when tasked with improving code seecurity.
+allowed-tools: Read, Replace, MultiReplace
+---
+
+# Secure Refactoring Framework
+
+> "Security by Design."
+
+## 🎯 Selective Reading Rule
+
+**Read ONLY files that need refactoring!**
+
+| File | Description | When to Read |
+|------|-------------|--------------|
+| `*.py`, `*.js`, `*.ts` | Source code files | Identify refactoring targets |
+| `tests/` | Unit and integration tests | Verify changes don't break functionality |
+
+---
+
+## 🔗 Related Skills
+
+| Skill | Use For |
+|-------|---------|
+| `@[skills/code-auditing]` | Identifying code to refactor |
+| `@[skills/testing-patterns]` | Ensuring no regression |
+
+---
+
+## Core Principle
+
+**"Rewrite with security in mind."**
+
+- Prefer parameterized queries over string concatenation for SQL
+- Use secure libraries for cryptography and hashing
+- Implement proper input validation and output encoding
+- Avoid using deprecated or vulnerable functions
+
+---
+
+## Refactoring Checklist
+
+Before finalizing changes:
+
+- [ ] Replaced unsafe SQL queries with parameterized queries
+- [ ] Validated input against strict allow-lists
+- [ ] Escaped output based on context (HTML, JS, CSS)
+- [ ] Replaced weak cryptographic algorithms with strong ones
+- [ ] Verified that refactoring did not break existing functionality
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/skills/security-documentation/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: security-documentation
+description: Explain vulnerability risks in plain English. Use when tasked with documenting security issues.
+allowed-tools: Read, Write
+---
+
+# Security Documentation Framework
+
+> "Clarity is Security."
+
+## 🎯 Selective Reading Rule
+
+**Read ONLY files that need documenting!**
+
+| File | Description | When to Read |
+|------|-------------|--------------|
+| `*.py`, `*.js`, `*.ts` | Source code files | Identify what needs documenting |
+| `findings.md` | Audit findings | Source for documentation |
+
+---
+
+## 🔗 Related Skills
+
+| Skill | Use For |
+|-------|---------|
+| `@[skills/code-auditing]` | Identifying vulnerabilities to document |
+| `@[skills/writing-plans]` | Structuring documentation |
+
+---
+
+## Core Principle
+
+**"Explain the risk, not just the flaw."**
+
+- Describe the vulnerability (the flaw)
+- Explain the potential impact (the risk)
+- Recommend remediation (the fix)
+
+---
+
+## Documentation Checklist
+
+Before publishing:
+
+- [ ] Clear description of the vulnerability
+- [ ] Realistic impact assessment
+- [ ] Actionable remediation steps
+- [ ] References to relevant standards (OWASP, CWE)
+- [ ] Check for technical accuracy
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/skills/senior-architect/SKILL.md

@@ -0,0 +1,213 @@
+---
+name: senior-architect
+description: Comprehensive software architecture skill for designing scalable, maintainable systems using ReactJS, NextJS, NodeJS, Express, React Native, Swift, Kotlin, Flutter, Postgres, GraphQL, Go, Python. Includes architecture diagram generation, system design patterns, tech stack decision frameworks, and dependency analysis. Use when designing system architecture, making technical decisions, creating architecture diagrams, evaluating trade-offs, or defining integration patterns.
+---
+
+# Senior Architect
+
+Complete toolkit for senior architect with modern tools and best practices.
+
+## Quick Start
+
+### Main Capabilities
+
+This skill provides three core capabilities through automated scripts:
+
+```bash
+# Script 1: Architecture Diagram Generator
+python scripts/architecture_diagram_generator.py [options]
+
+# Script 2: Project Architect
+python scripts/project_architect.py [options]
+
+# Script 3: Dependency Analyzer
+python scripts/dependency_analyzer.py [options]
+```
+
+## Core Capabilities
+
+### 1. Architecture Diagram Generator
+
+Automated tool for architecture diagram generator tasks.
+
+**Features:**
+- Automated scaffolding
+- Best practices built-in
+- Configurable templates
+- Quality checks
+
+**Usage:**
+```bash
+python scripts/architecture_diagram_generator.py <project-path> [options]
+```
+
+### 2. Project Architect
+
+Comprehensive analysis and optimization tool.
+
+**Features:**
+- Deep analysis
+- Performance metrics
+- Recommendations
+- Automated fixes
+
+**Usage:**
+```bash
+python scripts/project_architect.py <target-path> [--verbose]
+```
+
+### 3. Dependency Analyzer
+
+Advanced tooling for specialized tasks.
+
+**Features:**
+- Expert-level automation
+- Custom configurations
+- Integration ready
+- Production-grade output
+
+**Usage:**
+```bash
+python scripts/dependency_analyzer.py [arguments] [options]
+```
+
+## Reference Documentation
+
+### Architecture Patterns
+
+Comprehensive guide available in `references/architecture_patterns.md`:
+
+- Detailed patterns and practices
+- Code examples
+- Best practices
+- Anti-patterns to avoid
+- Real-world scenarios
+
+### System Design Workflows
+
+Complete workflow documentation in `references/system_design_workflows.md`:
+
+- Step-by-step processes
+- Optimization strategies
+- Tool integrations
+- Performance tuning
+- Troubleshooting guide
+
+### Tech Decision Guide
+
+Technical reference guide in `references/tech_decision_guide.md`:
+
+- Technology stack details
+- Configuration examples
+- Integration patterns
+- Security considerations
+- Scalability guidelines
+
+## Tech Stack
+
+**Languages:** TypeScript, JavaScript, Python, Go, Swift, Kotlin
+**Frontend:** React, Next.js, React Native, Flutter
+**Backend:** Node.js, Express, GraphQL, REST APIs
+**Database:** PostgreSQL, Prisma, NeonDB, Supabase
+**DevOps:** Docker, Kubernetes, Terraform, GitHub Actions, CircleCI
+**Cloud:** AWS, GCP, Azure
+
+## Development Workflow
+
+### 1. Setup and Configuration
+
+```bash
+# Install dependencies
+npm install
+# or
+pip install -r requirements.txt
+
+# Configure environment
+cp .env.example .env
+```
+
+### 2. Run Quality Checks
+
+```bash
+# Use the analyzer script
+python scripts/project_architect.py .
+
+# Review recommendations
+# Apply fixes
+```
+
+### 3. Implement Best Practices
+
+Follow the patterns and practices documented in:
+- `references/architecture_patterns.md`
+- `references/system_design_workflows.md`
+- `references/tech_decision_guide.md`
+
+## Best Practices Summary
+
+### Code Quality
+- Follow established patterns
+- Write comprehensive tests
+- Document decisions
+- Review regularly
+
+### Performance
+- Measure before optimizing
+- Use appropriate caching
+- Optimize critical paths
+- Monitor in production
+
+### Security
+- Validate all inputs
+- Use parameterized queries
+- Implement proper authentication
+- Keep dependencies updated
+
+### Maintainability
+- Write clear code
+- Use consistent naming
+- Add helpful comments
+- Keep it simple
+
+## Common Commands
+
+```bash
+# Development
+npm run dev
+npm run build
+npm run test
+npm run lint
+
+# Analysis
+python scripts/project_architect.py .
+python scripts/dependency_analyzer.py --analyze
+
+# Deployment
+docker build -t app:latest .
+docker-compose up -d
+kubectl apply -f k8s/
+```
+
+## Troubleshooting
+
+### Common Issues
+
+Check the comprehensive troubleshooting section in `references/tech_decision_guide.md`.
+
+### Getting Help
+
+- Review reference documentation
+- Check script output messages
+- Consult tech stack documentation
+- Review error logs
+
+## Resources
+
+- Pattern Reference: `references/architecture_patterns.md`
+- Workflow Guide: `references/system_design_workflows.md`
+- Technical Guide: `references/tech_decision_guide.md`
+- Tool Scripts: `scripts/` directory
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.