@ruyfranca/myskills 1.0.24 → 1.0.26

package/.agent/skills/doc-coauthoring/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: doc-coauthoring
+description: Structured workflow for collaborative document creation. Use when writing documentation, proposals, technical specs, decision docs, PRDs, design docs, RFCs, or any substantial writing task. Guides through Context Gathering, Refinement and Structure, and Reader Testing stages.
+tags: [documentation, writing, co-authoring, prd, rfc, spec, proposal, design-doc]
+triggers: [write a doc, draft a proposal, create a spec, write up, PRD, design doc, decision doc, RFC, documentation, technical spec, co-author]
+risk: safe
+source: sickn33/antigravity-awesome-skills
+date_added: "2026-03-15"
+---
+
+# Doc Co-Authoring Workflow
+
+Workflow estruturado para co-criação colaborativa de documentos. Atua como guia ativo, conduzindo o usuário por 3 etapas: **Coleta de Contexto**, **Refinamento & Estrutura** e **Teste com Leitor**.
+
+---
+
+## Quando Ativar
+
+**Gatilhos:**
+- Usuário menciona escrever documentação: "escreve uma doc", "cria um PRD", "preciso de uma spec"
+- Tipos específicos: **PRD, design doc, decision doc, RFC, proposta técnica**
+- Qualquer tarefa de escrita substancial
+
+**Oferta inicial:**
+Ofereça o workflow estruturado. Explique as 3 etapas:
+1. **Coleta de Contexto**: usuário fornece todo o contexto enquanto você faz perguntas
+2. **Refinamento & Estrutura**: construir cada seção iterativamente via brainstorming e edição
+3. **Teste com Leitor**: testar o doc com um Claude "sem contexto" para encontrar pontos cegos
+
+Se o usuário recusar, trabalhe de forma livre. Se aceitar, inicie o **Estágio 1**.
+
+---
+
+## Estágio 1: Coleta de Contexto
+
+**Objetivo:** Fechar a lacuna entre o que o usuário sabe e o que você sabe.
+
+### Coleta Ativa
+Peça ao usuário que despeje tudo o que sabe sobre o tópico. Enquanto ele fala:
+- Faça perguntas de acompanhamento sobre pontos que precisam de esclarecimento
+- Identifique lacunas ou suposições
+- Continue até ter contexto suficiente para guiar de forma inteligente
+
+### Questões Típicas de Contexto
+- **Propósito**: O que este documento alcança?
+- **Audiência**: Quem vai ler? O que eles já sabem?
+- **Escopo**: O que está dentro/fora do escopo?
+- **Restrições**: Prazo, comprimento, formato, aprovadores?
+- **Sucesso**: Como saber se o doc fez seu trabalho?
+
+---
+
+## Estágio 2: Refinamento & Estrutura
+
+Trabalhe **uma seção por vez**:
+
+### Passo 1: Perguntas Clarificadoras
+Anuncie que vai trabalhar na seção [NOME DA SEÇÃO]. Faça 5-10 perguntas específicas sobre o que deve ser incluído.
+
+### Passo 2: Brainstorming
+Para a seção, faça brainstorming de 5-20 itens que poderiam ser incluídos. Numere cada um. Ofereça mais se o usuário quiser.
+
+### Passo 3: Curação
+Pergunte quais pontos manter, remover ou combinar:
+- "Manter 1, 4, 7, 9"
+- "Remover 3 (duplica o 1)"
+- "Combinar 11 e 12"
+
+Se o usuário der feedback livre ("ficou bom" ou "gostei de maioria, mas..."), extraia suas preferências e prossiga.
+
+### Passo 4: Verificação de Lacunas
+Baseado no que selecionou, pergunte se está faltando algo importante.
+
+### Passo 5: Rascunho
+Escreva o conteúdo da seção. Use `str_replace` para substituir o texto placeholder.
+
+**Instrução para o usuário (inclua ao rascunhar a PRIMEIRA seção):**
+*"Em vez de editar o doc diretamente, me diga o que mudar. Isso me ajuda a aprender seu estilo para as próximas seções. Por exemplo: 'Remove o bullet X - já coberto por Y' ou 'Deixa o terceiro parágrafo mais conciso'."*
+
+### Passo 6: Refinamento Iterativo
+Conforme o usuário dá feedback:
+- Use `str_replace` para edits (nunca reimprima o doc inteiro)
+- Continue até o usuário estar satisfeito com a seção
+- Após 3+ iterações sem mudanças substanciais, pergunte se algo pode ser removido sem perder informação
+
+**Repita para todas as seções.**
+
+### Perto da Conclusão
+Quando 80%+ das seções estiverem prontas:
+1. Releia o documento inteiro e verifique: fluxo/consistência, redundância, "slop" genérico, frases sem peso
+2. Forneça feedback final
+3. Pergunte se está pronto para o Teste com Leitor
+
+---
+
+## Estágio 3: Teste com Leitor
+
+**Objetivo:** Pegar pontos cegos antes que outras pessoas leiam.
+
+### Abordagem de Teste
+Analise o documento como se fosse um leitor **sem nenhum contexto da conversa**:
+
+**Passo 1: Prever Perguntas do Leitor**
+Liste 3-5 perguntas que um leitor novo faria ao ler o doc.
+
+**Passo 2: Verificações Adicionais**
+- O propósito/audiência fica claro nos primeiros parágrafos?
+- Existem termos ou siglas não definidas?
+- Alguma seção pressupõe conhecimento que o leitor não teria?
+- O fluxo faz sentido sem saber da conversa que levou a isso?
+
+**Passo 3: Relatório e Correção**
+Para cada problema encontrado:
+- Descreva o problema
+- Sugira como corrigir
+- Ofereça fazer a correção
+
+---
+
+## Revisão Final
+
+- [ ] Propósito claro nos primeiros parágrafos?
+- [ ] Audiência definida?
+- [ ] Escopo explícito?
+- [ ] Sem termos não definidos?
+- [ ] Fluxo coerente entre seções?
+- [ ] Cada frase carrega peso?
+
+## Related Skills
+- `writing-plans` — para planos de implementação técnica
+- `documentation-templates` — templates e estrutura de documentação
+- `brainstorming` — exploração criativa de ideias antes de escrever

