@ruyfranca/myskills 1.0.27 → 1.0.29

package/.agent/skills/react-patterns/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: react-patterns
+description: "Modern React patterns and principles. Hooks, composition, performance, TypeScript best practices."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# React Patterns
+
+> Principles for building production-ready React applications.
+
+---
+
+## 1. Component Design Principles
+
+### Component Types
+
+| Type | Use | State |
+|------|-----|-------|
+| **Server** | Data fetching, static | None |
+| **Client** | Interactivity | useState, effects |
+| **Presentational** | UI display | Props only |
+| **Container** | Logic/state | Heavy state |
+
+### Design Rules
+
+- One responsibility per component
+- Props down, events up
+- Composition over inheritance
+- Prefer small, focused components
+
+---
+
+## 2. Hook Patterns
+
+### When to Extract Hooks
+
+| Pattern | Extract When |
+|---------|-------------|
+| **useLocalStorage** | Same storage logic needed |
+| **useDebounce** | Multiple debounced values |
+| **useFetch** | Repeated fetch patterns |
+| **useForm** | Complex form state |
+
+### Hook Rules
+
+- Hooks at top level only
+- Same order every render
+- Custom hooks start with "use"
+- Clean up effects on unmount
+
+---
+
+## 3. State Management Selection
+
+| Complexity | Solution |
+|------------|----------|
+| Simple | useState, useReducer |
+| Shared local | Context |
+| Server state | React Query, SWR |
+| Complex global | Zustand, Redux Toolkit |
+
+### State Placement
+
+| Scope | Where |
+|-------|-------|
+| Single component | useState |
+| Parent-child | Lift state up |
+| Subtree | Context |
+| App-wide | Global store |
+
+---
+
+## 4. React 19 Patterns
+
+### New Hooks
+
+| Hook | Purpose |
+|------|---------| 
+| **useActionState** | Form submission state |
+| **useOptimistic** | Optimistic UI updates |
+| **use** | Read resources in render |
+
+### Compiler Benefits
+
+- Automatic memoization
+- Less manual useMemo/useCallback
+- Focus on pure components
+
+---
+
+## 5. Composition Patterns
+
+### Compound Components
+
+- Parent provides context
+- Children consume context
+- Flexible slot-based composition
+- Example: Tabs, Accordion, Dropdown
+
+### Render Props vs Hooks
+
+| Use Case | Prefer |
+|----------|--------|
+| Reusable logic | Custom hook |
+| Render flexibility | Render props |
+| Cross-cutting | Higher-order component |
+
+---
+
+## 6. Performance Principles
+
+### When to Optimize
+
+| Signal | Action |
+|--------|--------|
+| Slow renders | Profile first |
+| Large lists | Virtualize |
+| Expensive calc | useMemo |
+| Stable callbacks | useCallback |
+
+### Optimization Order
+
+1. Check if actually slow
+2. Profile with DevTools
+3. Identify bottleneck
+4. Apply targeted fix
+
+---
+
+## 7. Error Handling
+
+### Error Boundary Usage
+
+| Scope | Placement |
+|-------|-----------|
+| App-wide | Root level |
+| Feature | Route/feature level |
+| Component | Around risky component |
+
+### Error Recovery
+
+- Show fallback UI
+- Log error
+- Offer retry option
+- Preserve user data
+
+---
+
+## 8. TypeScript Patterns
+
+### Props Typing
+
+| Pattern | Use |
+|---------|-----|
+| Interface | Component props |
+| Type | Unions, complex |
+| Generic | Reusable components |
+
+### Common Types
+
+| Need | Type |
+|------|------|
+| Children | ReactNode |
+| Event handler | MouseEventHandler |
+| Ref | RefObject<Element> |
+
+---
+
+## 9. Testing Principles
+
+| Level | Focus |
+|-------|-------|
+| Unit | Pure functions, hooks |
+| Integration | Component behavior |
+| E2E | User flows |
+
+### Test Priorities
+
+- User-visible behavior
+- Edge cases
+- Error states
+- Accessibility
+
+---
+
+## 10. Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Prop drilling deep | Use context |
+| Giant components | Split smaller |
+| useEffect for everything | Server components |
+| Premature optimization | Profile first |
+| Index as key | Stable unique ID |
+
+---
+
+> **Remember:** React is about composition. Build small, combine thoughtfully.

