javi-forge 0.1.0

package/ai-config/skills/frontend/zustand-state/SKILL.md

@@ -0,0 +1,350 @@
+---
+name: zustand-state
+description: >
+  Zustand state management patterns with immer, persist middleware, and React integration.
+  Trigger: Zustand, state management, store, React state, immer, persist, global state
+tools:
+  - Read
+  - Write
+  - Grep
+metadata:
+  author: plataforma-industrial
+  version: "2.0"
+  tags: [zustand, state-management, react, immer, typescript]
+  updated: "2026-02"
+---
+
+# Zustand State Management
+
+Modern state management patterns with Zustand 4.5+.
+
+## Stack
+
+```json
+{
+  "zustand": "4.5.2",
+  "immer": "10.0.3"
+}
+```
+
+## Basic Store
+
+```typescript
+// src/stores/ui.ts
+import { create } from 'zustand';
+
+interface UIState {
+  sidebarOpen: boolean;
+  theme: 'light' | 'dark' | 'auto';
+  toggleSidebar: () => void;
+  setTheme: (theme: 'light' | 'dark' | 'auto') => void;
+}
+
+export const useUIStore = create<UIState>((set) => ({
+  sidebarOpen: true,
+  theme: 'auto',
+  toggleSidebar: () => set((state) => ({ sidebarOpen: !state.sidebarOpen })),
+  setTheme: (theme) => set({ theme }),
+}));
+```
+
+## Auth Store with Persist
+
+```typescript
+// src/stores/auth.ts
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+
+interface User {
+  id: string;
+  email: string;
+  name: string;
+  role: 'admin' | 'user';
+}
+
+interface AuthState {
+  user: User | null;
+  token: string | null;
+  isAuthenticated: boolean;
+  login: (user: User, token: string) => void;
+  logout: () => void;
+}
+
+export const useAuthStore = create<AuthState>()(
+  persist(
+    (set) => ({
+      user: null,
+      token: null,
+      isAuthenticated: false,
+      login: (user, token) => set({ user, token, isAuthenticated: true }),
+      logout: () => set({ user: null, token: null, isAuthenticated: false }),
+    }),
+    {
+      name: 'auth-storage',
+      storage: createJSONStorage(() => localStorage),
+      partialize: (state) => ({
+        user: state.user,
+        token: state.token,
+        isAuthenticated: state.isAuthenticated,
+      }),
+    }
+  )
+);
+```
+
+## Complex Store with Immer
+
+```typescript
+// src/stores/items.ts
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import { subscribeWithSelector } from 'zustand/middleware';
+
+interface Item {
+  id: string;
+  name: string;
+  value: number;
+  status: 'active' | 'inactive';
+}
+
+interface ItemsState {
+  items: Record<string, Item>;
+  selectedId: string | null;
+  filters: { status?: string; search?: string };
+
+  setItems: (items: Item[]) => void;
+  updateItem: (id: string, updates: Partial<Item>) => void;
+  selectItem: (id: string | null) => void;
+  setFilters: (filters: Partial<ItemsState['filters']>) => void;
+}
+
+export const useItemsStore = create<ItemsState>()(
+  subscribeWithSelector(
+    immer((set) => ({
+      items: {},
+      selectedId: null,
+      filters: {},
+
+      setItems: (items) =>
+        set((state) => {
+          state.items = items.reduce((acc, item) => {
+            acc[item.id] = item;
+            return acc;
+          }, {} as Record<string, Item>);
+        }),
+
+      updateItem: (id, updates) =>
+        set((state) => {
+          if (state.items[id]) {
+            Object.assign(state.items[id], updates);
+          }
+        }),
+
+      selectItem: (id) =>
+        set((state) => {
+          state.selectedId = id;
+        }),
+
+      setFilters: (filters) =>
+        set((state) => {
+          Object.assign(state.filters, filters);
+        }),
+    }))
+  )
+);
+
+// Selectors
+export const selectItemsList = (state: ItemsState) => Object.values(state.items);
+
+export const selectFilteredItems = (state: ItemsState) => {
+  const items = Object.values(state.items);
+  const { status, search } = state.filters;
+
+  return items.filter((item) => {
+    if (status && item.status !== status) return false;
+    if (search && !item.name.toLowerCase().includes(search.toLowerCase())) return false;
+    return true;
+  });
+};
+```
+
+## Alerts Store
+
+```typescript
+// src/stores/alerts.ts
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+
+interface Alert {
+  id: string;
+  type: 'warning' | 'error' | 'info';
+  message: string;
+  acknowledged: boolean;
+}
+
+interface AlertsState {
+  alerts: Alert[];
+  unreadCount: number;
+  addAlert: (alert: Alert) => void;
+  acknowledgeAlert: (id: string) => void;
+  acknowledgeAll: () => void;
+}
+
+export const useAlertsStore = create<AlertsState>()(
+  immer((set) => ({
+    alerts: [],
+    unreadCount: 0,
+
+    addAlert: (alert) =>
+      set((state) => {
+        state.alerts.unshift(alert);
+        if (!alert.acknowledged) state.unreadCount++;
+      }),
+
+    acknowledgeAlert: (id) =>
+      set((state) => {
+        const alert = state.alerts.find((a) => a.id === id);
+        if (alert && !alert.acknowledged) {
+          alert.acknowledged = true;
+          state.unreadCount = Math.max(0, state.unreadCount - 1);
+        }
+      }),
+
+    acknowledgeAll: () =>
+      set((state) => {
+        state.alerts.forEach((a) => (a.acknowledged = true));
+        state.unreadCount = 0;
+      }),
+  }))
+);
+```
+
+## React Patterns
+
+### Selector Hook
+
+```typescript
+export function useItemById(id: string) {
+  return useItemsStore(useCallback((state) => state.items[id], [id]));
+}
+```
+
+### Shallow Compare
+
+```typescript
+import { shallow } from 'zustand/shallow';
+
+function ItemFilters() {
+  const { filters, setFilters } = useItemsStore(
+    (state) => ({
+      filters: state.filters,
+      setFilters: state.setFilters,
+    }),
+    shallow
+  );
+}
+```
+
+### Actions Outside Components
+
+```typescript
+// Access store outside React
+const currentUser = useAuthStore.getState().user;
+
+// Execute action outside React
+useAlertsStore.getState().addAlert(newAlert);
+```
+
+### Subscribe to Changes
+
+```typescript
+const unsubscribe = useItemsStore.subscribe(
+  (state) => state.selectedId,
+  (selectedId) => {
+    console.log('Selected:', selectedId);
+  }
+);
+```
+
+## Slice Pattern (Large Apps)
+
+```typescript
+// src/stores/slices/userSlice.ts
+import { StateCreator } from 'zustand';
+
+export interface UserSlice {
+  user: User | null;
+  setUser: (user: User | null) => void;
+}
+
+export const createUserSlice: StateCreator<UserSlice & OtherSlice, [], [], UserSlice> = (
+  set
+) => ({
+  user: null,
+  setUser: (user) => set({ user }),
+});
+```
+
+```typescript
+// src/stores/index.ts
+import { create } from 'zustand';
+import { createUserSlice, UserSlice } from './slices/userSlice';
+import { createItemSlice, ItemSlice } from './slices/itemSlice';
+
+type AppStore = UserSlice & ItemSlice;
+
+export const useAppStore = create<AppStore>()((...a) => ({
+  ...createUserSlice(...a),
+  ...createItemSlice(...a),
+}));
+```
+
+## DevTools
+
+```typescript
+import { devtools } from 'zustand/middleware';
+
+export const useItemsStore = create<ItemsState>()(
+  devtools(
+    immer((set) => ({
+      // ...
+    })),
+    { name: 'items-store' }
+  )
+);
+```
+
+## Testing
+
+```typescript
+import { useAuthStore } from '../auth';
+
+describe('AuthStore', () => {
+  beforeEach(() => {
+    useAuthStore.setState({ user: null, token: null, isAuthenticated: false });
+  });
+
+  it('should login user', () => {
+    const user = { id: '1', email: 'test@test.com', name: 'Test', role: 'user' };
+
+    useAuthStore.getState().login(user, 'token');
+
+    expect(useAuthStore.getState().user).toEqual(user);
+    expect(useAuthStore.getState().isAuthenticated).toBe(true);
+  });
+});
+```
+
+## Best Practices
+
+1. **One store per domain** - Separate stores for auth, items, alerts, UI
+2. **Specific selectors** - `state.user?.name` not entire state
+3. **Actions in store** - Logic inside store, not components
+4. **Use immer for complex updates** - Direct mutation syntax
+5. **Shallow compare for objects** - Prevent unnecessary re-renders
+
+## Related Skills
+
+- `frontend-web`: Full frontend integration
+- `tanstack-query`: Server state complement
+- `mantine-ui`: UI state binding

