@spec-wave/cli 1.7.6 → 1.9.0

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.
Files changed (56) hide show
  1. package/README.md +1 -1
  2. package/package.json +1 -1
  3. package/src/agent/errors.mjs +31 -1
  4. package/src/agent/openrouter-agent.mjs +25 -2
  5. package/src/api/github-graphql.mjs +31 -0
  6. package/src/api/github-rest.mjs +20 -0
  7. package/src/cli.mjs +103 -36
  8. package/src/commands/auth-check.mjs +72 -0
  9. package/src/commands/decompose.mjs +14 -2
  10. package/src/commands/doctor.mjs +139 -2
  11. package/src/commands/generate-bug.mjs +6 -6
  12. package/src/commands/generate-plan.mjs +9 -8
  13. package/src/commands/generate-qa-plan.mjs +9 -6
  14. package/src/commands/generate-spec.mjs +12 -7
  15. package/src/commands/implement.mjs +21 -0
  16. package/src/commands/init.mjs +2 -2
  17. package/src/commands/preflight.mjs +38 -2
  18. package/src/commands/progress.mjs +144 -0
  19. package/src/commands/relink.mjs +105 -0
  20. package/src/commands/report-failure.mjs +99 -0
  21. package/src/commands/retry.mjs +91 -0
  22. package/src/commands/task.mjs +5 -0
  23. package/src/commands/update.mjs +70 -0
  24. package/src/config.mjs +8 -8
  25. package/src/lib/cited-paths.mjs +89 -0
  26. package/src/lib/claude.mjs +4 -2
  27. package/src/lib/cli-line.mjs +153 -0
  28. package/src/lib/cli-ref.mjs +53 -2
  29. package/src/lib/failure-report.mjs +319 -0
  30. package/src/lib/progress-events.mjs +46 -0
  31. package/src/lib/repo-identity.mjs +55 -0
  32. package/src/lib/spec-index.mjs +114 -0
  33. package/src/lib/tech-context.mjs +144 -5
  34. package/src/plugin/.claude-plugin/plugin.json +1 -1
  35. package/src/plugin/skills/plan/SKILL.md +1 -1
  36. package/src/plugin/skills/plan/reference/tech-context.md +12 -4
  37. package/src/plugin/skills/setup/SKILL.md +1 -1
  38. package/src/plugin/skills/spec/model-prompt.md +8 -1
  39. package/src/plugins/scm-github/index.mjs +8 -1
  40. package/src/plugins/tracker-github-projects/index.mjs +11 -4
  41. package/src/ports/tracker.mjs +2 -1
  42. package/src/setup/labels.mjs +5 -3
  43. package/src/setup/project.mjs +5 -3
  44. package/src/templates/config/tech_context.yml +29 -25
  45. package/src/templates/skill/SKILL.md +27 -9
  46. package/src/templates/skill/core.md +25 -7
  47. package/src/templates/workflows/code-review.yml +1 -0
  48. package/src/templates/workflows/critique.yml +11 -0
  49. package/src/templates/workflows/decompose.yml +27 -0
  50. package/src/templates/workflows/generate-bug.yml +26 -0
  51. package/src/templates/workflows/generate-plan.yml +26 -0
  52. package/src/templates/workflows/generate-qa-plan.yml +27 -0
  53. package/src/templates/workflows/generate-spec.yml +26 -0
  54. package/src/templates/workflows/pr-events.yml +5 -0
  55. package/src/templates/workflows/qa.yml +1 -0
  56. package/src/templates/workflows/validate.yml +11 -0