package/.agent/skills/react-state-management/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: react-state-management
+description: "Comprehensive guide to modern React state management patterns, from local component state to global stores and server state synchronization."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# React State Management
+
+Comprehensive guide to modern React state management patterns, from local component state to global stores and server state synchronization.
+
+## Use this skill when
+
+- Choosing the right state management solution
+- Implementing Zustand, Redux Toolkit, Jotai, or React Query
+- Migrating from legacy Redux to modern patterns
+- Combining client and server state
+
+## Do not use this skill when
+
+- The task is unrelated to React state
+- Simple useState is clearly sufficient
+
+## Core Concepts
+
+### 1. State Categories
+
+| Category | Examples | Best Solution |
+|----------|----------|---------------|
+| **Local UI** | modal open, input focus | useState |
+| **Form** | values, errors, submission | React Hook Form + Zod |
+| **Server** | fetched data, cache | React Query / SWR |
+| **Global Client** | auth, theme, cart | Zustand |
+| **Atomic** | fine-grained subscriptions | Jotai |
+
+### 2. Selection Criteria
+
+```
+Do you need this state in >2 components?
+→ No → useState / useReducer
+→ Yes → Is it server data?
+   → Yes → React Query / SWR
+   → No → Zustand / Jotai
+```
+
+## Patterns
+
+### Zustand (Simplest Global Store)
+
+```typescript
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+interface CartStore {
+  items: CartItem[];
+  addItem: (item: CartItem) => void;
+  removeItem: (id: string) => void;
+  total: () => number;
+}
+
+const useCartStore = create<CartStore>()(
+  persist(
+    (set, get) => ({
+      items: [],
+      addItem: (item) => set(state => ({ items: [...state.items, item] })),
+      removeItem: (id) => set(state => ({ items: state.items.filter(i => i.id !== id) })),
+      total: () => get().items.reduce((sum, item) => sum + item.price, 0),
+    }),
+    { name: 'cart-storage' }
+  )
+);
+
+// Usage — subscribe to only what you need (performance!)
+const items = useCartStore(state => state.items);
+const addItem = useCartStore(state => state.addItem);
+```
+
+### Redux Toolkit (Complex Domain Logic)
+
+```typescript
+const orderSlice = createSlice({
+  name: 'orders',
+  initialState: { items: [], status: 'idle' } as OrdersState,
+  reducers: {
+    orderAdded: (state, action: PayloadAction<Order>) => {
+      state.items.push(action.payload);
+    },
+  },
+  extraReducers: builder => {
+    builder
+      .addCase(fetchOrders.pending, state => { state.status = 'loading'; })
+      .addCase(fetchOrders.fulfilled, (state, action) => {
+        state.status = 'idle';
+        state.items = action.payload;
+      });
+  },
+});
+```
+
+### React Query (Server State)
+
+```typescript
+// Fetching
+const { data: users, isLoading } = useQuery({
+  queryKey: ['users', filters],
+  queryFn: () => api.getUsers(filters),
+  staleTime: 5 * 60 * 1000, // 5 minutes
+});
+
+// Mutations with optimistic updates
+const updateUser = useMutation({
+  mutationFn: api.updateUser,
+  onMutate: async (updated) => {
+    await queryClient.cancelQueries({ queryKey: ['users'] });
+    const previous = queryClient.getQueryData(['users']);
+    queryClient.setQueryData(['users'], old =>
+      old.map(u => u.id === updated.id ? { ...u, ...updated } : u)
+    );
+    return { previous }; // rollback context
+  },
+  onError: (err, _, context) => {
+    queryClient.setQueryData(['users'], context?.previous);
+  },
+  onSettled: () => queryClient.invalidateQueries({ queryKey: ['users'] }),
+});
+```
+
+### Jotai (Atomic State)
+
+```typescript
+const themeAtom = atom<'light' | 'dark'>('light');
+const derivedAtom = atom(get => get(themeAtom) === 'dark' ? '#000' : '#fff');
+
+function ThemeToggle() {
+  const [theme, setTheme] = useAtom(themeAtom);
+  const bgColor = useAtomValue(derivedAtom);
+  return <button onClick={() => setTheme(t => t === 'light' ? 'dark' : 'light')}>Toggle</button>;
+}
+```
+
+## Best Practices
+
+- **Don't** put server data in global stores — use React Query
+- **Do** keep Zustand stores focused (one concern per store)
+- **Don't** select the entire store object (`state => state`) — causes re-renders
+- **Do** derive computed values outside the component when possible

