up-cc 0.3.0 → 0.3.2

package/README.md

@@ -63,40 +63,56 @@ Apos instalar, reinicie o Claude Code e digite `/up:ajuda` para ver todos os com
 
 ### 1. Inicializando um projeto
 
-O UP funciona tanto para projetos novos (greenfield) quanto para codebases existentes (brownfield). A deteccao e automatica.
+O UP tem duas formas de comecar, dependendo do que voce precisa.
 
-#### Projeto novo (do zero)
+#### Adocao leve — `/up:iniciar` (recomendado para projetos existentes)
+
+```
+/up:iniciar
+```
+
+O UP vai:
+1. Detectar automaticamente a stack, estrutura e features do seu projeto
+2. Criar `PROJECT.md` documentando o que existe — **sem fazer perguntas**
+3. Criar `config.json` com valores padrao
+4. Parar
+
+Sem questionario, sem requisitos, sem roadmap. Voce vai construindo incrementalmente conforme precisa:
+
+```
+/up:iniciar                    # Registra projeto, cria PROJECT.md
+/up:mapear-codigo              # Analise profunda do codebase (opcional)
+/up:melhorias                  # Descobre o que melhorar
+/up:planejar-fase 1            # Quando tiver algo para implementar
+```
+
+Ideal quando voce quer adotar o UP num projeto existente sem definir tudo de cara.
+
+#### Pipeline completo — `/up:novo-projeto`
 
 ```
 /up:novo-projeto
 ```
 
 O UP vai:
-1. Perguntar "O que voce quer construir?"
+1. Perguntar "O que voce quer construir?" (greenfield) ou "O que voce quer fazer com esse codigo?" (brownfield)
 2. Fazer perguntas de acompanhamento para entender o projeto
 3. Opcionalmente pesquisar o ecossistema do dominio (stack, features, armadilhas)
 4. Definir requisitos interativamente, agrupados por categoria
 5. Gerar ROADMAP.md com fases, criterios de sucesso e rastreabilidade
 6. Criar PROJECT.md, STATE.md e config.json
 
-Ao final voce tera um `.plano/` completo pronto para o pipeline de fases.
+Ideal quando voce ja sabe o que quer fazer e quer o pipeline completo de cara. Funciona tanto para projetos novos (greenfield) quanto existentes (brownfield) — a deteccao e automatica.
 
-#### Projeto existente (brownfield)
+#### Mapeamento de codebase
+
+Ambos os caminhos se beneficiam do mapeamento profundo do codebase:
 
 ```
-/up:mapear-codigo         # Opcional, mas recomendado
-/up:novo-projeto          # Detecta brownfield automaticamente
+/up:mapear-codigo
 ```
 
-Se voce tem codigo no diretorio, o UP detecta e adapta:
-- Carrega o mapeamento do codebase (se `/up:mapear-codigo` ja rodou)
-- Pergunta "O que voce quer **fazer** com esse codigo?" em vez de "O que voce quer construir?"
-- Infere requisitos **validados** do codebase existente (features que ja funcionam)
-- Separa seus novos objetivos como requisitos **ativos**
-- Pesquisa foca em tecnologias **novas**, nao nas que voce ja usa
-- Todo o pipeline downstream (discutir, planejar, executar) recebe contexto do codebase
-
-O `/up:mapear-codigo` produz 7 documentos em `.plano/codebase/`:
+Produz 7 documentos em `.plano/codebase/`:
 
 | Documento | Conteudo |
 |-----------|----------|
@@ -108,14 +124,7 @@ O `/up:mapear-codigo` produz 7 documentos em `.plano/codebase/`:
 | TESTING.md | Infraestrutura de testes, cobertura |
 | CONCERNS.md | Divida tecnica, areas frageis, seguranca |
 
-Esses documentos alimentam automaticamente o restante do pipeline.
-
-#### Reinicializando um projeto
-
-Se voce ja tem um `.plano/PROJECT.md` e roda `/up:novo-projeto` novamente, o UP oferece:
-- **Revisar e atualizar** — Atualizar com novos objetivos
-- **Recomecar do zero** — Recriar tudo
-- **Cancelar** — Manter como esta
+Esses documentos alimentam automaticamente o restante do pipeline (discutir, planejar, executar).
 
 ### 2. O pipeline de fases
 
@@ -300,7 +309,8 @@ O UP:
 
 | Comando | Descricao |
 |---------|-----------|
