@onion-ai/cli 1.0.0-beta.1

package/framework/commands/product/extract-meeting.md

@@ -0,0 +1,226 @@
+---
+name: extract-meeting
+description: |
+  Extração estruturada de conhecimento de transcrições de reuniões usando Framework EXTRACT.
+  Use para transformar arquivos de contexto bruto em artefatos de alto valor para humanos, sistemas e IA.
+model: sonnet
+
+parameters:
+  - name: source
+    description: Caminho do arquivo ou pasta com transcrição(ões)
+    required: true
+  - name: level
+    description: Nível de output (compact, executive, complete, graph)
+    required: false
+  - name: focus
+    description: Foco específico (decisions, tasks, gaps, all)
+    required: false
+
+category: product
+tags:
+  - meeting
+  - extraction
+  - knowledge-base
+  - documentation
+
+version: "3.0.0"
+updated: "2025-12-01"
+
+related_commands:
+  - /product/task
+  - /docs/build-tech-docs
+  - /meta/create-knowledge-base
+
+related_agents:
+  - extract-meeting-specialist
+  - product-agent
+  - task-specialist
+
+knowledge_bases:
+  - docs/knowbase/concepts/meeting-transcription-to-knowledge-base.md
+---
+
+# 📋 Extrair Conhecimento de Reunião
+
+Transformação de transcrições brutas em conhecimento estruturado usando o Framework EXTRACT.
+
+## 🎯 Objetivo
+
+Processar transcrições de reuniões e gerar outputs estruturados consumíveis por humanos, sistemas e IA, seguindo as 7 dimensões do Framework EXTRACT.
+
+## ⚡ Fluxo de Execução
+
+### Passo 1: Validar Input
+
+```bash
+# Verificar se source existe
+test -e "{{source}}" || echo "❌ Arquivo/pasta não encontrado"
+
+# Identificar tipo (arquivo ou pasta)
+if [ -d "{{source}}" ]; then
+  echo "📁 Processando pasta com múltiplos arquivos"
+  FILES=$(find "{{source}}" -type f \( -name "*.txt" -o -name "*.md" \))
+else
+  echo "📄 Processando arquivo único"
+  FILES="{{source}}"
+fi
+```
+
+### Passo 2: Ler Conteúdo
+
+```bash
+# Ler transcrição(ões)
+read_file "{{source}}"
+```
+
+### Passo 3: Aplicar Framework EXTRACT
+
+Invocar `@extract-meeting-specialist` com instruções:
+
+```markdown
+## Tarefa
+Processar a transcrição abaixo aplicando o Framework EXTRACT completo.
+
+## Framework EXTRACT (7 Dimensões)
+- **E**ssência: Resumo executivo em 3 linhas
+- **X**pectativas: Objetivos da reunião e status (atingido/parcial/não)
+- **T**arefas: Ações definidas (quem, o quê, quando)
+- **R**esoluções: Decisões tomadas com justificativa
+- **A**mbiguidades: Gaps, contradições, pontos não resolvidos
+- **C**onexões: Dependências, stakeholders, documentos relacionados
+- **T**imeline: Datas e marcos mencionados
+
+## Nível de Output
+{{level}} (default: executive)
+
+## Foco
+{{focus}} (default: all)
+
+## Regras
+1. NUNCA inventar informações — usar [INFERIDO] ou [NÃO ESPECIFICADO]
+2. Indicar confidence level em decisões (high/medium/low)
+3. Capturar TODOS os gaps — o que NÃO foi decidido é crítico
+4. Tasks devem ter owner + deadline sempre que possível
+5. Preservar citações importantes entre aspas
+
+## Transcrição
+[CONTEÚDO DO ARQUIVO]
+```
+
+### Passo 4: Gerar Output
+
+**Nível `compact`:**
+```markdown
+## Reunião: [Título] | [Data]
+**Decisão**: [Principal decisão]
+**Ações**: [Nome] faz [quê] até [quando]
+**Pendente**: [Principal gap]
+```
+
+**Nível `executive`:**
+```markdown
+## [Título] - [Data]
+
+### Resumo
+[3-5 linhas]
+
+### Decisões
+- ✅ [Decisão 1]
+- ✅ [Decisão 2]
+
+### Ações
+| Responsável | Ação | Prazo |
+|-------------|------|-------|
+| [Nome] | [Descrição] | [Data] |
+
+### Pendências
+- ⚠️ [Gap 1]
+- ⚠️ [Gap 2]
+
+### Timeline
+- 📅 [Data]: [Marco]
+```
+
+**Nível `complete`:**
+Output YAML completo seguindo schema do knowledge base.
+
+**Nível `graph`:**
+JSON com entidades e relacionamentos para sistemas.
+
+### Passo 5: Salvar Resultado
+
+```bash
+# Determinar nome do output
+OUTPUT_NAME=$(basename "{{source}}" | sed 's/\.[^.]*$//')
+OUTPUT_FILE="docs/meetings/${OUTPUT_NAME}-extract.md"
+
+# Criar diretório se não existir
+mkdir -p docs/meetings/
+
+# Salvar
+write "${OUTPUT_FILE}"
+```
+
+## 📤 Output Esperado
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ EXTRAÇÃO CONCLUÍDA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📁 Arquivo: docs/meetings/[nome]-extract.md
+
+📊 Extração EXTRACT:
+∟ Essência: ✅
+∟ Expectativas: ✅
+∟ Tarefas: [N] itens
+∟ Resoluções: [N] decisões
+∟ Ambiguidades: [N] gaps
+∟ Conexões: [N] links
+∟ Timeline: [N] datas
+
+📈 Qualidade:
+∟ Confidence Score: [0.X]
+∟ Tasks com Owner: [X]%
+∟ Tasks com Deadline: [X]%
+∟ Gaps com Owner Sugerido: [X]%
+
+🚀 Próximos Passos:
+1. Revisar gaps críticos
+2. Validar decisões com participantes
+3. Criar tasks no gerenciador (@task-specialist)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## 🎯 Exemplos de Uso
+
+```bash
+# Extrair reunião específica (nível executivo default)
+/product/extract-meeting source=rhilo-reuniao-28-nov.txt
+
+# Nível completo com YAML
+/product/extract-meeting source=reuniao.txt level=complete
+
+# Foco apenas em decisões
+/product/extract-meeting source=reuniao.txt focus=decisions
+
+# Processar pasta de contexto
+/product/extract-meeting source=contextos/projeto-x/
+
+# Gerar grafo para sistemas
+/product/extract-meeting source=reuniao.txt level=graph
+```
+
+## 🔗 Referências
+
+- **Agente**: `@extract-meeting-specialist`
+- **Knowledge Base**: `docs/knowbase/concepts/meeting-transcription-to-knowledge-base.md`
+- **Framework**: EXTRACT (7 dimensões)
+
+## ⚠️ Notas
+
+- Processar em até 24h após reunião (contexto fresco)
+- Validar decisões críticas com participantes
+- Gaps são tão importantes quanto decisões
+- Para criar tasks automaticamente, usar `@task-specialist` após extração
+