package/.agent/skills/ruby-pro/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: ruby-pro
+description: Write idiomatic Ruby code with metaprogramming, Rails patterns, and performance optimization. Specializes in Ruby on Rails, gem development, and testing frameworks.
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Ruby Pro
+
+You are a Ruby expert specializing in clean, maintainable, and performant Ruby code.
+
+## Use this skill when
+
+- Building Ruby on Rails applications
+- Working with Ruby metaprogramming, modules, and DSLs
+- Developing gems and managing dependencies
+- Optimizing Ruby performance and profiling
+
+## Do not use this skill when
+
+- The task is unrelated to Ruby/Rails
+- You need a different language or runtime
+
+## Focus Areas
+
+- Ruby metaprogramming (modules, mixins, DSLs)
+- Rails patterns (ActiveRecord, controllers, views)
+- Gem development and dependency management
+- Performance optimization and profiling
+- Testing with RSpec and Minitest
+- Code quality with RuboCop and static analysis
+
+## Core Patterns
+
+```ruby
+# Concerns as mixins
+module Timestampable
+  extend ActiveSupport::Concern
+
+  included do
+    before_create :set_timestamps
+  end
+
+  def set_timestamps
+    self.created_at = Time.current
+    self.updated_at = Time.current
+  end
+end
+
+# Service objects
+class ProcessOrderService
+  def initialize(order, payment_gateway)
+    @order = order
+    @gateway = payment_gateway
+  end
+
+  def call
+    ActiveRecord::Base.transaction do
+      charge_customer
+      update_inventory
+      send_confirmation
+    end
+  end
+
+  private
+
+  def charge_customer
+    @gateway.charge(@order.total)
+  end
+end
+
+# Enumerables
+users
+  .select(&:active?)
+  .map { |u| { id: u.id, name: u.full_name } }
+  .sort_by { |u| u[:name] }
+```
+
+## Approach
+
+1. Embrace Ruby's expressiveness and metaprogramming features
+2. Follow Ruby and Rails conventions and idioms
+3. Use blocks and enumerables effectively
+4. Handle exceptions with proper rescue/ensure patterns
+5. Optimize for readability first, performance second
+
+## Testing
+
+```ruby
+# RSpec example
+RSpec.describe ProcessOrderService do
+  subject(:service) { described_class.new(order, gateway) }
+
+  describe '#call' do
+    context 'when payment succeeds' do
+      it 'updates order status to paid' do
+        expect { service.call }.to change(order, :status).to('paid')
+      end
+    end
+  end
+end
+```
+
+Favor Ruby's expressiveness. Include Gemfile and .rubocop.yml when relevant.

package/.agent/skills/zod-validation-expert/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: zod-validation-expert
+description: "Expert in Zod schema validation, type inference, and integration with React Hook Form, Next.js Server Actions, and tRPC."
+risk: safe
+source: community
+date_added: "2026-02-27"
+---
+
+# Zod Validation Expert
+
+You are a production-grade Zod expert. You help developers build type-safe schema definitions and validation logic. You master Zod fundamentals, type inference, complex validations, transformations, and integrations across the modern TypeScript ecosystem.
+
+## When to Use This Skill
+
+- Defining schemas for forms, APIs, environment variables
+- Integrating Zod with React Hook Form
+- Validating in Next.js Server Actions or API routes
+- Building type-safe tRPC routers
+- Parsing and transforming external data
+
+## Core Concepts
+
+### Why Zod?
+
+- Runtime type-safety (TypeScript types disappear at runtime)
+- Single source of truth for schema + types
+- Composable and tree-shakeable
+
+### Schema Definition & Inference
+
+```typescript
+import { z } from 'zod';
+
+// Define schema
+const UserSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(2).max(50),
+  email: z.string().email(),
+  age: z.number().int().min(0).max(120).optional(),
+  role: z.enum(['admin', 'user', 'editor']).default('user'),
+});
+
+// Infer TypeScript type — single source of truth
+type User = z.infer<typeof UserSchema>;
+```
+
+### Parsing & Validation
+
+```typescript
+// parse — throws ZodError
+const user = UserSchema.parse(rawData); // always typed
+
+// safeParse — never throws
+const result = UserSchema.safeparse(rawData);
+if (result.success) {
+  console.log(result.data); // typed
+} else {
+  console.error(result.error.flatten());
+}
+```
+
+### Custom Validation (Refinements)
+
+```typescript
+const PasswordSchema = z.object({
+  password: z.string().min(8),
+  confirm: z.string(),
+}).refine(data => data.password === data.confirm, {
+  message: "Passwords don't match",
+  path: ['confirm'],
+});
+```
+
+### Transformations
+
+```typescript
+const DateSchema = z.string()
+  .datetime()
+  .transform(val => new Date(val)); // string → Date after parse
+```
+
+## Integration Patterns
+
+### React Hook Form
+
+```tsx
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+
+const form = useForm<User>({
+  resolver: zodResolver(UserSchema),
+  defaultValues: { role: 'user' },
+});
+```
+
+### Next.js Server Actions
+
+```tsx
+async function createUser(formData: FormData) {
+  'use server';
+  
+  const result = UserSchema.safeParse({
+    name: formData.get('name'),
+    email: formData.get('email'),
+  });
+  
+  if (!result.success) {
+    return { error: result.error.flatten().fieldErrors };
+  }
+  
+  await db.user.create({ data: result.data });
+}
+```
+
+### Environment Variables
+
+```typescript
+const EnvSchema = z.object({
+  DATABASE_URL: z.string().url(),
+  API_KEY: z.string().min(32),
+  PORT: z.coerce.number().default(3000),
+});
+
+export const env = EnvSchema.parse(process.env);
+```
+
+## Best Practices
+
+- Always use `z.infer<typeof Schema>` — never duplicate types
+- Use `safeParse` at system boundaries (API, form submit)
+- Compose schemas with `.extend()`, `.merge()`, `.pick()`
+- Add `.describe()` for OpenAPI documentation generation

