@spec-wave/cli 0.1.0

package/src/commands/feature.mjs

@@ -0,0 +1,7 @@
+import { issue } from './issue.mjs';
+
+// `feature` é um atalho de `issue --type feature`, mantido para compatibilidade
+// com a skill e o fluxo do RFC-001. Toda a lógica vive em issue.mjs.
+export async function feature(options) {
+  return issue({ ...options, type: 'feature' });
+}

package/src/commands/generate-plan.mjs

@@ -0,0 +1,71 @@
+import { execSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { resolveToken } from '../api/auth.mjs';
+import { getIssue, removeLabel, commentOnIssue } from '../api/github-rest.mjs';
+import { generateDocument } from '../lib/claude.mjs';
+import { slugify } from '../lib/slugify.mjs';
+
+const SYSTEM_PROMPT = `Você é um Tech Lead experiente. Gere um plano técnico (plan.md) completo e detalhado para a Feature descrita pelo usuário.
+
+O plano deve conter exatamente estas seções em português:
+# Frontend
+# Backend
+# Banco de dados
+# Infraestrutura
+# Segurança
+# Testes
+# Estimativa (Story Points)
+
+Para cada seção, forneça detalhes técnicos concretos e acionáveis baseados na descrição da Feature.
+A estimativa de Story Points deve usar a sequência de Fibonacci: 1, 2, 3, 5, 8, 13, 21.
+Responda APENAS com o conteúdo do plan.md, sem texto adicional.`;
+
+export async function generatePlan({ issueNumber }) {
+  const token = await resolveToken();
+  const [owner, repo] = (process.env.GITHUB_REPOSITORY || '').split('/');
+
+  if (!owner || !repo) {
+    throw new Error(
+      'GITHUB_REPOSITORY env var não definida.\n' +
+      'Este comando roda no GitHub Actions. Para testar localmente:\n' +
+      '  GITHUB_REPOSITORY=owner/repo spec-wave generate-plan --issue-number 1'
+    );
+  }
+
+  console.log(`Buscando issue #${issueNumber}...`);
+  const issue = await getIssue(token, owner, repo, parseInt(issueNumber, 10));
+  const slug = slugify(issue.title);
+  const featureDir = `docs/features/${slug}`;
+  const filePath = `${featureDir}/plan.md`;
+
+  console.log(`Gerando plan.md para: ${issue.title}`);
+  const content = await generateDocument(
+    SYSTEM_PROMPT,
+    `Feature: ${issue.title}\n\nDescrição:\n${issue.body || '(sem descrição)'}`
+  );
+
+  mkdirSync(featureDir, { recursive: true });
+  writeFileSync(filePath, content, 'utf-8');
+
+  // Commit and push
+  const git = (cmd) => execSync(cmd, { stdio: 'inherit' });
+  git(`git config user.email "spec-wave[bot]@github.com"`);
+  git(`git config user.name "spec-wave[bot]"`);
+  git(`git add "${filePath}"`);
+  git(`git commit -m "docs: generate plan.md for ${slug} [spec-wave]"`);
+  git('git push');
+
+  // Remove trigger label
+  await removeLabel(token, owner, repo, parseInt(issueNumber, 10), 'spec-wave:plan');
+
+  // Comment on issue
+  await commentOnIssue(
+    token, owner, repo, parseInt(issueNumber, 10),
+    `📋 **plan.md gerado automaticamente!**\n\n` +
+    `📄 Arquivo: [\`${filePath}\`](${filePath})\n\n` +
+    `Revise o plano e, quando estiver pronto, mova o card para a coluna **📋 Spec** ou use:\n` +
+    `\`\`\`\ngh issue edit ${issueNumber} --add-label "spec-wave:spec"\n\`\`\``
+  );
+
+  console.log(`plan.md criado em: ${filePath}`);
+}

package/src/commands/generate-spec.mjs

@@ -0,0 +1,77 @@
+import { execSync } from 'node:child_process';
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { resolveToken } from '../api/auth.mjs';
+import { getIssue, removeLabel, commentOnIssue } from '../api/github-rest.mjs';
+import { generateDocument } from '../lib/claude.mjs';
+import { slugify } from '../lib/slugify.mjs';
+
+const SYSTEM_PROMPT = `Você é um Product Manager experiente. Gere uma especificação funcional (spec.md) completa para a Feature descrita pelo usuário.
+
+O spec deve conter exatamente estas seções em português:
+# Objetivo
+# Regras de Negócio
+# Fluxos
+# Critérios de Aceite
+# Casos de Erro
+# Dependências
+
+Para cada seção, seja específico e detalhado. Os Critérios de Aceite devem estar no formato de checklist markdown (- [ ] item).
+Se um plano técnico (plan.md) for fornecido, use-o para enriquecer os detalhes técnicos relevantes.
+Responda APENAS com o conteúdo do spec.md, sem texto adicional.`;
+
+export async function generateSpec({ issueNumber }) {
+  const token = await resolveToken();
+  const [owner, repo] = (process.env.GITHUB_REPOSITORY || '').split('/');
+
+  if (!owner || !repo) {
+    throw new Error(
+      'GITHUB_REPOSITORY env var não definida.\n' +
+      'Este comando roda no GitHub Actions. Para testar localmente:\n' +
+      '  GITHUB_REPOSITORY=owner/repo spec-wave generate-spec --issue-number 1'
+    );
+  }
+
+  console.log(`Buscando issue #${issueNumber}...`);
+  const issue = await getIssue(token, owner, repo, parseInt(issueNumber, 10));
+  const slug = slugify(issue.title);
+  const featureDir = `docs/features/${slug}`;
+  const filePath = `${featureDir}/spec.md`;
+
+  // Read existing plan.md if available
+  const planPath = `${featureDir}/plan.md`;
+  const planContent = existsSync(planPath) ? readFileSync(planPath, 'utf-8') : null;
+
+  const userContent = [
+    `Feature: ${issue.title}`,
+    `\nDescrição:\n${issue.body || '(sem descrição)'}`,
+    planContent ? `\nPlano Técnico (plan.md):\n${planContent}` : '',
+  ].join('');
+
+  console.log(`Gerando spec.md para: ${issue.title}`);
+  const content = await generateDocument(SYSTEM_PROMPT, userContent);
+
+  mkdirSync(featureDir, { recursive: true });
+  writeFileSync(filePath, content, 'utf-8');
+
+  // Commit and push
+  const git = (cmd) => execSync(cmd, { stdio: 'inherit' });
+  git(`git config user.email "spec-wave[bot]@github.com"`);
+  git(`git config user.name "spec-wave[bot]"`);
+  git(`git add "${filePath}"`);
+  git(`git commit -m "docs: generate spec.md for ${slug} [spec-wave]"`);
+  git('git push');
+
+  // Remove trigger label
+  await removeLabel(token, owner, repo, parseInt(issueNumber, 10), 'spec-wave:spec');
+
+  // Comment on issue
+  await commentOnIssue(
+    token, owner, repo, parseInt(issueNumber, 10),
+    `📋 **spec.md gerado automaticamente!**\n\n` +
+    `📄 Arquivo: [\`${filePath}\`](${filePath})\n\n` +
+    `Revise a especificação e, quando estiver pronto, mova o card para **✅ Ready** ou use:\n` +
+    `\`\`\`\ngh issue edit ${issueNumber} --add-label "spec-wave:ready"\n\`\`\``
+  );
+
+  console.log(`spec.md criado em: ${filePath}`);
+}

package/src/commands/info.mjs

@@ -0,0 +1,53 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_FILE } from '../config.mjs';
+
+// Lê o marcador .spec-wave.json do repositório atual (cwd) e reporta se o
+// spec-wave já foi inicializado. Usado pela skill para decidir entre mostrar
+// as informações ou oferecer rodar o `init`.
+export async function info(options = {}) {
+  const configPath = path.join(process.cwd(), CONFIG_FILE);
+
+  if (!existsSync(configPath)) {
+    if (options.json) {
+      console.log(JSON.stringify({ initialized: false }));
+      return;
+    }
+    p.intro(chalk.bold('spec-wave info'));
+    p.log.warn(`Este repositório ${chalk.bold('não foi inicializado')} (sem ${CONFIG_FILE}).`);
+    p.outro('Execute `npx @spec-wave/cli init` para configurar.');
+    return;
+  }
+
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch (err) {
+    if (options.json) {
+      console.log(JSON.stringify({ initialized: false, error: err.message }));
+      return;
+    }
+    p.log.error(`${CONFIG_FILE} existe mas está corrompido: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify({ initialized: true, ...config }));
+    return;
+  }
+
+  p.intro(chalk.bold('spec-wave info'));
+  p.log.success(`Repositório ${chalk.bold('inicializado')}.`);
+  p.note(
+    `${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('Versão CLI:')}  ${config.version ?? '?'}\n` +
+    `${chalk.dim('Criado em:')}   ${config.initializedAt ?? '?'}`,
+    'Configuração'
+  );
+  p.outro('Use `/spec-wave feature <descrição>` para criar uma Feature.');
+}

package/src/commands/init.mjs

@@ -0,0 +1,191 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { resolveToken, verifyTokenScopes } from '../api/auth.mjs';
+import { runWizard } from '../ui/wizard.mjs';
+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';
+
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dir, '..', '..', 'package.json'), 'utf-8'));
+
+export async function init(options) {
+  // --- Token ---
+  let token;
+  try {
+    token = await resolveToken();
+  } catch (err) {
+    p.log.error(err.message);
+    process.exit(1);
+  }
+
+  const tokenSpinner = p.spinner();
+  tokenSpinner.start('Verificando token GitHub...');
+  let tokenInfo;
+  try {
+    tokenInfo = await verifyTokenScopes(token);
+    tokenSpinner.stop(`Autenticado como ${chalk.bold(tokenInfo.login)}`);
+  } catch (err) {
+    tokenSpinner.stop('');
+    p.log.error(`Falha ao verificar token: ${err.message}`);
+    process.exit(1);
+  }
+
+  const missingScopes = [];
+  if (!tokenInfo.hasProject) missingScopes.push('project');
+  if (!tokenInfo.hasRepo) missingScopes.push('repo');
+  if (!tokenInfo.hasWorkflow) missingScopes.push('workflow');
+
+  if (missingScopes.length > 0) {
+    p.log.error(
+      `Token sem os escopos necessários: ${missingScopes.join(', ')}\n` +
+      `Execute: gh auth refresh --scopes project,repo,workflow\n` +
+      `Ou crie um Personal Access Token com os escopos "project", "repo" e "workflow".`
+    );
+    process.exit(1);
+  }
+
+  // --- Wizard ou flags ---
+  let owner, repo, projectTitle;
+  if (options.repo) {
+    if (!options.repo.includes('/')) {
+      p.log.error('Formato inválido para --repo. Use: owner/repo');
+      process.exit(1);
+    }
+    [owner, repo] = options.repo.split('/');
+    projectTitle = options.projectTitle ?? `${repo} — Spec Wave`;
+    p.log.info(`Repositório: ${owner}/${repo}`);
+    p.log.info(`Projeto: ${projectTitle}`);
+  } else {
+    ({ owner, repo, projectTitle } = await runWizard());
+  }
+
+  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('  Fases: project board → labels → workflow files');
+    p.outro('Dry-run concluído.');
+    return;
+  }
+
+  // --- Phase 1: Project Board ---
+  let projectUrl, projectId, projectNumber, projectFields;
+  if (options.skipProject) {
+    p.log.info('Pulando criação do GitHub Project (--skip-project).');
+  } else {
+    const projectSpinner = p.spinner();
+    projectSpinner.start('Criando GitHub Project...');
+    try {
+      const result = await setupProject(token, owner, repo, projectTitle, projectSpinner);
+      projectUrl = result.projectUrl;
+      projectId = result.projectId;
+      projectNumber = result.projectNumber;
+      projectFields = result.fields;
+      projectSpinner.stop(`Projeto criado: ${chalk.cyan(projectUrl)}`);
+      if (result.linkWarning) {
+        p.log.warn(
+          'Não foi possível vincular o projeto ao repositório (requer escopo "repo").\n' +
+          'Faça manualmente: abra o projeto → Settings → Linked repositories → Add repository.'
+        );
+      }
+    } catch (err) {
+      projectSpinner.stop('');
+      p.log.error(`Erro ao criar projeto: ${err.message}`);
+      p.log.info('Use --skip-project para pular esta fase e tentar de novo.');
+      process.exit(1);
+    }
+  }
+
+  // --- Phase 2: Labels ---
+  if (options.skipLabels) {
+    p.log.info('Pulando criação das labels (--skip-labels).');
+  } else {
+    const labelSpinner = p.spinner();
+    labelSpinner.start('Criando labels...');
+    try {
+      await setupLabels(token, owner, repo, labelSpinner);
+      labelSpinner.stop('Labels criadas (15 labels)');
+    } catch (err) {
+      labelSpinner.stop('');
+      p.log.error(`Erro ao criar labels: ${err.message}`);
+      p.log.info('Use --skip-labels para pular esta fase e tentar de novo.');
+      process.exit(1);
+    }
+  }
+
+  // --- Phase 3: Files ---
+  if (options.skipFiles) {
+    p.log.info('Pulando criação dos arquivos (--skip-files).');
+  } else {
+    const filesSpinner = p.spinner();
+    filesSpinner.start('Criando arquivos no repositório...');
+    try {
+      await setupFiles(token, owner, repo, filesSpinner);
+      filesSpinner.stop('Arquivos criados (4 workflows + 2 issue templates)');
+    } catch (err) {
+      filesSpinner.stop('');
+      p.log.error(`Erro ao criar arquivos: ${err.message}`);
+      p.log.info('Use --skip-files para pular esta fase e tentar de novo.');
+      process.exit(1);
+    }
+  }
+
+  // --- Marcador de configuração (.spec-wave.json) ---
+  // Commitado no repo-alvo para que a skill detecte, em sessões futuras, que o
+  // init já rodou e qual project/versão foi usado. É a fonte de estado persistente.
+  const configSpinner = p.spinner();
+  configSpinner.start(`Gravando ${CONFIG_FILE}...`);
+  try {
+    const config = {
+      version: pkg.version,
+      owner,
+      repo,
+      project: {
+        title: projectTitle,
+        url: projectUrl ?? null,
+        id: projectId ?? null,
+        number: projectNumber ?? null,
+        fields: projectFields ?? null,
+      },
+      initializedAt: new Date().toISOString(),
+    };
+    await upsertFile(
+      token,
+      owner,
+      repo,
+      CONFIG_FILE,
+      JSON.stringify(config, null, 2) + '\n',
+      'chore: record spec-wave config [spec-wave]'
+    );
+    configSpinner.stop(`${CONFIG_FILE} gravado (spec-wave v${pkg.version})`);
+  } catch (err) {
+    configSpinner.stop('');
+    p.log.warn(`Não foi possível gravar ${CONFIG_FILE}: ${err.message}`);
+  }
+
+  p.note(
+    'As 12 colunas do RFC-001 foram criadas no campo "Etapa".\n' +
+    'Para usá-las como colunas do board:\n' +
+    '  1. Abra o projeto no GitHub\n' +
+    '  2. Clique em "..." → "Settings" da view de Board\n' +
+    '  3. Em "Group by", selecione o campo "Etapa"',
+    'Configurar Board View'
+  );
+
+  p.outro(
+    `\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` +
+    `  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` +
+    `  ${chalk.dim('Para usar a skill: adicione skill/SKILL.md ao seu projeto Claude Code')}`
+  );
+}

package/src/commands/issue.mjs

@@ -0,0 +1,186 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { resolveToken } from '../api/auth.mjs';
+import { CONFIG_FILE, STATUS_OPTIONS, PRIORITY_LABELS, WORK_ITEM_TYPES } from '../config.mjs';
+import { createIssue, getIssue } from '../api/github-rest.mjs';
+import { addProjectItem, setItemSingleSelect, getSingleSelectField, addSubIssue } from '../api/github-graphql.mjs';
+
+// Etapa inicial de todo work item recém-criado (📥 Backlog).
+const INITIAL_STAGE = STATUS_OPTIONS[0].name;
+const VALID_PRIORITIES = PRIORITY_LABELS.map(l => l.name);
+
+// Resolve o tipo informado (case-insensitive) para o nome canônico (ex.: "Feature").
+function normalizeType(input) {
+  if (!input) return null;
+  return WORK_ITEM_TYPES.find(t => t.toLowerCase() === input.toLowerCase()) || null;
+}
+
+function buildBody(options, parent) {
+  const parts = [];
+  if (parent) parts.push(`**Parent:** #${parent.number} — ${parent.title}`);
+  const desc = (options.body || '').trim();
+  if (desc) parts.push(desc);
+  const meta = [];
+  if (options.area) meta.push(`- **Área:** ${options.area}`);
+  if (options.priority) meta.push(`- **Prioridade:** ${options.priority}`);
+  if (meta.length) parts.push(`## Metadados\n${meta.join('\n')}`);
+  return parts.join('\n\n') || '_(sem descrição)_';
+}
+
+// Resolve um campo SINGLE_SELECT pelo nome: usa o .spec-wave.json, cai para o
+// formato legado (etapaFieldId/stageOptions) e, por fim, consulta o Project.
+async function resolveField(token, project, name) {
+  if (project.fields && project.fields[name]) return project.fields[name];
+  if (name === 'Etapa' && project.etapaFieldId) {
+    return { id: project.etapaFieldId, options: project.stageOptions || {} };
+  }
+  return await getSingleSelectField(token, project.id, name);
+}
+
+// Seta o valor de um campo do item no board. Retorna true se aplicou.
+async function setField(token, project, itemId, fieldName, optionName) {
+  const field = await resolveField(token, project, fieldName);
+  const optionId = field?.options?.[optionName];
+  if (field?.id && optionId) {
+    await setItemSingleSelect(token, project.id, itemId, field.id, optionId);
+    return true;
+  }
+  return false;
+}
+
+// Cria um work item (issue tipada), opcionalmente como sub-issue de um parent,
+// adiciona ao Project e define Etapa, Work Item Type, Prioridade e Área no board.
+export async function issue(options) {
+  if (!options.title) {
+    p.log.error('Informe o título: --title "<título>"');
+    process.exitCode = 1;
+    return;
+  }
+  const type = normalizeType(options.type || 'feature');
+  if (!type) {
+    p.log.error(`Tipo inválido: "${options.type}". Use um de: ${WORK_ITEM_TYPES.join(', ')}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (options.priority && !VALID_PRIORITIES.includes(options.priority)) {
+    p.log.error(`Prioridade inválida: ${options.priority}. Use uma de: ${VALID_PRIORITIES.join(', ')}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  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;
+  const project = config.project || {};
+  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 issue (${type})`));
+
+  // Resolve o parent (se informado) — precisamos do node id para a sub-issue.
+  let parent = null;
+  if (options.parent) {
+    const parentNumber = parseInt(String(options.parent).replace('#', ''), 10);
+    if (!Number.isInteger(parentNumber)) {
+      p.log.error(`--parent inválido: ${options.parent}. Use o número da issue pai.`);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const data = await getIssue(token, owner, repo, parentNumber);
+      parent = { number: data.number, nodeId: data.node_id, title: data.title };
+    } catch (err) {
+      p.log.error(`Não foi possível ler a issue pai #${parentNumber}: ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // 1. Cria a issue (título e label prefixados pelo tipo, ex.: [FEATURE]).
+  const tag = `[${type.toUpperCase()}]`;
+  const labels = [tag];
+  if (options.priority) labels.push(options.priority);
+
+  const issueSpinner = p.spinner();
+  issueSpinner.start('Criando issue...');
+  let created;
+  try {
+    created = await createIssue(token, owner, repo, `${tag} ${options.title}`, buildBody(options, parent), labels);
+    issueSpinner.stop(`Issue #${created.number} criada: ${chalk.cyan(created.url)}`);
+  } catch (err) {
+    issueSpinner.stop('');
+    p.log.error(`Erro ao criar issue: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // 2. Vincula como sub-issue do parent (relação nativa do GitHub).
+  if (parent) {
+    try {
+      await addSubIssue(token, parent.nodeId, created.nodeId);
+      p.log.success(`Vinculada como sub-issue de #${parent.number}.`);
+    } catch (err) {
+      p.log.warn(`Issue criada, mas falhou ao vincular ao parent #${parent.number}: ${err.message}`);
+    }
+  }
+
+  // 3. Adiciona ao Project e define os campos do board.
+  if (!project.id) {
+    p.log.warn(
+      `Project não configurado no ${CONFIG_FILE} — a issue não foi adicionada ao board.\n` +
+      'Re-rode `spec-wave init` (sem --skip-project) ou `spec-wave refresh --config`.'
+    );
+    p.outro(`${type} #${created.number} criado (fora do board).`);
+    return;
+  }
+
+  const boardSpinner = p.spinner();
+  boardSpinner.start('Adicionando ao Project...');
+  try {
+    const itemId = await addProjectItem(token, project.id, created.nodeId);
+
+    const stageOk = await setField(token, project, itemId, 'Etapa', INITIAL_STAGE);
+    const typeOk = await setField(token, project, itemId, 'Work Item Type', type);
+    if (options.priority) await setField(token, project, itemId, 'Priority', options.priority);
+    if (options.area) await setField(token, project, itemId, 'Area', options.area);
+
+    boardSpinner.stop(`Adicionada ao Project${stageOk ? ` em "${INITIAL_STAGE}"` : ''}.`);
+    if (!stageOk) p.log.warn(`Não foi possível definir a Etapa "${INITIAL_STAGE}" (campo não encontrado).`);
+    if (!typeOk) p.log.warn(`Não foi possível definir o Work Item Type "${type}" (campo não encontrado).`);
+  } catch (err) {
+    boardSpinner.stop('');
+    p.log.warn(`Issue criada, mas falhou ao adicionar ao Project: ${err.message}`);
+  }
+
+  const parentLine = parent ? ` (sub-issue de #${parent.number})` : '';
+  p.outro(
+    `${chalk.green('✓')} ${type} #${created.number} criado em "${INITIAL_STAGE}"${parentLine}.\n` +
+    `  ${type === 'Feature' ? `Próximo: \`/spec-wave plan ${created.number}\` para o planejamento técnico.` : ''}`
+  );
+}