wizz-method 2.2.0 → 2.3.0

package/src/skills-lib/wizz-cloud-and-infra/SKILL.md

@@ -1,36 +1,36 @@
 ---
 name: wizz-cloud-and-infra
-description: Otimização de custo de cloud — right-sizing, spot instances, reserved instances, S3 lifecycle, auto-scaling, auditoria de custo AWS/GCP. Use quando o pedido envolver redução de custo de infra, cloud spend, billing de cloud.
+description: Cloud cost optimization — right-sizing, spot instances, reserved instances, S3 lifecycle, auto-scaling, AWS/GCP cost audits. Use when the request involves reducing infra cost, cloud spend, cloud billing.
 ---
 
 # Cloud and Infrastructure Cost Optimization
 
-## Principais alavancas de economia em cloud
+## Main cloud savings levers
 
 ### Compute (EC2, VPS, Cloud Run)
-- **Right-sizing**: instâncias superdimensionadas são o erro mais comum. Use métricas de CPU/RAM dos últimos 30 dias para dimensionar corretamente
-- **Spot/Preemptible instances**: para workloads tolerantes a interrupção, economia de 60-90%
-- **Reserved instances**: compromisso de 1 ano = ~40% de desconto frente ao on-demand
-- **Auto-scaling**: nunca deixe instâncias fixas onde há variação de tráfego
+- **Right-sizing**: oversized instances are the most common mistake. Use CPU/RAM metrics from the last 30 days to size correctly
+- **Spot/Preemptible instances**: for interruption-tolerant workloads, 60-90% savings
+- **Reserved instances**: a 1-year commitment = ~40% discount vs. on-demand
+- **Auto-scaling**: never leave fixed instances where traffic varies
 
 ### Storage
-- **S3/Object Storage lifecycle policies**: mova arquivos antigos para tiers mais baratos (Glacier, Nearline) automaticamente
-- **Snapshots desnecessários**: audite snapshots de discos que já foram deletados
-- **Egress**: tráfego de saída é caro. CDN resolve a maioria dos casos
+- **S3/Object Storage lifecycle policies**: automatically move old files to cheaper tiers (Glacier, Nearline)
+- **Unnecessary snapshots**: audit snapshots of disks that have already been deleted
+- **Egress**: outbound traffic is expensive. A CDN solves most cases
 
-### Banco de dados
-- **Leitura vs escrita**: separe réplicas de leitura. RDS Multi-AZ só vale para produção crítica
-- **Connection pooling**: PgBouncer/RDS Proxy evita custos de instâncias maiores só por conexões
-- **Backups automáticos**: defina retention period adequado, não deixe no padrão infinito
+### Database
+- **Read vs write**: separate read replicas. RDS Multi-AZ is only worth it for critical production
+- **Connection pooling**: PgBouncer/RDS Proxy avoids the cost of bigger instances just to handle connections
+- **Automatic backups**: set an appropriate retention period, don't leave it at the infinite default
 
 ### Kubernetes / Containers
-- **Namespace resource limits**: sem limits definidos, pods consomem tudo
-- **Idle pods**: use HPA (Horizontal Pod Autoscaler) para zerar réplicas fora do horário
-- **Container registry**: limpe imagens antigas, cobranças por GB armazenado
+- **Namespace resource limits**: without limits defined, pods consume everything
+- **Idle pods**: use HPA (Horizontal Pod Autoscaler) to zero out replicas outside business hours
+- **Container registry**: clean up old images, billed per GB stored
 
-## Checklist rápido de auditoria
-- [ ] CPU médio > 20% nas instâncias principais?
-- [ ] Algum serviço sem auto-scaling em produção?
-- [ ] Snapshots/backups com retenção indefinida?
-- [ ] Egress sem CDN em assets estáticos?
-- [ ] Banco de dados em instância maior que o necessário?
+## Quick audit checklist
+- [ ] Average CPU > 20% on the main instances?
+- [ ] Any service without auto-scaling in production?
+- [ ] Snapshots/backups with indefinite retention?
+- [ ] Egress without a CDN on static assets?
+- [ ] Database on a bigger instance than necessary?

package/src/skills-lib/wizz-database-and-deps/SKILL.md

@@ -1,81 +1,81 @@
 ---
 name: wizz-database-and-deps
 description: >