package/README.md

@@ -1,6 +1,21 @@
 # mySkills
 
-Este repositório contém uma coleção de skills especializadas para o **Antigravity**, projetadas para estender as capacidades do assistente em áreas específicas como gestão de produtos, marketing e negócios.
+Biblioteca de skills, agents e workflows especializados para o **Antigravity**.
+
+## ⚡ Quick Start
+
+> Execute esses dois comandos em qualquer projeto para ativar o kit completo:
+
+```bash
+npx @ruyfranca/myskills init && npx @ruyfranca/myskills install-global
+```
+
+- `init` → instala a pasta `.agent/` (skills, agents, workflows) no projeto atual
+- `install-global` → instala os workflows em `~/.gemini/antigravity/global_workflows/` para o menu `/` do Antigravity
+
+> **Após rodar, feche e reabra o Antigravity.** Os comandos `/brainstorm`, `/debug`, `/plan` e todos os outros estarão disponíveis.
+
+---
 
 ## 🚀 Skills Disponíveis
 
@@ -301,42 +316,48 @@ Toolkit para sistemas de design e consistência visual:
 
 ## 📦 Instalação e Uso via NPX
 
-Esta biblioteca de skills pode ser usada em qualquer projeto local sem a necessidade de clonar o repositório manualmente.
+Esta biblioteca pode ser usada em qualquer projeto sem clonar o repositório.
 
-### Comandos Disponíveis
+### 🏁 Primeiros Passos (Recomendado)
 
 ```bash
-# 1. Listar todas as skills na biblioteca
+# Instala o kit completo + ativa o menu / no Antigravity
+npx @ruyfranca/myskills init && npx @ruyfranca/myskills install-global
+```
+
+Após executar, **feche e reabra o Antigravity**. Os slash commands (`/brainstorm`, `/debug`, `/plan`, etc.) estarão disponíveis em qualquer projeto.
+
+### Todos os Comandos
+
+```bash
+# Listar skills disponíveis
 npx @ruyfranca/myskills list
 
-# 2. Listar todos os agents na biblioteca
+# Listar agents disponíveis
 npx @ruyfranca/myskills list-agents
 
-# 3. Inicializar kit completo em um novo projeto
-# (Instala a pasta .agent completa com skills, agents e workflows)
+# Inicializar kit completo no projeto atual (.agent/ com skills, agents, workflows)
 npx @ruyfranca/myskills init
 
-# 4. Instalar uma skill individual
+# 🌐 Ativar o menu / do Antigravity com todos os workflows (roda uma vez por máquina)
+npx @ruyfranca/myskills install-global
+
+# Instalar uma skill individual
 npx @ruyfranca/myskills add <nome-da-skill>
 
-# 5. Instalar um agent individual
+# Instalar um agent individual
 npx @ruyfranca/myskills add <nome-do-agent> --agent
 
-# 6. Instalar TODAS as 40+ skills individuais
+# Instalar todas as 40+ skills
 npx @ruyfranca/myskills add --all
 
-# 7. 🆕 Atualizar o kit (skills + agents + workflows) no projeto atual
+# Atualizar o kit no projeto atual (skills + agents + workflows + global_workflows)
 npx @ruyfranca/myskills update
 
-# ou com opções granulares:
-npx @ruyfranca/myskills update --skills     # só as skills
-npx @ruyfranca/myskills update --agents     # só os agents
-npx @ruyfranca/myskills update --workflows  # só os workflows
-
-# Exemplo prático:
-npx @ruyfranca/myskills init
-npx @ruyfranca/myskills add frontend-developer --agent
-npx @ruyfranca/myskills update  # mantém o projeto atualizado
+# Atualizar apenas um componente específico:
+npx @ruyfranca/myskills update --skills
+npx @ruyfranca/myskills update --agents
+npx @ruyfranca/myskills update --workflows
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruyfranca/myskills",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "Biblioteca de skills customizadas para Antigravity / Claude Code",
   "main": "index.js",
   "bin": {