javi-forge 1.2.0 → 1.4.0

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

@@ -1,350 +0,0 @@
----
-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

@@ -1,244 +0,0 @@
----
-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
-
-