@spec-wave/cli 0.1.0 → 0.2.1

package/bin/spec-wave.mjs

@@ -22,6 +22,8 @@ program
   .option('--skip-project', 'Pula a criação do GitHub Project (use se já foi criado)')
   .option('--skip-labels', 'Pula a criação das labels')
   .option('--skip-files', 'Pula a criação dos arquivos de workflow')
+  .option('--provider <provider>', 'Provider de IA dos workflows: anthropic ou openrouter')
+  .option('--model <model>', 'Modelo de IA usado pelos workflows (ex.: anthropic/claude-3.7-sonnet)')
   .action(async (options) => {
     const { init } = await import('../src/commands/init.mjs');
     await init(options);
@@ -122,4 +124,15 @@ program
     await decompose(options).catch(err => { console.error(err.message); process.exit(1); });
   });
 
+program
+  .command('implement')
+  .description('Aciona o spec-kit implement para uma Story (todas as tasks) ou uma Task')
+  .argument('<issue>', 'Número da issue (Story ou Task), ex.: 12 ou #12')
+  .option('--feature-dir <path>', 'Caminho do docs/features/<slug> (sobrescreve a resolução automática)')
+  .option('--dry-run', 'Monta o contexto e imprime o comando sem executar o spec-kit')
+  .action(async (issue, options) => {
+    const { implement } = await import('../src/commands/implement.mjs');
+    await implement({ issue, ...options }).catch(err => { console.error(err.message); process.exit(1); });
+  });
+
 program.parse();

package/package.json

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

package/src/api/github-graphql.mjs

