@spec-wave/cli 1.0.1 → 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 +1 -1
- package/src/cli.mjs +19 -0
- package/src/commands/code-review.mjs +3 -1
- package/src/commands/decompose.mjs +4 -4
- package/src/commands/implement.mjs +31 -3
- package/src/commands/merge.mjs +157 -59
- package/src/commands/repo.mjs +103 -0
- package/src/lib/pr-ready.mjs +43 -21
- package/src/lib/repo-role.mjs +67 -0
- package/src/lib/workspace.mjs +15 -0
- package/src/plugin/.claude-plugin/plugin.json +1 -1
- package/src/plugin/skills/merge/SKILL.md +1 -0
- package/src/plugin/skills/setup/SKILL.md +8 -1
- package/src/templates/skill/SKILL.md +8 -1
package/package.json
CHANGED
package/src/cli.mjs
CHANGED
|
@@ -372,6 +372,25 @@ Re-teste após o fix: qa <story> --only <cenário> (não duplica Bug — comenta
|
|
|
372
372
|
|
|
373
373
|
Docs: https://astratech-net-br.github.io/spec-wave-cli/guia/qa/`);
|
|
374
374
|
|
|
375
|
+
program
|
|
376
|
+
.command('repo')
|
|
377
|
+
.description('Vincula (link), desvincula (unlink) ou lista (list) os repositórios de código do hub — repositories[] do .spec-wave.json (RFC-005)')
|
|
378
|
+
.argument('<acao>', 'link | unlink | list')
|
|
379
|
+
.argument('[slug]', 'Slug do repositório: minúsculas, [a-z0-9-], até 39 caracteres — vai na label repo:<slug> e não muda depois')
|
|
380
|
+
.argument('[repo]', 'No link: o repositório de código, como owner/repo')
|
|
381
|
+
.option('--dry-run', 'Mostra o que mudaria sem gravar o arquivo nem criar label')
|
|
382
|
+
.option('--json', 'No list: saída em JSON')
|
|
383
|
+
.action(async (acao, slug, repo, options) => {
|
|
384
|
+
const { repoCommand } = await import('./commands/repo.mjs');
|
|
385
|
+
await repoCommand({ action: acao, slug, repo, ...options })
|
|
386
|
+
.catch(err => { console.error(err.message); process.exit(1); });
|
|
387
|
+
})
|
|
388
|
+
.addHelpText('after', `
|
|
389
|
+
Edita só o .spec-wave.json LOCAL do hub (commite depois — os workflows leem a branch default) e cria a
|
|
390
|
+
label repo:<slug> no hub. O slug é imutável depois do primeiro vínculo: o mesmo slug só aceita o mesmo
|
|
391
|
+
repositório, e um repositório já vinculado não ganha um segundo slug. unlink não toca nas labels já
|
|
392
|
+
aplicadas. A UI grava o mesmo repositories[] — este comando é o caminho de quem não a usa.`);
|
|
393
|
+
|
|
375
394
|
program
|
|
376
395
|
.command('workspace')
|
|
377
396
|
.description('Monta o workspace multi-repo de uma issue (RFC-005): mapeia ou clona, ao lado do hub, os repositórios que ela declara com repo:<slug>')
|
|
@@ -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(
|
|
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
|
);
|
|
@@ -22,7 +22,7 @@ import {
|
|
|
22
22
|
getIssue, createIssue, createLabel, removeLabel, addLabel, commentOnIssue, addBlockedBy, listIssueComments,
|
|
23
23
|
getRepoDefaultBranch,
|
|
24
24
|
} from '../api/github-rest.mjs';
|
|
25
|
-
import { codeRepositories, repoLabel } from '../lib/repo-role.mjs';
|
|
25
|
+
import { codeRepositories, repoLabel, repoLabelSpec } from '../lib/repo-role.mjs';
|
|
26
26
|
import { addSubIssue, listSubIssues, getProjectSnapshot } from '../api/github-graphql.mjs';
|
|
27
27
|
import { loadProjectConfig, resolveField, advanceToStage } from '../lib/board.mjs';
|
|
28
28
|
import { generateDocument } from '../lib/claude.mjs';
|
|
@@ -818,12 +818,12 @@ async function resolveRepoLabels({ token, owner, repo, config }, doc) {
|
|
|
818
818
|
}
|
|
819
819
|
|
|
820
820
|
for (const slug of slugs) {
|
|
821
|
-
const
|
|
821
|
+
const spec = repoLabelSpec(slug);
|
|
822
822
|
try {
|
|
823
823
|
// createLabel já engole o 422 de "já existe".
|
|
824
|
-
await createLabel(token, owner, repo,
|
|
824
|
+
await createLabel(token, owner, repo, spec);
|
|
825
825
|
} catch (err) {
|
|
826
|
-
console.warn(` Não consegui garantir a label ${name}: ${err.message}`);
|
|
826
|
+
console.warn(` Não consegui garantir a label ${spec.name}: ${err.message}`);
|
|
827
827
|
}
|
|
828
828
|
}
|
|
829
829
|
for (const story of doc.stories || []) {
|
|
@@ -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 {
|
|
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),
|
package/src/commands/merge.mjs
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
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
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
);
|
|
92
|
-
|
|
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
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
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
|
|
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
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
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
|
|
272
|
-
// (`Closes #N`) é a fonte que o
|
|
273
|
-
|
|
274
|
-
|
|
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
|
|
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
|
|
281
|
-
' — vínculo pelo corpo (Closes
|
|
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
|
|
291
|
-
|
|
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
|
-
|
|
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
|
|
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
|
|
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
|
|
433
|
+
p.log.info(`PR ${ref} já estava mergeado — seguindo.`);
|
|
338
434
|
continue;
|
|
339
435
|
}
|
|
340
|
-
if (atual.base?.ref !==
|
|
341
|
-
p.log.step(`PR
|
|
342
|
-
await updatePRBase(token, owner, repo, pr.number,
|
|
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
|
|
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
|
|
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
|
|
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 {
|
|
@@ -0,0 +1,103 @@
|
|
|
1
|
+
// `spec-wave repo link|unlink|list` — o vínculo hub ↔ repositório de código
|
|
2
|
+
// pelo lado da CLI (RFC-005). A UI grava o mesmo `repositories[]` no
|
|
3
|
+
// .spec-wave.json do hub via Contents API; este comando é o caminho de quem
|
|
4
|
+
// não usa a UI. Só edita o arquivo LOCAL (o dev commita, como no init) e cria
|
|
5
|
+
// a label `repo:<slug>` no hub, best-effort — o decompose --apply a garante de
|
|
6
|
+
// novo se faltar.
|
|
7
|
+
import * as p from '@clack/prompts';
|
|
8
|
+
import chalk from 'chalk';
|
|
9
|
+
import { resolveToken } from '../api/auth.mjs';
|
|
10
|
+
import { getRepoNodeId, createLabel } from '../api/github-rest.mjs';
|
|
11
|
+
import { resolveHubContext } from '../lib/project-root.mjs';
|
|
12
|
+
import { updateConfig } from '../lib/config-file.mjs';
|
|
13
|
+
import {
|
|
14
|
+
codeRepositories, linkRepository, unlinkRepository, parseRepoRef, repoLabelSpec,
|
|
15
|
+
} from '../lib/repo-role.mjs';
|
|
16
|
+
import { CONFIG_FILE } from '../config.mjs';
|
|
17
|
+
|
|
18
|
+
export async function repoCommand({ action, slug, repo: repoArg, dryRun = false, json = false } = {}) {
|
|
19
|
+
if (!['link', 'unlink', 'list'].includes(action)) {
|
|
20
|
+
throw new Error(`Ação inválida: "${action}". Use \`repo link <slug> <owner/repo>\`, \`repo unlink <slug>\` ou \`repo list\`.`);
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
const ctx = resolveHubContext();
|
|
24
|
+
if (ctx.role === 'code') {
|
|
25
|
+
throw new Error(
|
|
26
|
+
`${ctx.self.owner}/${ctx.self.repo} é um repositório de código; o vínculo é registrado no hub` +
|
|
27
|
+
(ctx.owner && ctx.repo ? ` ${ctx.owner}/${ctx.repo}.` : '.')
|
|
28
|
+
);
|
|
29
|
+
}
|
|
30
|
+
if (!ctx.root || !ctx.config) {
|
|
31
|
+
throw new Error(`Rode dentro do hub (diretório com ${CONFIG_FILE}) — ${ctx.error || 'config não encontrado'}.`);
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
if (action === 'list') {
|
|
35
|
+
const repos = codeRepositories(ctx.config);
|
|
36
|
+
if (json) { console.log(JSON.stringify({ hub: { owner: ctx.owner, repo: ctx.repo }, repositories: repos }, null, 2)); return repos; }
|
|
37
|
+
if (repos.length === 0) {
|
|
38
|
+
p.log.info(`Nenhum repositório de código vinculado ao hub ${ctx.owner}/${ctx.repo} (mono-repo).`);
|
|
39
|
+
return repos;
|
|
40
|
+
}
|
|
41
|
+
p.log.info(`Hub ${ctx.owner}/${ctx.repo} — ${repos.length} repositório(s) de código:`);
|
|
42
|
+
for (const r of repos) p.log.message(` ${chalk.cyan(r.slug)} → ${r.owner}/${r.repo} (label repo:${r.slug})`);
|
|
43
|
+
return repos;
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
if (!slug) throw new Error(`Informe o slug: \`spec-wave repo ${action} <slug>${action === 'link' ? ' <owner/repo>' : ''}\`.`);
|
|
47
|
+
|
|
48
|
+
if (action === 'unlink') {
|
|
49
|
+
const preview = unlinkRepository(ctx.config, slug);
|
|
50
|
+
if (preview.error) throw new Error(preview.error);
|
|
51
|
+
if (dryRun) {
|
|
52
|
+
p.log.info(`Dry-run: ${slug} sairia de repositories[] do ${CONFIG_FILE}. As labels repo:${slug} já aplicadas ficam.`);
|
|
53
|
+
return preview.config;
|
|
54
|
+
}
|
|
55
|
+
const { changed } = updateConfig(cfg => unlinkRepository(cfg, slug).config, { cwd: ctx.root });
|
|
56
|
+
p.log.success(`${slug} desvinculado (${CONFIG_FILE}${changed ? ' atualizado' : ' já estava assim'}).`);
|
|
57
|
+
p.log.warn(`As labels repo:${slug} já aplicadas em issues não foram tocadas — são histórico. Commite o ${CONFIG_FILE}.`);
|
|
58
|
+
return null;
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
// link
|
|
62
|
+
const target = parseRepoRef(repoArg);
|
|
63
|
+
if (!target) throw new Error(`Informe o repositório como owner/repo: \`spec-wave repo link ${slug} <owner/repo>\`.`);
|
|
64
|
+
const preview = linkRepository(ctx.config, { slug, ...target });
|
|
65
|
+
if (preview.error) throw new Error(preview.error);
|
|
66
|
+
if (!preview.changed) {
|
|
67
|
+
p.log.info(`${slug} → ${target.owner}/${target.repo} já está vinculado. Nada a fazer.`);
|
|
68
|
+
return preview.config;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
// O repo precisa existir e ser legível pelo token — um slug apontando para
|
|
72
|
+
// o nada só apareceria na primeira Story, dentro do apply.
|
|
73
|
+
const token = await resolveToken();
|
|
74
|
+
try {
|
|
75
|
+
await getRepoNodeId(token, target.owner, target.repo);
|
|
76
|
+
} catch (err) {
|
|
77
|
+
throw new Error(`Não consegui ler ${target.owner}/${target.repo}: ${err.status === 404 ? 'não existe ou o token não o enxerga' : err.message}.`);
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
if (dryRun) {
|
|
81
|
+
p.log.info(`Dry-run: ${slug} → ${target.owner}/${target.repo} entraria em repositories[] do ${CONFIG_FILE}; label repo:${slug} seria criada no hub.`);
|
|
82
|
+
return preview.config;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
const { changed } = updateConfig(cfg => linkRepository(cfg, { slug, ...target }).config, { cwd: ctx.root });
|
|
86
|
+
p.log.success(`${chalk.cyan(slug)} → ${target.owner}/${target.repo} vinculado (${CONFIG_FILE}${changed ? ' atualizado' : ' já estava assim'}).`);
|
|
87
|
+
|
|
88
|
+
const spec = repoLabelSpec(slug);
|
|
89
|
+
try {
|
|
90
|
+
await createLabel(token, ctx.owner, ctx.repo, spec);
|
|
91
|
+
p.log.success(`Label ${spec.name} garantida em ${ctx.owner}/${ctx.repo}.`);
|
|
92
|
+
} catch (err) {
|
|
93
|
+
p.log.warn(`Não consegui criar a label ${spec.name}: ${err.message} — o decompose --apply tenta de novo.`);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
p.note(
|
|
97
|
+
`1. Commite o ${CONFIG_FILE} (os workflows do hub leem repositories[] da branch default).\n` +
|
|
98
|
+
`2. No repositório de código: npx @spec-wave/cli@latest init --role code --repo ${target.owner}/${target.repo} --hub ${ctx.owner}/${ctx.repo}\n` +
|
|
99
|
+
`3. Nas Stories, declare \`**Repos:** ${slug}\` no decomposition.md (vira a label ${spec.name}).`,
|
|
100
|
+
'Próximos passos'
|
|
101
|
+
);
|
|
102
|
+
return null;
|
|
103
|
+
}
|
package/src/lib/pr-ready.mjs
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
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
|
|
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
|
|
70
|
-
//
|
|
71
|
-
//
|
|
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
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
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
|
|
82
|
-
|
|
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 [...
|
|
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
|
-
* @
|
|
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 =>
|
|
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
|
|
149
|
+
marcados.push(prLabel(pr, hub));
|
|
128
150
|
} catch (err) {
|
|
129
|
-
falhas.push(
|
|
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.
|
|
157
|
+
marcados.join(', ')
|
|
136
158
|
);
|
|
137
159
|
}
|
|
138
160
|
if (falhas.length > 0) {
|
package/src/lib/repo-role.mjs
CHANGED
|
@@ -85,6 +85,73 @@ export function repoLabel(slug) {
|
|
|
85
85
|
return `${REPO_LABEL_PREFIX}${slug}`;
|
|
86
86
|
}
|
|
87
87
|
|
|
88
|
+
/** Cor e descrição únicas: `repo link`, `decompose --apply` e a UI criam a mesma label. */
|
|
89
|
+
export function repoLabelSpec(slug) {
|
|
90
|
+
return { name: repoLabel(slug), color: '0e8a16', description: `Story toca o repositório ${slug}` };
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
/**
|
|
94
|
+
* Vincula um repositório de código ao hub (função PURA — devolve um config
|
|
95
|
+
* novo). Recusa o que a label tornaria irreversível: o slug é IMUTÁVEL depois
|
|
96
|
+
* do primeiro vínculo, então o mesmo slug só aceita o MESMO repo; e um repo já
|
|
97
|
+
* vinculado sob outro slug não ganha um segundo nome.
|
|
98
|
+
*
|
|
99
|
+
* @param {object} config .spec-wave.json do hub
|
|
100
|
+
* @param {{slug: string, owner: string, repo: string}} entry
|
|
101
|
+
* @returns {{ config: object, changed: boolean, error: string|null }}
|
|
102
|
+
*/
|
|
103
|
+
export function linkRepository(config, { slug, owner, repo }) {
|
|
104
|
+
if (isCodeRepo(config)) {
|
|
105
|
+
return { config, changed: false, error: 'este repositório é de código (role "code"); o vínculo é registrado no hub.' };
|
|
106
|
+
}
|
|
107
|
+
if (!isValidRepoSlug(slug)) {
|
|
108
|
+
return { config, changed: false, error: `slug inválido "${slug}": minúsculas, [a-z0-9-], até 39 caracteres, começando por letra ou dígito.` };
|
|
109
|
+
}
|
|
110
|
+
if (!owner || !repo) return { config, changed: false, error: 'informe o repositório como owner/repo.' };
|
|
111
|
+
const same = (a, b) => String(a).toLowerCase() === String(b).toLowerCase();
|
|
112
|
+
if (config?.owner && config?.repo && same(config.owner, owner) && same(config.repo, repo)) {
|
|
113
|
+
return { config, changed: false, error: `${owner}/${repo} é o próprio hub — o hub não se vincula a si mesmo.` };
|
|
114
|
+
}
|
|
115
|
+
const current = codeRepositories(config);
|
|
116
|
+
const bySlug = current.find(r => r.slug === slug);
|
|
117
|
+
if (bySlug && same(bySlug.owner, owner) && same(bySlug.repo, repo)) {
|
|
118
|
+
return { config, changed: false, error: null };
|
|
119
|
+
}
|
|
120
|
+
if (bySlug) {
|
|
121
|
+
return {
|
|
122
|
+
config, changed: false,
|
|
123
|
+
error: `o slug "${slug}" já aponta para ${bySlug.owner}/${bySlug.repo} e é imutável (está nas labels repo:${slug}). Use outro slug ou desvincule antes.`,
|
|
124
|
+
};
|
|
125
|
+
}
|
|
126
|
+
const byRepo = current.find(r => same(r.owner, owner) && same(r.repo, repo));
|
|
127
|
+
if (byRepo) {
|
|
128
|
+
return { config, changed: false, error: `${owner}/${repo} já está vinculado como "${byRepo.slug}".` };
|
|
129
|
+
}
|
|
130
|
+
// Preserva as entradas como estão no arquivo (a UI pode gravar campos além
|
|
131
|
+
// de slug/owner/repo); `current` serviu só para as checagens.
|
|
132
|
+
const raw = Array.isArray(config?.repositories) ? config.repositories : [];
|
|
133
|
+
return {
|
|
134
|
+
config: { ...config, repositories: [...raw, { slug, owner, repo }] },
|
|
135
|
+
changed: true,
|
|
136
|
+
error: null,
|
|
137
|
+
};
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
/**
|
|
141
|
+
* Desvincula pelo slug (função PURA). As labels `repo:<slug>` já aplicadas em
|
|
142
|
+
* issues NÃO são tocadas — são histórico, e o `update` nunca as classifica
|
|
143
|
+
* como órfãs (§3.3).
|
|
144
|
+
*
|
|
145
|
+
* @returns {{ config: object, changed: boolean, error: string|null }}
|
|
146
|
+
*/
|
|
147
|
+
export function unlinkRepository(config, slug) {
|
|
148
|
+
if (!codeRepositories(config).some(r => r.slug === slug)) {
|
|
149
|
+
return { config, changed: false, error: `não há repositório vinculado com o slug "${slug}".` };
|
|
150
|
+
}
|
|
151
|
+
const raw = Array.isArray(config?.repositories) ? config.repositories : [];
|
|
152
|
+
return { config: { ...config, repositories: raw.filter(r => r?.slug !== slug) }, changed: true, error: null };
|
|
153
|
+
}
|
|
154
|
+
|
|
88
155
|
/**
|
|
89
156
|
* Slugs declarados pelas labels de uma issue, na ordem em que aparecem.
|
|
90
157
|
* A label é a fonte de verdade (§3.3) — o campo do board é só espelho.
|
package/src/lib/workspace.mjs
CHANGED
|
@@ -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.
|
|
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
|
|
|
@@ -36,7 +36,14 @@ Um Project tem **um** hub (issues, docs, labels, Project, workflows do fluxo) e
|
|
|
36
36
|
npx @spec-wave/cli@latest init --role code --repo <owner/api> --hub <owner/hub>
|
|
37
37
|
```
|
|
38
38
|
|
|
39
|
-
Isso grava **só** dois despachantes (`code-review.yml`, `qa.yml`, que avisam o hub por `repository_dispatch`) e um `.spec-wave.json` com `role: "code"` e `hub`. Nada de labels, Project, issue templates ou secret de IA. Depois: o secret `SPEC_WAVE_HUB_TOKEN` no repo de código (token com escrita em Contents no hub), `spec-wave update` no hub (instala o `pr-events.yml`), e o registro
|
|
39
|
+
Isso grava **só** dois despachantes (`code-review.yml`, `qa.yml`, que avisam o hub por `repository_dispatch`) e um `.spec-wave.json` com `role: "code"` e `hub`. Nada de labels, Project, issue templates ou secret de IA. Depois: o secret `SPEC_WAVE_HUB_TOKEN` no repo de código (token com escrita em Contents no hub), `spec-wave update` no hub (instala o `pr-events.yml`), e o registro do vínculo **no hub**:
|
|
40
|
+
|
|
41
|
+
```bash
|
|
42
|
+
npx @spec-wave/cli@latest repo link <slug> <owner/api> # dentro do hub
|
|
43
|
+
npx @spec-wave/cli@latest repo list
|
|
44
|
+
```
|
|
45
|
+
|
|
46
|
+
`repo link` grava `{ slug, owner, repo }` em `repositories[]` do `.spec-wave.json` local do hub (commite depois — os workflows leem a branch default) e cria a label `repo:<slug>`. Slug em `[a-z0-9-]`, até 39 caracteres, **imutável** depois do primeiro vínculo; `repo unlink <slug>` remove a entrada sem tocar nas labels já aplicadas. Os PRs do repo de código vinculam a Story com `Closes <owner>/<hub>#<n>`.
|
|
40
47
|
|
|
41
48
|
## Passos
|
|
42
49
|
|
|
@@ -560,7 +560,14 @@ Um Project tem **um** hub (issues, docs, labels, Project, workflows do fluxo) e
|
|
|
560
560
|
npx @spec-wave/cli@latest init --role code --repo <owner/api> --hub <owner/hub>
|
|
561
561
|
```
|
|
562
562
|
|
|
563
|
-
Isso grava **só** dois despachantes (`code-review.yml`, `qa.yml`, que avisam o hub por `repository_dispatch`) e um `.spec-wave.json` com `role: "code"` e `hub`. Nada de labels, Project, issue templates ou secret de IA. Depois: o secret `SPEC_WAVE_HUB_TOKEN` no repo de código (token com escrita em Contents no hub), `spec-wave update` no hub (instala o `pr-events.yml`), e o registro
|
|
563
|
+
Isso grava **só** dois despachantes (`code-review.yml`, `qa.yml`, que avisam o hub por `repository_dispatch`) e um `.spec-wave.json` com `role: "code"` e `hub`. Nada de labels, Project, issue templates ou secret de IA. Depois: o secret `SPEC_WAVE_HUB_TOKEN` no repo de código (token com escrita em Contents no hub), `spec-wave update` no hub (instala o `pr-events.yml`), e o registro do vínculo **no hub**:
|
|
564
|
+
|
|
565
|
+
```bash
|
|
566
|
+
npx @spec-wave/cli@latest repo link <slug> <owner/api> # dentro do hub
|
|
567
|
+
npx @spec-wave/cli@latest repo list
|
|
568
|
+
```
|
|
569
|
+
|
|
570
|
+
`repo link` grava `{ slug, owner, repo }` em `repositories[]` do `.spec-wave.json` local do hub (commite depois — os workflows leem a branch default) e cria a label `repo:<slug>`. Slug em `[a-z0-9-]`, até 39 caracteres, **imutável** depois do primeiro vínculo; `repo unlink <slug>` remove a entrada sem tocar nas labels já aplicadas. Os PRs do repo de código vinculam a Story com `Closes <owner>/<hub>#<n>`.
|
|
564
571
|
|
|
565
572
|
#### Passos
|
|
566
573
|
|