@spec-wave/cli 1.0.2 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@spec-wave/cli",
3
- "version": "1.0.2",
3
+ "version": "1.0.3",
4
4
  "description": "Setup spec-driven GitHub workflow with Projects v2, labels, issue templates, and AI-powered Actions",
5
5
  "type": "module",
6
6
  "bin": {
@@ -8,6 +8,7 @@ import { detectIssueType } from '../lib/issue-type.mjs';
8
8
  import { loadProjectConfig, resolveField, advanceToStage } from '../lib/board.mjs';
9
9
  import { resolveHubContext, resolvePrRepo } from '../lib/project-root.mjs';
10
10
  import { markFeaturePrsReady } from '../lib/pr-ready.mjs';
11
+ import { codeReposForItems } from '../lib/workspace.mjs';
11
12
  import { extractIssueRefs, hubIssueNumbers, resolveLinkMode, sameRepo } from '../lib/pr-link.mjs';
12
13
  import {
13
14
  STATUS_OPTIONS, STAGE_ORDER, STAGE_DONE, PROGRESS_TODO, PROGRESS_DONE, isManualStageType,
@@ -379,6 +380,7 @@ export async function codeReview({ prNumber, prRepo: prRepoOpt, resolveOnly = fa
379
380
  // impossível de mergear no GitHub. Best-effort, como o resto.
380
381
  const marcados = await markFeaturePrsReady({
381
382
  token, owner, repo, feature, stories: featureStories, linkMode,
383
+ codeRepos: codeReposForItems(cfg, { labels: feature.labels || [], children: featureStories }).repos,
382
384
  // `updated` vira a lista "Board atualizado" no comentário do PR;
383
385
  // desrascunhar não é movimento de board e ganha parágrafo próprio.
384
386
  log: { info: console.log, success: console.log, warn: console.warn },
@@ -407,7 +409,7 @@ export async function codeReview({ prNumber, prRepo: prRepoOpt, resolveOnly = fa
407
409
  if (prontos.length > 0) {
408
410
  partes.push(
409
411
  `✅ **Feature concluída — PRs prontos para revisão:** ` +
410
- `${[...new Set(prontos)].sort((a, b) => a - b).map(n => `#${n}`).join(', ')}.\n\n` +
412
+ `${[...new Set(prontos)].sort().join(', ')}.\n\n` +
411
413
  'Todas as Stories terminaram, então os PRs saíram do rascunho juntos. ' +
412
414
  'Enquanto uma feature está em desenvolvimento, os PRs dela ficam em rascunho de propósito.'
413
415
  );
@@ -31,7 +31,10 @@ import { renderTrailers, missingTrailers, readLocalCommitMessages } from '../lib
31
31
  import { currentGitBranch } from '../lib/repo-links.mjs';
32
32
 
33
33
  // Diretório onde montamos o arquivo de contexto entregue ao spec-kit.
34
- import { slugsForItem, resolveWorkspaceLayout, readWorkspaceOverride, renderRepoDirs } from '../lib/workspace.mjs';
34
+ import {
35
+ slugsForItem, resolveWorkspaceLayout, readWorkspaceOverride, renderRepoDirs, codeReposForItems,
36
+ } from '../lib/workspace.mjs';
37
+ import { repoSlugsFromLabels } from '../lib/repo-role.mjs';
35
38
 
36
39
  const WORK_DIR = '.spec-wave';
37
40
 
@@ -499,6 +502,20 @@ export function buildFeatureContext({
499
502
  'reaponta as bases, move o board até 🧪 QA e só apaga as branches no fim. ' +
500
503
  '**NUNCA** mergeie um PR da pilha com `--delete-branch` à mão — apagar a branch antes de reapontar o dependente fecha o PR seguinte.'
501
504
  );
505
+ // Multi-repo (RFC-005 §6.2): a pilha é por repositório. Story 1 em `api` e
506
+ // Story 2 em `web` não formam pilha — são duas raízes; e uma Story que toca
507
+ // dois repos abre dois PRs, ambos fechando a mesma issue do hub.
508
+ if (stories.some(s => repoSlugsFromLabels(s.labels).length > 0)) {
509
+ lines.push('');
510
+ lines.push(
511
+ '**Esta Feature toca mais de um repositório** (linha `Repos:` de cada Story). A pilha é **por repositório**: ' +
512
+ 'o PR de uma Story no repositório X é baseado no PR da Story anterior **no mesmo repositório X** ' +
513
+ '(`gh pr create --draft --base <branch-do-PR-anterior-em-X>`), ou na branch default de X quando nenhuma Story anterior o tocou. ' +
514
+ 'Uma Story que declara N repos abre **N PRs** (um por repo), **cada um** com ' +
515
+ `\`Closes ${closesRef(hub, '<story>')}\` no corpo — a forma qualificada é a única que o hub reconhece fora dele. ` +
516
+ 'Abra cada PR no diretório do repositório certo (`{repoDirs}` do comando; `spec-wave workspace prepare --issue <story>` monta o workspace).'
517
+ );
518
+ }
502
519
  }
503
520
  lines.push('');
504
521
  lines.push(boardRuleBlockquote());
@@ -524,6 +541,11 @@ export function buildFeatureContext({
524
541
  lines.push('');
525
542
  lines.push(depLine);
526
543
  }
544
+ const repos = repoSlugsFromLabels(s.labels);
545
+ if (repos.length > 0) {
546
+ lines.push('');
547
+ lines.push(`**Repos:** ${repos.join(', ')} — um PR em cada, empilhado na pilha desse repositório.`);
548
+ }
527
549
  if (s.body && s.body.trim()) {
528
550
  lines.push('');
529
551
  lines.push(s.body.trim());
@@ -705,7 +727,11 @@ async function implementFeature({ token, owner, repo, config, feature, featureDi
705
727
 
706
728
  const enriched = stories.map(s => ({
707
729
  number: s.number, title: s.title, nodeId: s.nodeId, body: s.body || '', dependsOn: s.dependsOn,
730
+ labels: s.labels || [],
708
731
  }));
732
+ // Repos de código da Feature (RFC-005): onde os PRs das Stories vivem além
733
+ // do hub — o desrascunho precisa olhar neles também.
734
+ const codeRepos = codeReposForItems(config, { labels: feature.labels || [], children: enriched }).repos;
709
735
 
710
736
  // F3. Etapa de cada Story no board (best-effort — sem board, nada é pulado).
711
737
  const stageOf = await fetchStagesOf(token, enriched, { warnOnSkip: true });
@@ -741,7 +767,7 @@ async function implementFeature({ token, owner, repo, config, feature, featureDi
741
767
  // Mesmo destravamento do lado dos PRs: a Feature está pronta para review,
742
768
  // então nenhum PR dela tem motivo para continuar em rascunho.
743
769
  await markFeaturePrsReady({
744
- token, owner, repo, dryRun,
770
+ token, owner, repo, dryRun, codeRepos,
745
771
  feature: { nodeId: feature.node_id, number: feature.number },
746
772
  stories: enriched,
747
773
  linkMode: resolveLinkMode(config),
@@ -898,7 +924,7 @@ async function implementFeature({ token, owner, repo, config, feature, featureDi
898
924
  // dizer "ainda estou trabalhando" — agora todos saem juntos, e a feature
899
925
  // inteira fica revisável no mesmo instante.
900
926
  await markFeaturePrsReady({
901
- token, owner, repo,
927
+ token, owner, repo, codeRepos,
902
928
  feature: { nodeId: feature.node_id, number: feature.number },
903
929
  stories: enriched,
904
930
  linkMode: resolveLinkMode(config),
@@ -1158,6 +1184,8 @@ export async function implement({
1158
1184
  // rascunho de uma vez e a review pode começar pela pilha inteira.
1159
1185
  await markFeaturePrsReady({
1160
1186
  token, owner, repo, dryRun,
1187
+ // União dos repos de todas as Stories: os PRs da Feature vivem neles.
1188
+ codeRepos: codeReposForItems(config, { children: [...siblingStories, { labels: issue.labels }] }).repos,
1161
1189
  feature: { nodeId: feature.nodeId, number: feature.number },
1162
1190
  stories: [...siblingStories, { number: issue.number, nodeId: issue.node_id }],
1163
1191
  linkMode: resolveLinkMode(config),
@@ -29,7 +29,8 @@ import { missingTrailers } from '../lib/commit-trailers.mjs';
29
29
  import { detectIssueType } from '../lib/issue-type.mjs';
30
30
  import { orderStories } from '../lib/dependencies.mjs';
31
31
  import { resolveHubContext, loadConfig } from '../lib/project-root.mjs';
32
- import { extractIssueRefs, hubIssueNumbers, resolveLinkMode } from '../lib/pr-link.mjs';
32
+ import { extractIssueRefs, hubIssueNumbers, resolveLinkMode, sameRepo } from '../lib/pr-link.mjs';
33
+ import { codeReposForItems } from '../lib/workspace.mjs';
33
34
  import { loadFeatureStories } from '../lib/story-graph.mjs';
34
35
  import { resolveCacheTtl, invalidateCache } from '../lib/net-cache.mjs';
35
36
  import { CONFIG_FILE } from '../config.mjs';
@@ -55,13 +56,46 @@ import { qa } from './qa.mjs';
55
56
  * @returns {{ fila: Array<{story:number, pr:object}>, concluidas: Array<{story:number, pr:object}>,
56
57
  * semPr: number[], bloqueios: string[], avisos: string[] }}
57
58
  */
58
- export function planMerge({ sorted = [], byNumber = new Map(), prsByStory = new Map(), defaultBranch } = {}) {
59
+ /**
60
+ * Repositório de um PR. Os PRs passam a carregar `repo` ({owner, repo}, o
61
+ * repositório de onde foram listados — RFC-005); sem o campo, é o hub.
62
+ */
63
+ export function prRepoOf(pr, hub) {
64
+ return pr?.repo?.owner && pr?.repo?.repo ? pr.repo : hub;
65
+ }
66
+
67
+ export function repoKey(r) {
68
+ return r ? `${r.owner}/${r.repo}`.toLowerCase() : '';
69
+ }
70
+
71
+ /** `#12` no hub, `acme/api#12` fora dele — a forma que o GitHub reconhece. */
72
+ export function prRef(pr, hub) {
73
+ const r = prRepoOf(pr, hub);
74
+ return !r || !hub || sameRepo(r, hub) ? `#${pr.number}` : `${r.owner}/${r.repo}#${pr.number}`;
75
+ }
76
+
77
+ /**
78
+ * @param {object} params
79
+ * @param {number[]} params.sorted ordem topológica (números de Story)
80
+ * @param {Map<number, {title: string}>} params.byNumber
81
+ * @param {Map<number, Array<{number, state, merged, isDraft, baseRefName, headRefName, repo?}>>} params.prsByStory
82
+ * @param {string} params.defaultBranch branch default do hub (e de quem não tiver a sua)
83
+ * @param {Map<string, string>} [params.defaultBranches] repoKey → branch default, por repo de código
84
+ * @param {{owner:string, repo:string}} [params.hub]
85
+ */
86
+ export function planMerge({
87
+ sorted = [], byNumber = new Map(), prsByStory = new Map(), defaultBranch, defaultBranches = new Map(), hub = null,
88
+ } = {}) {
59
89
  const fila = [];
60
90
  const concluidas = [];
61
91
  const semPr = [];
62
92
  const bloqueios = [];
63
93
  const avisos = [];
94
+ // A pilha é POR REPOSITÓRIO (RFC-005 §6.2): a head de um PR do `api` não é
95
+ // base válida para um PR do `web`. Chave = repo + branch.
64
96
  const headsNoPlano = new Set();
97
+ const ref = pr => prRef(pr, hub);
98
+ const defaultOf = r => defaultBranches.get(repoKey(r)) ?? defaultBranch;
65
99
 
66
100
  for (const story of sorted) {
67
101
  const prs = prsByStory.get(story) || [];
@@ -76,31 +110,54 @@ export function planMerge({ sorted = [], byNumber = new Map(), prsByStory = new
76
110
  semPr.push(story);
77
111
  continue;
78
112
  }
79
- if (abertos.length > 1) {
80
- bloqueios.push(
81
- `Story #${story} tem ${abertos.length} PRs abertos (${abertos.map(x => `#${x.number}`).join(', ')}) — ` +
82
- 'ambíguo; feche o que não vale antes de mergear.'
83
- );
84
- continue;
113
+
114
+ // Uma Story cross-repo tem UM PR por repositório (§3.4) — isso é o
115
+ // esperado. Ambíguo é mais de um PR aberto no MESMO repositório.
116
+ const porRepo = new Map();
117
+ for (const pr of abertos) {
118
+ const key = repoKey(prRepoOf(pr, hub));
119
+ porRepo.set(key, [...(porRepo.get(key) || []), pr]);
85
120
  }
86
- const pr = abertos[0];
87
- if (pr.isDraft) {
88
- bloqueios.push(
89
- `PR #${pr.number} (Story #${story}) está em RASCUNHO. Marcar pronto é a revisão humana ` +
90
- 'e o que dispara o CI — revise e marque pronto antes de mergear.'
91
- );
92
- continue;
121
+ // Hub primeiro, depois os repos de código em ordem estável.
122
+ const chaves = [...porRepo.keys()].sort((a, b) => (a === repoKey(hub) ? -1 : b === repoKey(hub) ? 1 : a.localeCompare(b)));
123
+ let bloqueada = false;
124
+ const daStory = [];
125
+ for (const key of chaves) {
126
+ const grupo = porRepo.get(key);
127
+ if (grupo.length > 1) {
128
+ bloqueios.push(
129
+ `Story #${story} tem ${grupo.length} PRs abertos no mesmo repositório (${grupo.map(ref).join(', ')}) — ` +
130
+ 'ambíguo; feche o que não vale antes de mergear.'
131
+ );
132
+ bloqueada = true;
133
+ continue;
134
+ }
135
+ const pr = grupo[0];
136
+ if (pr.isDraft) {
137
+ bloqueios.push(
138
+ `PR ${ref(pr)} (Story #${story}) está em RASCUNHO. Marcar pronto é a revisão humana ` +
139
+ 'e o que dispara o CI — revise e marque pronto antes de mergear.'
140
+ );
141
+ bloqueada = true;
142
+ continue;
143
+ }
144
+ // Base que não é a default do repo nem a head de alguém que mergeia
145
+ // antes NO MESMO repo: ou a pilha está fora de ordem, ou aponta para
146
+ // algo que este plano não conhece.
147
+ const r = prRepoOf(pr, hub);
148
+ if (pr.baseRefName !== defaultOf(r) && !headsNoPlano.has(`${key}:${pr.baseRefName}`)) {
149
+ avisos.push(
150
+ `PR ${ref(pr)} (Story #${story}) tem base "${pr.baseRefName}", que não é a default ` +
151
+ 'nem a branch de um PR anterior da fila nesse repositório — confira a pilha antes de confirmar.'
152
+ );
153
+ }
154
+ daStory.push(pr);
93
155
  }
94
- // Base que não é a default nem a head de alguém que mergeia antes: ou a
95
- // pilha está fora de ordem, ou aponta para algo que este plano não conhece.
96
- if (pr.baseRefName !== defaultBranch && !headsNoPlano.has(pr.baseRefName)) {
97
- avisos.push(
98
- `PR #${pr.number} (Story #${story}) tem base "${pr.baseRefName}", que não é a default ` +
99
- 'nem a branch de um PR anterior da fila — confira a pilha antes de confirmar.'
100
- );
156
+ if (bloqueada) continue;
157
+ for (const pr of daStory) {
158
+ headsNoPlano.add(`${repoKey(prRepoOf(pr, hub))}:${pr.headRefName}`);
159
+ fila.push({ story, pr });
101
160
  }
102
- headsNoPlano.add(pr.headRefName);
103
- fila.push({ story, pr });
104
161
  }
105
162
 
106
163
  if (semPr.length > 0) {
@@ -135,14 +192,20 @@ export function planMerge({ sorted = [], byNumber = new Map(), prsByStory = new
135
192
  export function complementWithBodyLinks({ sorted = [], prsByStory = new Map(), openPrs = [], hub, linkMode = 'explicit' } = {}) {
136
193
  const out = new Map(prsByStory);
137
194
  const adicionados = [];
138
- const faltantes = new Set(sorted.filter(s => (out.get(s) || []).length === 0));
139
- if (faltantes.size === 0) return { prsByStory: out, adicionados };
195
+ const stories = new Set(sorted);
140
196
 
197
+ // A regra "só Story sem vínculo nativo" é POR REPOSITÓRIO: o vínculo nativo
198
+ // só existe no hub (o GitHub não fecha issue entre repos, §4), então o PR do
199
+ // `web` de uma Story que já tem PR nativo no hub entra pelo corpo — e um PR
200
+ // do hub redundante continua ignorado. No mono-repo é o comportamento antigo.
141
201
  for (const pr of openPrs) {
142
- for (const n of hubIssueNumbers(extractIssueRefs(pr.body || '', { prRepo: hub, linkMode }), hub)) {
143
- if (!faltantes.has(n)) continue;
144
- out.set(n, [...(out.get(n) || []), pr]);
145
- adicionados.push({ story: n, pr: pr.number });
202
+ const r = prRepoOf(pr, hub);
203
+ for (const n of hubIssueNumbers(extractIssueRefs(pr.body || '', { prRepo: r, linkMode }), hub)) {
204
+ if (!stories.has(n)) continue;
205
+ const atuais = out.get(n) || [];
206
+ if (atuais.some(p => repoKey(prRepoOf(p, hub)) === repoKey(r))) continue;
207
+ out.set(n, [...atuais, pr]);
208
+ adicionados.push({ story: n, pr: pr.number, repo: r });
146
209
  }
147
210
  }
148
211
  return { prsByStory: out, adicionados };
@@ -247,8 +310,26 @@ export async function merge({
247
310
  }
248
311
 
249
312
  const enriched = stories.map(st => ({
250
- number: st.number, title: st.title, nodeId: st.nodeId, dependsOn: st.dependsOn,
313
+ number: st.number, title: st.title, nodeId: st.nodeId, dependsOn: st.dependsOn, labels: st.labels,
251
314
  }));
315
+
316
+ // Repositórios da Feature (RFC-005): o hub + os repos de código que as
317
+ // Stories declaram por label. No mono-repo a lista é só o hub — nada muda.
318
+ const hub = { owner, repo };
319
+ const { repos: codeRepos, unknown: desconhecidos } = codeReposForItems(fileConfig, {
320
+ labels: featureIssue.labels, children: stories,
321
+ });
322
+ if (desconhecidos.length > 0) {
323
+ p.log.warn(`Story(ies) declaram repositório(s) que o hub não conhece (${desconhecidos.join(', ')}) — PRs de lá não entram no plano; registre em repositories[] do ${CONFIG_FILE}.`);
324
+ }
325
+ const repos = [hub, ...codeRepos.map(r => ({ owner: r.owner, repo: r.repo, slug: r.slug }))];
326
+ const defaultBranches = new Map();
327
+ for (const r of codeRepos) {
328
+ const branch = await getRepoDefaultBranch(token, r.owner, r.repo).catch(() => null);
329
+ if (branch) defaultBranches.set(repoKey(r), branch);
330
+ else p.log.warn(`Não consegui ler a branch default de ${r.owner}/${r.repo} — assumindo "${defaultBranch}".`);
331
+ }
332
+ const defaultOf = r => defaultBranches.get(repoKey(r)) ?? defaultBranch;
252
333
  const byNumber = new Map(enriched.map(x => [x.number, x]));
253
334
  const { order: sorted, cycle } = orderStories(
254
335
  enriched.map(({ number, dependsOn }) => ({ number, dependsOn })));
@@ -268,30 +349,39 @@ export async function merge({
268
349
  }
269
350
 
270
351
  // Vínculo nativo só existe com base na default — numa pilha, só o PR de
271
- // baixo. Para as Stories que ficaram sem nada, o corpo dos PRs abertos
272
- // (`Closes #N`) é a fonte que o autor de fato escreveu.
273
- if (sorted.some(story => (prsByStory.get(story) || []).length === 0)) {
274
- const abertos = await listOpenPullRequests(token, owner, repo).catch(() => []);
352
+ // baixo — e só no hub: o GitHub não fecha issue entre repositórios (§4).
353
+ // O corpo dos PRs abertos (`Closes #N` / `Closes hub#N`) é a fonte que o
354
+ // autor de fato escreveu, em cada repositório da Feature.
355
+ if (codeRepos.length > 0 || sorted.some(story => (prsByStory.get(story) || []).length === 0)) {
356
+ const abertos = [];
357
+ for (const r of repos) {
358
+ const lista = await listOpenPullRequests(token, r.owner, r.repo).catch(() => []);
359
+ abertos.push(...lista.map(pr => ({ ...pr, repo: { owner: r.owner, repo: r.repo } })));
360
+ }
275
361
  const linkMode = resolveLinkMode(fileConfig);
276
- const comp = complementWithBodyLinks({ sorted, prsByStory, openPrs: abertos, hub: { owner, repo }, linkMode });
362
+ const comp = complementWithBodyLinks({ sorted, prsByStory, openPrs: abertos, hub, linkMode });
277
363
  prsByStory = comp.prsByStory;
278
364
  if (comp.adicionados.length > 0) {
279
365
  p.log.info(chalk.dim(
280
- comp.adicionados.map(({ story, pr }) => `Story #${story} ← PR #${pr}`).join(' · ') +
281
- ' — vínculo pelo corpo (Closes #N); o GitHub só registra o nativo quando a base é a default.'
366
+ comp.adicionados.map(({ story, pr, repo: r }) => `Story #${story} ← PR ${prRef({ number: pr, repo: r }, hub)}`).join(' · ') +
367
+ ' — vínculo pelo corpo (Closes); o GitHub só registra o nativo quando a base é a default, e só no hub.'
282
368
  ));
283
369
  }
284
370
  }
285
371
 
286
- const plano = planMerge({ sorted, byNumber, prsByStory, defaultBranch });
372
+ const plano = planMerge({ sorted, byNumber, prsByStory, defaultBranch, defaultBranches, hub });
287
373
  s.stop(`${plano.fila.length} PR(s) a mergear · ${plano.concluidas.length} já mergeado(s).`);
288
374
 
289
375
  const linha = ({ story, pr }) => {
290
- const retarget = pr.baseRefName !== defaultBranch ? ` ${chalk.dim(`base ${pr.baseRefName} → ${defaultBranch}`)}` : '';
291
- return ` PR #${pr.number} · Story #${story} ${byNumber.get(story)?.title || ''}${retarget}`;
376
+ const def = defaultOf(prRepoOf(pr, hub));
377
+ const retarget = pr.baseRefName !== def ? ` ${chalk.dim(`base ${pr.baseRefName} → ${def}`)}` : '';
378
+ return ` PR ${prRef(pr, hub)} · Story #${story} ${byNumber.get(story)?.title || ''}${retarget}`;
292
379
  };
293
380
  if (plano.fila.length > 0) {
294
- p.note(plano.fila.map(linha).join('\n'), `Ordem de merge (base: ${defaultBranch}, método: merge commit)`);
381
+ const bases = codeRepos.length > 0
382
+ ? repos.map(r => `${r.slug ?? 'hub'}: ${defaultOf(r)}`).join(', ')
383
+ : defaultBranch;
384
+ p.note(plano.fila.map(linha).join('\n'), `Ordem de merge (base: ${bases}, método: merge commit)`);
295
385
  }
296
386
  for (const a of plano.avisos) p.log.warn(a);
297
387
  for (const b of plano.bloqueios) p.log.error(b);
@@ -301,12 +391,13 @@ export async function merge({
301
391
  // guarda. Só as PRs que de fato vão ser mergeadas (plano.fila) valem a
302
392
  // chamada extra por PR; falha de rede não afirma nada, só é pulada.
303
393
  for (const { story, pr } of plano.fila) {
304
- const messages = await listPullRequestCommitMessages(token, owner, repo, pr.number).catch(() => null);
394
+ const r = prRepoOf(pr, hub);
395
+ const messages = await listPullRequestCommitMessages(token, r.owner, r.repo, pr.number).catch(() => null);
305
396
  if (messages === null) continue;
306
397
  const { missingStories } = missingTrailers(messages, { stories: [story] });
307
398
  if (missingStories.length > 0) {
308
399
  p.log.warn(
309
- `PR #${pr.number} (Story #${story}): nenhum commit traz o trailer \`Spec-Wave-Story: #${story}\` ` +
400
+ `PR ${prRef(pr, hub)} (Story #${story}): nenhum commit traz o trailer \`Spec-Wave-Story: #${story}\` ` +
310
401
  '— confira se é mesmo o trabalho certo antes de mergear.'
311
402
  );
312
403
  }
@@ -331,48 +422,55 @@ export async function merge({
331
422
  const mergedHeads = [];
332
423
  try {
333
424
  for (const { story, pr } of plano.fila) {
425
+ // Cada PR é mergeado NO SEU repositório; a pilha é por repo (RFC-005).
426
+ const r = prRepoOf(pr, hub);
427
+ const def = defaultOf(r);
428
+ const ref = prRef(pr, hub);
429
+ const prRepoOpt = sameRepo(r, hub) ? undefined : `${r.owner}/${r.repo}`;
334
430
  // Estado fresco: a fila pode ter envelhecido entre o plano e este ponto.
335
- const atual = await getPR(token, owner, repo, pr.number);
431
+ const atual = await getPR(token, r.owner, r.repo, pr.number);
336
432
  if (atual.merged_at) {
337
- p.log.info(`PR #${pr.number} já estava mergeado — seguindo.`);
433
+ p.log.info(`PR ${ref} já estava mergeado — seguindo.`);
338
434
  continue;
339
435
  }
340
- if (atual.base?.ref !== defaultBranch) {
341
- p.log.step(`PR #${pr.number}: base ${atual.base?.ref} → ${defaultBranch}`);
342
- await updatePRBase(token, owner, repo, pr.number, defaultBranch);
436
+ if (atual.base?.ref !== def) {
437
+ p.log.step(`PR ${ref}: base ${atual.base?.ref} → ${def}`);
438
+ await updatePRBase(token, r.owner, r.repo, pr.number, def);
343
439
  }
344
440
  try {
345
- await mergePR(token, owner, repo, pr.number, { method: 'merge' });
441
+ await mergePR(token, r.owner, r.repo, pr.number, { method: 'merge' });
346
442
  } catch (err) {
347
443
  // 405 = draft/check pendente/conflito. Parar AQUI preserva a ordem: os
348
444
  // dependentes continuam com branch e PR intactos, e rodar de novo retoma.
445
+ // Numa Story cross-repo isso pode deixar `api` mergeado e `web` não —
446
+ // a janela que a §3.4 aceita conscientemente; rodar de novo fecha.
349
447
  p.log.error(
350
- `Merge do PR #${pr.number} (Story #${story}) recusado: ${err.message}\n` +
448
+ `Merge do PR ${ref} (Story #${story}) recusado: ${err.message}\n` +
351
449
  'Nada depois dele foi mergeado. Resolva (checks, conflito) e rode o comando de novo — ' +
352
450
  'os já mergeados saem do plano sozinhos.'
353
451
  );
354
452
  process.exitCode = 1;
355
453
  return;
356
454
  }
357
- p.log.success(`PR #${pr.number} mergeado (Story #${story}).`);
358
- mergedHeads.push(pr.headRefName);
455
+ p.log.success(`PR ${ref} mergeado (Story #${story}).`);
456
+ mergedHeads.push({ repo: r, head: pr.headRefName });
359
457
 
360
458
  // Board: merge move até 🧪 QA. Falha aqui não desfaz merge — avisa e segue.
361
459
  try {
362
- await codeReview({ prNumber: String(pr.number) });
363
- await qa({ prNumber: String(pr.number) });
460
+ await codeReview({ prNumber: String(pr.number), prRepo: prRepoOpt });
461
+ await qa({ prNumber: String(pr.number), prRepo: prRepoOpt });
364
462
  } catch (err) {
365
- p.log.warn(`Board não atualizado para o PR #${pr.number}: ${err.message} — rode \`spec-wave run --pr ${pr.number}\` depois.`);
463
+ p.log.warn(`Board não atualizado para o PR ${ref}: ${err.message} — rode \`spec-wave run --pr ${pr.number}\` depois.`);
366
464
  }
367
465
  }
368
466
 
369
467
  // Branches só no FIM, quando nenhum PR aberto depende delas — apagar antes
370
468
  // do retarget do dependente foi o que fechou um PR empilhado sem volta.
371
469
  if (!keepBranches) {
372
- for (const head of mergedHeads) {
470
+ for (const { repo: r, head } of mergedHeads) {
373
471
  if (!head) continue;
374
- await deleteBranch(token, owner, repo, head).catch(err =>
375
- p.log.warn(`Branch ${head} não apagada: ${err.message}`));
472
+ await deleteBranch(token, r.owner, r.repo, head).catch(err =>
473
+ p.log.warn(`Branch ${head} (${r.owner}/${r.repo}) não apagada: ${err.message}`));
376
474
  }
377
475
  }
378
476
  } finally {
@@ -39,9 +39,12 @@ export function planPrsToReady(prs = []) {
39
39
  for (const pr of prs) {
40
40
  if (!pr?.id || !pr.isDraft || pr.merged) continue;
41
41
  if (pr.state && pr.state !== 'open') continue;
42
- if (!out.has(pr.number)) out.set(pr.number, pr);
42
+ // Chave = node id: o número colide entre repositórios (PR #42 do `api` e
43
+ // #42 do `web`), o id não.
44
+ if (!out.has(pr.id)) out.set(pr.id, pr);
43
45
  }
44
- return [...out.values()].sort((a, b) => a.number - b.number);
46
+ const repoOf = pr => (pr.repo ? `${pr.repo.owner}/${pr.repo.repo}`.toLowerCase() : '');
47
+ return [...out.values()].sort((a, b) => repoOf(a).localeCompare(repoOf(b)) || a.number - b.number);
45
48
  }
46
49
 
47
50
  /**
@@ -61,28 +64,42 @@ export function planPrsToReady(prs = []) {
61
64
  * @returns {Promise<Array<object>>} PRs sem repetição
62
65
  */
63
66
  export async function collectFeaturePullRequests({
64
- token, owner, repo, issueNumbers = [], issueNodes = [], linkMode = 'explicit',
67
+ token, owner, repo, issueNumbers = [], issueNodes = [], linkMode = 'explicit', codeRepos = [],
65
68
  }) {
66
69
  const alvo = new Set(issueNumbers);
67
- const byNumber = new Map();
70
+ const byKey = new Map();
71
+ const keyOf = pr => pr.id || `${pr.repo?.owner}/${pr.repo?.repo}#${pr.number}`.toLowerCase();
68
72
 
69
- // `owner/repo` é o hub: as issues são dele e, por ora, os PRs listados também.
70
- // Um `#N` solto num PR do hub é issue do hub; um `outro/repo#N` não é desta
71
- // Feature — sem isso `acme/api#412` num PR do hub casaria a Story #412.
73
+ // `owner/repo` é o hub: as issues são dele. Os PRs vivem no hub E nos repos
74
+ // de código da Feature (RFC-005); cada um sai marcado com o repositório de
75
+ // onde foi listado — o número colide entre repos, o par não. Um `#N` solto
76
+ // é issue do repo do PR; só o que aponta para o hub é desta Feature.
72
77
  const hub = { owner, repo };
73
- const abertos = await listOpenPullRequests(token, owner, repo).catch(() => []);
74
- for (const pr of abertos) {
75
- const fecha = hubIssueNumbers(extractIssueRefs(pr.body || '', { prRepo: hub, linkMode }), hub);
76
- if (fecha.some(n => alvo.has(n))) byNumber.set(pr.number, pr);
78
+ for (const r of [hub, ...codeRepos]) {
79
+ const abertos = await listOpenPullRequests(token, r.owner, r.repo).catch(() => []);
80
+ for (const raw of abertos) {
81
+ const pr = { ...raw, repo: { owner: r.owner, repo: r.repo } };
82
+ const fecha = hubIssueNumbers(extractIssueRefs(pr.body || '', { prRepo: pr.repo, linkMode }), hub);
83
+ if (fecha.some(n => alvo.has(n))) byKey.set(keyOf(pr), pr);
84
+ }
77
85
  }
78
86
 
87
+ // Vínculo nativo: só existe no hub (o GitHub não fecha issue entre repos).
79
88
  for (const node of issueNodes) {
80
89
  if (!node?.nodeId) continue;
81
- for (const pr of await listIssuePullRequests(token, node.nodeId).catch(() => [])) {
82
- if (!byNumber.has(pr.number)) byNumber.set(pr.number, pr);
90
+ for (const raw of await listIssuePullRequests(token, node.nodeId).catch(() => [])) {
91
+ const pr = { ...raw, repo: raw.repo || hub };
92
+ if (!byKey.has(keyOf(pr))) byKey.set(keyOf(pr), pr);
83
93
  }
84
94
  }
85
- return [...byNumber.values()];
95
+ return [...byKey.values()];
96
+ }
97
+
98
+ /** `#12` no hub, `acme/api#12` fora dele. */
99
+ export function prLabel(pr, hub) {
100
+ const r = pr.repo;
101
+ const noHub = !r || (r.owner.toLowerCase() === hub.owner.toLowerCase() && r.repo.toLowerCase() === hub.repo.toLowerCase());
102
+ return noHub ? `#${pr.number}` : `${r.owner}/${r.repo}#${pr.number}`;
86
103
  }
87
104
 
88
105
  /**
@@ -96,15 +113,18 @@ export async function collectFeaturePullRequests({
96
113
  * @param {{number:number, nodeId?:string}} params.feature
97
114
  * @param {Array<{number:number, nodeId?:string}>} params.stories todas as
98
115
  * Stories da Feature — as recém-concluídas E as que já estavam em Code Review
99
- * @returns {Promise<number[]>} números dos PRs marcados como prontos
116
+ * @param {Array<{owner:string, repo:string}>} [params.codeRepos] repos de código da
117
+ * Feature (RFC-005) — os PRs vivem neles além do hub
118
+ * @returns {Promise<string[]>} rótulos dos PRs marcados (`#12`, `acme/api#12`)
100
119
  */
101
120
  export async function markFeaturePrsReady({
102
- token, owner, repo, feature, stories = [], dryRun = false, log = p.log, linkMode = 'explicit',
121
+ token, owner, repo, feature, stories = [], dryRun = false, log = p.log, linkMode = 'explicit', codeRepos = [],
103
122
  }) {
104
123
  if (!token || !owner || !repo || !feature?.number) return [];
124
+ const hub = { owner, repo };
105
125
  try {
106
126
  const prs = await collectFeaturePullRequests({
107
- token, owner, repo, linkMode,
127
+ token, owner, repo, linkMode, codeRepos,
108
128
  issueNumbers: [feature.number, ...stories.map(s => s.number)].filter(Boolean),
109
129
  issueNodes: [feature, ...stories],
110
130
  });
@@ -113,26 +133,28 @@ export async function markFeaturePrsReady({
113
133
 
114
134
  if (dryRun) {
115
135
  log.info(
116
- `PRs (dry-run): ${alvos.map(pr => `#${pr.number}`).join(', ')} sairiam do rascunho ` +
136
+ `PRs (dry-run): ${alvos.map(pr => prLabel(pr, hub)).join(', ')} sairiam do rascunho ` +
117
137
  `(Feature #${feature.number} pronta para review) — não aplicado`
118
138
  );
119
139
  return [];
120
140
  }
121
141
 
142
+ // Devolve os rótulos (`#12`, `acme/api#12`), não os números: fora do hub o
143
+ // número sozinho não identifica o PR.
122
144
  const marcados = [];
123
145
  const falhas = [];
124
146
  for (const pr of alvos) {
125
147
  try {
126
148
  await markPullRequestReadyForReview(token, pr.id);
127
- marcados.push(pr.number);
149
+ marcados.push(prLabel(pr, hub));
128
150
  } catch (err) {
129
- falhas.push(`#${pr.number} (${err.message})`);
151
+ falhas.push(`${prLabel(pr, hub)} (${err.message})`);
130
152
  }
131
153
  }
132
154
  if (marcados.length > 0) {
133
155
  log.success(
134
156
  `${marcados.length} PR(s) da Feature #${feature.number} prontos para revisão: ` +
135
- marcados.map(n => `#${n}`).join(', ')
157
+ marcados.join(', ')
136
158
  );
137
159
  }
138
160
  if (falhas.length > 0) {
@@ -41,6 +41,21 @@ export function slugsForItem({ labels = [], children = [] } = {}) {
41
41
  return [...agg].sort();
42
42
  }
43
43
 
44
+ /**
45
+ * Repositórios de código de um item, resolvidos contra `repositories[]` do hub
46
+ * (função PURA): os slugs vêm das labels (Feature agrega os filhos), e um slug
47
+ * que o hub não conhece volta em `unknown` em vez de virar repositório.
48
+ *
49
+ * @returns {{ repos: Array<{slug:string, owner:string, repo:string}>, unknown: string[] }}
50
+ */
51
+ export function codeReposForItems(config, { labels = [], children = [] } = {}) {
52
+ const slugs = slugsForItem({ labels, children });
53
+ const known = codeRepositories(config);
54
+ const repos = known.filter(r => slugs.includes(r.slug));
55
+ const unknown = slugs.filter(s => !repos.some(r => r.slug === s));
56
+ return { repos, unknown };
57
+ }
58
+
44
59
  /**
45
60
  * Onde cada repositório fica (função PURA — `exists` é injetável).
46
61
  *
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "spec-wave",
3
3
  "displayName": "Spec Wave",
4
- "version": "1.0.2",
4
+ "version": "1.0.3",
5
5
  "description": "Fluxo spec-driven no GitHub (RFC-001): Projects v2, labels de gatilho, spec/plan gerados por Action, decomposição em duas etapas e implementação orientada a Stories/Tasks.",
6
6
  "author": {
7
7
  "name": "Astratech",
@@ -26,6 +26,7 @@ O `implement` empilha os PRs de propósito (cada Story revisável sozinha, diff
26
26
  - **PR em rascunho bloqueia o plano inteiro** — e é assim que se sabe que a feature ainda está em desenvolvimento. Quem tira do rascunho é o `implement`, quando a **última** Story da Feature entra em Code Review: aí todos os PRs da Feature ficam prontos de uma vez. Um PR ainda em rascunho aqui significa que a Feature não terminou (ou que o desrascunho falhou e avisou) — o `merge` não marca por você, de propósito.
27
27
  - **Rodar de novo retoma.** PR mergeado sai do plano sozinho; uma falha no meio (check pendente, conflito) para a fila com as branches dos dependentes intactas.
28
28
  - **PRs empilhados são achados pelo corpo** quando preciso: o GitHub só registra o vínculo nativo (`closedByPullRequestsReferences`) quando a base do PR é a default — numa pilha, só o PR de baixo. Para Stories sem vínculo nativo, o comando parseia o `Closes #N` do corpo dos PRs abertos (mesma régua do code-review). Garanta que cada PR da pilha tem `Closes #<story>` no corpo.
29
+ - **Multi-repo (RFC-005): a pilha é POR REPOSITÓRIO.** Uma Story que declara N repos (labels `repo:<slug>`) tem N PRs — um por repositório, cada um com `Closes <owner>/<hub>#<story>` no corpo — e isso não é ambíguo; ambíguo é mais de um PR aberto no **mesmo** repositório. O comando lista os PRs abertos do hub e de cada repo de código da Feature, reaponta a base para a default **daquele** repo, mergeia lá, apaga a branch lá e move o board com `--pr-repo`. A head de um PR só é base válida no mesmo repositório (Story 1 no `api` e Story 2 no `web` são duas raízes). Entre o primeiro e o último PR de uma Story cross-repo existe uma janela em que `api` já mergeou e `web` não — aceita conscientemente (§3.4); uma falha no meio para a fila e rodar de novo retoma.
29
30
  - Story **sem PR** vira aviso, não bloqueio — mas se um PR da fila depende do código dela, o merge leva esse código junto; confira antes de confirmar.
30
31
  - Cada PR da fila é conferido contra o trailer `Spec-Wave-Story: #<n>` (rastro do `implement`, best-effort — nunca bloqueia): PR sem nenhum commit com o trailer certo vira aviso, vale conferir se é mesmo o trabalho daquela Story antes de mergear.
31
32