plcode-linux-x64-baseline-musl 2.1.0

package/.plcode/skill/core/audit/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: audit
+description: Perform comprehensive audit of interface quality across accessibility, performance, theming, and responsive design. Generates detailed report of issues with severity ratings and recommendations.
+category: design
+args:
+  - name: area
+    description: The feature or area to audit (optional)
+    required: false
+user-invokable: true
+---
+
+Run systematic quality checks and generate a comprehensive audit report with prioritized issues and actionable recommendations. Don't fix issues - document them for other commands to address.
+
+**First**: Use the frontend-design skill for design principles and anti-patterns.
+
+## Diagnostic Scan
+
+Run comprehensive checks across multiple dimensions:
+
+1. **Accessibility (A11y)** - Check for:
+   - **Contrast issues**: Text contrast ratios < 4.5:1 (or 7:1 for AAA)
+   - **Missing ARIA**: Interactive elements without proper roles, labels, or states
+   - **Keyboard navigation**: Missing focus indicators, illogical tab order, keyboard traps
+   - **Semantic HTML**: Improper heading hierarchy, missing landmarks, divs instead of buttons
+   - **Alt text**: Missing or poor image descriptions
+   - **Form issues**: Inputs without labels, poor error messaging, missing required indicators
+
+2. **Performance** - Check for:
+   - **Layout thrashing**: Reading/writing layout properties in loops
+   - **Expensive animations**: Animating layout properties (width, height, top, left) instead of transform/opacity
+   - **Missing optimization**: Images without lazy loading, unoptimized assets, missing will-change
+   - **Bundle size**: Unnecessary imports, unused dependencies
+   - **Render performance**: Unnecessary re-renders, missing memoization
+
+3. **Theming** - Check for:
+   - **Hard-coded colors**: Colors not using design tokens
+   - **Broken dark mode**: Missing dark mode variants, poor contrast in dark theme
+   - **Inconsistent tokens**: Using wrong tokens, mixing token types
+   - **Theme switching issues**: Values that don't update on theme change
+
+4. **Responsive Design** - Check for:
+   - **Fixed widths**: Hard-coded widths that break on mobile
+   - **Touch targets**: Interactive elements < 44x44px
+   - **Horizontal scroll**: Content overflow on narrow viewports
+   - **Text scaling**: Layouts that break when text size increases
+   - **Missing breakpoints**: No mobile/tablet variants
+
+5. **Anti-Patterns (CRITICAL)** - Check against ALL the **DON'T** guidelines in the frontend-design skill. Look for AI slop tells (AI color palette, gradient text, glassmorphism, hero metrics, card grids, generic fonts) and general design anti-patterns (gray on color, nested cards, bounce easing, redundant copy).
+
+**CRITICAL**: This is an audit, not a fix. Document issues thoroughly with clear explanations of impact. Use other commands (normalize, optimize, harden, etc.) to fix issues after audit.
+
+## Generate Comprehensive Report
+
+Create a detailed audit report with the following structure:
+
+### Anti-Patterns Verdict
+
+**Start here.** Pass/fail: Does this look AI-generated? List specific tells from the skill's Anti-Patterns section. Be brutally honest.
+
+### Executive Summary
+
+- Total issues found (count by severity)
+- Most critical issues (top 3-5)
+- Overall quality score (if applicable)
+- Recommended next steps
+
+### Detailed Findings by Severity
+
+For each issue, document:
+
+- **Location**: Where the issue occurs (component, file, line)
+- **Severity**: Critical / High / Medium / Low
+- **Category**: Accessibility / Performance / Theming / Responsive
+- **Description**: What the issue is
+- **Impact**: How it affects users
+- **WCAG/Standard**: Which standard it violates (if applicable)
+- **Recommendation**: How to fix it
+- **Suggested command**: Which command to use (prefer: {{available_commands}} — or other installed skills you're sure exist)
+
+#### Critical Issues
+
+[Issues that block core functionality or violate WCAG A]
+
+#### High-Severity Issues
+
+[Significant usability/accessibility impact, WCAG AA violations]
+
+#### Medium-Severity Issues
+
+[Quality issues, WCAG AAA violations, performance concerns]
+
+#### Low-Severity Issues
+
+[Minor inconsistencies, optimization opportunities]
+
+### Patterns & Systemic Issues
+
+Identify recurring problems:
+
+- "Hard-coded colors appear in 15+ components, should use design tokens"
+- "Touch targets consistently too small (<44px) throughout mobile experience"
+- "Missing focus indicators on all custom interactive components"
+
+### Positive Findings
+
+Note what's working well:
+
+- Good practices to maintain
+- Exemplary implementations to replicate elsewhere
+
+### Recommendations by Priority
+
+Create actionable plan:
+
+1. **Immediate**: Critical blockers to fix first
+2. **Short-term**: High-severity issues (this sprint)
+3. **Medium-term**: Quality improvements (next sprint)
+4. **Long-term**: Nice-to-haves and optimizations
+
+### Suggested Commands for Fixes
+
+Map issues to available commands. Prefer these: {{available_commands}}. You may also suggest other installed skills you're sure exist, but never invent commands.
+
+Examples:
+
+- "Use `/normalize` to align with design system (addresses N theming issues)"
+- "Use `/optimize` to improve performance (addresses N performance issues)"
+- "Use `/harden` to improve resilience (addresses N edge cases)"
+
+**IMPORTANT**: Be thorough but actionable. Too many low-priority issues creates noise. Focus on what actually matters.
+
+**NEVER**:
+
+- Report issues without explaining impact (why does this matter?)
+- Mix severity levels inconsistently
+- Skip positive findings (celebrate what works)
+- Provide generic recommendations (be specific and actionable)
+- Forget to prioritize (everything can't be critical)
+- Report false positives without verification
+
+Remember: You're a quality auditor with exceptional attention to detail. Document systematically, prioritize ruthlessly, and provide clear paths to improvement. A good audit makes fixing easy.

package/.plcode/skill/core/backend-dev/README.md

@@ -0,0 +1,333 @@
+# Backend Development Skill - Complete Backend Engineering
+
+## 🚀 Quick Start
+
+**Basic Usage:**
+
+```
+"Create a backend API for [application]"
+```
+
+**Examples:**
+
+- "Build a REST API for user management system"
+- "Design database architecture for e-commerce platform"
+- "Implement secure authentication and authorization"
+- "Set up CI/CD pipeline for backend deployment"
+
+## 📋 What This Skill Does
+
+The backend development skill provides comprehensive backend engineering services by orchestrating multiple expert systems, advanced development techniques, and specialized tools. It transforms business requirements into production-ready backend systems with comprehensive architecture, security, scalability, and operational excellence.
+
+### 🎯 Key Features
+
+- **🏗️ Multi-Expert Backend Architecture** - Coordinates backend architects, security engineers, and DevOps specialists
+- **🎯 Full-Stack Development** - From API design to database architecture to deployment automation
+- **📊 Production-Ready Implementation** - Security-first, scalable, and maintainable code generation
+- **🔧 DevOps Integration** - CI/CD pipelines, monitoring, and infrastructure as code
+- **📋 Comprehensive Testing** - Unit, integration, and end-to-end testing strategies
+
+## 🔄 Backend Development Workflow
+
+### **Phase 1: Requirements Analysis & Technical Planning** 🔍
+
+_Understanding business needs and translating to technical requirements_
+
+- Analyze business requirements and translate to technical specifications
+- Identify scalability, security, and performance requirements
+- Evaluate technology stack options and architectural patterns
+- Define API contracts and data models
+- Plan integration points and external dependencies
+
+### **Phase 2: System Architecture & Design** 🏗️
+
+_Designing the technical architecture and system components_
+
+- Design system architecture and component boundaries
+- Create API specifications and data contracts
+- Design database schemas and relationships
+- Plan security architecture and authentication flows
+- Define scalability and performance strategies
+
+### **Phase 3: Implementation Planning & Technology Selection** ⚙️
+
+_Preparing for actual code implementation_
+
+- Select appropriate frameworks, libraries, and tools
+- Create implementation roadmap with milestones
+- Plan database migrations and data seeding strategies
+- Design error handling and logging strategies
+- Prepare development environment and tooling setup
+
+### **Phase 4: Secure & Scalable Implementation** 💻
+
+_Writing production-ready backend code_
+
+- Implement core business logic and API endpoints
+- Create secure authentication and authorization systems
+- Optimize database queries and implement caching strategies
+- Implement comprehensive error handling and logging
+- Write unit and integration tests with high coverage
+
+### **Phase 5: Testing & Quality Assurance** ✅
+
+_Ensuring system reliability and security_
+
+- Implement comprehensive test suites (unit, integration, E2E)
+- Conduct security testing and vulnerability assessments
+- Perform load testing and performance benchmarking
+- Validate API contracts and data integrity
+- Test error scenarios and recovery mechanisms
+
+### **Phase 6: DevOps & Deployment** 🚀
+
+_Preparing for production deployment_
+
+- Set up CI/CD pipelines with automated testing and deployment
+- Implement infrastructure as code and containerization
+- Configure monitoring, logging, and alerting systems
+- Create deployment strategies and rollback procedures
+- Document operations procedures and runbooks
+
+## 🛠️ Tool Integration
+
+### SuperClaude Framework Commands
+
+| Command                          | Purpose             | Output                                |
+| -------------------------------- | ------------------- | ------------------------------------- |
+| `/sc:design --type architecture` | System architecture | Technical architecture specifications |
+| `/sc:design --type api`          | API design          | RESTful/GraphQL API specifications    |
+| `/sc:design --type database`     | Database design     | Optimized schema and data models      |
+| `/sc:implement backend`          | Code implementation | Production-ready backend services     |
+| `/sc:test backend`               | Testing strategy    | Comprehensive testing plans           |
+| `/sc:build deploy`               | Deployment setup    | CI/CD and infrastructure automation   |
+
+### BMAD Method Integration
+
+| Technique                       | Role                    | Benefit                                    |
+| ------------------------------- | ----------------------- | ------------------------------------------ |
+| **Greenfield Service Workflow** | New project development | Complete backend service development       |
+| **Brownfield Integration**      | Legacy modernization    | Safe system evolution and integration      |
+| **Security-First Development**  | Secure implementation   | Built-in security practices and validation |
+| **Performance Optimization**    | Scalability planning    | Bottleneck identification and optimization |
+
+### MCP Server Integration
+
+| Server         | Expertise          | Use Case                                           |
+| -------------- | ------------------ | -------------------------------------------------- |
+| **Sequential** | Complex reasoning  | Architecture analysis and problem-solving          |
+| **Context7**   | Technical patterns | Framework best practices and implementation guides |
+| **Playwright** | API testing        | End-to-end API validation and testing              |
+| **Serena**     | Project memory     | Large codebase navigation and context management   |
+
+## 👥 Expert Panel
+
+### **Backend Architect**
+
+Leads system architecture design, focusing on API design, database architecture, and system scalability with performance and maintainability considerations.
+
+### **Security Engineer**
+
+Specializes in secure backend development, implementing authentication, authorization, data protection, and compliance with security best practices.
+
+### **DevOps Architect**
+
+Focuses on operations and deployment, creating CI/CD pipelines, infrastructure automation, monitoring systems, and reliability engineering.
+
+### **Database Specialist**
+
+Expert in data architecture, designing optimized database schemas, query optimization, data modeling, and migration strategies.
+
+### **Performance Engineer**
+
+Specializes in performance optimization, bottleneck analysis, caching strategies, load testing, and scaling solutions.
+
+## 📊 Example Workflows
+
+### New REST API Development
+
+```
+User: "Create a backend API for an e-commerce platform with user management, product catalog, and order processing"
+
+Path: Phase 1 → Phase 2 → Phase 3 → Phase 4 → Phase 5 → Phase 6
+Output: Production-ready e-commerce backend with 99.9% uptime target
+```
+
+### Database Architecture Optimization
+
+```
+User: "Optimize our database architecture for better performance and scalability"
+
+Path: Phase 1 → Phase 2 → Phase 3 → Phase 4 → Phase 5 → Phase 6
+Output: 60% performance improvement with horizontal scaling capability
+```
+
+### Security Implementation
+
+```
+User: "Implement comprehensive security for our financial services backend"
+
+Path: Phase 1 → Phase 2 → Phase 3 → Phase 4 → Phase 5 → Phase 6
+Output: Fully compliant financial services backend with comprehensive security
+```
+
+## 🎨 Output Deliverables
+
+### Core System Structure
+
+```
+backend-system/
+├── api/                          # API layer
+│   ├── controllers/              # Endpoint implementations
+│   ├── middleware/               # Auth, validation, error handling
+│   ├── routes/                   # API routing definitions
+│   └── documentation/            # API docs and contracts
+├── services/                     # Business logic layer
+│   ├── business/                 # Core business logic
+│   ├── data/                     # Data access services
+│   ├── external/                 # Third-party integrations
+│   └── security/                 # Security utilities
+├── database/                     # Data layer
+│   ├── migrations/               # Schema migrations
+│   ├── seeds/                    # Initial data
+│   ├── models/                   # Data models
+│   └── queries/                  # Optimized queries
+├── tests/                        # Testing layer
+│   ├── unit/                     # Unit tests
+│   ├── integration/              # Integration tests
+│   ├── e2e/                      # End-to-end tests
+│   └── performance/              # Load tests
+├── infrastructure/               # DevOps layer
+│   ├── docker/                   # Container configs
+│   ├── kubernetes/               # K8s deployments
+│   ├── ci-cd/                    # CI/CD pipelines
+│   └── monitoring/               # Observability setup
+├── documentation/               # System docs
+│   ├── architecture.md           # System architecture
+│   ├── api-specs.md              # API specifications
+│   ├── deployment.md             # Deployment procedures
+│   └── security.md               # Security procedures
+└── config/                      # Environment configs
+    ├── development/              # Dev environment
+    ├── staging/                  # Staging environment
+    └── production/               # Production environment
+```
+
+### Key Deliverables
+
+- **Complete API Implementation**: Production-ready REST/GraphQL APIs
+- **Optimized Database Architecture**: Scalable and efficient data storage
+- **Security Implementation**: Comprehensive authentication and authorization
+- **CI/CD Pipeline**: Automated testing, building, and deployment
+- **Monitoring Setup**: Comprehensive observability and alerting
+- **Documentation**: Complete system and API documentation
+
+## 🔍 Quality Assurance
+
+### Multi-Expert Validation
+
+- Cross-domain review with backend architect, security, and DevOps perspectives
+- Comprehensive vulnerability scanning and compliance checking
+- Load testing, stress testing, and optimization validation
+- Complete deployment and operational validation
+
+### Automated Quality Checks
+
+- Code quality with linting, formatting, and complexity analysis
+- Security scanning with automated vulnerability detection
+- Performance monitoring with response time and resource tracking
+- Test coverage validation for unit, integration, and E2E tests
+
+### Continuous Improvement
+
+- Real-time performance tracking and alerting
+- Continuous vulnerability scanning and threat detection
+- User feedback and performance data analysis
+- Successful pattern recognition and reuse
+
+## 💡 Pro Tips
+
+### For Best Results
+
+1. **Clear Requirements**: Provide detailed business requirements and technical constraints
+2. **Scale Planning**: Consider future growth and scalability requirements from the start
+3. **Security First**: Implement security practices from the beginning, not as an afterthought
+4. **Testing Strategy**: Plan comprehensive testing throughout the development process
+
+### When to Use Which Phase
+
+- **New Projects**: Start with Phase 1 (Requirements) and proceed through all phases
+- **Existing Systems**: Start with Phase 1 (Analysis) for optimization or Phase 4 (Implementation) for specific features
+- **Security Focus**: Emphasize Phase 2 (Security Architecture) and Phase 5 (Security Testing)
+- **Performance Issues**: Focus on Phase 2 (Performance Strategy) and Phase 5 (Performance Testing)
+
+### Technology Selection
+
+- **Team Expertise**: Consider team skills and learning curves
+- **Scalability Needs**: Plan for growth and performance requirements
+- **Maintenance**: Consider long-term maintenance and support
+- **Integration**: Evaluate existing systems and integration requirements
+
+## 🚀 Getting Started
+
+### Step 1: Define Your Requirements
+
+- Clearly state your backend system requirements
+- Identify expected user load and performance requirements
+- Specify security and compliance needs
+- Define integration points with existing systems
+
+### Step 2: Engage the Skill
+
+- Provide detailed business and technical requirements
+- Share existing system information if applicable
+- Specify preferred technology stack or constraints
+- Define success criteria and key metrics
+
+### Step 3: Follow the Workflow
+
+- Trust the 6-phase development process
+- Review each phase's outputs carefully
+- Provide feedback on architecture and design decisions
+- Allow time for comprehensive testing and validation
+
+### Step 4: Deploy and Monitor
+
+- Follow the deployment guidelines and procedures
+- Set up monitoring and alerting systems
+- Plan for ongoing maintenance and optimization
+- Establish operational procedures and runbooks
+
+## 🔧 Advanced Features
+
+### Intelligent Technology Selection
+
+- Automatic technology stack recommendations based on requirements
+- Team expertise and learning curve considerations
+- Scalability, performance, and cost optimization
+- Support for multiple programming languages and frameworks
+
+### Security-First Development
+
+- Built-in security practices and vulnerability prevention
+- Automated security scanning and compliance checking
+- Comprehensive authentication and authorization patterns
+- Integration with security monitoring and threat detection
+
+### Performance Optimization
+
+- Proactive performance monitoring and bottleneck identification
+- Automated optimization suggestions and implementation
+- Load testing and capacity planning tools
+- Real-time performance tracking and alerting
+
+### DevOps Automation
+
+- Complete CI/CD pipeline setup with automated testing and deployment
+- Infrastructure as code with version control and reproducibility
+- Container orchestration and microservice deployment
+- Comprehensive monitoring, logging, and alerting systems
+
+---
+
+This backend development skill provides a comprehensive, expert-driven approach to backend system creation, leveraging the full power of your integrated development toolset to deliver secure, scalable, and maintainable backend systems ready for production deployment.