@@ -0,0 +1,105 @@
1
+ // `spec-wave relink --project <url>` — reaponta o .spec-wave.json para o
2
+ // repositório e o Project ATUAIS.
3
+ //
4
+ // Existe por um repo transferido de dono (Nuviumdigital/semseguro): o config
5
+ // seguia com owner/repo antigos e o Project pessoal do dono anterior, e a
6
+ // correção foi à mão com `jq`, copiando ids de campo e de opção do Project da
7
+ // org. Aqui é o mesmo caminho de leitura do `refresh --config`
8
+ // (`tracker.setup({provision:false})`), só que apontado pela URL do board novo.
9
+ //
10
+ // Só reescreve o VÍNCULO: owner, repo e o bloco `project`. `version`, `ai`,
11
+ // `execution` e o resto ficam como estão — mudar a linha da CLI é do `update`.
12
+
13
+ import { readFileSync, writeFileSync } from 'node:fs';
14
+ import path from 'node:path';
15
+
16
+ import * as p from '@clack/prompts';
17
+ import chalk from 'chalk';
18
+
19
+ import { resolveToken } from '../api/auth.mjs';
20
+ import { CONFIG_FILE } from '../config.mjs';
21
+ import { findConfigPath } from '../lib/project-root.mjs';
22
+ import { gitRemoteRepo } from '../lib/repo-identity.mjs';
23
+ import { requireTracker } from '../ports/index.mjs';
24
+
25
+ /**
26
+ * Config novo (função PURA). Preserva tudo que não é vínculo, inclusive campos
27
+ * do bloco `project` que o snapshot não traz.
28
+ *
29
+ * @param {object} config atual
30
+ * @param {{owner: string, repo: string}} alvo
31
+ * @param {{id, number, url, title, fields}} board
32
+ * @param {string} [agora] ISO
33
+ * @returns {object}
34
+ */
35
+ export function relinkConfig(config, alvo, board, agora = new Date().toISOString()) {
36
+ const { etapaFieldId: _e, stageOptions: _s, ...projectRest } = config.project || {};
37
+ return {
38
+ ...config,
39
+ owner: alvo.owner,
40
+ repo: alvo.repo,
41
+ project: {
42
+ ...projectRest,
43
+ title: board.title,
44
+ url: board.url,
45
+ id: board.id,
46
+ number: board.number,
47
+ fields: board.fields,
48
+ },
49
+ refreshedAt: agora,
50
+ };
51
+ }
52
+
53
+ /**
54
+ * @param {object} options
55
+ * @param {string} options.project URL do Project v2
56
+ * @param {string} [options.repo] owner/repo (padrão: git remote origin)
57
+ * @param {boolean} [options.dryRun]
58
+ * @param {object} [deps] `tracker`, `remote`
59
+ */
60
+ export async function relink(options = {}, deps = {}) {
61
+ if (!options.project) throw new Error('Informe o Project novo: --project https://github.com/orgs/<org>/projects/<n>');
62
+ const configPath = findConfigPath();
63
+ if (!configPath) throw new Error(`Sem ${CONFIG_FILE} — rode \`spec-wave init\`.`);
64
+ const config = JSON.parse(readFileSync(configPath, 'utf-8'));
65
+
66
+ const alvoTexto = options.repo || (deps.remote !== undefined ? deps.remote : gitRemoteRepo(path.dirname(configPath)));
67
+ const [owner, repo] = String(alvoTexto || '').split('/');
68
+ if (!owner || !repo) {
69
+ throw new Error('Não consegui determinar o repositório: passe --repo <owner/repo> (o `origin` não é do GitHub).');
70
+ }
71
+
72
+ p.intro(chalk.bold('spec-wave relink'));
73
+ const token = await resolveToken();
74
+ const tracker = await requireTracker({ token, owner, repo, board: true, deps });
75
+ const { config: vivo, warnings } = await tracker.setup({ provision: false, boardUrl: options.project });
76
+ if (!vivo) throw new Error(warnings[0] || `Project ${options.project} não encontrado.`);
77
+ const board = {
78
+ id: vivo.projectId, number: vivo.projectNumber, url: vivo.projectUrl,
79
+ title: vivo.projectTitle, fields: vivo.fields,
80
+ };
81
+ if (!board.fields?.Etapa) {
82
+ p.log.warn('O Project novo não tem o campo "Etapa" — rode `spec-wave refresh --stages` depois do relink.');
83
+ }
84
+
85
+ const novo = relinkConfig(config, { owner, repo }, board);
86
+ const linha = (rotulo, antes, depois) =>
87
+ `${chalk.dim(rotulo.padEnd(9))} ${antes === depois ? depois : `${chalk.red(antes ?? '—')} → ${chalk.green(depois)}`}`;
88
+ p.note([
89
+ linha('repo', `${config.owner}/${config.repo}`, `${owner}/${repo}`),
90
+ linha('Project', config.project?.url, board.url),
91
+ linha('id', config.project?.id, board.id),
92
+ `${chalk.dim('campos'.padEnd(9))} ${Object.keys(board.fields || {}).join(', ') || '—'}`,
93
+ ].join('\n'), 'Vínculo');
94
+
95
+ if (options.dryRun) {
96
+ p.outro('Dry-run: nada foi gravado.');
97
+ return { config: novo, written: false };
98
+ }
99
+ writeFileSync(configPath, `${JSON.stringify(novo, null, 2)}\n`);
100
+ p.outro(
101
+ `${CONFIG_FILE} reapontado. Commite o arquivo — o runner do Actions lê o config do repositório — ` +
102
+ 'e rode `spec-wave doctor` para conferir o resto (secrets, workflows).'
103
+ );
104
+ return { config: novo, written: true };
105
+ }
@@ -0,0 +1,99 @@
1
+ // `spec-wave report-failure` — o passo `if: failure()` dos workflows de fluxo.
2
+ //
3
+ // Leva a falha até a issue quando o comando que falhou NÃO a comentou: falha
4
+ // antes da CLI (instalação, checkout) ou num passo que não é de geração (o
5
+ // `workspace prepare`, que foi o caso do 401 no semseguro). Quando o comando já
6
+ // comentou, o registro em `$RUNNER_TEMP` diz isso e aqui não se repete nada.
7
+ //
8
+ // Também remove a label de gatilho: com ela aplicada, reaplicá-la não emite
9
+ // evento `labeled`, e a issue vira beco sem saída — mesmo motivo do `catch`
10
+ // dos generate-*.
11
+ //
12
+ // NUNCA falha: o job já está vermelho, e um relatório que derruba o relatório
13
+ // esconde a causa original atrás de um erro novo.
14
+
15
+ import { resolveToken } from '../api/auth.mjs';
16
+ import { resolveFlowContext } from '../lib/flow-run.mjs';
17
+ import {
18
+ actionsRunUrl, classifyFailure, readFailureRecord, renderFailureComment,
19
+ } from '../lib/failure-report.mjs';
20
+ import { requireTracker } from '../ports/index.mjs';
21
+
22
+ /**
23
+ * A causa que o PASSO QUE FALHOU registrou, ou — só para registro sem ela — a
24
+ * reclassificação da mensagem (função PURA).
25
+ *
26
+ * O registro vence porque o `env` deste passo NÃO é o do passo que falhou: o
27
+ * `report-failure` roda com o GITHUB_TOKEN automático e sem `SPEC_WAVE_*_SOURCE`.
28
+ * Reclassificar aqui trocava o diagnóstico — um GH_PROJECT_TOKEN expirado virava
29
+ * "o GITHUB_TOKEN automático não expira", que é o conselho oposto.
30
+ */
31
+ function causaDoRegistro(record, env) {
32
+ if (record?.resumo && record?.proximoPasso) {
33
+ return { kind: record.kind ?? 'unknown', resumo: record.resumo, proximoPasso: record.proximoPasso };
34
+ }
35
+ return classifyFailure(record?.message ?? '', env);
36
+ }
37
+
38
+ /**
39
+ * O que fazer com o registro (função PURA).
40
+ *
41
+ * @param {{message?: string, kind?: string, resumo?: string, proximoPasso?: string, notified?: boolean}|null} record
42
+ * @param {Record<string,string|undefined>} [env] só para o registro sem causa gravada
43
+ * @returns {{comentar: boolean, message: string|null, causa: object}}
44
+ */
45
+ export function planFailureReport(record, env = process.env) {
46
+ if (record?.notified) return { comentar: false, message: record.message ?? null, causa: causaDoRegistro(record, env) };
47
+ if (!record) {
48
+ return {
49
+ comentar: true,
50
+ message: null,
51
+ causa: {
52
+ kind: 'workflow',
53
+ resumo: 'O workflow falhou antes de a CLI registrar um erro (instalação, checkout ou passo intermediário).',
54
+ proximoPasso: 'Veja o passo vermelho no log do run. Depois de corrigir, reaplique o gatilho com ' +
55
+ '`spec-wave retry <issue>`.',
56
+ },
57
+ };
58
+ }
59
+ return { comentar: true, message: record.message ?? null, causa: causaDoRegistro(record, env) };
60
+ }
61
+
62
+ /**
63
+ * @param {object} params
64
+ * @param {string|number} params.issue
65
+ * @param {string} [params.label] label de gatilho do run (removida para destravar)
66
+ * @param {string} [params.step] nome da etapa, para o título ("Falha no generate-spec")
67
+ * @param {object} [params.deps] `tracker`, `readRecord`, `env`
68
+ */
69
+ export async function reportFailure({ issue, label = null, step = null, deps = {} }) {
70
+ const env = deps.env ?? process.env;
71
+ try {
72
+ const plano = planFailureReport((deps.readRecord ?? readFailureRecord)(env), env);
73
+ if (!plano.comentar) {
74
+ console.log('A falha já foi comentada na issue pelo próprio comando — nada a repetir.');
75
+ return { commented: false };
76
+ }
77
+ const token = await resolveToken({ quiet: true });
78
+ const { owner, repo } = resolveFlowContext({ command: 'report-failure', env });
79
+ const tracker = await requireTracker({ token, owner, repo, deps });
80
+ const ref = { key: String(issue) };
81
+ if (label) await tracker.removeTag({ ref, tag: label }).catch(() => {});
82
+ await tracker.addComment({
83
+ ref,
84
+ body: renderFailureComment({
85
+ titulo: step ? `Falha no ${step}` : 'Falha no workflow do spec-wave',
86
+ message: plano.message,
87
+ causa: plano.causa,
88
+ trigger: label,
89
+ runUrl: actionsRunUrl(env),
90
+ issueNumber: String(issue),
91
+ }),
92
+ });
93
+ console.log(`Falha comentada na issue #${issue} (causa: ${plano.causa.kind}).`);
94
+ return { commented: true, kind: plano.causa.kind };
95
+ } catch (err) {
96
+ console.warn(`⚠️ Não consegui comentar a falha na issue #${issue}: ${err.message}`);
97
+ return { commented: false, error: err.message };
98
+ }
99
+ }
@@ -0,0 +1,91 @@
1
+ // `spec-wave retry <issue>` — dispara de novo a etapa atual de uma issue.
2
+ //
3
+ // `gh run rerun` não serve: ele reexecuta o COMMIT ORIGINAL do run, então
4
+ // correções já mergeadas (um override de prompt, um workflow atualizado) ficam
5
+ // de fora — foi o que aconteceu no semseguro. O gatilho do fluxo é a label, e o
6
+ // evento `labeled` só sai quando a label ENTRA: com ela ainda aplicada (falha
7
+ // antes do comando, que é quem a remove), reaplicar não faz nada. Aqui a label
8
+ // sai e volta, e o run novo pega o estado atual da branch default.
9
+ //
10
+ // Recusa no Actions: label aplicada com o GITHUB_TOKEN não dispara workflow
11
+ // (regra do GitHub contra recursão), então o retry "funcionaria" sem efeito.
12
+ // Recusa no modo local: ali as labels não disparam nada — o caminho é `run`.
13
+
14
+ import chalk from 'chalk';
15
+
16
+ import { resolveToken } from '../api/auth.mjs';
17
+ import { LABEL_DECOMPOSE_APPLY, labelNames } from '../config.mjs';
18
+ import { configuredMode } from '../lib/execution-mode.mjs';
19
+ import { isActionsRun, resolveFlowContext } from '../lib/flow-run.mjs';
20
+ import { STEPS } from '../lib/next-step.mjs';
21
+ import { requireTracker } from '../ports/index.mjs';
22
+
23
+ export const RETRY_TRIGGERS = [...new Set(Object.values(STEPS).map(s => s.trigger).filter(Boolean))];
24
+
25
+ /**
26
+ * Qual label reaplicar (função PURA).
27
+ *
28
+ * @param {object} p
29
+ * @param {string[]} p.labels labels atuais da issue
30
+ * @param {string|null} [p.label] label pedida explicitamente
31
+ * @param {boolean} [p.force] aceita o `decompose-apply`
32
+ * @returns {{label: string|null, present: boolean, error: string|null}}
33
+ */
34
+ export function planRetry({ labels = [], label = null, force = false }) {
35
+ const presentes = labels.filter(l => RETRY_TRIGGERS.includes(l));
36
+ let alvo = label;
37
+ if (alvo && !RETRY_TRIGGERS.includes(alvo)) {
38
+ return { label: null, present: false, error: `"${alvo}" não é label de gatilho. Use uma de: ${RETRY_TRIGGERS.join(', ')}.` };
39
+ }
40
+ if (!alvo) {
41
+ if (presentes.length > 1) {
42
+ return { label: null, present: false, error: `A issue tem ${presentes.length} labels de gatilho (${presentes.join(', ')}) — escolha com --label.` };
43
+ }
44
+ if (presentes.length === 0) {
45
+ return {
46
+ label: null, present: false,
47
+ error: 'A issue não tem label de gatilho aplicada (o comando que falhou a removeu). ' +
48
+ `Diga qual etapa repetir com --label: ${RETRY_TRIGGERS.join(', ')}.`,
49
+ };
50
+ }
51
+ alvo = presentes[0];
52
+ }
53
+ if (alvo === LABEL_DECOMPOSE_APPLY && !force) {
54
+ return {
55
+ label: null, present: false,
56
+ error: `\`${LABEL_DECOMPOSE_APPLY}\` cria issues: se o run anterior criou parte delas e o guard de ` +
57
+ 'idempotência não pegou, repetir DUPLICA. Confira as sub-issues e rode de novo com --force.',
58
+ };
59
+ }
60
+ return { label: alvo, present: labels.includes(alvo), error: null };
61
+ }
62
+
63
+ /**
64
+ * @param {string|number} issue
65
+ * @param {{label?: string, force?: boolean, deps?: object}} [options]
66
+ */
67
+ export async function retry(issue, { label = null, force = false, deps = {} } = {}) {
68
+ if (isActionsRun()) {
69
+ throw new Error('`spec-wave retry` não roda no GitHub Actions: label aplicada pelo GITHUB_TOKEN não dispara workflow.');
70
+ }
71
+ const { owner, repo, config } = resolveFlowContext({ command: 'retry' });
72
+ if (configuredMode(config) === 'local') {
73
+ throw new Error(`Modo local: as labels não disparam workflow. Use \`spec-wave run ${issue}\`.`);
74
+ }
75
+ const token = await resolveToken();
76
+ const tracker = await requireTracker({ token, owner, repo, deps });
77
+ const ref = { key: String(issue) };
78
+ const item = await tracker.getWorkItem({ ref });
79
+
80
+ const plano = planRetry({ labels: labelNames(item), label, force });
81
+ if (plano.error) throw new Error(`#${issue}: ${plano.error}`);
82
+
83
+ // Sai e volta: é a ENTRADA da label que emite `labeled`.
84
+ if (plano.present) await tracker.removeTag({ ref, tag: plano.label });
85
+ await tracker.addTag({ ref, tag: plano.label });
86
+ console.log(
87
+ `${chalk.green('✓')} #${issue}: \`${plano.label}\` ${plano.present ? 'removida e reaplicada' : 'aplicada'} — ` +
88
+ `o workflow roda sobre o estado atual da branch default de ${owner}/${repo}.`
89
+ );
90
+ return { label: plano.label };
91
+ }
@@ -16,6 +16,7 @@ import { detectIssueType } from '../lib/issue-type.mjs';
16
16
  import { openTracker, advanceToStage, setProgress } from '../lib/board.mjs';