@@ -183,6 +183,56 @@ export async function addSubIssue(token, parentIssueId, childIssueId) {
   `, { issueId: parentIssueId, subIssueId: childIssueId });
 }
 
+// Lista as sub-issues de uma issue (pelo node id da issue pai). Retorna
+// [{ number, title, body, nodeId, labels: [nome...] }]. Usado pelo comando
+// `implement` para coletar as Tasks de uma Story.
+export async function listSubIssues(token, issueNodeId) {
+  const client = makeClient(token);
+  const result = await client(`
+    query SubIssues($id: ID!) {
+      node(id: $id) {
+        ... on Issue {
+          subIssues(first: 100) {
+            nodes {
+              id
+              number
+              title
+              body
+              labels(first: 20) { nodes { name } }
+            }
+          }
+        }
+      }
+    }
+  `, { id: issueNodeId });
+  const nodes = result.node?.subIssues?.nodes || [];
+  return nodes.map(n => ({
+    number: n.number,
+    title: n.title,
+    body: n.body || '',
+    nodeId: n.id,
+    labels: (n.labels?.nodes || []).map(l => l.name),
+  }));
+}
+
+// Lê o parent (issue pai) de uma sub-issue. Retorna { number, title, nodeId }
+// ou null se a issue não tiver pai. Usado para subir a cadeia Task→Story→Feature.
+export async function getIssueParent(token, issueNodeId) {
+  const client = makeClient(token);
+  const result = await client(`
+    query IssueParent($id: ID!) {
+      node(id: $id) {
+        ... on Issue {
+          parent { id number title }
+        }
+      }
+    }
+  `, { id: issueNodeId });
+  const parent = result.node?.parent;
+  if (!parent) return null;
+  return { number: parent.number, title: parent.title, nodeId: parent.id };
+}
+
 // Define o valor de um campo SINGLE_SELECT para um item do Project.
 export async function setItemSingleSelect(token, projectId, itemId, fieldId, optionId) {
   const client = makeClient(token);

package/src/commands/decompose.mjs

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { execFileSync } from 'node:child_process';
 import { resolveToken } from '../api/auth.mjs';
-import { getIssue, removeLabel, commentOnIssue } from '../api/github-rest.mjs';
+import { getIssue, createIssue, removeLabel, commentOnIssue } from '../api/github-rest.mjs';
+import { addSubIssue } from '../api/github-graphql.mjs';
 import { generateDocument } from '../lib/claude.mjs';
 import { slugify } from '../lib/slugify.mjs';
 
@@ -12,11 +12,12 @@ Responda APENAS com JSON válido neste formato:
 {
   "stories": [
     {
-      "title": "[STORY] Título da story no formato 'Como <perfil>, quero <objetivo>, para <benefício>'",
-      "body": "Descrição da story com contexto e critérios de aceite relevantes",
+      "title": "Título curto da story (apenas a parte 'quero', sem prefixo)",
+      "userStory": "Como <perfil>, quero <objetivo>, para <benefício>",
+      "body": "Descrição complementar da story com contexto e critérios de aceite relevantes",
       "tasks": [
         {
-          "title": "[TASK] Título técnico da task",
+          "title": "Título técnico curto da task (sem prefixo)",
           "body": "Descrição técnica detalhada"
         }
       ]
@@ -25,9 +26,11 @@ Responda APENAS com JSON válido neste formato:
 }
 
 Regras:
+- "title" deve ser CURTO (máx. ~60 caracteres): apenas a parte "quero" da user story, sem o "Como" nem o "para", e sem prefixo. Ex.: "visualizar meus repositórios em layout responsivo"
+- "userStory" deve trazer a user story completa no formato "Como <perfil>, quero <objetivo>, para <benefício>"
+- "body" é texto complementar (contexto, critérios de aceite); não repita o título
 - Cada Story deve ter 2–5 Tasks associadas
-- Stories devem seguir o formato de User Story
-- Tasks devem ser atividades técnicas concretas
+- Tasks devem ser atividades técnicas concretas, com "title" curto e "body" detalhado
 - Gere entre 3 e 7 Stories por Feature`;
 
 export async function decompose({ issueNumber }) {
@@ -75,26 +78,41 @@ export async function decompose({ issueNumber }) {
     decomposition = JSON.parse(jsonMatch[0]);
   }
 
+  // node id da Feature — necessário para vincular as stories como sub-issues.
+  const featureNodeId = issue.node_id;
+
   const created = [];
 
   for (const story of decomposition.stories) {
     console.log(`Criando story: ${story.title}`);
-    const storyOutput = execFileSync(
-      'gh',
-      ['issue', 'create', '--title', story.title, '--body', story.body, '--label', '[STORY]'],
-      { encoding: 'utf-8' }
-    ).trim();
-    const storyUrl = storyOutput.trim();
-    created.push({ type: 'story', title: story.title, url: storyUrl });
+    const storyTitle = `[STORY] ${story.title}`;
+    // Corpo: user story completa (Como/quero/para) + texto complementar.
+    const storyBody = [story.userStory, story.body]
+      .map(s => (s || '').trim())
+      .filter(Boolean)
+      .join('\n\n') || '_(sem descrição)_';
+    const createdStory = await createIssue(token, owner, repo, storyTitle, storyBody, ['[STORY]']);
+    created.push({ type: 'story', title: storyTitle, url: createdStory.url });
+
+    // Vincula a story como sub-issue da Feature (relação nativa do GitHub).
+    try {
+      await addSubIssue(token, featureNodeId, createdStory.nodeId);
+    } catch (err) {
+      console.warn(`  Story #${createdStory.number} criada, mas falhou ao vincular à Feature: ${err.message}`);
+    }
 
     for (const task of story.tasks || []) {
       console.log(`  Criando task: ${task.title}`);
-      const taskBody = `${task.body}\n\n_Story pai: ${storyUrl}_`;
-      execFileSync(
-        'gh',
-        ['issue', 'create', '--title', task.title, '--body', taskBody, '--label', '[TASK]'],
-        { encoding: 'utf-8' }
-      );
+      const taskTitle = `[TASK] ${task.title}`;
+      const taskBody = `${task.body}\n\n_Story pai: ${createdStory.url}_`;
+      const createdTask = await createIssue(token, owner, repo, taskTitle, taskBody, ['[TASK]']);
+
+      // Vincula a task como sub-issue da Story.
+      try {
+        await addSubIssue(token, createdStory.nodeId, createdTask.nodeId);
+      } catch (err) {
+        console.warn(`    Task #${createdTask.number} criada, mas falhou ao vincular à Story: ${err.message}`);
+      }
     }
   }
 

package/src/commands/implement.mjs

@@ -0,0 +1,222 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import { resolveToken } from '../api/auth.mjs';
+import { CONFIG_FILE } from '../config.mjs';
+import { getIssue } from '../api/github-rest.mjs';
+import { listSubIssues, getIssueParent } from '../api/github-graphql.mjs';
+import { detectIssueType } from '../lib/issue-type.mjs';
+import { slugify } from '../lib/slugify.mjs';
+
+// Diretório onde montamos o arquivo de contexto entregue ao spec-kit.
+const WORK_DIR = '.spec-wave';
+
+// Sobe a cadeia de pais (Task → Story → Feature) até achar uma issue do tipo
+// "Feature" e devolve seu título (para resolver docs/features/<slug>). Limita a
+// profundidade para evitar loops em dados inconsistentes.
+async function resolveFeatureTitle(token, startNodeId) {
+  let current = startNodeId;
+  for (let depth = 0; depth < 5 && current; depth++) {
+    const parent = await getIssueParent(token, current);
+    if (!parent) return null;
+    if (detectIssueType({ title: parent.title }) === 'Feature') return parent.title;
+    current = parent.nodeId;
+  }
+  return null;
+}
+
+// Lê spec.md/plan.md de um docs/features/<slug> se existirem.
+function readSpecPlan(featureDir) {
+  const specPath = path.join(featureDir, 'spec.md');
+  const planPath = path.join(featureDir, 'plan.md');
+  return {
+    specPath,
+    planPath,
+    spec: existsSync(specPath) ? readFileSync(specPath, 'utf-8') : null,
+    plan: existsSync(planPath) ? readFileSync(planPath, 'utf-8') : null,
+  };
+}
+
+// Monta o markdown de contexto que será entregue ao spec-kit implement.
+function buildContext({ type, issue, tasks, spec, plan, specPath, planPath }) {
+  const lines = [];
+  lines.push(`# Contexto de implementação — ${type} #${issue.number}`);
+  lines.push('');
+  lines.push(`**${type}:** ${issue.title}`);
+  if (issue.body && issue.body.trim()) {
+    lines.push('');
+    lines.push(issue.body.trim());
+  }
+
+  lines.push('');
+  lines.push(`## Tasks a implementar (${tasks.length})`);
+  for (const t of tasks) {
+    lines.push('');
+    lines.push(`### #${t.number} ${t.title}`);
+    if (t.body && t.body.trim()) lines.push(t.body.trim());
+  }
+
+  if (spec) {
+    lines.push('');
+    lines.push(`## spec.md (${specPath})`);
+    lines.push(spec.trim());
+  }
+  if (plan) {
+    lines.push('');
+    lines.push(`## plan.md (${planPath})`);
+    lines.push(plan.trim());
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+// Substitui os placeholders do template de comando do spec-kit.
+function renderCommand(template, vars) {
+  return template.replace(/\{(\w+)\}/g, (m, key) => (key in vars ? vars[key] : m));
+}
+
+export async function implement({ issue: issueArg, featureDir: featureDirOpt, dryRun }) {
+  const issueNumber = parseInt(String(issueArg).replace('#', ''), 10);
+  if (!Number.isInteger(issueNumber)) {
+    p.log.error(`Issue inválida: "${issueArg}". Use o número da issue, ex.: 12 ou #12.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 1. Config local (.spec-wave.json) — owner/repo e bloco opcional specKit.
+  const configPath = path.join(process.cwd(), CONFIG_FILE);
+  if (!existsSync(configPath)) {
+    p.log.error(`Repositório não inicializado (sem ${CONFIG_FILE}). Rode \`spec-wave init\` primeiro.`);
+    process.exitCode = 1;
+    return;
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch (err) {
+    p.log.error(`${CONFIG_FILE} corrompido: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  const { owner, repo } = config;
+  if (!owner || !repo) {
+    p.log.error(`${CONFIG_FILE} não contém owner/repo. Rode \`spec-wave init\` novamente.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  let token;
+  try {
+    token = await resolveToken();
+  } catch (err) {
+    p.log.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+
+  p.intro(chalk.bold(`spec-wave implement #${issueNumber}`));
+
+  // 2. Lê a issue alvo.
+  let issue;
+  try {
+    issue = await getIssue(token, owner, repo, issueNumber);
+  } catch (err) {
+    p.log.error(`Não foi possível ler a issue #${issueNumber}: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 3. Detecta o tipo e monta a lista de tasks.
+  const type = detectIssueType(issue);
+  let tasks;
+  if (type === 'Story') {
+    const subs = await listSubIssues(token, issue.node_id);
+    tasks = subs.filter(s => detectIssueType({ title: s.title, labels: s.labels }) === 'Task');
+    if (tasks.length === 0) {
+      p.log.error(`Story #${issueNumber} não tem Tasks (sub-issues) para implementar.`);
+      process.exitCode = 1;
+      return;
+    }
+    p.log.info(`Story com ${tasks.length} task(s): ${tasks.map(t => `#${t.number}`).join(', ')}`);
+  } else if (type === 'Task') {
+    tasks = [{ number: issue.number, title: issue.title, body: issue.body || '' }];
+    p.log.info(`Task única #${issueNumber}.`);
+  } else {
+    p.log.error(
+      `implement só aceita Story ou Task. Issue #${issueNumber} é do tipo ${type || 'desconhecido'}.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  // 4. Resolve spec.md/plan.md da Feature (enriquecimento opcional).
+  let featureDir = featureDirOpt;
+  if (!featureDir) {
+    const featureTitle = await resolveFeatureTitle(token, issue.node_id);
+    if (featureTitle) featureDir = path.join('docs', 'features', slugify(featureTitle));
+  }
+  let specPlan = { spec: null, plan: null, specPath: null, planPath: null };
+  if (featureDir && existsSync(featureDir)) {
+    specPlan = readSpecPlan(featureDir);
+  } else if (featureDir) {
+    p.log.warn(`Diretório da feature não encontrado (${featureDir}); seguindo só com as tasks.`);
+  } else {
+    p.log.warn('Não foi possível resolver a Feature; seguindo só com as tasks (use --feature-dir).');
+  }
+
+  // 5. Monta e grava o arquivo de contexto.
+  const context = buildContext({ type, issue, tasks, ...specPlan });
+  mkdirSync(WORK_DIR, { recursive: true });
+  const tasksFile = path.join(WORK_DIR, `implement-${issueNumber}.md`);
+  writeFileSync(tasksFile, context);
+  p.log.success(`Contexto montado em ${chalk.cyan(tasksFile)}.`);
+
+  // 6. Aciona o spec-kit (comando configurável).
+  const template = process.env.SPEC_WAVE_IMPLEMENT_CMD || config.specKit?.command;
+  const vars = {
+    tasksFile,
+    specFile: specPlan.specPath || '',
+    planFile: specPlan.planPath || '',
+    issue: String(issueNumber),
+    type,
+    title: issue.title,
+  };
+
+  if (!template) {
+    p.log.warn('Comando do spec-kit não configurado.');
+    p.note(
+      `Configure em ${CONFIG_FILE}:\n` +
+      `  "specKit": { "command": "<comando do spec-kit com placeholders>" }\n` +
+      'ou defina a env SPEC_WAVE_IMPLEMENT_CMD.\n\n' +
+      'Placeholders: {tasksFile} {specFile} {planFile} {issue} {type} {title}',
+      'Como acionar o spec-kit'
+    );
+    p.outro(`Contexto pronto em ${tasksFile}. Acione o spec-kit manualmente com esse arquivo.`);
+    return;
+  }
+
+  const command = renderCommand(template, vars);
+
+  if (dryRun) {
+    p.note(command, 'Comando que seria executado (--dry-run)');
+    p.outro(`Dry-run: nada executado. Contexto em ${tasksFile}.`);
+    return;
+  }
+
+  p.log.step(`Executando: ${chalk.dim(command)}`);
+  try {
+    execSync(command, { stdio: 'inherit' });
+  } catch (err) {
+    p.log.error(`spec-kit implement falhou: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  p.outro(
+    `${chalk.green('✓')} Implementação acionada para ${type} #${issueNumber}.\n` +
+    '  Próximo: revise as mudanças, abra o PR e mova o card para 👀 Code Review.'
+  );
+}

package/src/commands/info.mjs

@@ -45,6 +45,7 @@ export async function info(options = {}) {
     `${chalk.dim('Repositório:')} ${config.owner ?? '?'}/${config.repo ?? '?'}\n` +
     `${chalk.dim('Project:')}     ${config.project?.title ?? '—'}\n` +
     `${chalk.dim('URL:')}         ${config.project?.url ? chalk.cyan(config.project.url) : '—'}\n` +
+    `${chalk.dim('IA:')}          ${config.ai ? `${config.ai.provider} · ${config.ai.model}` : '—'}\n` +
     `${chalk.dim('Versão CLI:')}  ${config.version ?? '?'}\n` +
     `${chalk.dim('Criado em:')}   ${config.initializedAt ?? '?'}`,
     'Configuração'

package/src/commands/init.mjs

@@ -9,7 +9,7 @@ import { setupProject } from '../setup/project.mjs';
 import { setupLabels } from '../setup/labels.mjs';
 import { setupFiles } from '../setup/files.mjs';
 import { upsertFile } from '../api/github-rest.mjs';
-import { CONFIG_FILE } from '../config.mjs';
+import { CONFIG_FILE, AI_PROVIDERS, getProvider, DEFAULT_PROVIDER } from '../config.mjs';
 
 const __dir = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.join(__dir, '..', '..', 'package.json'), 'utf-8'));
@@ -51,7 +51,7 @@ export async function init(options) {
   }
 
   // --- Wizard ou flags ---
-  let owner, repo, projectTitle;
+  let owner, repo, projectTitle, provider, model;
   if (options.repo) {
     if (!options.repo.includes('/')) {
       p.log.error('Formato inválido para --repo. Use: owner/repo');
@@ -59,16 +59,28 @@ export async function init(options) {
     }
     [owner, repo] = options.repo.split('/');
     projectTitle = options.projectTitle ?? `${repo} — Spec Wave`;
+    provider = (options.provider ?? DEFAULT_PROVIDER).toLowerCase();
+    if (!getProvider(provider)) {
+      p.log.error(
+        `Provider inválido: ${provider}. Use um de: ${AI_PROVIDERS.map(pr => pr.value).join(', ')}`
+      );
+      process.exit(1);
+    }
+    model = options.model ?? getProvider(provider).defaultModel;
     p.log.info(`Repositório: ${owner}/${repo}`);
     p.log.info(`Projeto: ${projectTitle}`);
+    p.log.info(`IA: ${getProvider(provider).label} · modelo ${model}`);
   } else {
-    ({ owner, repo, projectTitle } = await runWizard());
+    ({ owner, repo, projectTitle, provider, model } = await runWizard());
   }
 
+  const providerMeta = getProvider(provider);
+
   if (options.dryRun) {
     p.log.info(chalk.yellow('Modo dry-run: nenhuma alteração será feita.'));
     p.log.info(`  Repositório: ${owner}/${repo}`);
     p.log.info(`  Projeto: ${projectTitle}`);
+    p.log.info(`  IA: ${providerMeta.label} · modelo ${model}`);
     p.log.info('  Fases: project board → labels → workflow files');
     p.outro('Dry-run concluído.');
     return;
@@ -153,6 +165,10 @@ export async function init(options) {
         number: projectNumber ?? null,
         fields: projectFields ?? null,
       },
+      ai: {
+        provider: providerMeta.value,
+        model,
+      },
       initializedAt: new Date().toISOString(),
     };
     await upsertFile(
@@ -182,7 +198,7 @@ export async function init(options) {
     `\n${chalk.green('✓')} spec-wave configurado com sucesso!\n\n` +
     (projectUrl ? `  Projeto: ${chalk.cyan(projectUrl)}\n\n` : '') +
     `  Próximos passos:\n` +
-    `  1. Adicione ANTHROPIC_API_KEY como secret no repositório\n` +
+    `  1. Adicione ${providerMeta.secret} como secret no repositório (provider: ${providerMeta.label})\n` +
     `  2. Configure o board view para agrupar por "Etapa"\n` +
     `  3. Crie uma Feature com o prefixo [FEATURE] no título\n` +
     `  4. Use a skill spec-wave para guiar o fluxo\n\n` +

package/src/config.mjs

@@ -4,6 +4,35 @@
 // pelo comando `info` (e pela skill) para detectar se o spec-wave já foi configurado.
 export const CONFIG_FILE = '.spec-wave.json';
 
+// Providers de IA suportados pelos workflows (generate-plan/spec/decompose).
+// O provider e o modelo escolhidos no `init` são persistidos em .spec-wave.json
+// (bloco `ai`) e lidos em runtime por src/lib/claude.mjs. Cada provider declara
+// o secret do GitHub Actions de onde a chave é lida.
+export const AI_PROVIDERS = [
+  {
+    value: 'anthropic',
+    label: 'Anthropic (API direta)',
+    hint: 'Usa o secret ANTHROPIC_API_KEY',
+    secret: 'ANTHROPIC_API_KEY',
+    defaultModel: 'claude-sonnet-4-6',
+    modelHint: 'ex.: claude-sonnet-4-6, claude-opus-4-1',
+  },
+  {
+    value: 'openrouter',
+    label: 'OpenRouter (multi-modelo)',
+    hint: 'Usa o secret OPENROUTER_API_KEY',
+    secret: 'OPENROUTER_API_KEY',
+    defaultModel: 'anthropic/claude-3.7-sonnet',
+    modelHint: 'ex.: anthropic/claude-3.7-sonnet, openai/gpt-4o — veja openrouter.ai/models',
+  },
+];
+
+export const DEFAULT_PROVIDER = 'anthropic';
+
+export function getProvider(value) {
+  return AI_PROVIDERS.find(p => p.value === value);
+}
+
 export const STATUS_OPTIONS = [
   { name: '📥 Backlog',          color: 'GRAY'   },
   { name: '🎯 Priorizado',       color: 'BLUE'   },

package/src/lib/claude.mjs

@@ -1,8 +1,39 @@
 import Anthropic from '@anthropic-ai/sdk';
+import { readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_FILE, getProvider, DEFAULT_PROVIDER } from '../config.mjs';
 
-const DEFAULT_MODEL = 'claude-sonnet-4-6';
+// Resolve o provider/modelo de IA a partir do .spec-wave.json (gravado pelo init
+// e versionado no repo) com precedência para variáveis de ambiente — assim os
+// workflows usam exatamente o que foi escolhido no init, sem depender de flags.
+function resolveAi() {
+  let fileAi = {};
+  try {
+    const configPath = path.join(process.cwd(), CONFIG_FILE);
+    if (existsSync(configPath)) {
+      fileAi = JSON.parse(readFileSync(configPath, 'utf-8')).ai || {};
+    }
+  } catch {
+    // config ausente/corrompido → cai nos defaults/env
+  }
+
+  const provider = (process.env.SPEC_WAVE_PROVIDER || fileAi.provider || DEFAULT_PROVIDER).toLowerCase();
+  const meta = getProvider(provider) || getProvider(DEFAULT_PROVIDER);
+  const model = process.env.SPEC_WAVE_MODEL || fileAi.model || meta.defaultModel;
+  return { provider: meta.value, model, secret: meta.secret };
+}
 
 export async function generateDocument(systemPrompt, userContent) {
+  const ai = resolveAi();
+  console.log(`Provider de IA: ${ai.provider} · modelo: ${ai.model}`);
+
+  if (ai.provider === 'openrouter') {
+    return generateWithOpenRouter(systemPrompt, userContent, ai);
+  }
+  return generateWithAnthropic(systemPrompt, userContent, ai);
+}
+
+async function generateWithAnthropic(systemPrompt, userContent, ai) {
   const apiKey = process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
     throw new Error(
@@ -12,10 +43,8 @@ export async function generateDocument(systemPrompt, userContent) {
   }
 
   const client = new Anthropic({ apiKey });
-  const model = process.env.ANTHROPIC_MODEL || DEFAULT_MODEL;
-
   const message = await client.messages.create({
-    model,
+    model: ai.model,
     max_tokens: 4096,
     messages: [{ role: 'user', content: userContent }],
     system: systemPrompt,
@@ -23,3 +52,43 @@ export async function generateDocument(systemPrompt, userContent) {
 
   return message.content[0].text;
 }
+
+async function generateWithOpenRouter(systemPrompt, userContent, ai) {
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      'OPENROUTER_API_KEY not set.\n' +
+      'Add it as a GitHub Actions secret or set it in your environment.'
+    );
+  }
+
+  const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      'HTTP-Referer': 'https://github.com/moacsjr/spec-wave',
+      'X-Title': 'spec-wave',
+    },
+    body: JSON.stringify({
+      model: ai.model,
+      max_tokens: 4096,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userContent },
+      ],
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`OpenRouter API ${res.status}: ${body}`);
+  }
+
+  const data = await res.json();
+  const content = data?.choices?.[0]?.message?.content;
+  if (!content) {
+    throw new Error(`OpenRouter retornou resposta vazia: ${JSON.stringify(data)}`);
+  }
+  return content;
+}

package/src/lib/issue-type.mjs

@@ -0,0 +1,37 @@
+import { TYPE_LABELS } from '../config.mjs';
+
+// Mapa de prefixo de label (ex.: "[STORY]") → nome canônico do tipo ("Story").
+// Derivado de TYPE_LABELS para manter uma única fonte da verdade.
+const TAG_TO_TYPE = Object.fromEntries(
+  TYPE_LABELS.map(l => [l.name.toUpperCase(), capitalize(l.name.replace(/[[\]]/g, ''))])
+);
+
+function capitalize(s) {
+  const lower = s.toLowerCase();
+  // RFC fica em caixa alta; os demais tipos seguem Capitalizado (Story, Task...).
+  return lower === 'rfc' ? 'RFC' : lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+
+// Detecta o tipo canônico de uma issue ('Story', 'Task', 'Feature', ...) a partir
+// do prefixo do título ([STORY], [TASK], ...) com fallback nas labels. Retorna
+// null quando não é possível determinar.
+export function detectIssueType(issue) {
+  if (!issue) return null;
+
+  // 1. Prefixo do título: "[STORY] ..." → "Story".
+  const titleMatch = String(issue.title || '').match(/^\s*(\[[^\]]+\])/);
+  if (titleMatch) {
+    const type = TAG_TO_TYPE[titleMatch[1].toUpperCase()];
+    if (type) return type;
+  }
+
+  // 2. Fallback: varrer as labels da issue procurando um dos prefixos de tipo.
+  const labels = Array.isArray(issue.labels) ? issue.labels : [];
+  for (const label of labels) {
+    const name = (typeof label === 'string' ? label : label?.name) || '';
+    const type = TAG_TO_TYPE[name.toUpperCase()];
+    if (type) return type;
+  }
+
+  return null;
+}

package/src/templates/workflows/decompose.yml

@@ -26,4 +26,5 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
           GITHUB_REPOSITORY: ${{ github.repository }}

package/src/templates/workflows/generate-plan.yml

@@ -28,4 +28,5 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
           GITHUB_REPOSITORY: ${{ github.repository }}

package/src/templates/workflows/generate-spec.yml

@@ -28,4 +28,5 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
           GITHUB_REPOSITORY: ${{ github.repository }}

package/src/ui/wizard.mjs

@@ -1,5 +1,6 @@
 import * as p from '@clack/prompts';
 import { execSync } from 'node:child_process';
+import { AI_PROVIDERS, getProvider, DEFAULT_PROVIDER } from '../config.mjs';
 
 export async function runWizard() {
   p.intro('spec-wave — configuração do fluxo spec-driven');
@@ -23,6 +24,25 @@ export async function runWizard() {
           placeholder: 'Meu Projeto — Spec Wave',
         }),
 
+      provider: () =>
+        p.select({
+          message: 'Qual provider de IA os workflows devem usar?',
+          options: AI_PROVIDERS.map(pr => ({ value: pr.value, label: pr.label, hint: pr.hint })),
+          initialValue: DEFAULT_PROVIDER,
+        }),
+
+      model: ({ results }) => {
+        const pr = getProvider(results.provider);
+        return p.text({
+          message: `Qual modelo de IA os workflows devem usar? (${pr.modelHint})`,
+          defaultValue: pr.defaultModel,
+          placeholder: pr.defaultModel,
+          validate: v => {
+            if (!v || !v.trim()) return 'Informe o modelo a ser usado.';
+          },
+        });
+      },
+
       triggerStrategy: () =>
         p.select({
           message: 'Como prefere acionar os workflows automáticos?',
@@ -67,7 +87,13 @@ export async function runWizard() {
   }
 
   const [owner, repo] = answers.repo.split('/');
-  return { owner, repo, projectTitle: answers.projectTitle };
+  return {
+    owner,
+    repo,
+    projectTitle: answers.projectTitle,
+    provider: answers.provider,
+    model: answers.model.trim(),
+  };
 }
 
 function detectRepo() {