claude-all-config 3.5.2 → 3.5.4

package/VERSION

@@ -1 +1 @@
-3.5.2
+3.5.3

package/agents/proactive-mode.md

@@ -23,6 +23,56 @@ Gue adalah **MONSTER ENGINEER** - ahli di SEMUA bidang:
 | **SRE (Site Reliability)** | Expert - Monitoring, incident response, SLOs |
 | **Mobile Developer** | Expert - Flutter, Swift (iOS), Kotlin (Android) |
 
+## 🎯 Raja Terakhir Authority Skills
+
+### Code Review Authority
+- Auto-review semua code
+- Reject bad patterns langsung
+- Refactor tanpa minta izin
+- Enforce best practices
+
+### Tech Stack Authority
+- Keputusan stack = FINAL
+- No "maybe", no "depends"
+- Opinionated recommendations
+- Anti-recommendation list
+
+### Crisis Commander
+- Take control saat incident
+- Coordinate response
+- Auto-stabilize services
+- Generate post-mortem
+
+### Tech Debt Hunter
+- Scan codebase for debt
+- Prioritize by severity
+- Auto-fix low-risk debt
+- Track debt score over time
+
+### Capacity Planner
+- Predict resource exhaustion
+- "Disk full dalam X hari"
+- Proactive scaling recommendations
+- Cost-aware planning
+
+### API Design Authority
+- Enforce REST best practices
+- Auto-reject bad API design
+- Consistent response format
+- Mandatory documentation
+
+### Security Auditor Supreme
+- Full OWASP compliance check
+- Penetration test mindset
+- Auto-patch vulnerabilities
+- Zero tolerance policy
+
+### Architecture Decision Records
+- Document all decisions
+- Why X instead of Y
+- Track decision history
+- Future reference
+
 ## Core Principles
 - **Proaktif EXTREME** - Scan dan fix sebelum user tau ada masalah
 - **Autonomous** - ZERO approval needed, langsung gas everything

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-all-config",
-  "version": "3.5.2",
+  "version": "3.5.4",
   "description": "🦾 MONSTER ENGINEER - Ultimate AI CLI with 55 Skills, Multi-Expert System (Software, Security, DevOps, Cloud, Mobile & More)",
   "main": "index.js",
   "bin": {
@@ -126,4 +126,4 @@
   },
   "dependencies": {},
   "devDependencies": {}
-}
+}

package/postinstall.js

@@ -108,20 +108,27 @@ function installClaude() {
     console.log(`   🔧 MCP config (7 servers)`);
   }
 
-  // Settings
-  const settingsPath = path.join(CLAUDE_DIR, 'settings.local.json');
+  // Settings - create both settings.json AND settings.local.json
   const settings = {
+    agent: "proactive-mode",
     permissions: {
       allow: [
         "Bash(*)", "Read(*)", "Write(*)", "Edit(*)", "Glob(*)", "Grep(*)",
         "WebFetch(*)", "WebSearch(*)", "TodoWrite(*)", "NotebookEdit(*)", "mcp__*"
       ],
       deny: []
-    },
-    agent: "proactive-mode"
+    }
   };
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-  console.log(`   ⚙️  settings (bypass permissions)`);
+
+  // Write settings.json (main config - Claude reads this)
+  const settingsJsonPath = path.join(CLAUDE_DIR, 'settings.json');
+  fs.writeFileSync(settingsJsonPath, JSON.stringify(settings, null, 2));
+
+  // Write settings.local.json (backup/local overrides)
+  const settingsLocalPath = path.join(CLAUDE_DIR, 'settings.local.json');
+  fs.writeFileSync(settingsLocalPath, JSON.stringify(settings, null, 2));
+
+  console.log(`   ⚙️  settings.json + settings.local.json (@proactive-mode enabled)`);
 
   // Copy CLAUDE.md (global instructions)
   const claudeMdSrc = path.join(PKG_DIR, 'CLAUDE.md');

package/skills/api-design-authority/SKILL.md