17
17
  import { resolveHubContext } from '../lib/project-root.mjs';
18
18
  import { requireTracker } from '../ports/index.mjs';
19
+ import { emitProgress } from '../lib/progress-events.mjs';
19
20
  import {
20
21
  CONFIG_FILE, STAGE_DEVELOPMENT, STAGE_DONE,
21
22
  PROGRESS_IN_PROGRESS, PROGRESS_DONE,
@@ -164,6 +165,10 @@ export async function task({ action, issue: issueArg, deps = {} }) {
164
165
  }
165
166
  }
166
167
 
168
+ // Sob o spec-wave-agent: avisa que a Task terminou (barra de progresso da
169
+ // tela Development). Sem SPEC_WAVE_STREAM_DIR, não faz nada.
170
+ if (action === 'done') emitProgress({ event: 'task_done', task: issueNumber });
171
+
167
172
  p.outro(
168
173
  action === 'start'
169
174
  ? `${chalk.green('✓')} Task #${issueNumber} em andamento. Ao concluir: spec-wave task done ${issueNumber}`
@@ -333,6 +333,62 @@ async function applyLabels(token, owner, repo, labelDiff, forceLabels = false) {
333
333
  return done;
334
334
  }
335
335
 
336
+ /**
337
+ * O config sem o que o próprio `update` regrava (função PURA). `null` quando
338
+ * não é JSON — aí quem chama compara o texto cru.
339
+ */
340
+ function configSemVersao(raw) {
341
+ try {
342
+ const { version: _v, ...resto } = JSON.parse(raw);
343
+ return JSON.stringify(resto);
344
+ } catch {
345
+ return null;
346
+ }
347
+ }
348
+
349
+ /**
350
+ * PRs abertos contra `base` que MEXEM no `.spec-wave.json`. Só usa operações
351
+ * da porta (listar PRs, ler arquivo numa ref, comparar branches); best-effort:
352
+ * qualquer falha vira lista vazia, e o teto evita pagar uma leitura por PR num
353
+ * repositório com dezenas abertos.
354
+ *
355
+ * "O config da head difere do da PONTA da base" não basta: toda branch apenas
356
+ * ATRASADA difere, porque cada `update` regrava `version` na base — e o aviso
357
+ * listaria quase todo PR antigo. A porta não expõe o merge-base nem os
358
+ * arquivos do PR, então a decisão sai do `compare`:
359
+ * • `ahead` — a head contém a ponta da base; diferença é mudança do PR. Exato.
360
+ * • `diverged` (ou comparação indisponível) — a diferença pode ser só atraso.
361
+ * Conta apenas o que difere ALÉM de `version`, o campo que o `update`
362
+ * regrava. Perde o PR atrasado que só mexe em `version`; em troca, não
363
+ * acusa todo PR antigo.
364
+ * • `behind`/`identical` — a head não tem commit próprio: não mexe em nada.
365
+ *
366
+ * @returns {Promise<Array<{number: string, headRef: string}>>}
367
+ */
368
+ export async function openPrsTouchingConfig({ scm, base, baseContent, branch, limit = 20 }) {
369
+ try {
370
+ const abertos = (await scm.listOpenPullRequests())
371
+ .filter(pr => pr.headRef && pr.headRef !== branch && (!pr.baseRef || pr.baseRef === base))
372
+ .slice(0, limit);
373
+ const semVersaoDaBase = configSemVersao(baseContent);
374
+ // Em paralelo: são leituras independentes, e o teto (`limit`) já limita o
375
+ // leque. `Promise.all` preserva a ordem da listagem.
376
+ const mexe = await Promise.all(abertos.map(async (pr) => {
377
+ const conteudo = await scm.readFile({ path: CONFIG_FILE, ref: pr.headRef }).catch(() => null);
378
+ if (conteudo == null || conteudo === baseContent) return false;
379
+ // `async` em volta: um `compare` que lance SINCRONAMENTE não passaria pelo `.catch`.
380
+ const status = await (async () => scm.compare({ base, head: pr.headRef }))().catch(() => null);
381
+ if (status === 'ahead') return true;
382
+ if (status === 'behind' || status === 'identical') return false;
383
+ const semVersao = configSemVersao(conteudo);
384
+ return semVersao == null || semVersaoDaBase == null || semVersao !== semVersaoDaBase;
385
+ }));
386
+ return abertos.filter((_, i) => mexe[i]).map(pr => ({ number: pr.number, headRef: pr.headRef }));
387
+ } catch {
388
+ return [];
389
+ }
390
+ }
391
+
336
392
  export async function update(options = {}) {
337
393
  p.intro(chalk.bold(`spec-wave update (CLI v${CLI_VERSION})`));
338
394
 
@@ -483,6 +539,20 @@ export async function update(options = {}) {
483
539
  );
484
540
  prMode = false;
485
541
  }
542
+ // Outro PR aberto mexendo no .spec-wave.json: as linhas de `version` e de
543
+ // `owner` são adjacentes, e os dois PRs conflitam no merge (caso real).
544
+ if (prMode) {
545
+ const outros = await openPrsTouchingConfig({
546
+ scm: await scmDe(tk, owner, repo), base, baseContent: remoteConfigRaw, branch,
547
+ });
548
+ if (outros.length > 0) {
549
+ p.log.warn(
550
+ `PR(s) aberto(s) que também alteram o ${CONFIG_FILE}: ` +
551
+ `${outros.map(pr => `#${pr.number} (${pr.headRef})`).join(', ')}. ` +
552
+ 'Mergeie esse(s) antes — ou espere conflito no merge deste.'
553
+ );
554
+ }
555
+ }
486
556
  }