package/.agent/skills/skill-developer/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: skill-developer
+description: Guide for creating and managing skills in Antigravity/Claude Code. Use when creating new skills, understanding YAML frontmatter format, writing SKILL.md files, setting up trigger patterns, following the 500-line rule, or debugging skill activation issues.
+tags: [skill-development, antigravity, claude-code, yaml, frontmatter, triggers, skill-creation]
+triggers: [create a skill, new skill, skill template, skill frontmatter, SKILL.md, skill trigger, skill activation, 500-line rule, add skill to project]
+risk: safe
+source: sickn33/antigravity-awesome-skills
+date_added: "2026-03-15"
+---
+
+# Skill Developer Guide
+
+Guia completo para criar e gerenciar skills no Antigravity/Claude Code, seguindo as melhores práticas da Anthropic incluindo a regra das 500 linhas e o padrão de divulgação progressiva.
+
+---
+
+## Estrutura de uma Skill
+
+```
+.agent/skills/
+└── minha-skill/
+    ├── SKILL.md          ← arquivo principal (obrigatório, < 500 linhas)
+    └── references/       ← detalhes opcionais referenciados pelo SKILL.md
+        └── guia-avancado.md
+```
+
+---
+
+## Template de SKILL.md
+
+```markdown
+---
+name: minha-skill
+description: Descrição breve incluindo palavras-chave que disparam esta skill.
+  Mencione tópicos, tipos de arquivo e casos de uso. Seja explícito sobre termos gatilho.
+tags: [tag1, tag2, tag3]
+triggers: [frase gatilho 1, frase gatilho 2, keyword]
+risk: safe
+source: community
+date_added: "2025-01-15"
+---
+
+# Nome da Skill
+
+## Propósito
+Para que esta skill serve.
+
+## Quando Usar
+Cenários específicos e condições.
+
+## Informação Principal
+A orientação real, documentação, padrões, exemplos.
+```
+
+---
+
+## Regras de Ouro (Anthropic Best Practices)
+
+| Regra | Detalhe |
+|-------|---------|
+| **< 500 linhas** | SKILL.md deve ter menos de 500 linhas — use arquivos de referência para detalhes |
+| **Descrição com keywords** | Inclua TODOS os termos que disparam esta skill (max 1024 chars) |
+| **Títulos claros** | Nomes em minúsculo com hífens, forma gerundiva preferida (verb + -ing) |
+| **Exemplos reais** | Inclua exemplos de código reais, não genéricos |
+| **Divulgação progressiva** | SKILL.md = visão geral; `references/` = profundidade |
+
+---
+
+## Campos do Frontmatter
+
+```yaml
+---
+name: nome-da-skill           # obrigatório: identificador único
+description: "texto..."       # obrigatório: inclui triggers e contexto
+tags: [tag1, tag2]            # recomendado: para indexação e busca
+triggers: [frase, keyword]    # recomendado: termos que ativam a skill
+risk: safe                    # safe | caution | dangerous
+source: community             # origem da skill
+date_added: "2025-01-15"      # data de adição
+---
+```
+
+---
+
+## Como Criar uma Skill — Passo a Passo
+
+### 1. Crie o arquivo
+```bash
+mkdir -p .agent/skills/minha-skill
+touch .agent/skills/minha-skill/SKILL.md
+```
+
+### 2. Escreva o conteúdo
+Siga o template acima. Foque em:
+- **Propósito**: o que esta skill FAZ?
+- **Quando usar**: condições específicas, não genéricas
+- **Exemplos**: código real, comandos reais
+
+### 3. Teste os gatilhos
+Confirme que os `triggers` no frontmatter cobrem as frases que o usuário usaria naturalmente.
+
+Exemplos de bons triggers:
+```yaml
+triggers: [create new component, add react component, novo componente react]
+```
+
+### 4. Adicione ao GEMINI.md ou arquivos de configuração
+Para que o Antigravity indexe a skill, ela precisa estar no diretório `.agent/skills/` do projeto.
+
+### 5. Iterate
+- Teste com 3+ cenários reais antes de considerar pronto
+- Refine os triggers baseado no uso real
+- Adicione sections `references/` se ultrapassar 500 linhas
+
+---
+
+## Checklist de Qualidade
+
+```
+[ ] SKILL.md tem menos de 500 linhas?
+[ ] Frontmatter tem `name` e `description`?
+[ ] Description inclui palavras-chave que ativariam esta skill?
+[ ] Triggers são naturais e cobrem variações de linguagem?
+[ ] Há pelo menos um exemplo real no conteúdo?
+[ ] A skill tem um propósito claro e delimitado?
+[ ] Se > 300 linhas, há `references/` para detalhes?
+```
+
+---
+
+## Divulgação Progressiva
+
+Para skills complexas, divida o conteúdo:
+
+```
+SKILL.md (visão geral, < 500 linhas)
+├── Propósito e quando usar
+├── Conceitos chave com exemplos breves
+└── Links para: [guia-avancado.md](./references/guia-avancado.md)
+
+references/guia-avancado.md (detalhe técnico)
+├── Tópico 1 aprofundado
+├── Tópico 2 aprofundado
+└── Edge cases e troubleshooting
+```
+
+## Related Skills
+- `intelligent-routing` — como o Antigravity faz o roteamento automático de skills
+- `clean-code` — boas práticas aplicadas à própria escrita de skills
+- `brainstorming` — exploração antes de criar uma skill nova