-| `/up:novo-projeto` | Inicializar projeto (detecta greenfield/brownfield) |
+| `/up:iniciar` | Registrar projeto existente (leve, sem questionario) |
+| `/up:novo-projeto` | Inicializar projeto completo (questionario + requisitos + roadmap) |
 | `/up:mapear-codigo` | Analisar codebase existente com agentes paralelos |
 | `/up:retomar` | Restaurar contexto da sessao anterior |
 | `/up:discutir-fase N` | Coletar contexto por questionamento estruturado |
@@ -312,6 +322,8 @@ O UP:
 | `/up:adicionar-fase "desc"` | Adicionar fase ao final do roadmap |
 | `/up:remover-fase N` | Remover fase futura e renumerar |
 | `/up:adicionar-testes N` | Gerar testes para fase completa |
+| `/up:melhorias` | Auditoria completa (UX, performance, modernidade) |
+| `/up:ideias` | Sugestoes de features com pesquisa de mercado |
 | `/up:rapido "tarefa"` | Tarefa rapida com commits atomicos |
 | `/up:depurar` | Depuracao sistematica com metodo cientifico |
 | `/up:configurar` | Configurar opcoes do workflow |
@@ -332,14 +344,17 @@ O UP:
 --gaps-only       Executar apenas planos de fechamento de gaps
 ```
 
-### Pipeline
+### Pipelines
 
 ```
+Leve (recomendado para projetos existentes):
+/up:iniciar → /up:planejar-fase N → /up:executar-fase N → /up:verificar-trabalho N
+
+Completo:
 /up:novo-projeto → /up:discutir-fase N → /up:planejar-fase N → /up:executar-fase N → /up:verificar-trabalho N