487
557
 
488
558
  // 2d) Skill: a BASE versiona alguma destas cópias?
package/src/config.mjs CHANGED
@@ -69,16 +69,16 @@ export const MODEL_LABEL_PREFIX = 'spec-wave:model:';
69
69
  // obrigar cada projeto a inventar a própria nomenclatura.
70
70
  //
71
71
  // O mapa é POR BACKEND, não por provider, porque o que ele distingue é o
72
- // formato do id: a OpenRouter usa slug com "/" (anthropic/claude-opus-5) e a
73
- // Anthropic usa o id nu (claude-opus-5). Sugerir o formato errado geraria
72
+ // formato do id: a OpenRouter usa slug com "/" (anthropic/claude-opus-5.5) e a
73
+ // Anthropic usa o id nu (claude-opus-5-5). Sugerir o formato errado geraria
74
74
  // exatamente o aviso de "apelido com formato incompatível" que o doctor emite
75
75
  // na linha seguinte. `anthropic` e `claude-oauth` compartilham o mesmo mapa
76
76
  // porque compartilham o backend.
77
77
  export const RECOMMENDED_MODEL_ALIASES = {
78
78
  openrouter: {
79
- opus: 'anthropic/claude-opus-5',
80
- sonnet: 'anthropic/claude-sonnet-5',
81
- haiku: 'anthropic/claude-haiku-4.5',
79
+ opus: 'anthropic/claude-opus-5.5',
80
+ sonnet: 'anthropic/claude-sonnet-5.5',
81
+ haiku: 'anthropic/claude-haiku-5.5',
82
82
  glm: 'z-ai/glm-5.2',
83
83
  'kimi-k3': 'moonshotai/kimi-k3',
84
84
  'gpt-sol': 'openai/gpt-5.6-sol',
@@ -86,9 +86,9 @@ export const RECOMMENDED_MODEL_ALIASES = {
86
86
  },
87
87
  // Só os modelos da própria Anthropic — os demais não existem nessa API.
88
88
  anthropic: {
89
- opus: 'claude-opus-5',
90
- sonnet: 'claude-sonnet-5',
91
- haiku: 'claude-haiku-4-5',
89
+ opus: 'claude-opus-5-5',
90
+ sonnet: 'claude-sonnet-5-5',
91
+ haiku: 'claude-haiku-5-5',
92
92
  },
93
93
  };
94
94
 
@@ -0,0 +1,89 @@
1
+ // Caminhos de arquivo citados no corpo de uma issue que NÃO existem no repo.
2
+ //
3
+ // Caso real (Nuviumdigital/semseguro): todas as issues citavam
4
+ // "Fonte: docs/sem-seguro.md", e o arquivo nunca foi commitado. O modelo
5
+ // recebia a referência, procurava, não achava — e escrevia a spec sem a fonte,
6
+ // sem que ninguém soubesse. O preflight avisa antes de a rodada pagar modelo.
7
+
8
+ import { existsSync } from 'node:fs';
9
+ import path from 'node:path';
10
+
11
+ // Caminho relativo com ao menos um diretório OU precedido de "Fonte:", sempre
12
+ // com extensão. URL fica de fora (o lookbehind barra `://` e domínio).
13
+ //
14
+ // A extensão COMEÇA por letra: `1.0/2.0` e "Fonte: 14.5px" não são arquivos.
15
+ const EXT = '[A-Za-z][A-Za-z0-9]{0,5}';
16
+ const COM_DIR = new RegExp(`(?<![\\w/:.@-])((?:\\.\\/)?[\\w.-]+(?:\\/[\\w.-]+)+\\.${EXT})(?![\\w/])`, 'g');
17
+ const FONTE = new RegExp(`\\bfontes?\\s*:\\s*\`?((?:\\.\\/)?[\\w./-]+\\.${EXT})\`?(?![\\w/])`, 'gi');
18
+
19
+ // Segmento de DIRETÓRIO com cara de arquivo ou de domínio (`Node.js`,
20
+ // `api.example.com`): o token é "Node.js/React.js" ou uma URL sem esquema, não
21
+ // um caminho. `.github` e `v1.2` passam — começam por ponto ou têm "extensão"
22
+ // numérica. O custo é não avisar sobre um `conf.d/x.md`; o viés é deliberado:
23
+ // aviso falso muda o veredito do preflight, aviso que faltou não muda nada.
24
+ const DIR_COM_EXTENSAO = /^[\w-][\w.-]*\.[A-Za-z]{2,}$/;
25
+
26
+ /** O token tem forma de caminho de arquivo do repositório? (função PURA) */
27
+ function pareceCaminho(p) {
28
+ const partes = p.split('/');
29
+ const arquivo = partes.pop();
30
+ if (partes.some(d => DIR_COM_EXTENSAO.test(d))) return false;
31
+ // Nome sem letra antes da extensão é medida ou versão: `14.5px`, `1.2.x`.
32
+ return /[A-Za-z_]/.test(arquivo.slice(0, arquivo.lastIndexOf('.')));
33
+ }
34
+
35
+ /**
36
+ * Caminhos citados (função PURA), sem repetição, na ordem do texto.
37
+ *
38
+ * @param {string} body
39
+ * @returns {string[]}
40
+ */
41
+ export function citedPaths(body = '') {
42
+ const texto = String(body || '').replace(/https?:\/\/\S+/g, ' ');
43
+ const achados = [];
44
+ const add = (p) => {
45
+ const limpo = p.replace(/^\.\//, '').replace(/[.,;:]+$/, '');
46
+ if (pareceCaminho(limpo) && !achados.includes(limpo)) achados.push(limpo);
47
+ };
48
+ for (const m of texto.matchAll(FONTE)) add(m[1]);
49
+ for (const m of texto.matchAll(COM_DIR)) add(m[1]);
50
+ return achados;
51
+ }
52
+
53
+ /**
54
+ * Caminhos citados que não existem sob `root`.
55
+ *
56
+ * `multiRepo`: o hub tem repositórios de CÓDIGO vinculados, e a Feature pode
57
+ * citar um arquivo que mora num deles (`src/a/b.kt`) — que daqui não dá para
58
+ * conferir. Aí só é "ausente" o caminho cujo diretório de topo EXISTE no hub
59
+ * (ou que fica na raiz dele): `docs/sem-seguro.md` com `docs/` presente é falta
60
+ * de verdade; `src/…` sem `src/` no hub é, quase sempre, do repo de código.
61
+ *
62
+ * @param {string} body
63
+ * @param {string} root
64
+ * @param {(abs: string) => boolean} [exists]
65
+ * @param {{multiRepo?: boolean}} [opts]
66
+ * @returns {string[]}
67
+ */
68
+ export function missingCitedPaths(body, root, exists = existsSync, { multiRepo = false } = {}) {
69
+ const base = root || process.cwd();
70
+ return citedPaths(body).filter((rel) => {
71
+ if (exists(path.join(base, rel))) return false;
72
+ if (!multiRepo || !rel.includes('/')) return true;
73
+ return exists(path.join(base, rel.split('/')[0]));
74
+ });
75
+ }
76
+
77
+ /**
78
+ * Agrupa por caminho (função PURA): `{ 'docs/x.md': [37, 38] }`.
79
+ *
80
+ * @param {Array<{number: number, missing: string[]}>} porIssue
81
+ * @returns {Record<string, number[]>}
82
+ */
83
+ export function groupMissingPaths(porIssue = []) {
84
+ const out = {};
85
+ for (const { number, missing } of porIssue) {
86
+ for (const p of missing || []) (out[p] ||= []).push(number);
87
+ }
88
+ return out;
89
+ }
@@ -245,8 +245,10 @@ export { TruncatedOutputError, MaxTurnsError, isTruncationReason };
245
245
  // da Anthropic quebraria em toda requisição — daí a checagem no modelo, não no
246
246
  // provider. Aceita tanto o id primário (`claude-opus-4-8`) quanto o slug da
247
247
  // OpenRouter (`anthropic/claude-opus-4.8`).
248
+ // Haiku 5.5 também (o Haiku 4.5 ainda aceita). `opus-5`/`sonnet-5`/`fable-5`
249
+ // cobrem as 5.5 e 5.1 por prefixo.
248
250
  const MODELS_WITHOUT_SAMPLING_PARAMS =
249
- /claude-(?:opus-(?:4[.-]7|4[.-]8|5)|sonnet-5|fable-5|mythos-5)/i;
251
+ /claude-(?:opus-(?:4[.-]7|4[.-]8|5)|sonnet-5|haiku-5|fable-5|mythos-5)/i;
250
252
 
251
253
  /** O modelo ainda aceita `temperature`? (função PURA) */
252
254
  export function supportsTemperature(model) {
@@ -258,7 +260,7 @@ export function supportsTemperature(model) {
258
260
  // devolve 400. Sem strict, o tool_choice forçado ainda garante um bloco tool_use
259
261
  // com input JSON; quem fecha o contrato é o validador do schema.
260
262
  const MODELS_WITH_STRICT_SCHEMA =
261
- /claude-(?:fable-5|mythos-5|opus-5|opus-4[.-](?:1|5|8)|sonnet-5|haiku-4[.-]5)/i;
263
+ /claude-(?:fable-5|mythos-5|opus-5|opus-4[.-](?:1|5|8)|sonnet-5|haiku-4[.-]5|haiku-5)/i;
262
264
 
263
265
  /** O modelo aceita `strict: true` na definição de tool? (função PURA) */
264
266
  export function supportsStrictSchema(model) {