-  Segurança de banco de dados e dependências. Usar quando: revisar queries de banco, checar SQL injection,
-  auditar permissões de banco, criptografar PII, revisar pacotes vulneráveis, configurar Dependabot/Renovate,
-  auditar RPCs Supabase, verificar menor privilégio no banco. Use quando o usuário mencionar SQL,
-  query builder, RPC do Supabase, npm/pnpm audit, Dependabot, pacotes vulneráveis, PII no banco ou lock file.
+  Database and dependency security. Use when: reviewing database queries, checking for SQL injection,
+  auditing database permissions, encrypting PII, reviewing vulnerable packages, configuring Dependabot/Renovate,
+  auditing Supabase RPCs, verifying least privilege in the database. Use when the user mentions SQL,
+  query builder, Supabase RPC, npm/pnpm audit, Dependabot, vulnerable packages, PII in the database, or lock file.
 ---
 
 # Database and Dependencies Security
 
-## Banco de dados
+## Database
 
 ### SQL Injection
-- Use sempre queries parametrizadas ou ORM com binding correto
-- Nunca concatene input do usuário em SQL
-- Mesmo com ORM: raw queries precisam de atenção
-- Teste com payloads: `' OR '1'='1`, `'; DROP TABLE users;--`
+- Always use parameterized queries or an ORM with correct binding
+- Never concatenate user input into SQL
+- Even with an ORM: raw queries need attention
+- Test with payloads: `' OR '1'='1`, `'; DROP TABLE users;--`
 
-### Stack Supabase — como prevenir SQLi
-O Supabase client já é parametrizado por design:
+### Supabase stack — how to prevent SQLi
+The Supabase client is already parameterized by design:
 ```ts
-// SEGURO — query-builder: valores passados como args separados
+// SAFE — query-builder: values passed as separate args
 const { data } = await supabase
   .from("captou_leads")
   .select("*")
-  .eq("workspace_id", workspaceId)  // parametrizado
-  .ilike("name", `%${search}%`)     // parametrizado (não concatenado em SQL)
+  .eq("workspace_id", workspaceId)  // parameterized
+  .ilike("name", `%${search}%`)     // parameterized (not concatenated into SQL)
 
-// SEGURO — RPC com params nomeados
+// SAFE — RPC with named params
 await supabase.rpc("find_captou_extraction_job_by_run_id", { run_id: runId })
 
-// PERIGOSO — raw SQL com interpolação (evitar)
+// DANGEROUS — raw SQL with interpolation (avoid)
 await supabase.rpc("exec_sql", { sql: `SELECT * WHERE id = '${id}'` })
 ```
 
-**Ressalva importante:** o corpo das funções RPC vive no Postgres (fora do repo). Auditar no dashboard do Supabase se alguma RPC usa `EXECUTE format('... %s', input)` com input do usuário — isso é SQL injection server-side.
+**Important caveat:** RPC function bodies live in Postgres (outside the repo). Audit the Supabase dashboard for any RPC using `EXECUTE format('... %s', input)` with user input — that's server-side SQL injection.
 
-### Princípio do menor privilégio
-- Usuário da aplicação: apenas SELECT/INSERT/UPDATE/DELETE nas tabelas necessárias
-- Nunca use usuário root/admin da aplicação
-- Crie usuário separado para migrations (com ALTER TABLE, CREATE, DROP)
-- Read replicas: usuário somente leitura
-- Supabase: `SUPABASE_SERVICE_ROLE_KEY` bypassa RLS — só usar em server-side para operações admin; para operações de usuário, usar a `anon key` + RLS
+### Principle of least privilege
+- Application user: only SELECT/INSERT/UPDATE/DELETE on the necessary tables
+- Never use a root/admin user for the application
+- Create a separate user for migrations (with ALTER TABLE, CREATE, DROP)
+- Read replicas: read-only user
+- Supabase: `SUPABASE_SERVICE_ROLE_KEY` bypasses RLS — only use it server-side for admin operations; for user operations, use the `anon key` + RLS
 
-### Dados sensíveis em banco
-- Criptografe PII (CPF, dados de cartão) em repouso com AES-256
-- Não armazene dados de cartão (use tokenização via gateway de pagamento)
-- Logs e audit trail: guarde quem acessou/modificou dados sensíveis
-- Backups criptografados: a cópia do banco não pode ser mais fraca que o banco
-- `deleted_at timestamp` para soft delete — nunca apague dados reais; isto também é auditoria
+### Sensitive data in the database
+- Encrypt PII (national ID, card data) at rest with AES-256
+- Don't store card data (use tokenization via the payment gateway)
+- Logs and audit trail: keep a record of who accessed/modified sensitive data
+- Encrypted backups: the database copy can't be weaker than the database itself
+- `deleted_at timestamp` for soft delete — never delete real data; this is also an audit trail
 