-                                                                                              │
-                                                                                       Gaps? ─┤
-                                                                                       Sim  → /up:planejar-fase N --gaps
-                                                                                       Nao  → Proxima fase
+
+Ciclo de gaps:
+/up:verificar-trabalho N → Gaps? → /up:planejar-fase N --gaps → /up:executar-fase N --gaps-only → Re-verificar
 ```
 
 ## Estrutura do `.plano/`

package/bin/up-tools.cjs

@@ -8,7 +8,7 @@
  * Usage: node up-tools.cjs <command> [args] [--raw] [--cwd <path>]
  *
  * Commands:
- *   init planejar-fase|executar-fase|novo-projeto|rapido|retomar|operacao-fase|progresso|verificar-trabalho|melhorias|ideias
+ *   init planejar-fase|executar-fase|novo-projeto|rapido|retomar|operacao-fase|progresso|verificar-trabalho|melhorias|ideias|iniciar
  *   state load|get|update|advance-plan|update-progress|add-decision|record-session|record-metric|snapshot
  *   roadmap get-phase|analyze|update-plan-progress
  *   phase add|remove|find|complete|generate-from-report
@@ -206,8 +206,11 @@ function main() {
         case 'ideias':
           cmdInitIdeias(cwd, raw);
           break;
+        case 'iniciar':
+          cmdInitIniciar(cwd, raw);
+          break;
         default:
-          error(`Unknown init workflow: ${workflow}\nAvailable: planejar-fase, executar-fase, novo-projeto, rapido, retomar, operacao-fase, progresso, verificar-trabalho, melhorias, ideias`);
+          error(`Unknown init workflow: ${workflow}\nAvailable: planejar-fase, executar-fase, novo-projeto, rapido, retomar, operacao-fase, progresso, verificar-trabalho, melhorias, ideias, iniciar`);
       }
       break;
     }
@@ -487,6 +490,66 @@ function cmdInitNovoProjeto(cwd, raw) {
   output(result, raw);
 }
 
+function cmdInitIniciar(cwd, raw) {
+  const config = loadConfig(cwd);
+  const { execSync } = require('child_process');
+
+  let hasCode = false;
+  try {
+    const files = execSync('find . -maxdepth 3 \\( -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" \\) 2>/dev/null | grep -v node_modules | grep -v .git | head -5', {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    hasCode = files.trim().length > 0;
+  } catch {}
+
+  const hasCodebaseMap = pathExistsInternal(cwd, '.plano/codebase');
+  let codebaseFiles = [];
+  if (hasCodebaseMap) {
+    try {
+      codebaseFiles = fs.readdirSync(path.join(cwd, '.plano/codebase'))
+        .filter(f => f.endsWith('.md'))
+        .map(f => `.plano/codebase/${f}`);
+    } catch {}
+  }
+
+  // Stack hints from package.json
+  const pkgPath = path.join(cwd, 'package.json');
+  let stackHints = {};
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const allDeps = Object.assign({}, pkg.dependencies || {}, pkg.devDependencies || {});
+    stackHints = {
+      has_react: !!allDeps.react,
+      has_next: !!allDeps.next,
+      has_vue: !!allDeps.vue,
+      has_nuxt: !!allDeps.nuxt,
+      has_svelte: !!allDeps.svelte,
+      has_tailwind: !!allDeps.tailwindcss,
+      has_prisma: !!(allDeps['@prisma/client'] || allDeps.prisma),
+      has_typescript: !!(allDeps.typescript || pathExistsInternal(cwd, 'tsconfig.json')),
+      type_module: pkg.type === 'module',
+    };
+  } catch {}
+
+  const result = {
+    commit_docs: config.commit_docs,
+    project_exists: pathExistsInternal(cwd, '.plano/PROJECT.md'),
+    planning_exists: pathExistsInternal(cwd, '.plano'),
+    has_existing_code: hasCode,
+    has_codebase_map: hasCodebaseMap,
+    codebase_files: codebaseFiles,
+    has_git: pathExistsInternal(cwd, '.git'),
+    has_package_json: pathExistsInternal(cwd, 'package.json'),
+    has_readme: pathExistsInternal(cwd, 'README.md') || pathExistsInternal(cwd, 'readme.md'),
+    stack_hints: stackHints,
+    project_path: '.plano/PROJECT.md',
+  };
+
+  output(result, raw);
+}
+
 function cmdInitRapido(cwd, description, raw) {
   const config = loadConfig(cwd);
   const now = new Date();

package/commands/ajuda.md

@@ -27,7 +27,8 @@ Sistema de desenvolvimento orientado a fases para projetos de software.
 
 | Comando | Descricao | Uso |
 |---------|-----------|-----|
-| `/up:novo-projeto` | Inicializar novo projeto com coleta de contexto | `/up:novo-projeto` |
+| `/up:iniciar` | Registrar projeto existente (leve, sem questionario) | `/up:iniciar` |
+| `/up:novo-projeto` | Inicializar projeto completo (questionario + requisitos + roadmap) | `/up:novo-projeto` |
 | `/up:mapear-codigo` | Analisar codebase existente com agentes paralelos | `/up:mapear-codigo` |
 | `/up:retomar` | Restaurar contexto da sessao anterior | `/up:retomar` |
 
@@ -96,10 +97,21 @@ Sistema de desenvolvimento orientado a fases para projetos de software.
 
 ## Fluxos de Trabalho Comuns
 
-### Projeto com Codigo Existente (mais comum)
+### Projeto Existente — Adocao Leve (recomendado)
+```
+/up:iniciar                    # Registra projeto, cria PROJECT.md automaticamente
+/up:mapear-codigo              # Analise profunda do codebase (opcional)
+/up:planejar-fase 1            # Quando tiver algo para implementar
+/up:executar-fase 1
+/up:verificar-trabalho 1
+```
+Dica: /up:iniciar nao faz perguntas — documenta o que existe e para.
+Use /up:melhorias ou /up:ideias para descobrir o que fazer.
+
+### Projeto Existente — Pipeline Completo
 ```
 /up:mapear-codigo              # Analisa codebase (stack, arquitetura, concerns)
-/up:novo-projeto               # Detecta brownfield automaticamente
+/up:novo-projeto               # Questionario completo + requisitos + roadmap
 /up:discutir-fase 1            # Discute no contexto do codigo existente
 /up:planejar-fase 1            # Planos respeitam convencoes do codebase
 /up:executar-fase 1

package/commands/iniciar.md

