up-cc 0.1.0

package/workflows/planejar-fase.md

@@ -0,0 +1,208 @@
+<purpose>
+Criar prompts executaveis (PLAN.md) para uma fase do roteiro. Fluxo simplificado: um unico up-planejador faz pesquisa inline (se necessario), cria planos e auto-verifica. Sem loop planner-checker separado.
+
+Flags: --pesquisar (pesquisa profunda), --sem-pesquisa (pular), --auto (encadear executar+verificar), --gaps (replanejar a partir de lacunas).
+</purpose>
+
+<process>
+
+## 1. Inicializar
+
+```bash
+INIT=$(node "$HOME/.claude/up/bin/up-tools.cjs" init plan-phase "$PHASE")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse JSON: `commit_docs`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `has_research`, `has_context`, `has_plans`, `plan_count`, `planning_exists`, `roadmap_exists`, `phase_req_ids`.
+
+**Caminhos de arquivo:** `state_path`, `roadmap_path`, `requirements_path`, `context_path`, `research_path`, `verification_path`.
+
+**Se `planning_exists` = false:** Erro -- executar `/up:novo-projeto` primeiro.
+
+## 2. Parsear Argumentos
+
+Extrair do $ARGUMENTS: numero da fase, flags (`--pesquisar`, `--sem-pesquisa`, `--gaps`, `--auto`).
+
+**Se sem numero da fase:** Detectar proxima fase nao planejada do roteiro.
+
+**Se `phase_found` = false:** Validar fase existe no ROADMAP.md. Se valida, criar diretorio:
+```bash
+mkdir -p ".plano/fases/${padded_phase}-${phase_slug}"
+```
+
+## 3. Validar Fase
+
+```bash
+PHASE_INFO=$(node "$HOME/.claude/up/bin/up-tools.cjs" roadmap get-phase "${PHASE}")
+```
+
+**Se `found` = false:** Erro com fases disponiveis.
+**Se `found` = true:** Extrair `phase_number`, `phase_name`, `goal`.
+
+## 4. Carregar CONTEXT.md
+
+Verificar `context_path` do init JSON.
+
+Se `context_path` nao e null, exibir: `Usando contexto da fase: ${context_path}`
+
+**Se `context_path` e null (sem CONTEXT.md):**
+
+Use AskUserQuestion:
+- header: "Sem contexto"
+- question: "Sem CONTEXT.md para Fase {X}. Planos usarao pesquisa e requisitos apenas. Continuar ou capturar contexto primeiro?"
+- options:
+  - "Continuar sem contexto" -- Planejar usando pesquisa + requisitos apenas
+  - "Executar discutir-fase primeiro" -- Capturar decisoes de design antes de planejar
+
+Se "Continuar sem contexto": Prosseguir para passo 5.
+Se "Executar discutir-fase primeiro": Exibir `/up:discutir-fase {X}` e sair.
+
+## 5. Tratar Pesquisa
+
+**Pular se:** flag `--gaps`, flag `--sem-pesquisa`.
+
+**Se `has_research` = true (do init) E sem flag `--pesquisar`:** Usar existente, pular para passo 6.
+
+**Se RESEARCH.md faltando OU flag `--pesquisar`:**
+
+O up-planejador fara a pesquisa inline como parte do planejamento. Definir `RESEARCH_INLINE=true`.
+
+## 6. Verificar Planos Existentes
+
+```bash
+ls "${PHASE_DIR}"/*-PLAN.md 2>/dev/null
+```
+
+**Se existem:** Oferecer: 1) Adicionar mais planos, 2) Ver existentes, 3) Replanejar do zero.
+
+## 7. Spawn up-planejador
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > PLANEJANDO FASE {X}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Spawning planejador...
+```
+
+```
+Task(
+  prompt="
+<planning_context>
+**Fase:** {phase_number}
+**Modo:** {standard | gap_closure}
+**Pesquisa inline:** {RESEARCH_INLINE}
+
+<files_to_read>
+- {state_path} (Estado do Projeto)
+- {roadmap_path} (Roteiro)
+- {requirements_path} (Requisitos)
+- {context_path} (DECISOES DO USUARIO de /up:discutir-fase)
+- {research_path} (Pesquisa Tecnica - se existir)
+- {verification_path} (Lacunas de Verificacao - se --gaps)
+</files_to_read>
+
+**IDs de requisitos da fase (cada ID DEVE aparecer no campo `requirements` de um plano):** {phase_req_ids}
+
+**Instrucoes do projeto:** Ler ./CLAUDE.md se existir
+
+Se RESEARCH_INLINE=true:
+- Pesquisar o dominio antes de planejar
+- Usar Context7/docs oficiais para verificar versoes e APIs
+- Documentar achados de pesquisa no inicio de cada PLAN.md
+</planning_context>
+
+<self_check>
+Apos criar os planos, auto-verificar:
+- [ ] Cada requisito da fase mapeado a um plano
+- [ ] Frontmatter valido (wave, depends_on, files_modified, autonomous)
+- [ ] Tarefas sao especificas e acionaveis
+- [ ] Dependencias corretamente identificadas
+- [ ] Waves atribuidas para execucao paralela
+- [ ] must_haves derivados do objetivo da fase
+Se algo falhar na verificacao, corrija antes de retornar.
+</self_check>
+
+<output>
+Escrever PLAN.md em: {phase_dir}/
+Retornar: ## PLANNING COMPLETE com resumo dos planos
+</output>
+",
+  subagent_type="up-planejador",
+  description="Planejar Fase {phase}"
+)
+```
+
+## 8. Tratar Retorno do Planejador
+
+- **`## PLANNING COMPLETE`:** Exibir contagem de planos. Prosseguir para passo 9.
+- **`## CHECKPOINT REACHED`:** Apresentar ao usuario, obter resposta, spawn continuacao.
+- **`## PLANNING INCONCLUSIVE`:** Mostrar tentativas, oferecer: Adicionar contexto / Tentar novamente / Manual.
+
+## 9. Apresentar Status Final
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > FASE {X} PLANEJADA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Fase {X}: {Nome}** -- {N} plano(s) em {M} wave(s)
+
+| Wave | Planos | O que constroi |
+|------|--------|----------------|
+| 1    | 01, 02 | [objetivos] |
+| 2    | 03     | [objetivo]  |
+
+Pesquisa: {Completa | Usou existente | Pulada | Inline}
+
+───────────────────────────────────────────────────────────────
+
+## Proximo
+
+**Executar Fase {X}** -- rodar todos {N} planos
+
+/up:executar-fase {X}
+
+<sub>/clear primeiro -> janela de contexto limpa</sub>
+
+───────────────────────────────────────────────────────────────
+
+**Tambem disponivel:**
+- cat .plano/fases/{fase-dir}/*-PLAN.md -- revisar planos
+- /up:planejar-fase {X} --pesquisar -- re-pesquisar primeiro
+
+───────────────────────────────────────────────────────────────
+```
+
+## 10. Auto-Advance (se --auto)
+
+**Se flag `--auto` presente:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > AUTO-AVANCANDO PARA EXECUTAR
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Planos prontos. Lancando executar-fase...
+```
+
+Lancar executar-fase:
+```
+Skill(skill="up:executar-fase", args="${PHASE}")
+```
+
+</process>
+
+<success_criteria>
+- [ ] .plano/ diretorio validado
+- [ ] Fase validada contra roteiro
+- [ ] Diretorio da fase criado se necessario
+- [ ] CONTEXT.md carregado e passado ao planejador
+- [ ] Pesquisa tratada (inline, existente ou pulada)
+- [ ] Planos existentes verificados
+- [ ] up-planejador spawned com contexto completo
+- [ ] Planejador auto-verificou os planos
+- [ ] Planos criados (PLANNING COMPLETE ou CHECKPOINT tratado)
+- [ ] Usuario ve status entre spawns de agentes
+- [ ] Usuario sabe proximos passos
+</success_criteria>

package/workflows/progresso.md

@@ -0,0 +1,226 @@
+<purpose>
+Verificar progresso do projeto, resumir trabalho recente e o que vem a seguir, entao rotear inteligentemente para a proxima acao -- seja executar um plano existente ou criar o proximo.
+</purpose>
+
+<process>
+
+<step name="init_context">
+**Carregar contexto de progresso:**
+
+```bash
+INIT=$(node "$HOME/.claude/up/bin/up-tools.cjs" init progress)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Extrair do init JSON: `project_exists`, `roadmap_exists`, `state_exists`, `phases`, `current_phase`, `next_phase`, `completed_count`, `phase_count`, `paused_at`, `state_path`, `roadmap_path`, `project_path`, `config_path`.
+
+Se `project_exists` = false (sem diretorio `.plano/`):
+
+```
+Sem estrutura de planejamento encontrada.
+
+Execute /up:novo-projeto para iniciar um novo projeto.
+```
+
+Sair.
+
+Se STATE.md faltando: sugerir `/up:novo-projeto`.
+Se ROADMAP.md faltando mas PROJECT.md existe: sugerir `/up:novo-projeto`.
+</step>
+
+<step name="load">
+**Usar extracao estruturada:**
+
+```bash
+ROADMAP=$(node "$HOME/.claude/up/bin/up-tools.cjs" roadmap analyze)
+STATE=$(node "$HOME/.claude/up/bin/up-tools.cjs" state-snapshot)
+```
+</step>
+
+<step name="recent">
+**Reunir contexto de trabalho recente:**
+
+Encontrar os 2-3 SUMMARY.md mais recentes:
+```bash
+node "$HOME/.claude/up/bin/up-tools.cjs" summary-extract <caminho> --fields one_liner
+```
+</step>
+
+<step name="report">
+**Gerar barra de progresso e apresentar relatorio:**
+
+```bash
+PROGRESS_BAR=$(node "$HOME/.claude/up/bin/up-tools.cjs" progress bar --raw)
+```
+
+```
+# [Nome do Projeto]
+
+**Progresso:** {PROGRESS_BAR}
+
+## Trabalho Recente
+- [Fase X, Plano Y]: [o que foi realizado - 1 linha]
+- [Fase X, Plano Z]: [o que foi realizado - 1 linha]
+
+## Posicao Atual
+Fase [N] de [total]: [nome-da-fase]
+Plano [M] de [total-fase]: [status]
+CONTEXTO: [ok se has_context | - se nao]
+
+## Decisoes-Chave Tomadas
+- [extrair de $STATE.decisions[]]
+
+## Bloqueios/Preocupacoes
+- [extrair de $STATE.blockers[]]
+
+## Proximo
+[Proximo objetivo fase/plano do roadmap analyze]
+```
+</step>
+
+<step name="route">
+**Determinar proxima acao baseada em contagens verificadas.**
+
+**Passo 1: Contar planos e summaries na fase atual**
+
+```bash
+ls -1 .plano/fases/[dir-fase-atual]/*-PLAN.md 2>/dev/null | wc -l
+ls -1 .plano/fases/[dir-fase-atual]/*-SUMMARY.md 2>/dev/null | wc -l
+```
+
+**Passo 2: Rotear baseado em contagens**
+
+| Condicao | Significado | Acao |
+|----------|-------------|------|
+| summaries < plans | Planos nao executados existem | Ir para **Rota A** |
+| summaries = plans E plans > 0 | Fase completa | Ir para Passo 3 |
+| plans = 0 | Fase ainda nao planejada | Ir para **Rota B** |
+
+---
+
+**Rota A: Plano nao executado existe**
+
+Encontrar primeiro PLAN.md sem SUMMARY.md correspondente.
+
+```
+---
+
+## Proximo
+
+**{fase}-{plano}: [Nome do Plano]** -- [resumo do objetivo]
+
+`/up:executar-fase {fase}`
+
+<sub>`/clear` primeiro -> janela de contexto limpa</sub>
+
+---
+```
+
+---
+
+**Rota B: Fase precisa planejamento**
+
+Verificar se `{fase_num}-CONTEXT.md` existe no diretorio da fase.
+
+**Se CONTEXT.md existe:**
+
+```
+---
+
+## Proximo
+
+**Fase {N}: {Nome}** -- {Objetivo do ROADMAP.md}
+<sub>Contexto reunido, pronto para planejar</sub>
+
+`/up:planejar-fase {numero-fase}`
+
+<sub>`/clear` primeiro -> janela de contexto limpa</sub>
+
+---
+```
+
+**Se CONTEXT.md NAO existe:**
+
+```
+---
+
+## Proximo
+
+**Fase {N}: {Nome}** -- {Objetivo do ROADMAP.md}
+
+`/up:discutir-fase {fase}` -- reunir contexto e esclarecer abordagem
+
+<sub>`/clear` primeiro -> janela de contexto limpa</sub>
+
+---
+
+**Tambem disponivel:**
+- `/up:planejar-fase {fase}` -- pular discussao, planejar diretamente
+
+---
+```
+
+---
+
+**Passo 3: Verificar status do projeto (apenas quando fase completa)**
+
+| Condicao | Significado | Acao |
+|----------|-------------|------|
+| fase atual < maior fase | Mais fases restam | **Rota C** |
+| fase atual = maior fase | Projeto completo | **Rota D** |
+
+---
+
+**Rota C: Fase completa, mais fases restam**
+
+```
+---
+
+## Fase {Z} Completa
+
+## Proximo
+
+**Fase {Z+1}: {Nome}** -- {Objetivo do ROADMAP.md}
+
+`/up:discutir-fase {Z+1}` -- reunir contexto e esclarecer abordagem
+
+<sub>`/clear` primeiro -> janela de contexto limpa</sub>
+
+---
+
+**Tambem disponivel:**
+- `/up:planejar-fase {Z+1}` -- pular discussao, planejar diretamente
+- `/up:verificar-trabalho {Z}` -- teste de aceitacao antes de continuar
+
+---
+```
+
+---
+
+**Rota D: Projeto completo**
+
+```
+---
+
+## Projeto Completo!
+
+Todas {N} fases finalizadas!
+
+---
+
+**Tambem disponivel:**
+- `/up:verificar-trabalho` -- teste de aceitacao antes de encerrar
+
+---
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Contexto rico fornecido (trabalho recente, decisoes, problemas)
+- [ ] Posicao atual clara com progresso visual
+- [ ] Proximo passo claramente explicado
+- [ ] Roteamento inteligente: /up:executar-fase se planos existem, /up:planejar-fase se nao
+- [ ] Handoff seamless para comando up apropriado
+</success_criteria>

package/workflows/rapido.md

@@ -0,0 +1,209 @@
+<purpose>
+Executar tarefas pequenas e ad-hoc com garantias UP (commits atomicos, rastreamento STATE.md). Modo rapido spawna up-planejador (modo rapido) + up-executor(s), rastreia tarefas em `.plano/rapido/`, e atualiza tabela "Tarefas Rapidas Completadas" do STATE.md.
+</purpose>
+
+<process>
+**Passo 1: Parsear argumentos e obter descricao da tarefa**
+
+Parsear `$ARGUMENTS` para:
+- Texto restante -> usar como `$DESCRIPTION` se nao-vazio
+
+Se `$DESCRIPTION` esta vazio, promptar usuario interativamente:
+
+```
+AskUserQuestion(
+  header: "Tarefa Rapida",
+  question: "O que voce quer fazer?",
+  followUp: null
+)
+```
+
+Guardar resposta como `$DESCRIPTION`.
+
+Se ainda vazio, re-promptar: "Por favor forneca descricao da tarefa."
+
+Exibir banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > TAREFA RAPIDA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+**Passo 2: Inicializar**
+
+```bash
+INIT=$(node "$HOME/.claude/up/bin/up-tools.cjs" init quick "$DESCRIPTION")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse JSON: `commit_docs`, `next_num`, `slug`, `date`, `timestamp`, `quick_dir`, `task_dir`, `roadmap_exists`, `planning_exists`.
+
+**Se `roadmap_exists` = false:** Erro -- Modo rapido requer projeto ativo com ROADMAP.md. Execute `/up:novo-projeto` primeiro.
+
+---
+
+**Passo 3: Criar diretorio da tarefa**
+
+```bash
+QUICK_DIR=".plano/rapido/${next_num}-${slug}"
+mkdir -p "$QUICK_DIR"
+```
+
+Reportar:
+```
+Criando tarefa rapida ${next_num}: ${DESCRIPTION}
+Diretorio: ${QUICK_DIR}
+```
+
+---
+
+**Passo 4: Spawn planejador (modo rapido)**
+
+```
+Task(
+  prompt="
+<planning_context>
+
+**Modo:** quick
+**Diretorio:** ${QUICK_DIR}
+**Descricao:** ${DESCRIPTION}
+
+<files_to_read>
+- .plano/STATE.md (Estado do Projeto)
+- ./CLAUDE.md (se existir -- seguir diretrizes do projeto)
+</files_to_read>
+
+</planning_context>
+
+<constraints>
+- Criar UM UNICO plano com 1-3 tarefas focadas
+- Tarefas rapidas devem ser atomicas e autocontidas
+- Sem fase de pesquisa
+- Alvo ~30% uso de contexto (simples, focado)
+</constraints>
+
+<output>
+Escrever plano em: ${QUICK_DIR}/${next_num}-PLAN.md
+Retornar: ## PLANNING COMPLETE com caminho do plano
+</output>
+",
+  subagent_type="up-planejador",
+  description="Plano rapido: ${DESCRIPTION}"
+)
+```
+
+Apos planejador retornar:
+1. Verificar plano existe em `${QUICK_DIR}/${next_num}-PLAN.md`
+2. Reportar: "Plano criado: ${QUICK_DIR}/${next_num}-PLAN.md"
+
+---
+
+**Passo 5: Spawn executor**
+
+```
+Task(
+  prompt="
+Executar tarefa rapida ${next_num}.
+
+<files_to_read>
+- ${QUICK_DIR}/${next_num}-PLAN.md (Plano)
+- .plano/STATE.md (Estado do projeto)
+- ./CLAUDE.md (Instrucoes do projeto, se existir)
+</files_to_read>
+
+<constraints>
+- Executar todas tarefas do plano
+- Commitar cada tarefa atomicamente
+- Criar summary em: ${QUICK_DIR}/${next_num}-SUMMARY.md
+- NAO atualizar ROADMAP.md (tarefas rapidas sao separadas de fases planejadas)
+</constraints>
+",
+  subagent_type="up-executor",
+  description="Executar: ${DESCRIPTION}"
+)
+```
+
+Apos executor retornar:
+1. Verificar summary existe em `${QUICK_DIR}/${next_num}-SUMMARY.md`
+2. Se summary nao encontrado, erro: "Executor falhou ao criar ${next_num}-SUMMARY.md"
+
+---
+
+**Passo 6: Atualizar STATE.md**
+
+**6a. Verificar se secao "Tarefas Rapidas Completadas" existe:**
+
+Ler STATE.md e verificar secao `### Tarefas Rapidas Completadas`.
+
+**6b. Se secao nao existe, criar:**
+
+Inserir apos secao `### Bloqueios/Preocupacoes`:
+
+```markdown
+### Tarefas Rapidas Completadas
+
+| # | Descricao | Data | Commit | Diretorio |
+|---|-----------|------|--------|-----------|
+```
+
+**6c. Adicionar nova linha a tabela:**
+
+```markdown
+| ${next_num} | ${DESCRIPTION} | ${date} | ${commit_hash} | [${next_num}-${slug}](./rapido/${next_num}-${slug}/) |
+```
+
+**6d. Atualizar linha "Ultima atividade":**
+
+```
+Ultima atividade: ${date} - Completou tarefa rapida ${next_num}: ${DESCRIPTION}
+```
+
+Usar ferramenta Edit para fazer mudancas atomicamente.
+
+---
+
+**Passo 7: Commit final e conclusao**
+
+Stagear e commitar artefatos da tarefa rapida:
+
+```bash
+node "$HOME/.claude/up/bin/up-tools.cjs" commit "docs(rapido-${next_num}): ${DESCRIPTION}" --files ${QUICK_DIR}/${next_num}-PLAN.md ${QUICK_DIR}/${next_num}-SUMMARY.md .plano/STATE.md
+```
+
+Obter hash do commit final:
+```bash
+commit_hash=$(git rev-parse --short HEAD)
+```
+
+Exibir saida de conclusao:
+
+```
+---
+
+UP > TAREFA RAPIDA COMPLETA
+
+Tarefa Rapida ${next_num}: ${DESCRIPTION}
+
+Summary: ${QUICK_DIR}/${next_num}-SUMMARY.md
+Commit: ${commit_hash}
+
+---
+
+Pronto para proxima tarefa: /up:rapido
+```
+
+</process>
+
+<success_criteria>
+- [ ] Validacao ROADMAP.md passa
+- [ ] Usuario forneceu descricao da tarefa
+- [ ] Slug gerado (minusculo, hifens, max 40 chars)
+- [ ] Proximo numero calculado (001, 002, 003...)
+- [ ] Diretorio criado em `.plano/rapido/NNN-slug/`
+- [ ] `${next_num}-PLAN.md` criado pelo planejador
+- [ ] `${next_num}-SUMMARY.md` criado pelo executor
+- [ ] STATE.md atualizado com linha da tarefa rapida
+- [ ] Artefatos committed
+</success_criteria>