-### Checklist de segurança de banco
-- [ ] Nenhuma query monta SQL com template literal/concatenação?
-- [ ] `grep -r "\.sql\|\.query(\|raw(" src/` → revisar manualmente?
-- [ ] RPCs Supabase auditadas no dashboard (sem `EXECUTE format(...)` inseguro)?
-- [ ] RLS ativo nas tabelas de domínio? (`SELECT tablename, rowsecurity FROM pg_tables`)
-- [ ] `SUPABASE_SERVICE_ROLE_KEY` usada apenas em server-side?
+### Database security checklist
+- [ ] No query builds SQL via template literal/concatenation?
+- [ ] `grep -r "\.sql\|\.query(\|raw(" src/` → reviewed manually?
+- [ ] Supabase RPCs audited in the dashboard (no unsafe `EXECUTE format(...)`)?
+- [ ] RLS enabled on domain tables? (`SELECT tablename, rowsecurity FROM pg_tables`)
+- [ ] `SUPABASE_SERVICE_ROLE_KEY` used only server-side?
 
-## Dependências
+## Dependencies
 
-### Vulnerabilidades em pacotes
-- `npm audit` / `pnpm audit` / `pip audit`: rode em CI em cada PR
-- Dependabot ou Renovate: automatize atualizações de segurança
-- Lock files (`package-lock.json`, `pnpm-lock.yaml`): sempre commite, garante reprodutibilidade
+### Package vulnerabilities
+- `npm audit` / `pnpm audit` / `pip audit`: run in CI on every PR
+- Dependabot or Renovate: automate security updates
+- Lock files (`package-lock.json`, `pnpm-lock.yaml`): always commit them, they guarantee reproducibility
 
 ### Supply chain attacks
-- Prefira pacotes com muitos downloads e manutenção ativa
-- Verifique integridade: `npm install --ignore-scripts` para pacotes suspeitos
-- SBOM (Software Bill of Materials): documente todas as dependências em produção
+- Prefer packages with many downloads and active maintenance
+- Verify integrity: `npm install --ignore-scripts` for suspicious packages
+- SBOM (Software Bill of Materials): document all dependencies in production
 
-### Atualizações
-- Dependências de segurança: atualize imediatamente
-- Dependências menores: sprint a sprint
-- Major versions: planeje com antecedência, não deixe acumular
+### Updates
+- Security dependencies: update immediately
+- Minor dependencies: sprint by sprint
+- Major versions: plan ahead, don't let them pile up
 
-### Checklist de dependências
-- [ ] `pnpm audit` (ou `npm audit`) rodado e sem HIGH/CRITICAL abertos?
-- [ ] Lock file commitado?
-- [ ] Dependabot ou Renovate configurado no repo?
-- [ ] Pacotes de dev não vão para produção (`devDependencies` correto)?
+### Dependencies checklist
+- [ ] `pnpm audit` (or `npm audit`) run with no open HIGH/CRITICAL findings?
+- [ ] Lock file committed?
+- [ ] Dependabot or Renovate configured in the repo?
+- [ ] Dev packages don't go to production (`devDependencies` correct)?

package/src/skills-lib/wizz-database-scaling/SKILL.md

@@ -1,44 +1,44 @@
 ---
 name: wizz-database-scaling
-description: Escalar banco de dados — sharding, réplicas de leitura, connection pooling, índices, N+1, particionamento. Use quando o pedido envolver banco lento, performance de queries, escala de dados.
+description: Scaling databases — sharding, read replicas, connection pooling, indexes, N+1, partitioning. Use when the request involves a slow database, query performance, data scaling.
 ---
 
 # Database Scaling
 
-## Identificando o gargalo de banco
-- Queries lentas: ative slow query log (> 100ms é sinal de alerta)
-- Connections esgotadas: use connection pooling (PgBouncer, RDS Proxy)
-- CPU alta no banco: índices faltando ou queries ineficientes
-- I/O alto: volume de dados crescendo mais rápido que o hardware
+## Identifying the database bottleneck
+- Slow queries: enable the slow query log (> 100ms is a warning sign)
+- Exhausted connections: use connection pooling (PgBouncer, RDS Proxy)
+- High CPU on the database: missing indexes or inefficient queries
+- High I/O: data volume growing faster than the hardware
 
-## Índices
+## Indexes
 
-### Quando criar
-- Colunas usadas em WHERE, ORDER BY, JOIN
-- Colunas de foreign key que não têm índice automático
-- Combinações de colunas usadas juntas em filtros
+### When to create one
+- Columns used in WHERE, ORDER BY, JOIN
+- Foreign key columns that don't have an automatic index
+- Combinations of columns used together in filters
 