@@ -0,0 +1,31 @@
+---
+name: up:iniciar
+description: Registrar projeto existente no UP (leve, sem questionario)
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+---
+<objective>
+Registrar projeto no UP de forma leve. Detecta o que existe, cria PROJECT.md automaticamente sem questionario, e para. Ideal para quem quer adotar UP num projeto existente sem definir roadmap/requisitos de cara.
+
+Diferente de /up:novo-projeto que faz questionamento profundo + requisitos + roadmap, este comando apenas documenta o estado atual e configura o minimo necessario.
+</objective>
+
+<execution_context>
+@~/.claude/up/workflows/iniciar.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+Modo leve: registra projeto, documenta o que existe, e para. O usuario vai planejando fases incrementalmente depois.
+</context>
+
+<process>
+Execute the iniciar workflow from @~/.claude/up/workflows/iniciar.md end-to-end.
+</process>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "up-cc",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Simplified spec-driven development for Claude Code, Gemini and OpenCode.",
   "bin": {
     "up-cc": "bin/install.js"

package/workflows/iniciar.md

@@ -0,0 +1,235 @@
+<purpose>
+Registrar projeto no UP de forma leve. Sem questionario, sem requisitos, sem roadmap.
+Detecta o que existe, gera PROJECT.md automaticamente, cria config padrao, para.
+
+O PROJECT.md vai crescer conforme o usuario planeja fases com /up:planejar-fase e /up:discutir-fase.
+</purpose>
+
+<process>
+
+## 1. Setup
+
+**PRIMEIRO PASSO OBRIGATORIO -- Execute antes de qualquer interacao:**
+
+```bash
+INIT=$(node "$HOME/.claude/up/bin/up-tools.cjs" init iniciar)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse JSON: `commit_docs`, `project_exists`, `planning_exists`, `has_existing_code`, `has_codebase_map`, `codebase_files`, `has_git`, `has_package_json`, `has_readme`, `stack_hints`.
+
+**Se `project_exists` = true:**
+
+Use AskUserQuestion:
+- header: "PROJECT.md existente"
+- question: "Ja existe um PROJECT.md. O que fazer?"
+- options:
+  - "Sobrescrever" -- Gerar novamente a partir do codebase
+  - "Cancelar" -- Manter como esta
+
+Se "Cancelar": Sair. Sugerir `/up:progresso`.
+
+**Se `has_git` = false:** Inicializar git:
+```bash
+git init
+```
+
+## 2. Coletar informacoes do projeto (AUTOMATICO, sem perguntar)
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > REGISTRANDO PROJETO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Fontes de informacao (ler em paralelo, o que existir):
+
+**Sempre ler:**
+```bash
+# package.json (nome, descricao, dependencias)
+cat package.json 2>/dev/null
+
+# README (descricao do projeto)
+cat README.md 2>/dev/null || cat readme.md 2>/dev/null
+
+# CLAUDE.md do projeto (instrucoes existentes)
+cat CLAUDE.md 2>/dev/null
+
+# Estrutura de diretorios (top-level)
+ls -d */ 2>/dev/null | head -20
+```
+
+**Se `has_codebase_map` = true (mapeamento completo existe):**
+```bash
+cat .plano/codebase/STACK.md 2>/dev/null
+cat .plano/codebase/ARCHITECTURE.md 2>/dev/null
+cat .plano/codebase/CONCERNS.md 2>/dev/null
+cat .plano/codebase/CONVENTIONS.md 2>/dev/null
+```
+
+**Se `has_codebase_map` = false E `has_existing_code` = true (mini-scan):**
+```bash
+# Detectar stack pelos arquivos de config
+ls package.json go.mod Cargo.toml requirements.txt pyproject.toml pom.xml build.gradle composer.json Gemfile mix.exs 2>/dev/null
+
+# Detectar estrutura
+ls -d src/ app/ lib/ cmd/ internal/ pages/ components/ public/ api/ server/ 2>/dev/null | head -15
+
+# Detectar frameworks (package.json deps)
+node -e "try{const p=require('./package.json');console.log(JSON.stringify({deps:Object.keys(p.dependencies||{}),devDeps:Object.keys(p.devDependencies||{})}))}catch{}" 2>/dev/null
+```
+
+### Sintetizar informacoes coletadas:
+
+A partir das fontes lidas, extrair:
+- **Nome do projeto**: de package.json name, ou nome do diretorio
+- **Descricao**: de package.json description, ou primeiro paragrafo do README, ou inferir do codigo
+- **Stack**: frameworks, linguagens, dependencias principais
+- **Estrutura**: organizacao de diretorios, entry points
+- **Contexto adicional**: do CLAUDE.md, README, ou codebase map
+
+## 3. Gerar PROJECT.md (AUTOMATICO)
+
+Escrever `.plano/PROJECT.md` sintetizando tudo que foi coletado:
+
+```markdown
+# [Nome do Projeto]
+
+## O que e Isso
+
+[Descricao gerada automaticamente a partir de package.json, README, e/ou analise do codigo.
+2-3 frases descrevendo o que o produto faz e para quem.]
+
+## Valor Central
+
+[Inferido do codigo/README. Se nao for possivel inferir com confianca, usar:]
+[A definir -- sera refinado conforme o projeto evolui]
+
+## Requisitos
+
+### Validados
+
+<!-- Inferidos do codebase existente -->
+
+- [x] [Feature existente 1 detectada no codigo]
+- [x] [Feature existente 2 detectada no codigo]
+- [x] [Feature existente 3 detectada no codigo]
+
+### Ativos
+
+<!-- Adicione objetivos com /up:planejar-fase ou /up:discutir-fase -->
+
+(Nenhum ainda)
+
+### Fora do Escopo
+
+(A definir)
+
+## Contexto
+
+**Stack:** [linguagens, frameworks, dependencias principais]
+**Estrutura:** [organizacao do projeto]
+[Se codebase map existe:]
+**Mapeamento detalhado:** .plano/codebase/
+[Se README existe:]
+**Documentacao:** README.md
+[Se CLAUDE.md existe:]
+**Instrucoes de desenvolvimento:** CLAUDE.md
+
+## Restricoes
+
+- **Stack**: [stack detectada] -- projeto existente
+[Outras restricoes inferidas, ex: se tem TypeScript strict, se tem ESLint, etc.]
+
+## Decisoes-Chave
+
+| Decisao | Justificativa | Resultado |
+|---------|---------------|-----------|
+| Registrado via /up:iniciar | Adocao incremental do UP | -- |
+
+---
+*Ultima atualizacao: [data] apos registro inicial*
+```
+
+**IMPORTANTE:** Preencher Requisitos Validados com features REAIS detectadas no codigo. Se tem codebase map, usar ARCHITECTURE.md como fonte. Se nao, inferir das dependencias e estrutura (ex: "Sistema de autenticacao com NextAuth", "API REST com Express", "Interface com React e Tailwind").
+
+Nao inventar features. So listar o que e evidente no codigo.
+
+**Commit PROJECT.md:**
+
+```bash
+mkdir -p .plano
+node "$HOME/.claude/up/bin/up-tools.cjs" commit "docs: registrar projeto via /up:iniciar" --files .plano/PROJECT.md
+```
+
+## 4. Criar config.json padrao
+
+Criar `.plano/config.json` com valores padrao (sem perguntar):
+
+```json
+{
+  "mode": "yolo",
+  "granularity": "standard",
+  "parallelization": true,
+  "commit_docs": true
+}
+```
+
+**Commit config.json:**
+
+```bash
+node "$HOME/.claude/up/bin/up-tools.cjs" commit "chore: config padrao do projeto" --files .plano/config.json
+```
+
+## 5. Finalizar
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > PROJETO REGISTRADO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**[Nome do Projeto]**
+
+[Descricao curta -- 1 linha do "O que e Isso"]
+
+| Artefato  | Localizacao          |
+|-----------|----------------------|
+| Projeto   | `.plano/PROJECT.md`  |
+| Config    | `.plano/config.json` |
+[Se codebase map existe:]
+| Codebase  | `.plano/codebase/`   |
+
+**[N] features existentes documentadas**
+
+───────────────────────────────────────────────────────────────
+
+## Proximos Passos
+
+O UP esta pronto. Use conforme precisar:
+
+- `/up:mapear-codigo` -- Analise profunda do codebase (se ainda nao mapeou)
+- `/up:melhorias` -- Auditoria de UX, performance, modernidade
+- `/up:ideias` -- Sugestoes de features novas
+- `/up:planejar-fase` -- Quando tiver algo especifico para implementar
+- `/up:rapido` -- Tarefa rapida sem fase formal
+
+PROJECT.md e um documento vivo -- sera atualizado conforme voce planeja e executa fases.
+
+<sub>/clear antes do proximo comando -- janela de contexto limpa</sub>
+
+───────────────────────────────────────────────────────────────
+```
+
+</process>
+
+<success_criteria>
+
+- [ ] .plano/ diretorio criado
+- [ ] Git repo inicializado (se nao existia)
+- [ ] Informacoes coletadas automaticamente (sem perguntas ao usuario)
+- [ ] PROJECT.md gerado com features existentes documentadas -> **committed**
+- [ ] config.json criado com valores padrao -> **committed**
+- [ ] NENHUM questionario, NENHUM REQUIREMENTS.md, NENHUM ROADMAP.md
+- [ ] Proximos passos apresentados
+
+</success_criteria>