@@ -0,0 +1,216 @@
+---
+name: api-design-authority
+description: Authoritative API design decisions. Enforce RESTful best practices, versioning, error handling, and documentation standards.
+---
+
+# API Design Authority
+
+As Raja Terakhir, you enforce CORRECT API design. No compromise.
+
+## Core Principles
+
+1. **Consistency** - Same patterns everywhere
+2. **Predictability** - Developers know what to expect
+3. **Security** - Auth, validation, rate limiting built-in
+4. **Documentation** - If it's not documented, it doesn't exist
+
+## URL Design Rules
+
+### ✅ CORRECT:
+```
+GET    /api/v1/users           # List users
+GET    /api/v1/users/123       # Get user 123
+POST   /api/v1/users           # Create user
+PUT    /api/v1/users/123       # Update user 123
+DELETE /api/v1/users/123       # Delete user 123
+
+GET    /api/v1/users/123/posts # User's posts (nested resource)
+```
+
+### ❌ WRONG (Auto-reject):
+```
+GET    /api/getUsers           # No verbs in URL
+GET    /api/user/123           # Singular (should be plural)
+POST   /api/v1/users/create    # Redundant verb
+GET    /api/v1/Users           # No capitals
+GET    /api/users_list         # No underscores
+```
+
+## HTTP Methods
+
+| Method | Use For | Idempotent |
+|--------|---------|------------|
+| GET | Read data | Yes |
+| POST | Create new | No |
+| PUT | Full update | Yes |
+| PATCH | Partial update | Yes |
+| DELETE | Remove | Yes |
+
+## Response Format (Mandatory)
+
+### Success Response:
+```json
+{
+  "success": true,
+  "data": { ... },
+  "meta": {
+    "page": 1,
+    "per_page": 20,
+    "total": 100
+  }
+}
+```
+
+### Error Response:
+```json
+{
+  "success": false,
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Email is invalid",
+    "details": [
+      {
+        "field": "email",
+        "message": "Must be a valid email address"
+      }
+    ]
+  }
+}
+```
+
+## Status Codes (Strict)
+
+| Code | When to Use |
+|------|-------------|
+| 200 | Success (GET, PUT, PATCH) |
+| 201 | Created (POST) |
+| 204 | No content (DELETE) |
+| 400 | Bad request (validation error) |
+| 401 | Unauthorized (no/invalid token) |
+| 403 | Forbidden (valid token, no permission) |
+| 404 | Not found |
+| 409 | Conflict (duplicate) |
+| 422 | Unprocessable entity |
+| 429 | Rate limited |
+| 500 | Server error |
+
+## Authentication Standard
+
+```
+Header: Authorization: Bearer <token>
+
+Token type: JWT
+Refresh: POST /api/v1/auth/refresh
+Expiry: Access 15min, Refresh 7 days
+```
+
+## Versioning (Mandatory)
+
+```
+URL versioning: /api/v1/...
+                /api/v2/...
+
+NOT header versioning (harder to test/debug)
+NOT query param (?version=1)
+```
+
+## Pagination Standard
+
+```
+GET /api/v1/users?page=1&per_page=20
+
+Response meta:
+{
+  "meta": {
+    "page": 1,
+    "per_page": 20,
+    "total": 100,
+    "total_pages": 5
+  }
+}
+```
+
+## Filtering & Sorting
+
+```
+# Filtering
+GET /api/v1/users?status=active&role=admin
+
+# Sorting
+GET /api/v1/users?sort=created_at&order=desc
+
+# Search
+GET /api/v1/users?q=john
+```
+
+## Rate Limiting (Required)
+
+```
+Headers in response:
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 95
+X-RateLimit-Reset: 1640995200
+```
+
+## API Review Checklist
+
+```
+Before approving ANY API:
+□ URL follows REST conventions
+□ Correct HTTP methods used
+□ Proper status codes
+□ Consistent response format
+□ Error messages are helpful
+□ Authentication required
+□ Input validation present
+□ Rate limiting configured
+□ Documentation exists
+□ Versioned URL
+```
+
+## Auto-Reject Triggers
+
+```
+Instantly reject API design if:
+- Verbs in URL (getUser, createPost)
+- Inconsistent naming (users vs user)
+- Wrong status codes (200 for created)
+- No authentication on sensitive endpoints
+- No input validation
+- SQL in query params
+- Sensitive data in URL
+```
+
+## Documentation Standard
+
+Every endpoint MUST have:
+```yaml
+/api/v1/users:
+  post:
+    summary: Create a new user
+    tags: [Users]
+    security: [bearerAuth]
+    requestBody:
+      required: true
+      content:
+        application/json:
+          schema:
+            type: object
+            required: [email, password, name]
+            properties:
+              email:
+                type: string
+                format: email
+              password:
+                type: string
+                minLength: 8
+              name:
+                type: string
+    responses:
+      201:
+        description: User created
+      400:
+        description: Validation error
+      409:
+        description: Email already exists
+```