package/.agent/skills/uncle-bob-craft/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: uncle-bob-craft
+description: Applies Uncle Bob's body of work for code review and writing. Use when reviewing code, refactoring, discussing architecture, evaluating SOLID principles, identifying code smells, or discussing Clean Architecture, Clean Code, The Clean Coder principles.
+tags: [clean-code, clean-architecture, solid, code-review, craftsmanship, refactoring, code-smells]
+triggers: [code review, clean code, SOLID, refactor, architecture review, code smell, dependency rule, uncle bob, clean architecture, single responsibility, open closed, liskov, interface segregation, dependency inversion]
+risk: safe
+source: sickn33/antigravity-awesome-skills
+date_added: "2026-03-15"
+---
+
+# Uncle Bob Craft
+
+Agrega os princípios dos livros do Uncle Bob para **revisão** e **escrita** de código: nomenclatura e funções (Clean Code), arquitetura e fronteiras (Clean Architecture), profissionalismo e estimativa (The Clean Coder), valores ágeis (Clean Agile), e uso vs abuso de design patterns.
+
+> **Não substitui** o linter, formatter ou testes automatizados do projeto — esses permanecem responsabilidade das ferramentas do projeto.
+
+---
+
+## Quando Usar
+
+- **Code review**: Aplique Dependency Rule, fronteiras, SOLID, e heurísticas de smell; sugira refactors concretos
+- **Refactoring**: Decida o que extrair, onde desenhar fronteiras, e se um design pattern é justificado
+- **Discussão de arquitetura**: Verifique camadas, direção de dependências, e separação de interesses
+- **Design patterns**: Avalie uso correto vs cargo-cult ou overuse antes de introduzir um pattern
+- **Estimativa e profissionalismo**: Aplique ideias do Clean Coder (dizer não, ritmo sustentável, estimativas de 3 pontos)
+
+---
+
+## Fontes por Livro
+
+| Fonte | Foco |
+|-------|------|
+| **Clean Code** | Nomes, funções, comentários, formatação, testes, classes, smells |
+| **Clean Architecture** | Dependency Rule, camadas, fronteiras, SOLID na arquitetura |
+| **The Clean Coder** | Profissionalismo, estimativa, dizer não, ritmo sustentável |
+| **Clean Agile** | Valores, Iron Cross, TDD, refactoring, pair programming |
+| **Design Patterns** | Quando usar, abuso, cargo cult |
+
+---
+
+## Dependency Rule (Clean Architecture)
+
+```
+Externas → Frameworks/Drivers
+           → Interface Adapters
+             → Application Business Rules
+               → Enterprise Business Rules (Entities)
+```
+
+- Dependências apontam **para dentro** (em direção às Entities)
+- Camadas internas **não conhecem** camadas externas
+- **Violação**: quando uma Entity importa algo de um Controller
+
+---
+
+## SOLID em Contexto
+
+| Princípio | Verificação Rápida |
+|-----------|-------------------|
+| **SRP** | Esta classe/função tem mais de um motivo para mudar? |
+| **OCP** | Posso adicionar comportamento sem modificar código existente? |
+| **LSP** | Posso substituir por uma subclasse sem quebrar o sistema? |
+| **ISP** | A interface tem métodos que os clientes não usam? |
+| **DIP** | Módulos de alto nível dependem de abstrações, não de implementações? |
+
+---
+
+## Design Patterns: Uso vs Abuso
+
+- **Use patterns** quando resolvem um problema de design real (variação de comportamento, ciclo de vida, cross-cutting)
+- **Evite cargo-cult**: não adicione Factory/Strategy/Repository só porque o codebase "deveria" tê-los
+- **Sinais de abuso**: nome do pattern em toda classe, camadas que só delegam sem lógica, patterns que tornam código simples mais difícil
+- **Regra de ouro**: introduza um pattern na terceira duplicação ou segunda razão para mudar
+
+---
+
+## Code Smells e Heurísticas
+
+| Smell | Significado |
+|-------|-------------|
+| **Rigidity** | Pequena mudança força muitas edições |
+| **Fragility** | Mudanças quebram áreas não relacionadas |
+| **Immobility** | Difícil de reusar em outro contexto |
+| **Viscosity** | Fácil de hackear, difícil de fazer a coisa certa |
+| **Needless Complexity** | Abstração especulativa ou não usada |
+| **Needless Repetition** | DRY violado; mesma ideia em múltiplos lugares |
+| **Opacity** | Código difícil de entender |
+
+---
+
+## Aplicação por Contexto
+
+| Contexto | Aplicar |
+|----------|---------|
+| **Code review** | Dependency Rule e fronteiras; SOLID em contexto; listar smells; sugerir 1-2 refactors concretos (ex: extrair função, inverter dependência); verificar testes |
+| **Escrevendo código** | Prefira funções pequenas e responsabilidade única; dependa para dentro (Clean Architecture); escreva testes primeiro quando fazendo TDD; evite patterns até duplicação ou variação justificar |
+| **Refactoring** | Identifique um smell por vez; refatore em pequenos passos com testes verdes; melhore nomes e estrutura antes de adicionar comportamento |
+
+---
+
+## Ao Fazer Code Review
+
+```
+1. Dependency Rule está sendo respeitada?
+2. SOLID violations óbvias?
+3. Code smells presentes?
+4. Nomes comunicam intenção?
+5. Funções fazem uma coisa?
+6. Testes presentes e significativos?
+7. Design patterns justificados (ou desnecessários)?
+```
+
+**Formato de sugestão:**
+```
+Smell: [nome]
+Local: [arquivo/função]
+Refactor: [sugestão concreta]
+Justificativa: [qual princípio ou heurística]
+```
+
+## Related Skills
+- `clean-code` — regras práticas de código limpo
+- `code-reviewer` — processo de code review
+- `software-architecture` — padrões de arquitetura limpa e DDD

