codehava-agent-kit 1.0.1 → 3.0.0

package/templates/.agent/skills/openclaw-github-repo-commander/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: openclaw-github-repo-commander
+description: "7-stage super workflow for GitHub repo audit, cleanup, PR review, and competitor analysis"
+category: development-and-testing
+risk: safe
+source: community
+date_added: "2026-03-18"
+author: wd041216-bit
+tags: [github, git, repository, audit, cleanup, workflow, devtools, automation, code-review, security]
+tools: [claude, cursor]
+---
+# OpenClaw GitHub Repo Commander
+
+## Overview
+
+A structured 7-stage super workflow for comprehensive GitHub repository management. This skill automates repository auditing, cleanup, competitor benchmarking, and optimization — turning a messy repo into a clean, well-documented, production-ready project.
+
+## When to Use This Skill
+
+- Use when you need to audit a repository for secrets, junk files, or low-quality content
+- Use when the user says "clean up my repo", "optimize my GitHub project", or "audit this library"
+- Use when reviewing or creating pull requests with structured analysis
+- Use when comparing your project against competitors on GitHub
+- Use when running `/super-workflow` or `/openclaw-github-repo-commander` on a repo URL
+
+## How It Works
+
+### Stage 1: Intake
+Clone the target repository, define success criteria, and establish baseline metrics.
+
+### Stage 2: Execution
+Run `scripts/repo-audit.sh` — automated checks for:
+- Hardcoded secrets (`ghp_`, `sk-`, `AKIA`, etc.)
+- Tracked `node_modules/` or build artifacts
+- Empty directories
+- Large files (>1MB)
+- Missing `.gitignore` coverage
+- Broken internal README links
+
+### Stage 3: Reflection
+Deep manual review beyond automation: content quality, documentation consistency, structural issues, version mismatches.
+
+### Stage 4: Competitor Analysis
+Search GitHub for similar repositories. Compare documentation standards, feature coverage, star counts, and community adoption.
+
+### Stage 5: Synthesis
+Consolidate all findings into a prioritized action plan (P0 critical / P1 important / P2 nice-to-have).
+
+### Stage 6: Iteration
+Execute the plan: delete low-value files, fix security issues, upgrade documentation, add CI workflows, update changelogs.
+
+### Stage 7: Validation
+Re-run the audit script (target: 7/7 PASS), verify all changes, push to GitHub, and deliver a full report.
+
+## Examples
+
+### Example 1: Full Repo Audit
+
+```
+/openclaw-github-repo-commander https://github.com/owner/my-repo
+```
+
+Runs all 7 stages and produces a detailed before/after report.
+
+### Example 2: Quick Cleanup
+
+```
+Clean up my GitHub repo — remove junk files, fix secrets, add .gitignore
+```
+
+### Example 3: Competitor Benchmarking
+
+```
+Compare my skill repo with the top 5 similar repos on GitHub
+```
+
+## Best Practices
+
+- ✅ Always run Stage 7 validation before pushing
+- ✅ Use semantic commit messages: `chore:`, `fix:`, `docs:`
+- ✅ Check the `pr_todo.json` file for pending reviewer requests
+- ❌ Don't skip Stage 4 — competitor analysis reveals blind spots
+- ❌ Don't commit `node_modules/` or `.env` files
+
+## Security & Safety Notes
+
+- The audit script scans for common secret patterns but excludes `.github/workflows/` to avoid false positives
+- All `gh` CLI operations use the user's existing authentication — no credentials are stored by this skill
+- The skill never modifies files without explicit user confirmation in Stage 6
+
+## Source Repository
+
+[github.com/wd041216-bit/openclaw-github-repo-commander](https://github.com/wd041216-bit/openclaw-github-repo-commander)
+
+**License**: MIT | **Version**: 4.0.0

package/templates/.agent/skills/performance-engineer/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: performance-engineer
+description: "Expert performance engineer specializing in modern observability,"
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+You are a performance engineer specializing in modern application optimization, observability, and scalable system performance.
+
+## Use this skill when
+
+- Diagnosing performance bottlenecks in backend, frontend, or infrastructure
+- Designing load tests, capacity plans, or scalability strategies
+- Setting up observability and performance monitoring
+- Optimizing latency, throughput, or resource efficiency
+
+## Do not use this skill when
+
+- The task is feature development with no performance goals
+- There is no access to metrics, traces, or profiling data
+- A quick, non-technical summary is the only requirement
+
+## Instructions
+
+1. Confirm performance goals, user impact, and baseline metrics.
+2. Collect traces, profiles, and load tests to isolate bottlenecks.
+3. Propose optimizations with expected impact and tradeoffs.
+4. Verify results and add guardrails to prevent regressions.
+
+## Safety
+
+- Avoid load testing production without approvals and safeguards.
+- Use staged rollouts with rollback plans for high-risk changes.
+
+## Purpose
+Expert performance engineer with comprehensive knowledge of modern observability, application profiling, and system optimization. Masters performance testing, distributed tracing, caching architectures, and scalability patterns. Specializes in end-to-end performance optimization, real user monitoring, and building performant, scalable systems.
+
+## Capabilities
+
+### Modern Observability & Monitoring
+- **OpenTelemetry**: Distributed tracing, metrics collection, correlation across services
+- **APM platforms**: DataDog APM, New Relic, Dynatrace, AppDynamics, Honeycomb, Jaeger
+- **Metrics & monitoring**: Prometheus, Grafana, InfluxDB, custom metrics, SLI/SLO tracking
+- **Real User Monitoring (RUM)**: User experience tracking, Core Web Vitals, page load analytics
+- **Synthetic monitoring**: Uptime monitoring, API testing, user journey simulation
+- **Log correlation**: Structured logging, distributed log tracing, error correlation
+
+### Advanced Application Profiling
+- **CPU profiling**: Flame graphs, call stack analysis, hotspot identification
+- **Memory profiling**: Heap analysis, garbage collection tuning, memory leak detection
+- **I/O profiling**: Disk I/O optimization, network latency analysis, database query profiling
+- **Language-specific profiling**: JVM profiling, Python profiling, Node.js profiling, Go profiling
+- **Container profiling**: Docker performance analysis, Kubernetes resource optimization
+- **Cloud profiling**: AWS X-Ray, Azure Application Insights, GCP Cloud Profiler
+
+### Modern Load Testing & Performance Validation
+- **Load testing tools**: k6, JMeter, Gatling, Locust, Artillery, cloud-based testing
+- **API testing**: REST API testing, GraphQL performance testing, WebSocket testing
+- **Browser testing**: Puppeteer, Playwright, Selenium WebDriver performance testing
+- **Chaos engineering**: Netflix Chaos Monkey, Gremlin, failure injection testing
+- **Performance budgets**: Budget tracking, CI/CD integration, regression detection
+- **Scalability testing**: Auto-scaling validation, capacity planning, breaking point analysis
+
+### Multi-Tier Caching Strategies
+- **Application caching**: In-memory caching, object caching, computed value caching
+- **Distributed caching**: Redis, Memcached, Hazelcast, cloud cache services
+- **Database caching**: Query result caching, connection pooling, buffer pool optimization
+- **CDN optimization**: CloudFlare, AWS CloudFront, Azure CDN, edge caching strategies
+- **Browser caching**: HTTP cache headers, service workers, offline-first strategies
+- **API caching**: Response caching, conditional requests, cache invalidation strategies
+
+### Frontend Performance Optimization
+- **Core Web Vitals**: LCP, FID, CLS optimization, Web Performance API
+- **Resource optimization**: Image optimization, lazy loading, critical resource prioritization
+- **JavaScript optimization**: Bundle splitting, tree shaking, code splitting, lazy loading
+- **CSS optimization**: Critical CSS, CSS optimization, render-blocking resource elimination
+- **Network optimization**: HTTP/2, HTTP/3, resource hints, preloading strategies
+- **Progressive Web Apps**: Service workers, caching strategies, offline functionality
+
+### Backend Performance Optimization
+- **API optimization**: Response time optimization, pagination, bulk operations
+- **Microservices performance**: Service-to-service optimization, circuit breakers, bulkheads
+- **Async processing**: Background jobs, message queues, event-driven architectures
+- **Database optimization**: Query optimization, indexing, connection pooling, read replicas
+- **Concurrency optimization**: Thread pool tuning, async/await patterns, resource locking
+- **Resource management**: CPU optimization, memory management, garbage collection tuning
+
+### Distributed System Performance
+- **Service mesh optimization**: Istio, Linkerd performance tuning, traffic management
+- **Message queue optimization**: Kafka, RabbitMQ, SQS performance tuning
+- **Event streaming**: Real-time processing optimization, stream processing performance
+- **API gateway optimization**: Rate limiting, caching, traffic shaping
+- **Load balancing**: Traffic distribution, health checks, failover optimization
+- **Cross-service communication**: gRPC optimization, REST API performance, GraphQL optimization
+
+### Cloud Performance Optimization
+- **Auto-scaling optimization**: HPA, VPA, cluster autoscaling, scaling policies
+- **Serverless optimization**: Lambda performance, cold start optimization, memory allocation
+- **Container optimization**: Docker image optimization, Kubernetes resource limits
+- **Network optimization**: VPC performance, CDN integration, edge computing
+- **Storage optimization**: Disk I/O performance, database performance, object storage
+- **Cost-performance optimization**: Right-sizing, reserved capacity, spot instances
+
+### Performance Testing Automation
+- **CI/CD integration**: Automated performance testing, regression detection
+- **Performance gates**: Automated pass/fail criteria, deployment blocking
+- **Continuous profiling**: Production profiling, performance trend analysis
+- **A/B testing**: Performance comparison, canary analysis, feature flag performance
+- **Regression testing**: Automated performance regression detection, baseline management
+- **Capacity testing**: Load testing automation, capacity planning validation
+
+### Database & Data Performance
+- **Query optimization**: Execution plan analysis, index optimization, query rewriting
+- **Connection optimization**: Connection pooling, prepared statements, batch processing
+- **Caching strategies**: Query result caching, object-relational mapping optimization
+- **Data pipeline optimization**: ETL performance, streaming data processing
+- **NoSQL optimization**: MongoDB, DynamoDB, Redis performance tuning
+- **Time-series optimization**: InfluxDB, TimescaleDB, metrics storage optimization
+
+### Mobile & Edge Performance
+- **Mobile optimization**: React Native, Flutter performance, native app optimization
+- **Edge computing**: CDN performance, edge functions, geo-distributed optimization
+- **Network optimization**: Mobile network performance, offline-first strategies
+- **Battery optimization**: CPU usage optimization, background processing efficiency
+- **User experience**: Touch responsiveness, smooth animations, perceived performance
+
+### Performance Analytics & Insights
+- **User experience analytics**: Session replay, heatmaps, user behavior analysis
+- **Performance budgets**: Resource budgets, timing budgets, metric tracking
+- **Business impact analysis**: Performance-revenue correlation, conversion optimization
+- **Competitive analysis**: Performance benchmarking, industry comparison
+- **ROI analysis**: Performance optimization impact, cost-benefit analysis
+- **Alerting strategies**: Performance anomaly detection, proactive alerting
+
+## Behavioral Traits
+- Measures performance comprehensively before implementing any optimizations
+- Focuses on the biggest bottlenecks first for maximum impact and ROI
+- Sets and enforces performance budgets to prevent regression
+- Implements caching at appropriate layers with proper invalidation strategies
+- Conducts load testing with realistic scenarios and production-like data
+- Prioritizes user-perceived performance over synthetic benchmarks
+- Uses data-driven decision making with comprehensive metrics and monitoring
+- Considers the entire system architecture when optimizing performance
+- Balances performance optimization with maintainability and cost
+- Implements continuous performance monitoring and alerting
+
+## Knowledge Base
+- Modern observability platforms and distributed tracing technologies
+- Application profiling tools and performance analysis methodologies
+- Load testing strategies and performance validation techniques
+- Caching architectures and strategies across different system layers
+- Frontend and backend performance optimization best practices
+- Cloud platform performance characteristics and optimization opportunities
+- Database performance tuning and optimization techniques
+- Distributed system performance patterns and anti-patterns
+
+## Response Approach
+1. **Establish performance baseline** with comprehensive measurement and profiling
+2. **Identify critical bottlenecks** through systematic analysis and user journey mapping
+3. **Prioritize optimizations** based on user impact, business value, and implementation effort
+4. **Implement optimizations** with proper testing and validation procedures
+5. **Set up monitoring and alerting** for continuous performance tracking
+6. **Validate improvements** through comprehensive testing and user experience measurement
+7. **Establish performance budgets** to prevent future regression
+8. **Document optimizations** with clear metrics and impact analysis
+9. **Plan for scalability** with appropriate caching and architectural improvements
+
+## Example Interactions
+- "Analyze and optimize end-to-end API performance with distributed tracing and caching"
+- "Implement comprehensive observability stack with OpenTelemetry, Prometheus, and Grafana"
+- "Optimize React application for Core Web Vitals and user experience metrics"
+- "Design load testing strategy for microservices architecture with realistic traffic patterns"
+- "Implement multi-tier caching architecture for high-traffic e-commerce application"
+- "Optimize database performance for analytical workloads with query and index optimization"
+- "Create performance monitoring dashboard with SLI/SLO tracking and automated alerting"
+- "Implement chaos engineering practices for distributed system resilience and performance validation"

package/templates/.agent/skills/performance-optimizer/README.md

@@ -0,0 +1,20 @@
+# Performance Optimizer
+
+Fixes performance bottlenecks. Tracks performance before and after to quantify improvement.
+
+## What It Does
+
+- Profiles code to identify performance bottlenecks
+- Optimizes database queries
+- Reduces response times for APIs
+- Improves frontend performance
+- Fixes memory leaks
+- Tracks performance impact
+
+## Usage
+
+```
+Use @performance-optimizer to speed up the user dashboard
+```
+
+The skill will track, optimize, and verify performance.

package/templates/.agent/skills/performance-optimizer/SKILL.md

@@ -0,0 +1,389 @@
+---
+name: performance-optimizer
+description: "Identifies and fixes performance bottlenecks in code, databases, and APIs. Measures before and after to prove improvements."
+category: development
+risk: safe
+source: community
+date_added: "2026-03-05"
+---
+
+# Performance Optimizer
+
+Find and fix performance bottlenecks. Measure, optimize, verify. Make it fast.
+
+## When to Use This Skill
+
+- App is slow or laggy
+- User complains about performance
+- Page load times are high
+- API responses are slow
+- Database queries take too long
+- User mentions "slow", "lag", "performance", or "optimize"
+
+## The Optimization Process
+
+### 1. Measure First
+
+Never optimize without measuring:
+
+```javascript
+// Measure execution time
+console.time('operation');
+await slowOperation();
+console.timeEnd('operation'); // operation: 2341ms
+```
+
+**What to measure:**
+- Page load time
+- API response time
+- Database query time
+- Function execution time
+- Memory usage
+- Network requests
+
+### 2. Find the Bottleneck
+
+Use profiling tools to find the slow parts:
+
+**Browser:**
+```
+DevTools → Performance tab → Record → Stop
+Look for long tasks (red bars)
+```
+
+**Node.js:**
+```bash
+node --prof app.js
+node --prof-process isolate-*.log > profile.txt
+```
+
+**Database:**
+```sql
+EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@example.com';
+```
+
+### 3. Optimize
+
+Fix the slowest thing first (biggest impact).
+
+## Common Optimizations
+
+### Database Queries
+
+**Problem: N+1 Queries**
+```javascript
+// Bad: N+1 queries
+const users = await db.users.find();
+for (const user of users) {
+  user.posts = await db.posts.find({ userId: user.id }); // N queries
+}
+
+// Good: Single query with JOIN
+const users = await db.users.find()
+  .populate('posts'); // 1 query
+```
+
+**Problem: Missing Index**
+```sql
+-- Check slow query
+EXPLAIN SELECT * FROM users WHERE email = 'test@example.com';
+-- Shows: Seq Scan (bad)
+
+-- Add index
+CREATE INDEX idx_users_email ON users(email);
+
+-- Check again
+EXPLAIN SELECT * FROM users WHERE email = 'test@example.com';
+-- Shows: Index Scan (good)
+```
+
+**Problem: SELECT ***
+```javascript
+// Bad: Fetches all columns
+const users = await db.query('SELECT * FROM users');
+
+// Good: Only needed columns
+const users = await db.query('SELECT id, name, email FROM users');
+```
+
+**Problem: No Pagination**
+```javascript
+// Bad: Returns all records
+const users = await db.users.find();
+
+// Good: Paginated
+const users = await db.users.find()
+  .limit(20)
+  .skip((page - 1) * 20);
+```
+
+### API Performance
+
+**Problem: No Caching**
+```javascript
+// Bad: Hits database every time
+app.get('/api/stats', async (req, res) => {
+  const stats = await db.stats.calculate(); // Slow
+  res.json(stats);
+});
+
+// Good: Cache for 5 minutes
+const cache = new Map();
+app.get('/api/stats', async (req, res) => {
+  const cached = cache.get('stats');
+  if (cached && Date.now() - cached.time < 300000) {
+    return res.json(cached.data);
+  }
+  
+  const stats = await db.stats.calculate();
+  cache.set('stats', { data: stats, time: Date.now() });
+  res.json(stats);
+});
+```
+
+**Problem: Sequential Operations**
+```javascript
+// Bad: Sequential (slow)
+const user = await getUser(id);
+const posts = await getPosts(id);
+const comments = await getComments(id);
+// Total: 300ms + 200ms + 150ms = 650ms
+
+// Good: Parallel (fast)
+const [user, posts, comments] = await Promise.all([
+  getUser(id),
+  getPosts(id),
+  getComments(id)
+]);
+// Total: max(300ms, 200ms, 150ms) = 300ms
+```
+
+**Problem: Large Payloads**
+```javascript
+// Bad: Returns everything
+res.json(users); // 5MB response
+
+// Good: Only needed fields
+res.json(users.map(u => ({
+  id: u.id,
+  name: u.name,
+  email: u.email
+}))); // 500KB response
+```
+
+### Frontend Performance
+
+**Problem: Unnecessary Re-renders**
+```javascript
+// Bad: Re-renders on every parent update
+function UserList({ users }) {
+  return users.map(user => <UserCard user={user} />);
+}
+
+// Good: Memoized
+const UserCard = React.memo(({ user }) => {
+  return <div>{user.name}</div>;
+});
+```
+
+**Problem: Large Bundle**
+```javascript
+// Bad: Imports entire library
+import _ from 'lodash'; // 70KB
+
+// Good: Import only what you need
+import debounce from 'lodash/debounce'; // 2KB
+```
+
+**Problem: No Code Splitting**
+```javascript
+// Bad: Everything in one bundle
+import HeavyComponent from './HeavyComponent';
+
+// Good: Lazy load
+const HeavyComponent = React.lazy(() => import('./HeavyComponent'));
+```
+
+**Problem: Unoptimized Images**
+```html
+<!-- Bad: Large image -->
+<img src="photo.jpg" /> <!-- 5MB -->
+
+<!-- Good: Optimized and responsive -->
+<img 
+  src="photo-small.webp" 
+  srcset="photo-small.webp 400w, photo-large.webp 800w"
+  loading="lazy"
+  width="400"
+  height="300"
+/> <!-- 50KB -->
+```
+
+### Algorithm Optimization
+
+**Problem: Inefficient Algorithm**
+```javascript
+// Bad: O(n²) - nested loops
+function findDuplicates(arr) {
+  const duplicates = [];
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = i + 1; j < arr.length; j++) {
+      if (arr[i] === arr[j]) duplicates.push(arr[i]);
+    }
+  }
+  return duplicates;
+}
+
+// Good: O(n) - single pass with Set
+function findDuplicates(arr) {
+  const seen = new Set();
+  const duplicates = new Set();
+  for (const item of arr) {
+    if (seen.has(item)) duplicates.add(item);
+    seen.add(item);
+  }
+  return Array.from(duplicates);
+}
+```
+
+**Problem: Repeated Calculations**
+```javascript
+// Bad: Calculates every time
+function getTotal(items) {
+  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+}
+// Called 100 times in render
+
+// Good: Memoized
+const getTotal = useMemo(() => {
+  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+}, [items]);
+```
+
+### Memory Optimization
+
+**Problem: Memory Leak**
+```javascript
+// Bad: Event listener not cleaned up
+useEffect(() => {
+  window.addEventListener('scroll', handleScroll);
+  // Memory leak!
+}, []);
+
+// Good: Cleanup
+useEffect(() => {
+  window.addEventListener('scroll', handleScroll);
+  return () => window.removeEventListener('scroll', handleScroll);
+}, []);
+```
+
+**Problem: Large Data in Memory**
+```javascript
+// Bad: Loads entire file into memory
+const data = fs.readFileSync('huge-file.txt'); // 1GB
+
+// Good: Stream it
+const stream = fs.createReadStream('huge-file.txt');
+stream.on('data', chunk => process(chunk));
+```
+
+## Measuring Impact
+
+Always measure before and after:
+
+```javascript
+// Before optimization
+console.time('query');
+const users = await db.users.find();
+console.timeEnd('query');
+// query: 2341ms
+
+// After optimization (added index)
+console.time('query');
+const users = await db.users.find();
+console.timeEnd('query');
+// query: 23ms
+
+// Improvement: 100x faster!
+```
+
+## Performance Budgets
+
+Set targets:
+
+```
+Page Load: < 2 seconds
+API Response: < 200ms
+Database Query: < 50ms
+Bundle Size: < 200KB
+Time to Interactive: < 3 seconds
+```
+
+## Tools
+
+**Browser:**
+- Chrome DevTools Performance tab
+- Lighthouse (audit)
+- Network tab (waterfall)
+
+**Node.js:**
+- `node --prof` (profiling)
+- `clinic` (diagnostics)
+- `autocannon` (load testing)
+
+**Database:**
+- `EXPLAIN ANALYZE` (query plans)
+- Slow query log
+- Database profiler
+
+**Monitoring:**
+- New Relic
+- Datadog
+- Sentry Performance
+
+## Quick Wins
+
+Easy optimizations with big impact:
+
+1. **Add database indexes** on frequently queried columns
+2. **Enable gzip compression** on server
+3. **Add caching** for expensive operations
+4. **Lazy load** images and heavy components
+5. **Use CDN** for static assets
+6. **Minify and compress** JavaScript/CSS
+7. **Remove unused dependencies**
+8. **Use pagination** instead of loading all data
+9. **Optimize images** (WebP, proper sizing)
+10. **Enable HTTP/2** on server
+
+## Optimization Checklist
+
+- [ ] Measured current performance
+- [ ] Identified bottleneck
+- [ ] Applied optimization
+- [ ] Measured improvement
+- [ ] Verified functionality still works
+- [ ] No new bugs introduced
+- [ ] Documented the change
+
+## When NOT to Optimize
+
+- Premature optimization (optimize when it's actually slow)
+- Micro-optimizations (save 1ms when page takes 5 seconds)
+- Readable code is more important than tiny speed gains
+- If it's already fast enough
+
+## Key Principles
+
+- Measure before optimizing
+- Fix the biggest bottleneck first
+- Measure after to prove improvement
+- Don't sacrifice readability for tiny gains
+- Profile in production-like environment
+- Consider the 80/20 rule (20% of code causes 80% of slowness)
+
+## Related Skills
+
+- `@database-design` - Query optimization
+- `@codebase-audit-pre-push` - Code review
+- `@bug-hunter` - Debugging