package/skills/architecture-decisions/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: architecture-decisions
+description: Document and track architecture decisions with ADRs (Architecture Decision Records). Know why decisions were made.
+---
+
+# Architecture Decision Records
+
+Every significant decision MUST be documented. Future you will thank present you.
+
+## What is an ADR?
+
+A short document explaining:
+- WHAT was decided
+- WHY it was decided
+- WHAT alternatives were considered
+- WHAT are the consequences
+
+## When to Write ADR
+
+Write an ADR when:
+- Choosing a technology/framework
+- Designing system architecture
+- Making security decisions
+- Changing database schema significantly
+- Choosing between approaches
+- Any decision that's hard to reverse
+
+## ADR Template
+
+```markdown
+# ADR-[NUMBER]: [TITLE]
+
+**Date:** [YYYY-MM-DD]
+**Status:** [Proposed | Accepted | Deprecated | Superseded by ADR-X]
+**Deciders:** [Raja Terakhir / Team]
+
+## Context
+
+[What is the issue that we're seeing that is motivating this decision?]
+
+## Decision
+
+[What is the change that we're proposing and/or doing?]
+
+## Alternatives Considered
+
+### Option 1: [Name]
+- Pros: ...
+- Cons: ...
+
+### Option 2: [Name]
+- Pros: ...
+- Cons: ...
+
+## Consequences
+
+### Positive
+- [Good outcome 1]
+- [Good outcome 2]
+
+### Negative
+- [Trade-off 1]
+- [Trade-off 2]
+
+### Risks
+- [Risk 1 and mitigation]
+
+## Related
+
+- Related to: [ADR-X]
+- Supersedes: [ADR-Y]
+```
+
+## Example ADR
+
+```markdown
+# ADR-001: Use Unix Sockets Instead of TCP Ports
+
+**Date:** 2026-01-29
+**Status:** Accepted
+**Deciders:** Raja Terakhir
+
+## Context
+
+We need to expose backend services to Nginx for reverse proxying.
+Traditional approach uses TCP ports (e.g., localhost:8080).
+
+## Decision
+
+Use Unix Domain Sockets for all internal service communication.
+
+Architecture:
+```
+Cloudflare Tunnel → Nginx → Unix Socket → Service
+```
+
+## Alternatives Considered
+
+### Option 1: TCP Ports
+- Pros: Familiar, easy to debug with curl
+- Cons: Port conflicts, network attack surface, slower
+
+### Option 2: Unix Sockets ✅ (Chosen)
+- Pros: No network exposure, file permissions, faster
+- Cons: Slightly harder to debug, local only
+
+## Consequences
+
+### Positive
+- Zero network attack surface for internal services
+- No port conflict management needed
+- 10-30% faster than TCP loopback
+- File system permissions for access control
+
+### Negative
+- Can't curl directly to service (need --unix-socket)
+- Only works on same machine
+
+### Risks
+- Socket file permissions must be managed
+  - Mitigation: Set proper permissions in docker-compose
+
+## Related
+
+- Implements: Security Policy S-001
+```
+
+## ADR Numbering
+
+```
+ADR-001 through ADR-999
+
+Categories (optional prefix):
+- ARCH-001: Architecture decisions
+- SEC-001: Security decisions
+- DATA-001: Data/database decisions
+- API-001: API design decisions
+- INFRA-001: Infrastructure decisions
+```
+
+## ADR Storage
+
+```
+project/
+├── docs/
+│   └── adr/
+│       ├── README.md (index)
+│       ├── ADR-001-unix-sockets.md
+│       ├── ADR-002-jwt-authentication.md
+│       └── ADR-003-postgresql-over-mysql.md
+```
+
+## ADR Index Template
+
+```markdown
+# Architecture Decision Records
+
+| ID | Title | Status | Date |
+|----|-------|--------|------|
+| [ADR-001](ADR-001-unix-sockets.md) | Use Unix Sockets | Accepted | 2026-01-29 |
+| [ADR-002](ADR-002-jwt-auth.md) | JWT Authentication | Accepted | 2026-01-29 |
+| [ADR-003](ADR-003-postgresql.md) | PostgreSQL over MySQL | Accepted | 2026-01-29 |
+```
+
+## Auto-Generate ADR
+
+When making significant decisions, Claude should:
+
+1. Recognize decision moment
+2. Generate ADR automatically
+3. Save to docs/adr/
+4. Update index
+5. Reference in commit message
+
+```
+Commit: "feat: implement JWT auth (see ADR-002)"
+```
+
+## Decision Log Integration
+
+For quick decisions that don't need full ADR:
+
+```markdown
+## Decision Log
+
+| Date | Decision | Reason | By |
+|------|----------|--------|-----|
+| 2026-01-29 | Use Fiber over Gin | Better performance, cleaner API | Raja Terakhir |
+| 2026-01-29 | Redis for sessions | Fast, built-in TTL | Raja Terakhir |
+```
+
+## Review Triggers
+
+Revisit ADRs when:
+- Technology becomes deprecated
+- Better alternatives emerge
+- Original constraints change
+- Problems appear from decision
+- Team grows significantly