package/ai-config/skills/infrastructure/chaos-engineering/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: chaos-engineering
+description: >
+  Chaos engineering principles. Fault injection, resilience testing, game days.
+  Trigger: chaos, fault injection, resilience, chaos monkey, failure testing
+tools:
+  - Read
+  - Write
+  - Edit
+  - Grep
+metadata:
+  author: apigen-team
+  version: "1.0"
+  tags: [chaos, testing, resilience, sre]
+  scope: ["**/chaos/**"]
+---
+
+# Chaos Engineering Concepts
+
+## Core Principles
+
+```
+Chaos Engineering: Discipline of experimenting on a system
+to build confidence in its ability to withstand turbulent
+conditions in production.
+
+Key Principles:
+1. Build hypothesis around steady state behavior
+2. Vary real-world events (failures, traffic spikes)
+3. Run experiments in production (safely)
+4. Automate experiments for continuous validation
+5. Minimize blast radius
+```
+
+## Steady State Hypothesis
+
+```
+Define "normal" before breaking things:
+
+Metrics to establish:
+- Response time P99 < 200ms
+- Error rate < 0.1%
+- Throughput > 1000 RPS
+- CPU utilization < 70%
+
+Hypothesis example:
+"When the payment service fails, orders should still
+be accepted and queued for later processing.
+Response time may increase by 50% but stay under 500ms."
+```
+
+## Fault Types
+
+### Network Faults
+```
+Latency injection:
+- Add 100-500ms delay to service calls
+- Simulate cross-region communication
+- Test timeout configurations
+
+Packet loss:
+- Drop 5-10% of packets
+- Test retry mechanisms
+- Validate idempotency
+
+DNS failures:
+- Simulate DNS resolution failures
+- Test fallback configurations
+- Validate service discovery resilience
+
+Connection limits:
+- Exhaust connection pools
+- Test circuit breaker activation
+- Validate graceful degradation
+```
+
+### Service Faults
+```
+Service unavailability:
+- Kill service instances
+- Test load balancer failover
+- Validate health check accuracy
+
+Slow responses:
+- Inject delays before response
+- Test client timeouts
+- Validate async processing
+
+Error responses:
+- Return 500/503 errors
+- Test retry with backoff
+- Validate error handling
+```
+
+### Database Faults
+```
+Connection failures:
+- Drop database connections
+- Test connection pool recovery
+- Validate transaction rollback
+
+Slow queries:
+- Inject query delays
+- Test query timeouts
+- Validate read replica failover
+
+Data corruption (controlled):
+- Inject invalid data
+- Test validation layers
+- Validate data integrity checks
+```
+
+### Resource Faults
+```
+CPU stress:
+- Consume CPU cycles
+- Test autoscaling triggers
+- Validate performance degradation
+
+Memory pressure:
+- Consume available memory
+- Test OOM handling
+- Validate garbage collection
+
+Disk I/O:
+- Slow disk operations
+- Fill disk space
+- Test log rotation
+```
+
+## Experiment Design
+
+```
+1. Define Scope
+   - Which service(s)?
+   - Which environment?
+   - What time window?
+
+2. Set Hypothesis
+   - Expected behavior under fault
+   - Acceptable degradation limits
+   - Recovery time expectations
+
+3. Design Fault
+   - Type of failure
+   - Duration and intensity
+   - Rollback mechanism
+
+4. Define Metrics
+   - What to measure
+   - Baseline values
+   - Alert thresholds
+
+5. Execute & Observe
+   - Start with small blast radius
+   - Monitor dashboards
+   - Ready to abort
+
+6. Analyze & Report
+   - Did hypothesis hold?
+   - What broke unexpectedly?
+   - Action items for improvement
+```
+
+## Blast Radius Control
+
+```
+Start small, expand gradually:
+
+Phase 1: Development
+- Local development environment
+- Single service instance
+- Synthetic traffic
+
+Phase 2: Staging
+- Staging/pre-prod environment
+- Full service mesh
+- Replayed production traffic
+
+Phase 3: Production (canary)
+- Single production instance
+- < 1% of traffic
+- Immediate abort capability
+
+Phase 4: Production (expanded)
+- Multiple instances
+- 5-10% of traffic
+- Automated rollback
+```
+
+## Game Days
+
+```
+Planned chaos exercises with team participation:
+
+Preparation:
+- Schedule 2-4 hours
+- Notify stakeholders
+- Prepare runbooks
+- Set up monitoring dashboards
+
+Execution:
+- Inject failures per plan
+- Observe and document
+- Practice incident response
+- Test communication channels
+
+Post-mortem:
+- Review what worked/failed
+- Update runbooks
+- Create improvement tickets
+- Share learnings
+```
+
+## Tools Landscape
+
+```
+| Tool | Best For |
+|------|----------|
+| Chaos Monkey | Random instance termination |
+| Gremlin | Comprehensive fault injection |
+| Litmus | Kubernetes-native chaos |
+| Toxiproxy | Network fault simulation |
+| Chaos Mesh | K8s chaos orchestration |
+| AWS FIS | AWS service faults |
+```
+
+## Anti-patterns
+
+```
+❌ Starting in production without staging tests
+❌ No abort mechanism or kill switch
+❌ Chaos without monitoring
+❌ No hypothesis before experiment
+❌ Blaming instead of learning
+❌ One-time exercises (should be continuous)
+```
+
+## Related Skills
+
+- `chaos-spring`: Spring Boot chaos implementation
+- `apigen-architecture`: Overall system architecture
+
+