package/index.js

@@ -175,19 +175,21 @@ program
   .option('-w, --workflows', 'Atualiza apenas os workflows')
   .action(async (options) => {
     const updateAll = !options.skills && !options.agents && !options.workflows;
+    const destRoot = process.cwd();
+    const srcRoot = __dirname;
 
     console.log(chalk.cyan('\n🔄 Atualizando kit do Antigravity...\n'));
 
     const tasks = [];
 
     if (updateAll || options.skills) {
-      tasks.push({ label: 'skills', src: path.join(__dirname, '.agent', 'skills'), dest: path.join(process.cwd(), '.agent', 'skills') });
+      tasks.push({ label: 'skills', src: path.join(srcRoot, '.agent', 'skills'), dest: path.join(destRoot, '.agent', 'skills') });
     }
     if (updateAll || options.agents) {
-      tasks.push({ label: 'agents', src: path.join(__dirname, '.agent', 'agents'), dest: path.join(process.cwd(), '.agent', 'agents') });
+      tasks.push({ label: 'agents', src: path.join(srcRoot, '.agent', 'agents'), dest: path.join(destRoot, '.agent', 'agents') });
     }
     if (updateAll || options.workflows) {
-      tasks.push({ label: 'workflows', src: path.join(__dirname, '.agent', 'workflows'), dest: path.join(process.cwd(), '.agent', 'workflows') });
+      tasks.push({ label: 'workflows', src: path.join(srcRoot, '.agent', 'workflows'), dest: path.join(destRoot, '.agent', 'workflows') });
     }
 
     for (const task of tasks) {
@@ -198,9 +200,60 @@ program
       try {
         await fs.ensureDir(task.dest);
         await fs.copy(task.src, task.dest, { overwrite: true });
-        console.log(chalk.green(`  ✅ ${task.label}: atualizado com sucesso`));
+        console.log(chalk.green(`  ✅ ${task.label}: copiado`));
       } catch (err) {
-        console.error(chalk.red(`  ❌ ${task.label}: erro — ${err.message}`));
+        console.error(chalk.red(`  ❌ ${task.label}: erro na cópia — ${err.message}`));
+        continue;
+      }
+    }
+
+    // Rewrite hardcoded paths (file:///...mySkills...) to point to the dest project
+    if (destRoot !== srcRoot) {
+      console.log(chalk.cyan('\n🔧 Corrigindo paths nos arquivos copiados...\n'));
+
+      const srcPathEncoded = `file://${srcRoot}`;
+      const destPathEncoded = `file://${destRoot}`;
+
+      const dirsToFix = [
+        path.join(destRoot, '.agent', 'workflows'),
+        path.join(destRoot, '.agent', 'agents'),
+        path.join(destRoot, '.agent', 'rules'),
+        path.join(destRoot, '.agent', 'skills'),
+      ];
+
+      let fixedFiles = 0;
+
+      for (const dir of dirsToFix) {
+        if (!await fs.pathExists(dir)) continue;
+
+        const walk = async (currentDir) => {
+          const entries = await fs.readdir(currentDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+              await walk(fullPath);
+            } else if (['.md', '.txt', '.json'].includes(path.extname(entry.name))) {
+              try {
+                const content = await fs.readFile(fullPath, 'utf8');
+                if (content.includes(srcPathEncoded)) {
+                  const fixed = content.replaceAll(srcPathEncoded, destPathEncoded);
+                  await fs.writeFile(fullPath, fixed, 'utf8');
+                  fixedFiles++;
+                }
+              } catch {
+                // ignorar arquivos binários ou inacessíveis
+              }
+            }
+          }
+        };
+
+        await walk(dir);
+      }
+
+      if (fixedFiles > 0) {
+        console.log(chalk.green(`  ✅ paths: ${fixedFiles} arquivo(s) corrigido(s)`));
+      } else {
+        console.log(chalk.gray('  ℹ️  paths: nenhuma substituição necessária'));
       }
     }
 
@@ -208,5 +261,6 @@ program
     console.log(chalk.gray('💡 Dica: reinicie o Antigravity para carregar as novas skills/workflows.\n'));
   });
 
+
 program.parse();
 

package/package.json

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