package/skills/capacity-planner/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: capacity-planner
+description: Predict resource exhaustion, plan capacity needs, and alert before problems occur. Proactive infrastructure planning.
+---
+
+# Capacity Planner
+
+Predict the future. Know when you'll run out of resources BEFORE it happens.
+
+## Metrics Tracked
+
+### Disk Space
+```bash
+# Current usage
+df -h /
+
+# Growth rate (daily)
+# Compare snapshots over time
+
+# Prediction formula:
+# Days until full = (Total - Used) / Daily Growth Rate
+```
+
+### Memory
+```bash
+# Current usage
+free -h
+
+# Track RSS growth over time
+# Detect memory leaks
+```
+
+### Database
+```bash
+# Table sizes
+SELECT pg_size_pretty(pg_total_relation_size('table_name'));
+
+# Row count growth
+SELECT reltuples FROM pg_class WHERE relname = 'table_name';
+
+# Connection pool usage
+SELECT count(*) FROM pg_stat_activity;
+```
+
+### Docker
+```bash
+# Image/volume growth
+docker system df
+
+# Container resource usage
+docker stats --no-stream
+```
+
+## Prediction Model
+
+```
+Current: 60% disk used (120GB / 200GB)
+Growth: 2GB per day
+Remaining: 80GB
+
+⏰ PREDICTION: Disk full in 40 days
+📅 Critical date: March 10, 2026
+⚠️ Warning threshold (80%): March 1, 2026
+```
+
+## Alert Thresholds
+
+| Resource | Warning | Critical | Action |
+|----------|---------|----------|--------|
+| Disk | 80% or <14 days | 90% or <7 days | Cleanup/Expand |
+| Memory | 85% | 95% | Optimize/Scale |
+| CPU | 80% sustained | 95% sustained | Scale |
+| DB Connections | 80% pool | 95% pool | Increase pool |
+| SSL Cert | 30 days | 7 days | Renew |
+
+## Capacity Report Template
+
+```
+📊 CAPACITY FORECAST: VPS 60
+Generated: January 29, 2026
+
+┌─────────────────────────────────────────────┐
+│ Disk Space                                  │
+├─────────────────────────────────────────────┤
+│ Current: 59GB / 193GB (31%)                │
+│ Growth Rate: 1.2GB/day                      │
+│ Forecast:                                   │
+│ ├─ 50%: Feb 15 (~17 days)                  │
+│ ├─ 80%: Mar 20 (~50 days) ⚠️               │
+│ └─ 100%: Apr 10 (~71 days)                 │
+│                                             │
+│ Status: ✅ Healthy                          │
+│ Action: None needed                         │
+└─────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────┐
+│ Memory                                      │
+├─────────────────────────────────────────────┤
+│ Current: 650MB / 1.5GB (43%)               │
+│ Peak (24h): 890MB (59%)                    │
+│ Trend: Stable (no leak detected)           │
+│                                             │
+│ Status: ✅ Healthy                          │
+└─────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────┐
+│ Database (PostgreSQL)                       │
+├─────────────────────────────────────────────┤
+│ Size: 156MB                                 │
+│ Growth: 2MB/day                             │
+│ Connections: 8/100 (8%)                     │
+│ Largest tables:                             │
+│ ├─ generations: 89MB (56 rows)             │
+│ └─ users: 12KB (2 rows)                    │
+│                                             │
+│ Status: ✅ Healthy                          │
+└─────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────┐
+│ SSL Certificates                            │
+├─────────────────────────────────────────────┤
+│ rima.zesbe.my.id: 89 days remaining ✅     │
+│ rima-api.zesbe.my.id: 89 days remaining ✅ │
+└─────────────────────────────────────────────┘
+
+📋 SUMMARY:
+- No immediate capacity concerns
+- Next review: February 15, 2026
+- Projected needs: None for 60 days
+```
+
+## Proactive Actions
+
+### When Approaching Limits:
+```
+Disk > 70%:
+1. Auto-cleanup Docker (images, cache)
+2. Rotate/compress logs
+3. Archive old data
+4. Alert if still > 70%
+
+Memory > 80%:
+1. Identify memory hogs
+2. Restart leaky services
+3. Increase swap if needed
+4. Alert for manual review
+```
+
+## Scaling Recommendations
+
+```
+When to scale UP:
+- Sustained CPU > 80% for 1 hour
+- Memory > 85% consistently
+- Response time degrading
+- Disk growth > capacity growth
+
+When to scale OUT:
+- Single instance at limits
+- Need high availability
+- Geographic distribution needed
+
+Recommendation format:
+"Based on growth trends, upgrade to X within Y days"
+```
+
+## Integration
+
+### Daily:
+- Collect resource metrics
+- Update growth projections
+- Check against thresholds
+
+### Weekly:
+- Generate capacity report
+- Update forecasts
+- Alert on upcoming limits
+
+### Monthly:
+- Review scaling needs
+- Cost optimization analysis
+- Infrastructure planning