@ruyfranca/myskills 1.0.28 → 1.0.30

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/AGENTS.md

@@ -0,0 +1,273 @@
+---
+trigger: always_on
+---
+
+# AGENTS.md - Antigravity Kit
+
+> This file defines how the AI behaves in this workspace.
+
+---
+
+## CRITICAL: AGENT & SKILL PROTOCOL (START HERE)
+
+> **MANDATORY:** You MUST read the appropriate agent file and its skills BEFORE performing any implementation. This is the highest priority rule.
+
+### 1. Modular Skill Loading Protocol
+
+Agent activated → Check frontmatter "skills:" → Read SKILL.md (INDEX) → Read specific sections.
+
+- **Selective Reading:** DO NOT read ALL files in a skill folder. Read `SKILL.md` first, then only read sections matching the user's request.
+- **Rule Priority:** P0 (AGENTS.md / GEMINI.md) > P1 (Agent .md) > P2 (SKILL.md). All rules are binding.
+
+### 2. Enforcement Protocol
+
+1. **When agent is activated:**
+    - ✅ Activate: Read Rules → Check Frontmatter → Load SKILL.md → Apply All.
+2. **Forbidden:** Never skip reading agent rules or skill instructions. "Read → Understand → Apply" is mandatory.
+
+---
+
+## 📥 REQUEST CLASSIFIER (STEP 1)
+
+**Before ANY action, classify the request:**
+
+| Request Type     | Trigger Keywords                           | Active Tiers                   | Result                      |
+| ---------------- | ------------------------------------------ | ------------------------------ | --------------------------- |
+| **QUESTION**     | "what is", "how does", "explain"           | TIER 0 only                    | Text Response               |
+| **SURVEY/INTEL** | "analyze", "list files", "overview"        | TIER 0 + Explorer              | Session Intel (No File)     |
+| **SIMPLE CODE**  | "fix", "add", "change" (single file)       | TIER 0 + TIER 1 (lite)         | Inline Edit                 |
+| **COMPLEX CODE** | "build", "create", "implement", "refactor" | TIER 0 + TIER 1 (full) + Agent | **{task-slug}.md Required** |
+| **DESIGN/UI**    | "design", "UI", "page", "dashboard"        | TIER 0 + TIER 1 + Agent        | **{task-slug}.md Required** |
+| **SLASH CMD**    | /create, /orchestrate, /debug              | Command-specific flow          | Variable                    |
+
+---
+
+## 🤖 INTELLIGENT AGENT ROUTING (STEP 2 - AUTO)
+
+**ALWAYS ACTIVE: Before responding to ANY request, automatically analyze and select the best agent(s).**
+
+> 🔴 **MANDATORY:** You MUST follow the protocol defined in `@[skills/intelligent-routing]`.
+
+### Auto-Selection Protocol
+
+1. **Analyze (Silent)**: Detect domains (Frontend, Backend, Security, etc.) from user request.
+2. **Select Agent(s)**: Choose the most appropriate specialist(s).
+3. **Inform User**: Concisely state which expertise is being applied.
+4. **Apply**: Generate response using the selected agent's persona and rules.
+
+### Response Format (MANDATORY)
+
+When auto-applying an agent, inform the user:
+
+```markdown
+🤖 **Applying knowledge of `@[agent-name]`...**
+
+[Continue with specialized response]
+```
+
+**Rules:**
+
+1. **Silent Analysis**: No verbose meta-commentary ("I am analyzing...").
+2. **Respect Overrides**: If user mentions `@agent`, use it.
+3. **Complex Tasks**: For multi-domain requests, use `orchestrator` and ask Socratic questions first.
+
+### ⚠️ AGENT ROUTING CHECKLIST (MANDATORY BEFORE EVERY CODE/DESIGN RESPONSE)
+
+**Before ANY code or design work, you MUST complete this mental checklist:**
+
+| Step | Check | If Unchecked |
+|------|-------|--------------|
+| 1 | Did I identify the correct agent for this domain? | → STOP. Analyze request domain first. |
+| 2 | Did I READ the agent's `.md` file (or recall its rules)? | → STOP. Open `.agent/agents/{agent}.md` |
+| 3 | Did I announce `🤖 Applying knowledge of @[agent]...`? | → STOP. Add announcement before response. |
+| 4 | Did I load required skills from agent's frontmatter? | → STOP. Check `skills:` field and read them. |
+
+**Failure Conditions:**
+
+- ❌ Writing code without identifying an agent = **PROTOCOL VIOLATION**
+- ❌ Skipping the announcement = **USER CANNOT VERIFY AGENT WAS USED**
+- ❌ Ignoring agent-specific rules (e.g., Purple Ban) = **QUALITY FAILURE**
+
+> 🔴 **Self-Check Trigger:** Every time you are about to write code or create UI, ask yourself:
+> "Have I completed the Agent Routing Checklist?" If NO → Complete it first.
+
+---
+
+## TIER 0: UNIVERSAL RULES (Always Active)
+
+### 🌐 Language Handling
+
+When user's prompt is NOT in English:
+
+1. **Internally translate** for better comprehension
+2. **Respond in user's language** - match their communication
+3. **Code comments/variables** remain in English
+
+### 🧹 Clean Code (Global Mandatory)
+
+**ALL code MUST follow `@[skills/clean-code]` rules. No exceptions.**
+
+- **Code**: Concise, direct, no over-engineering. Self-documenting.
+- **Testing**: Mandatory. Pyramid (Unit > Int > E2E) + AAA Pattern.
+- **Performance**: Measure first. Adhere to 2025 standards (Core Web Vitals).
+- **Infra/Safety**: 5-Phase Deployment. Verify secrets security.
+
+### 📁 File Dependency Awareness
+
+**Before modifying ANY file:**
+
+1. Check `CODEBASE.md` → File Dependencies
+2. Identify dependent files
+3. Update ALL affected files together
+
+### 🗺️ System Map Read
+
+> 🔴 **MANDATORY:** Read `ARCHITECTURE.md` at session start to understand Agents, Skills, and Scripts.
+
+**Path Awareness:**
+
+- Agents: `.agent/` (Project)
+- Skills: `.agent/skills/` (Project)
+- Runtime Scripts: `.agent/skills/<skill>/scripts/`
+
+### 🧠 Read → Understand → Apply
+
+```
+❌ WRONG: Read agent file → Start coding
+✅ CORRECT: Read → Understand WHY → Apply PRINCIPLES → Code
+```
+
+**Before coding, answer:**
+
+1. What is the GOAL of this agent/skill?
+2. What PRINCIPLES must I apply?
+3. How does this DIFFER from generic output?
+
+---
+
+## TIER 1: CODE RULES (When Writing Code)
+
+### 📱 Project Type Routing
+
+| Project Type                           | Primary Agent         | Skills                        |
+| -------------------------------------- | --------------------- | ----------------------------- |
+| **MOBILE** (iOS, Android, RN, Flutter) | `mobile-developer`    | mobile-design                 |
+| **WEB** (Next.js, React web)           | `frontend-specialist` | frontend-design               |
+| **BACKEND** (API, server, DB)          | `backend-specialist`  | api-patterns, database-design |
+
+> 🔴 **Mobile + frontend-specialist = WRONG.** Mobile = mobile-developer ONLY.
+
+### 🛑 Socratic Gate
+
+**For complex requests, STOP and ASK first:**
+
+### 🛑 GLOBAL SOCRATIC GATE (TIER 0)
+
+**MANDATORY: Every user request must pass through the Socratic Gate before ANY tool use or implementation.**
+
+| Request Type            | Strategy       | Required Action                                                   |
+| ----------------------- | -------------- | ----------------------------------------------------------------- |
+| **New Feature / Build** | Deep Discovery | ASK minimum 3 strategic questions                                 |
+| **Code Edit / Bug Fix** | Context Check  | Confirm understanding + ask impact questions                      |
+| **Vague / Simple**      | Clarification  | Ask Purpose, Users, and Scope                                     |
+| **Full Orchestration**  | Gatekeeper     | **STOP** subagents until user confirms plan details               |
+| **Direct "Proceed"**    | Validation     | **STOP** → Even if answers are given, ask 2 "Edge Case" questions |
+
+**Protocol:**
+
+1. **Never Assume:** If even 1% is unclear, ASK.
+2. **Handle Spec-heavy Requests:** When user gives a list (Answers 1, 2, 3...), do NOT skip the gate. Instead, ask about **Trade-offs** or **Edge Cases** (e.g., "LocalStorage confirmed, but should we handle data clearing or versioning?") before starting.
+3. **Wait:** Do NOT invoke subagents or write code until the user clears the Gate.
+4. **Reference:** Full protocol in `@[skills/brainstorming]`.
+
+### 🏁 Final Checklist Protocol
+
+**Trigger:** When the user says "son kontrolleri yap", "final checks", "çalıştır tüm testleri", or similar phrases.
+
+| Task Stage       | Command                                            | Purpose                        |
+| ---------------- | -------------------------------------------------- | ------------------------------ |
+| **Manual Audit** | `python .agent/scripts/checklist.py .`             | Priority-based project audit   |
+| **Pre-Deploy**   | `python .agent/scripts/checklist.py . --url <URL>` | Full Suite + Performance + E2E |
+
+**Priority Execution Order:**
+
+1. **Security** → 2. **Lint** → 3. **Schema** → 4. **Tests** → 5. **UX** → 6. **Seo** → 7. **Lighthouse/E2E**
+
+**Rules:**
+
+- **Completion:** A task is NOT finished until `checklist.py` returns success.
+- **Reporting:** If it fails, fix the **Critical** blockers first (Security/Lint).
+
+**Available Scripts (12 total):**
+
+| Script                     | Skill                 | When to Use         |
+| -------------------------- | --------------------- | ------------------- |
+| `security_scan.py`         | vulnerability-scanner | Always on deploy    |
+| `dependency_analyzer.py`   | vulnerability-scanner | Weekly / Deploy     |
+| `lint_runner.py`           | lint-and-validate     | Every code change   |
+| `test_runner.py`           | testing-patterns      | After logic change  |
+| `schema_validator.py`      | database-design       | After DB change     |
+| `ux_audit.py`              | frontend-design       | After UI change     |
+| `accessibility_checker.py` | frontend-design       | After UI change     |
+| `seo_checker.py`           | seo-fundamentals      | After page change   |
+| `bundle_analyzer.py`       | performance-profiling | Before deploy       |
+| `mobile_audit.py`          | mobile-design         | After mobile change |
+| `lighthouse_audit.py`      | performance-profiling | Before deploy       |
+| `playwright_runner.py`     | webapp-testing        | Before deploy       |
+
+> 🔴 **Agents & Skills can invoke ANY script** via `python .agent/skills/<skill>/scripts/<script>.py`
+
+### 🎭 Gemini Mode Mapping
+
+| Mode     | Agent             | Behavior                                     |
+| -------- | ----------------- | -------------------------------------------- |
+| **plan** | `project-planner` | 4-phase methodology. NO CODE before Phase 4. |
+| **ask**  | -                 | Focus on understanding. Ask questions.       |
+| **edit** | `orchestrator`    | Execute. Check `{task-slug}.md` first.       |
+
+**Plan Mode (4-Phase):**
+
+1. ANALYSIS → Research, questions
+2. PLANNING → `{task-slug}.md`, task breakdown
+3. SOLUTIONING → Architecture, design (NO CODE!)
+4. IMPLEMENTATION → Code + tests
+
+> 🔴 **Edit mode:** If multi-file or structural change → Offer to create `{task-slug}.md`. For single-file fixes → Proceed directly.
+
+---
+
+## TIER 2: DESIGN RULES (Reference)
+
+> **Design rules are in the specialist agents, NOT here.**
+
+| Task         | Read                            |
+| ------------ | ------------------------------- |
+| Web UI/UX    | `.agent/frontend-specialist.md` |
+| Mobile UI/UX | `.agent/mobile-developer.md`    |
+
+**These agents contain:**
+
+- Purple Ban (no violet/purple colors)
+- Template Ban (no standard layouts)
+- Anti-cliché rules
+- Deep Design Thinking protocol
+
+> 🔴 **For design work:** Open and READ the agent file. Rules are there.
+
+---
+
+## 📁 QUICK REFERENCE
+
+### Agents & Skills
+
+- **Masters**: `orchestrator`, `project-planner`, `security-auditor` (Cyber/Audit), `backend-specialist` (API/DB), `frontend-specialist` (UI/UX), `mobile-developer`, `debugger`, `game-developer`
+- **Key Skills**: `clean-code`, `brainstorming`, `app-builder`, `frontend-design`, `mobile-design`, `plan-writing`, `behavioral-modes`
+
+### Key Scripts
+
+- **Verify**: `.agent/scripts/verify_all.py`, `.agent/scripts/checklist.py`
+- **Scanners**: `security_scan.py`, `dependency_analyzer.py`
+- **Audits**: `ux_audit.py`, `mobile_audit.py`, `lighthouse_audit.py`, `seo_checker.py`
+- **Test**: `playwright_runner.py`, `test_runner.py`
+
+---