package/framework/commands/product/feature.md

@@ -0,0 +1,416 @@
+---
+name: feature
+description: Criar task de feature no gerenciador configurado para planejamento e backlog.
+model: sonnet
+category: product
+tags: [feature, task-manager, backlog]
+version: "3.0.0"
+updated: "2025-11-24"
+
+related_commands:
+  - /product/estimate
+  - /product/task
+
+related_agents:
+  - story-points-framework-specialist
+  - product-agent
+---
+
+# 🎯 Criar Feature - Task para Planejamento
+
+Você é um assistente de IA especializado em **criar tasks de feature no gerenciador configurado (via Task Manager abstraction) para planejamento e backlog** seguindo o padrão do Sistema Onion. Seu papel é criar tasks de backlog para organização e priorização sem iniciar desenvolvimento.
+
+## 🎯 **Funcionalidades**
+
+### **📋 Criar Task Backlog:**
+- Criar task no gerenciador configurado com tag "backlog" 
+- Status: "Backlog" (aguardando planejamento e priorização)
+- Projeto/Lista: Mesmo projeto da sessão atual ou projeto padrão
+- Auto-detecção de contexto e projeto via Task Manager
+
+### **🔗 Integração Inteligente:**
+- Auto-detecção do projeto/lista atual via Task Manager
+- Herda contexto da sessão ativa (se houver)
+- Links com tasks relacionadas
+- Tags apropriadas para categorização
+- Suporta múltiplos provedores (ClickUp, Asana, Linear)
+
+---
+
+## 🚀 **Uso do Comando**
+
+### **Sintaxe:**
+```bash
+/product/feature "nome-ou-descrição-da-feature"
+```
+
+### **Examples:**
+```bash
+/product/feature "implementar-autenticacao-oauth"
+/product/feature "adicionar-filtros-avancados-dashboard"  
+/product/feature "integrar-payment-gateway-stripe"
+```
+
+---
+
+## ⚙️ **Workflow Automático**
+
+### **1. Validação de Parâmetros**
+```bash
+# Verificar se nome da feature foi fornecido
+if [ "$#" -eq 0 ]; then
+    echo "❌ ERROR: Feature name required"
+    echo "📖 USAGE: /product/feature \"feature-name-or-description\""
+    echo ""
+    echo "💡 EXAMPLES:"
+    echo "  /product/feature \"implement-oauth-authentication\""
+    echo "  /product/feature \"add-advanced-dashboard-filters\""
+    exit 1
+fi
+
+FEATURE_NAME="$1"
+# Sanitizar nome da feature (remover caracteres especiais)
+FEATURE_SLUG=$(echo "$FEATURE_NAME" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]' | sed 's/--*/-/g' | sed 's/^-\\|-$//g')
+
+echo "🎯 Creating feature planning task: $FEATURE_NAME"
+echo "📝 Feature slug: $FEATURE_SLUG"
+```
+
+### **2. Detecção de Contexto via Task Manager**
+
+**IMPORTANTE:** Use Task Manager abstraction para detectar contexto independente do provedor:
+
+```typescript
+// Via abstração - funciona para qualquer provedor (ClickUp, Asana, Linear)
+const taskManager = getTaskManager();
+
+// Detectar projeto/lista da sessão atual
+function getCurrentProjectId() {
+  // Tentar obter de sessão ativa
+  const sessionContext = readSessionContext();
+  if (sessionContext?.taskId) {
+    const currentTask = await taskManager.getTask(sessionContext.taskId);
+    if (currentTask?.projectId) {
+      return currentTask.projectId;
+    }
+  }
+  
+  // Fallback: usar projeto padrão configurado
+  return taskManager.defaultProjectId;
+}
+
+const projectId = getCurrentProjectId();
+console.log(`📋 Target project/list ID: ${projectId}`);
+```
+
+**Nota:** Se o comando ainda usar código bash direto, atualizar para usar Task Manager abstraction quando possível.
+
+### **3. Criação da Task via Task Manager**
+```bash
+# Preparar dados da task
+TASK_TITLE="🚀 $FEATURE_NAME"
+
+# Descrição da task com contexto
+TASK_DESCRIPTION="## 🎯 **Feature para Planejamento**
+
+**Tipo**: Feature Development  
+**Status**: Backlog - Aguardando planejamento e priorização  
+**Criada via**: /product/feature
+
+---
+
+## 📋 **Descrição**
+$FEATURE_NAME
+
+---
+
+## 🔄 **Workflow de Desenvolvimento**
+
+### **Para Iniciar Desenvolvimento:**
+\`\`\`bash
+# Após planejamento, iniciar desenvolvimento GitFlow:
+/git/feature/start \"$FEATURE_SLUG\"
+
+# Ou usar sessão de desenvolvimento:
+/engineer/start $FEATURE_SLUG
+\`\`\`
+
+### **Workflow Sequencial Recomendado:**
+1. **🎯 Planejamento**: Task criada (atual) + detalhamento
+2. **🌿 Desenvolvimento**: /git/feature/start $FEATURE_SLUG  
+3. **🛠️ Iteração**: /engineer/work
+4. **🔄 Finalização**: /git/sync
+5. **🚀 Deploy**: /engineer/pr
+
+---
+
+## 📊 **Critérios de Aceitação**
+- [ ] Requisitos funcionais detalhados
+- [ ] Mockups ou wireframes definidos
+- [ ] Critérios de aceitação específicos
+- [ ] Estimativas de esforço
+- [ ] Dependências identificadas
+- [ ] Prioridade definida no roadmap
+
+### **Para Desenvolvimento:**
+- [ ] Funcionalidade implementada conforme especificação
+- [ ] Testes unitários criados
+- [ ] Documentação atualizada
+- [ ] Code review aprovado
+- [ ] Deploy em ambiente de teste
+
+---
+
+## 🏷️ **Tags e Categorização**
+- **Type**: feature
+- **Status**: backlog  
+- **Priority**: medium (ajustar conforme roadmap)
+- **Phase**: planning
+
+**Criada automaticamente pelo Sistema Onion** 🧅"
+
+# Criar task via Task Manager abstraction
+console.log("🚀 Creating feature planning task via Task Manager...");
+
+const taskManager = getTaskManager();
+const task = await taskManager.createTask({
+  name: TASK_TITLE,
+  projectId: projectId,
+  markdownDescription: TASK_DESCRIPTION,
+  status: 'backlog',
+  priority: 'medium',
+  tags: ['feature', 'backlog', 'planning']
+});
+
+const TASK_ID = task.id;
+console.log(`✅ Task created: ${TASK_ID}`);
+```
+
+### **4. Estimar Story Points (Automático)**
+
+**CRÍTICO:** Após criar task, SEMPRE estimar story points automaticamente.
+
+```markdown
+@story-points-framework-specialist
+
+Por favor, analise e estime a seguinte feature de backlog:
+
+**Feature:** $FEATURE_NAME
+**Descrição:** [descrição da feature]
+**Status:** Backlog (planejamento inicial)
+
+Forneça estimativa inicial de story points para planejamento.
+```
+
+**Atualizar Task com Estimativa:**
+
+```bash
+# Obter estimativa via agente
+ESTIMATE_RESPONSE=$(invoke_agent_story_points "$FEATURE_NAME")
+
+# Extrair story points
+STORY_POINTS=$(echo "$ESTIMATE_RESPONSE" | extract_story_points)
+
+# Atualizar task com custom field Story Points
+if [ "$STORY_POINTS" != "" ]; then
+    echo "📊 Updating task with story points: $STORY_POINTS"
+    
+    // Atualizar custom field via Task Manager
+    await taskManager.updateTask(TASK_ID, {
+      customFields: {
+        'Story Points': STORY_POINTS
+      }
+    });
+    
+    // Adicionar comentário com análise via Task Manager
+    const ESTIMATE_ANALYSIS = extractAnalysis(ESTIMATE_RESPONSE);
+    
+    await taskManager.addComment(TASK_ID, 
+      '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+      '📊 ESTIMATIVA INICIAL DE STORY POINTS\n' +
+      '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n' +
+      `🎲 Story Points: ${STORY_POINTS} pontos\n\n` +
+      `⚡ ANÁLISE:\n${ESTIMATE_ANALYSIS}\n\n` +
+      '💡 NOTA: Esta é uma estimativa inicial para planejamento. Pode ser refinada durante o refinement.\n' +
+      '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'
+    );
+fi
+```
+
+### **5. Resultado e Links**
+```bash
+if [ "$TASK_ID" != "" ] && [ "$TASK_ID" != "null" ]; then
+    TASK_URL = task.url; // Via Task Manager abstraction
+    
+    echo ""
+    echo "✅ FEATURE PLANNING TASK CREATED SUCCESSFULLY!"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "📋 TASK DETAILS:"
+    echo "   ▶ Title: $TASK_TITLE"
+    echo "   ▶ ID: $TASK_ID"
+    echo "   ▶ Status: Backlog"
+    echo "   ▶ URL: $TASK_URL"
+    echo ""
+    echo "🏷️  TAGS: feature, backlog, planning"
+    echo "📝 DESCRIPTION: Auto-generated with development workflow"
+    echo ""
+    if [ "$STORY_POINTS" != "" ]; then
+        echo "🎲 STORY POINTS: $STORY_POINTS pontos (estimativa inicial)"
+        echo ""
+    fi
+    echo ""
+    echo "🎯 NEXT STEPS:"
+    echo "   ∟ Add details: Open $TASK_URL"
+    echo "   ∟ Set priority: Adjust based on roadmap"  
+    echo "   ∟ Start development: /git/feature/start \"$FEATURE_SLUG\""
+    echo ""
+    echo "💡 WORKFLOW SEQUENCIAL:"
+    echo "   1. 🎯 Planning (current) → 2. 🌿 GitFlow Start → 3. 🛠️ Development → 4. ✅ Done"
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo ""
+    echo "🌟 Feature '$FEATURE_NAME' ready for planning!"
+    
+    # Adicionar comentário inicial na task
+    INITIAL_COMMENT="🎯 FEATURE BACKLOG PARA PLANEJAMENTO
+
+━━━━━━━━━━━━━━━━━━━━━━━━
+
+✅ TASK SETUP:
+   ▶ Feature: $FEATURE_NAME
+   ▶ Slug: $FEATURE_SLUG
+   ▶ Status: Backlog (Planning)
+   ▶ Criada via: /product/feature
+
+🎯 PLANEJAMENTO:
+   ▶ Detalhar requisitos funcionais
+   ▶ Definir critérios de aceitação
+   ▶ Estimar esforço e cronograma
+   ▶ Priorizar no roadmap
+
+🚀 PARA DESENVOLVIMENTO:
+   ▶ Após planejamento: /git/feature/start \"$FEATURE_SLUG\"
+   ▶ Para sessão: /engineer/start $FEATURE_SLUG
+
+📋 WORKFLOW:
+   ∟ Planning → GitFlow Start → Development → Done
+
+━━━━━━━━━━━━━━━━━━━━━━━━
+
+⏰ Criada: $(date +'%Y-%m-%d %H:%M:%S') | 🧅 Sistema Onion"
+
+    # Adicionar comentário via Task Manager (graceful degradation)
+    // Via Task Manager abstraction
+    await taskManager.addComment(TASK_ID, INITIAL_COMMENT).catch(() => {
+      console.warn("⚠️  Comment creation failed - task created successfully anyway");
+    });
+        
+else
+    console.error("❌ FAILED TO CREATE TASK");
+    console.error("");
+    console.error("💡 POSSIBLE CAUSES:");
+    console.error("   ∟ Task Manager provider not configured");
+    console.error("   ∟ Invalid project/list ID or permissions");  
+    console.error("   ∟ Network connectivity issues");
+    console.error("");
+    console.error("🔧 TROUBLESHOOTING:");
+    console.error("   ∟ Check TASK_MANAGER_PROVIDER environment variable");
+    console.error("   ∟ Verify project/list permissions and ID");
+    console.error("   ∟ Execute /meta/setup-integration to configure");
+    console.error("   ∟ Try manual task creation as fallback");
+    echo ""
+    echo "📖 MANUAL FALLBACK:"
+    echo "   ∟ Create task manually: '$TASK_TITLE'"
+    echo "   ∟ Add tags: feature, backlog, planning"
+    echo "   ∟ Set status: Backlog"
+    exit 1
+fi
+```
+
+---
+
+## 🔗 **Integração com Sistema Onion**
+
+### **Separação Clara de Responsabilidades:**
+- **`/product/feature`**: Cria task backlog para **planejamento**
+- **`/git/feature/start`**: Inicia desenvolvimento **GitFlow** (branch + session)
+- **`/git/sync`**: Finaliza desenvolvimento (pós-merge + cleanup)
+
+### **Workflow Sequencial Integrado:**
+```bash
+1. /product/feature "nova-funcionalidade"      # ← PLANEJAMENTO
+   # ... tempo de planejamento, detalhamento, priorização ...
+   
+2. /git/feature/start "nova-funcionalidade"   # ← DESENVOLVIMENTO GitFlow
+   # ... desenvolvimento usando sessões ...
+   
+3. /git/sync                                  # ← FINALIZAÇÃO
+```
+
+### **Quando Usar:**
+- ✅ **Criar features para backlog** e roadmap planning
+- ✅ **Organizar product backlog** e priorização  
+- ✅ **Capturar ideias** de features rapidamente
+- ✅ **Setup inicial** de projetos com múltiplas features
+
+### **Quando NÃO usar:**
+- ❌ Desenvolvimento imediato (use `/git/feature/start`)
+- ❌ Hotfixes urgentes (use `/engineer/hotfix`)  
+- ❌ Tasks já existem (use `/engineer/start <feature-slug>`)
+
+---
+
+## ⚠️ **Tratamento de Erros**
+
+### **Erro: Nome da feature não fornecido**
+```
+❌ ERROR: Feature name required
+📖 USAGE: /product/feature "feature-name-or-description"
+```
+
+### **Erro: Task Manager falhou**
+```
+❌ FAILED TO CREATE TASK
+🔧 Check TASK_MANAGER_PROVIDER configuration and permissions
+📖 Create task manually as fallback
+```
+
+### **Erro: Lista não encontrada**
+```
+❌ ERROR: Unable to detect project/list via Task Manager
+💡 Run from active session or configure default list
+```
+
+---
+
+## 💡 **Dicas de Uso**
+
+### **✅ Boas Práticas:**
+```bash
+# Nomes descritivos e específicos
+/product/feature "implement-oauth2-authentication-flow"
+
+# Features modulares e focadas  
+/product/feature "add-user-profile-avatar-upload"
+
+# Include context quando útil
+/product/feature "integrate-stripe-payment-gateway-checkout"
+```
+
+### **❌ Evitar:**
+```bash
+# Muito genérico
+/product/feature "melhorias"
+
+# Muito técnico/interno
+/product/feature "refactor-class-x"
+
+# Tasks que não são features
+/product/feature "fix-bug-payment"  # Use /engineer/hotfix
+```
+
+---
+
+**🎯 Criação rápida de features para backlog e planejamento! Para iniciar desenvolvimento GitFlow, use `/git/feature/start [feature-name]`.**