-### Quando não criar
-- Tabelas pequenas (< 10k linhas) raramente se beneficiam
-- Colunas com poucos valores distintos (ex: status com 3 opções)
-- Índices demais degradam escrita (todo INSERT/UPDATE precisa atualizar índices)
+### When not to create one
+- Small tables (< 10k rows) rarely benefit
+- Columns with few distinct values (e.g. a status with 3 options)
+- Too many indexes degrade writes (every INSERT/UPDATE has to update the indexes)
 
 ## Read Replicas
-- Separe queries de leitura (relatórios, listagens) para réplica
-- Escreva sempre no primário
-- Atenção ao replication lag em dados críticos
+- Route read queries (reports, listings) to a replica
+- Always write to the primary
+- Watch out for replication lag on critical data
 
 ## Sharding
-- Última opção, após esgotar otimizações de query e hardware
-- Shard por ID do usuário ou tenant é o padrão mais comum
-- Aumenta muito a complexidade de queries que cruzam shards
-
-## Particionamento (PostgreSQL)
-- Particione tabelas grandes por data (logs, eventos, transações)
-- Facilita DELETE de dados antigos (drop partition em vez de DELETE em massa)
-- Melhora performance de queries com filtro de data
-
-## Conexões e pool
-- Limite de conexões do Postgres: default 100, aumente com cuidado
-- PgBouncer em transaction mode: centenas de clientes, dezenas de conexões reais
-- Nunca abra conexão sem fechar (connection leak mata o banco)
+- Last resort, after exhausting query and hardware optimizations
+- Sharding by user ID or tenant is the most common pattern
+- Greatly increases the complexity of queries that cross shards
+
+## Partitioning (PostgreSQL)
+- Partition large tables by date (logs, events, transactions)
+- Makes deleting old data easier (drop partition instead of a bulk DELETE)
+- Improves performance of queries with a date filter
+
+## Connections and pooling
+- Postgres connection limit: default 100, increase with care
+- PgBouncer in transaction mode: hundreds of clients, dozens of real connections
+- Never open a connection without closing it (a connection leak kills the database)

package/src/skills-lib/wizz-desktop-security/SKILL.md

@@ -1,75 +1,75 @@
 ---
 name: wizz-desktop-security
 description: >
-  Segurança para apps desktop e Electron. Usar quando: desenvolver app Electron, configurar contextIsolation/IPC,
-  implementar code signing, armazenar tokens/credenciais localmente, configurar auto-update seguro,
-  distribuir app para macOS/Windows. Use quando o usuário mencionar Electron, IPC, contextBridge,
-  preload script, safeStorage, code signing, notarização ou auto-update.
+  Security for desktop and Electron apps. Use when: developing an Electron app, configuring contextIsolation/IPC,
+  implementing code signing, storing tokens/credentials locally, configuring secure auto-update,
+  distributing an app for macOS/Windows. Use when the user mentions Electron, IPC, contextBridge,
+  preload script, safeStorage, code signing, notarization, or auto-update.
 ---
 
 # Desktop Security
 
-## Electron / Apps Desktop
+## Electron / Desktop Apps
 
-### Contexto de segurança
-- nodeIntegration: false (padrão desde Electron 5, mantenha assim)
-- contextIsolation: true (obrigatório)
-- sandbox: true quando possível
-- webSecurity: false nunca em produção
-- Nunca carregue conteúdo remoto numa janela com acesso a APIs privilegiadas; conteúdo remoto = sandbox + sem preload sensível
-- Mantenha o Electron atualizado (patches de Chromium/Node chegam por release do Electron)
+### Security context
+- nodeIntegration: false (default since Electron 5, keep it that way)
+- contextIsolation: true (mandatory)
+- sandbox: true when possible
+- webSecurity: false never in production
+- Never load remote content in a window with access to privileged APIs; remote content = sandbox + no sensitive preload
+- Keep Electron up to date (Chromium/Node patches arrive via Electron releases)
 
-### Navegação e janelas
-- Bloqueie navegação para fora do app: handler em `will-navigate` que cancela URLs fora da allowlist
-- `setWindowOpenHandler`: negue por padrão (`{ action: "deny" }`), abra externo só o que for aprovado
-- `shell.openExternal` só com URL validada (esquema `https:` e host esperado), nunca com input cru do renderer
+### Navigation and windows
+- Block navigation outside the app: a `will-navigate` handler that cancels URLs outside the allowlist
+- `setWindowOpenHandler`: deny by default (`{ action: "deny" }`), only open externally what's been approved
+- `shell.openExternal` only with a validated URL (`https:` scheme and expected host), never with raw input from the renderer
 
