@spec-wave/cli 0.5.10 → 0.5.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spec-wave/cli",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "Setup spec-driven GitHub workflow with Projects v2, labels, issue templates, and AI-powered Actions",
   "type": "module",
   "bin": {

package/src/commands/code-review.mjs

@@ -54,24 +54,27 @@ async function resolveFeatureIssue(token, owner, repo, issueNumber) {
   return null;
 }
 
-// Coleta a "unidade de review" de uma issue referenciada no PR: a Feature
-// ancestral + a Story + as Tasks dessa Story — tudo anda junto com a Feature.
-// Retorna Map number -> { nodeId, title }.
+// Coleta a "unidade de review" de uma issue referenciada no PR. Separa a
+// Feature dos demais itens, porque a Feature tem regra própria (só avança
+// quando TODAS as suas Stories estiverem em Code Review). Retorna
+// { feature: {number,nodeId,title}|null, items: Map(number -> {nodeId,title}) }
+// onde `items` são as Stories + Tasks que andam juntas neste PR.
 async function collectReviewUnit(token, owner, repo, issueNumber) {
-  const unit = new Map();
-  const add = (n, nodeId, title) => { if (n && nodeId && !unit.has(n)) unit.set(n, { nodeId, title }); };
+  const items = new Map();
+  const add = (n, nodeId, title) => { if (n && nodeId && !items.has(n)) items.set(n, { nodeId, title }); };
 
   let issue;
-  try { issue = await getIssue(token, owner, repo, issueNumber); } catch { return unit; }
+  try { issue = await getIssue(token, owner, repo, issueNumber); } catch { return { feature: null, items }; }
   const type = detectIssueType(issue);
-  if (type !== 'Feature' && type !== 'Story' && type !== 'Task') return unit;
+  if (type !== 'Feature' && type !== 'Story' && type !== 'Task') return { feature: null, items };
 
-  // Feature ancestral (ou a própria).
-  const feature = await resolveFeatureIssue(token, owner, repo, issueNumber);
-  if (feature) add(feature.number, feature.node_id, feature.title);
+  const featureIssue = await resolveFeatureIssue(token, owner, repo, issueNumber);
+  const feature = featureIssue
+    ? { number: featureIssue.number, nodeId: featureIssue.node_id, title: featureIssue.title }
+    : null;
 
   if (type === 'Feature') {
-    // Toda a subárvore da Feature: Stories + Tasks.
+    // Referência direta à Feature: toda a subárvore (Stories + Tasks).
     const stories = await listSubIssues(token, issue.node_id).catch(() => []);
     for (const st of stories) {
       add(st.number, st.nodeId, st.title);
@@ -91,7 +94,24 @@ async function collectReviewUnit(token, owner, repo, issueNumber) {
       for (const t of tasks) add(t.number, t.nodeId, t.title);
     }
   }
-  return unit;
+  return { feature, items };
+}
+
+// A Feature só avança quando TODAS as suas Stories já estiverem em Code Review
+// (ou etapa posterior). readToken lê as issues; projToken opera no Project.
+async function allStoriesReadyForReview(readToken, projToken, project, etapaField, featureNodeId) {
+  if (!etapaField?.id) return true; // sem campo Etapa não há como checar — assume ok
+  const subs = await listSubIssues(readToken, featureNodeId).catch(() => []);
+  const stories = subs.filter(s => detectIssueType({ title: s.title }) === 'Story');
+  if (stories.length === 0) return true;
+  const tgtIdx = STAGE_ORDER.indexOf(CODE_REVIEW_STAGE);
+  for (const st of stories) {
+    const itemId = await addProjectItem(projToken, project.id, st.nodeId);
+    const current = await getItemSingleSelectValue(projToken, itemId, etapaField.id).catch(() => null);
+    const idx = current ? STAGE_ORDER.indexOf(current) : -1;
+    if (idx === -1 || idx < tgtIdx) return false; // há Story pendente
+  }
+  return true;
 }
 
 // Avança um item do board para a Etapa "👀 Code Review" e reinicia o Status
@@ -168,12 +188,14 @@ export async function codeReview({ prNumber }) {
 
   const seen = new Set();
   const updated = [];
+  const featuresChecked = new Set();
 
-  // Para cada issue referenciada, move a unidade inteira (Feature + Story +
-  // Tasks) para Code Review — tudo anda junto com a Feature.
+  // Para cada issue referenciada: move a Story + Tasks para Code Review. A
+  // Feature só avança quando TODAS as suas Stories já estiverem em Code Review.
   for (const num of issueNums) {
-    const unit = await collectReviewUnit(token, owner, repo, num);
-    for (const [n, info] of unit) {
+    const { feature, items } = await collectReviewUnit(token, owner, repo, num);
+
+    for (const [n, info] of items) {
       if (seen.has(n)) continue;
       seen.add(n);
       try {
@@ -188,13 +210,35 @@ export async function codeReview({ prNumber }) {
         console.warn(`Falha ao atualizar #${n}: ${err.message}`);
       }
     }
+
+    // Feature: só avança se todas as suas Stories já estão em Code Review+.
+    if (feature && !featuresChecked.has(feature.number)) {
+      featuresChecked.add(feature.number);
+      try {
+        const ready = await allStoriesReadyForReview(token, projectToken, project, etapaField, feature.nodeId);
+        if (!ready) {
+          console.log(`Feature #${feature.number} mantida em desenvolvimento — ainda há Stories pendentes (fora de "${CODE_REVIEW_STAGE}").`);
+        } else if (!seen.has(feature.number)) {
+          seen.add(feature.number);
+          const moved = await setCodeReview(projectToken, project, etapaField, statusField, feature.nodeId);
+          if (moved) {
+            updated.push(`#${feature.number} ${feature.title} (Feature)`);
+            console.log(`Feature #${feature.number} → "${CODE_REVIEW_STAGE}" (todas as Stories concluídas).`);
+          } else {
+            console.log(`Feature #${feature.number} já está em "${CODE_REVIEW_STAGE}" ou etapa posterior.`);
+          }
+        }
+      } catch (err) {
+        console.warn(`Falha ao avaliar a Feature #${feature.number}: ${err.message}`);
+      }
+    }
   }
 
   if (updated.length > 0) {
     await commentOnIssue(
       token, owner, repo, parseInt(prNumber, 10),
       `🔍 **Code Review iniciado**\n\n` +
-      `Movidos para **${CODE_REVIEW_STAGE}** (Feature + Story + Tasks):\n\n` +
+      `Movidos para **${CODE_REVIEW_STAGE}** (a Feature só avança quando todas as suas Stories concluírem):\n\n` +
       updated.map(f => `- ${f}`).join('\n')
     ).catch(() => {});
   }

package/src/commands/implement.mjs

@@ -26,7 +26,7 @@ async function resolveFeature(token, startNodeId) {
     const parent = await getIssueParent(token, current);
     if (!parent) return null;
     if (detectIssueType({ title: parent.title }) === 'Feature') {
-      return { number: parent.number, title: parent.title };
+      return { number: parent.number, title: parent.title, nodeId: parent.nodeId };
     }
     current = parent.nodeId;
   }
@@ -46,7 +46,7 @@ function readSpecPlan(featureDir) {
 }
 
 // Monta o markdown de contexto que será entregue ao spec-kit implement.
-function buildContext({ type, issue, tasks, feature, spec, plan, specPath, planPath }) {
+function buildContext({ type, issue, tasks, feature, siblingStories = [], spec, plan, specPath, planPath }) {
   const lines = [];
   lines.push(`# Contexto de implementação — ${type} #${issue.number}`);
   lines.push('');
@@ -86,11 +86,19 @@ function buildContext({ type, issue, tasks, feature, spec, plan, specPath, planP
     lines.push('   1. Faça o **commit** de todas as mudanças da implementação.');
     lines.push(`   2. Abra o **Pull Request** da Story #${issue.number}.`);
     lines.push(
-      `   3. **Avance a Etapa — em conjunto — ${feature ? `da Feature #${feature.number}` : 'da Feature (issue pai da Story)'}, ` +
-      `a Story #${issue.number} e todas as ${tasks.length} Task(s) (${tasks.map(t => `#${t.number}`).join(', ')}) ` +
-      `para ${STAGE_CODE_REVIEW}**, e **reinicie o Status de cada um para ${PROGRESS_TODO}**. ` +
-      'Tudo anda junto com a Feature e sempre para frente.'
+      `   3. **Avance a Etapa da Story #${issue.number} e de todas as suas ${tasks.length} Task(s) ` +
+      `(${tasks.map(t => `#${t.number}`).join(', ')}) para ${STAGE_CODE_REVIEW}**, reiniciando o Status ` +
+      `de cada uma para ${PROGRESS_TODO}. (Story e Tasks andam juntas.)`
     );
+    // A Feature só avança quando TODAS as suas Stories estiverem implementadas.
+    lines.push(`   4. **A Feature${feature ? ` #${feature.number}` : ' (issue pai da Story)'} só avança para ${STAGE_CODE_REVIEW} quando TODAS as suas Stories estiverem implementadas:**`);
+    if (siblingStories.length === 0) {
+      lines.push(`      - Esta é a **única Story** da Feature → avance também a Feature${feature ? ` #${feature.number}` : ''} para ${STAGE_CODE_REVIEW} (Status → ${PROGRESS_TODO}).`);
+    } else {
+      lines.push(`      - Outras Stories desta Feature: ${siblingStories.map(s => `#${s.number}`).join(', ')}.`);
+      lines.push(`      - Verifique a Etapa de cada uma. Avance a Feature para ${STAGE_CODE_REVIEW} **somente se TODAS** já estiverem em ${STAGE_CODE_REVIEW} (ou etapa posterior).`);
+      lines.push(`      - Se **qualquer** Story ainda estiver pendente (antes de ${STAGE_CODE_REVIEW}), **NÃO mova a Feature** — deixe-a em ${STAGE_DEVELOPMENT} até a última Story ser concluída.`);
+    }
   } else {
     lines.push(
       `Esta Task #${issue.number} está na Etapa **${STAGE_DEVELOPMENT}**. Acompanhe o progresso pelo ` +
@@ -212,7 +220,7 @@ export async function implement({ issue: issueArg, featureDir: featureDirOpt, dr
   }
 
   // 4. Resolve a Feature (pai na cadeia) — para spec.md/plan.md e para as
-  // instruções de fim de Story (mover Feature + Story para Code Review).
+  // instruções de fim de Story (avançar a Etapa para Code Review).
   const feature = await resolveFeature(token, issue.node_id);
   let featureDir = featureDirOpt;
   if (!featureDir && feature?.title) {
@@ -227,8 +235,19 @@ export async function implement({ issue: issueArg, featureDir: featureDirOpt, dr
     p.log.warn('Não foi possível resolver a Feature; seguindo só com as tasks (use --feature-dir).');
   }
 
+  // 4b. Stories irmãs da Feature — a Feature só avança para Code Review quando
+  // TODAS as suas Stories estiverem implementadas. Lista as outras para o agente
+  // verificar antes de mover a Feature.
+  let siblingStories = [];
+  if (type === 'Story' && feature?.nodeId) {
+    const featureSubs = await listSubIssues(token, feature.nodeId).catch(() => []);
+    siblingStories = featureSubs
+      .filter(s => detectIssueType({ title: s.title }) === 'Story' && s.number !== issue.number)
+      .map(s => ({ number: s.number, title: s.title }));
+  }
+
   // 5. Monta e grava o arquivo de contexto.
-  const context = buildContext({ type, issue, tasks, feature, ...specPlan });
+  const context = buildContext({ type, issue, tasks, feature, siblingStories, ...specPlan });
   mkdirSync(WORK_DIR, { recursive: true });
   const tasksFile = path.join(WORK_DIR, `implement-${issueNumber}.md`);
   writeFileSync(tasksFile, context);

package/src/templates/skill/SKILL.md

@@ -166,7 +166,7 @@ Mesmas flags do `issue` (exceto `--type`, fixo em `feature`). Mantido para o flu
 | `--feature-dir <path>` | string | Caminho `docs/features/<slug>` para anexar `spec.md`/`plan.md` como contexto (sobrescreve a resolução automática). |
 | `--dry-run` | flag | Monta o contexto e imprime o comando do spec-kit **sem executar**. |
 
-> Diferente dos quatro acima, `implement` roda **localmente** (lê `.spec-wave.json`, como `issue`), não por Action. Detecta o tipo da issue: **Story** → coleta todas as Tasks (sub-issues) e aciona o spec-kit uma única vez; **Task** → só aquela task. Monta o contexto em `.spec-wave/implement-<n>.md` e chama o comando configurado em `specKit.command` (no `.spec-wave.json`) ou na env `SPEC_WAVE_IMPLEMENT_CMD`. Placeholders disponíveis no template: `{tasksFile} {specFile} {planFile} {issue} {type} {title}`. Se nada estiver configurado, ele apenas monta o contexto e mostra como configurar (não executa). O contexto inclui instruções para o agente implementar as Tasks **sequencialmente, uma por vez**, usando o campo **Status** (Todo → In Progress → Done) para o progresso *dentro* da Etapa 🚧 Desenvolvimento — sem trocar a Etapa das tasks (nunca duas com Status "In Progress" ao mesmo tempo). **Ao concluir toda a Story**: fazer o commit, abrir o PR e **avançar a Etapa** da **Feature, Story e todas as Tasks juntas** para **👀 Code Review**, reiniciando o **Status** de cada uma para **Todo**. Etapa só avança (nunca volta); Status mede o progresso dentro da etapa.
+> Diferente dos quatro acima, `implement` roda **localmente** (lê `.spec-wave.json`, como `issue`), não por Action. Detecta o tipo da issue: **Story** → coleta todas as Tasks (sub-issues) e aciona o spec-kit uma única vez; **Task** → só aquela task. Monta o contexto em `.spec-wave/implement-<n>.md` e chama o comando configurado em `specKit.command` (no `.spec-wave.json`) ou na env `SPEC_WAVE_IMPLEMENT_CMD`. Placeholders disponíveis no template: `{tasksFile} {specFile} {planFile} {issue} {type} {title}`. Se nada estiver configurado, ele apenas monta o contexto e mostra como configurar (não executa). O contexto inclui instruções para o agente implementar as Tasks **sequencialmente, uma por vez**, usando o campo **Status** (Todo → In Progress → Done) para o progresso *dentro* da Etapa 🚧 Desenvolvimento — sem trocar a Etapa das tasks (nunca duas com Status "In Progress" ao mesmo tempo). **Ao concluir toda a Story**: fazer o commit, abrir o PR e **avançar a Etapa** da **Story e de todas as suas Tasks** para **👀 Code Review** (Status → Todo). A **Feature só avança** para Code Review quando **TODAS as suas Stories** já estiverem em Code Review — enquanto houver Story pendente, a Feature fica em 🚧 Desenvolvimento. Etapa só avança (nunca volta); Status mede o progresso dentro da etapa.
 
 ---
 
@@ -396,7 +396,7 @@ Aciona o spec-kit para implementar uma **Story** (todas as suas Tasks) ou uma **
    npx @spec-wave/cli implement <número> --dry-run
    ```
 3. Mostre ao usuário o contexto montado em `.spec-wave/implement-<número>.md` e o comando. Esse arquivo contém as **instruções de execução sequencial**: implemente as Tasks **uma por vez** — mova a task para **🚧 Desenvolvimento** só ao iniciá-la e para **🎉 Done** ao concluí-la, antes de passar para a próxima. **Nunca** coloque várias tasks em "in progress" ao mesmo tempo.
-4. **Se você (agente) for implementar diretamente** (sem `specKit.command`): siga o contexto task por task. Para cada task, use o campo **Status** (In Progress ao começar → Done ao concluir) *dentro* da Etapa 🚧 Desenvolvimento — não troque a Etapa da task. Atualize os campos via `gh`. **Ao concluir toda a Story**: faça o commit, abra o PR e **avance a Etapa** da **Feature, Story e todas as Tasks juntas** para **👀 Code Review**, reiniciando o **Status** de cada uma para **Todo**. Lembre: Etapa só avança (nunca volta); Status é o progresso dentro da etapa.
+4. **Se você (agente) for implementar diretamente** (sem `specKit.command`): siga o contexto task por task. Para cada task, use o campo **Status** (In Progress ao começar → Done ao concluir) *dentro* da Etapa 🚧 Desenvolvimento — não troque a Etapa da task. Atualize os campos via `gh`. **Ao concluir toda a Story**: faça o commit, abra o PR e **avance a Etapa** da **Story e de todas as suas Tasks** para **👀 Code Review** (Status → Todo). A **Feature só avança** quando **TODAS as suas Stories** já estiverem em Code Review — se houver Story pendente, deixe a Feature em 🚧 Desenvolvimento. Lembre: Etapa só avança (nunca volta); Status é o progresso dentro da etapa.
 5. Se o usuário aprovar e o spec-kit estiver configurado, rode sem `--dry-run`:
    ```bash
    npx @spec-wave/cli implement <número>
@@ -404,7 +404,7 @@ Aciona o spec-kit para implementar uma **Story** (todas as suas Tasks) ou uma **
    - Se o spec-kit **não** estiver configurado, o comando só monta o contexto e mostra como configurar (`specKit.command` / `SPEC_WAVE_IMPLEMENT_CMD`). Ajude o usuário a definir o template (placeholders: `{tasksFile} {specFile} {planFile} {issue} {type} {title}`).
    - Use `--feature-dir docs/features/<slug>` se a resolução automática da Feature falhar (a skill avisa com warning) e você quiser anexar `spec.md`/`plan.md` como contexto.
 6. Se a issue **não** for Story nem Task (ex.: Feature, Bug), o comando recusa — oriente o usuário: Features se decompõem (`/spec-wave decompose`); implemente as Stories/Tasks resultantes.
-7. Ao final (Story implementada, commit feito, PR aberto e Feature + Story + Tasks em **👀 Code Review**): confirme o resultado com o usuário e oriente a revisão do PR.
+7. Ao final (Story + Tasks em **👀 Code Review**; a Feature só vai para Code Review quando a última Story concluir): confirme o resultado com o usuário e oriente a revisão do PR.
 
 ---