-### IPC (comunicação renderer <> main)
-- Valide e sanitize todos os dados vindos do renderer (o renderer é território hostil: trate como input de usuário)
-- Exponha apenas as funções necessárias via contextBridge, cada uma com assinatura fixa
-- Nunca exponha ipcRenderer diretamente ao renderer
-- Em `ipcMain.handle`, valide tipo e tamanho dos argumentos; se houver múltiplas janelas, cheque `event.senderFrame.url` contra o esperado
+### IPC (renderer <> main communication)
+- Validate and sanitize all data coming from the renderer (the renderer is hostile territory: treat it as user input)
+- Expose only the necessary functions via contextBridge, each with a fixed signature
+- Never expose ipcRenderer directly to the renderer
+- In `ipcMain.handle`, validate the type and size of the arguments; if there are multiple windows, check `event.senderFrame.url` against what's expected
 
 ```ts
-// preload.ts: superfície mínima, sem repassar ipcRenderer
+// preload.ts: minimal surface, without passing through ipcRenderer
 contextBridge.exposeInMainWorld("api", {
   saveNote: (text: string) => ipcRenderer.invoke("notes:save", text),
 })
 
-// main.ts: valida antes de agir
+// main.ts: validate before acting
 ipcMain.handle("notes:save", (event, text) => {
-  if (typeof text !== "string" || text.length > 10_000) throw new Error("input inválido")
+  if (typeof text !== "string" || text.length > 10_000) throw new Error("invalid input")
   // ...
 })
 ```
 
-### Atualizações automáticas
-- Assine o pacote de atualização com certificado de código (code signing)
-- Valide assinatura antes de instalar atualização
-- Distribua via HTTPS com certificate pinning se possível
+### Automatic updates
+- Sign the update package with a code-signing certificate
+- Validate the signature before installing an update
+- Distribute over HTTPS with certificate pinning if possible
 
-## Armazenamento local
+## Local storage
 
-### O que armazenar localmente
-- Tokens de sessão: `safeStorage` do Electron (usa Keychain no macOS, DPAPI no Windows, libsecret no Linux), nunca localStorage
-  - `safeStorage.encryptString(token)` antes de gravar em disco; `keytar` está arquivado, não use em projeto novo
-- Dados sensíveis do usuário: criptografados via `safeStorage` ou AES-256-GCM com chave guardada no keychain do OS
+### What to store locally
+- Session tokens: Electron's `safeStorage` (uses Keychain on macOS, DPAPI on Windows, libsecret on Linux), never localStorage
+  - `safeStorage.encryptString(token)` before writing to disk; `keytar` is archived, don't use it in a new project
+- Sensitive user data: encrypted via `safeStorage` or AES-256-GCM with the key kept in the OS keychain
 
-### O que nunca armazenar localmente
-- Senhas em texto plano
-- Chaves privadas sem criptografia
-- Dados sensíveis em localStorage/sessionStorage sem criptografia
+### What to never store locally
+- Plaintext passwords
+- Unencrypted private keys
+- Sensitive data in localStorage/sessionStorage without encryption
 
-## Distribuição
-- Code signing obrigatório (Windows: Authenticode, macOS: Apple Developer ID)
-- Notarização no macOS para distribuição fora da App Store
-- Auto-update com verificação de integridade antes de executar
+## Distribution
+- Code signing mandatory (Windows: Authenticode, macOS: Apple Developer ID)
+- Notarization on macOS for distribution outside the App Store
+- Auto-update with integrity verification before running
 
-## Checklist rápido (antes de empacotar)
-- [ ] `contextIsolation: true`, `nodeIntegration: false`, `sandbox: true` onde possível?
-- [ ] Nenhuma janela privilegiada carrega URL remota?
-- [ ] `will-navigate` e `setWindowOpenHandler` restringem navegação?
-- [ ] Todo handler de `ipcMain` valida os argumentos?
-- [ ] Tokens em `safeStorage`/keychain, nada sensível em localStorage?
-- [ ] Build assinado (e notarizado no macOS)? Auto-update valida assinatura?
-- [ ] Versão do Electron atual (sem CVE aberta)?
+## Quick checklist (before packaging)
+- [ ] `contextIsolation: true`, `nodeIntegration: false`, `sandbox: true` where possible?
+- [ ] No privileged window loads a remote URL?
+- [ ] `will-navigate` and `setWindowOpenHandler` restrict navigation?
+- [ ] Every `ipcMain` handler validates its arguments?
+- [ ] Tokens in `safeStorage`/keychain, nothing sensitive in localStorage?
+- [ ] Build signed (and notarized on macOS)? Does auto-update validate the signature?
+- [ ] Current Electron version (no open CVE)?