@guilhermefsousa/open-spec-kit 0.1.0

package/src/commands/init.js

@@ -0,0 +1,981 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { writeFile, mkdir, access, cp } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import https from 'https';
+import http from 'http';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates');
+
+const AGENTS = {
+  claude: { name: 'Claude Code' },
+  copilot: { name: 'GitHub Copilot' },
+};
+
+const FIGMA_MCP_PACKAGE = 'figma-developer-mcp';
+
+const PRESETS = {
+  lean: {
+    name: 'Lean',
+    description: 'Bugfix ou feature trivial (brief + tasks)',
+    artifacts: ['brief.md', 'tasks.md'],
+  },
+  standard: {
+    name: 'Standard',
+    description: 'Feature média (brief + scenarios + contracts + tasks + links)',
+    artifacts: ['brief.md', 'scenarios.md', 'contracts.md', 'tasks.md', 'links.md'],
+  },
+  enterprise: {
+    name: 'Enterprise',
+    description: 'Feature crítica (standard + ADR + security review + runbook)',
+    artifacts: ['brief.md', 'scenarios.md', 'contracts.md', 'tasks.md', 'links.md'],
+    extras: ['adr', 'security-review', 'runbook'],
+  }
+};
+
+const KNOWN_TECH_KEYWORDS = [
+  '.NET', 'Node.js', 'React', 'PostgreSQL', 'RabbitMQ', 'Kafka', 'Docker',
+  'Redis', 'TypeScript', 'Java', 'Kotlin', 'Python', 'Spring Boot', 'Angular',
+  'Vue', 'MongoDB', 'MySQL', 'xUnit', 'Jest', 'MassTransit', 'C#', 'Go',
+  'Rust', 'PHP', 'Laravel', 'Django', 'Flask', 'Express', 'NestJS', 'Next.js',
+  'Nuxt', 'Svelte', 'Terraform', 'Kubernetes', 'AWS', 'Azure', 'GCP',
+  'SQL Server', 'Oracle', 'Elasticsearch', 'GraphQL', 'gRPC', 'REST',
+  'SQS', 'SNS', 'DynamoDB', 'Cassandra', 'Nginx', 'Apache',
+];
+
+// ──────────────────────────────────────────────────────
+// HTTP helper using Node.js built-in modules
+// ──────────────────────────────────────────────────────
+const SSL_ERROR_CODES = new Set([
+  'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+  'SELF_SIGNED_CERT_IN_CHAIN',
+  'DEPTH_ZERO_SELF_SIGNED_CERT',
+  'CERT_HAS_EXPIRED',
+  'ERR_TLS_CERT_ALTNAME_INVALID',
+  'UNABLE_TO_GET_ISSUER_CERT_LOCALLY',
+]);
+
+function isSslError(err) {
+  return err.status === 0 && (
+    SSL_ERROR_CODES.has(err.code) ||
+    SSL_ERROR_CODES.has(err.message) ||
+    (err.message && SSL_ERROR_CODES.has(err.message.split(':').pop()?.trim()))
+  );
+}
+
+function confluenceRequest(baseUrl, path, user, token, timeoutMs = 15000, allowInsecure = false) {
+  return new Promise((resolve, reject) => {
+    try {
+      const fullUrl = new URL(baseUrl.replace(/\/$/, '') + path);
+      const mod = fullUrl.protocol === 'https:' ? https : http;
+      const auth = Buffer.from(`${user}:${token}`).toString('base64');
+      const options = {
+        headers: {
+          'Authorization': `Basic ${auth}`,
+          'Accept': 'application/json',
+        },
+        timeout: timeoutMs,
+        ...(allowInsecure && fullUrl.protocol === 'https:'
+          ? { agent: new https.Agent({ rejectUnauthorized: false }) }
+          : {}),
+      };
+      const req = mod.get(fullUrl, options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve({ status: res.statusCode, data: JSON.parse(data) });
+            } catch {
+              resolve({ status: res.statusCode, data });
+            }
+          } else {
+            reject({ status: res.statusCode, message: `HTTP ${res.statusCode}` });
+          }
+        });
+      });
+      req.on('error', (err) => reject({ status: 0, message: err.message, code: err.code }));
+      req.on('timeout', () => {
+        req.destroy();
+        reject({ status: 0, message: 'Timeout (15s)' });
+      });
+    } catch (err) {
+      reject({ status: 0, message: err.message, code: err.code });
+    }
+  });
+}
+
+function stripHtml(html) {
+  if (!html) return '';
+  return html
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function detectTechInText(text) {
+  if (!text) return [];
+  const found = new Set();
+  for (const tech of KNOWN_TECH_KEYWORDS) {
+    const escaped = tech.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp('\\b' + escaped + '\\b', 'i');
+    if (regex.test(text)) {
+      found.add(tech);
+    }
+  }
+  const tablePatterns = /(?:tecnologia|stack|framework|linguagem|banco|database|message.?broker|cache|container)[\s:|\\-]+([^\n|]+)/gi;
+  let match;
+  while ((match = tablePatterns.exec(text)) !== null) {
+    const value = match[1].trim();
+    for (const tech of KNOWN_TECH_KEYWORDS) {
+      if (value.toLowerCase().includes(tech.toLowerCase())) {
+        found.add(tech);
+      }
+    }
+  }
+  return [...found];
+}
+
+function detectRepoNames(text) {
+  if (!text) return [];
+  const repos = new Set();
+  const repoPatterns = /(?:reposit[óo]rio|repo|github|gitlab)[:\s]+([a-zA-Z][\w.-]+(?:\/[\w.-]+)?)/gi;
+  let match;
+  while ((match = repoPatterns.exec(text)) !== null) {
+    repos.add(match[1].trim());
+  }
+  return [...repos];
+}
+
+function deriveSigla(projectName) {
+  if (!projectName) return '';
+  const words = projectName.trim().split(/\s+/).filter(w => w.length > 0);
+  const skip = new Set(['de', 'do', 'da', 'dos', 'das', 'e', 'o', 'a', 'os', 'as', 'em', 'no', 'na', 'para', 'com']);
+  const letters = words
+    .filter(w => !skip.has(w.toLowerCase()))
+    .map(w => w[0].toUpperCase())
+    .join('');
+  return letters.slice(0, 4) || projectName.slice(0, 3).toUpperCase();
+}
+
+// ──────────────────────────────────────────────────────
+// Auto-detection from Confluence
+// ──────────────────────────────────────────────────────
+async function autoDetectFromConfluence(confluenceUrl, confluenceRef, user, token, spinner, allowInsecure = false) {
+  const result = {
+    projectName: null,
+    stack: [],
+    repos: [],
+    spaceKey: null,
+    success: false,
+  };
+
+  try {
+    spinner.text = 'Lendo página raiz do Confluence...';
+    const rootPage = await confluenceRequest(
+      confluenceUrl,
+      `/rest/api/content/${confluenceRef}?expand=body.storage,space`,
+      user, token, 15000, allowInsecure
+    );
+    result.projectName = rootPage.data.title || null;
+    if (rootPage.data.space && rootPage.data.space.key) {
+      result.spaceKey = rootPage.data.space.key;
+    }
+
+    let allText = '';
+    if (rootPage.data.body && rootPage.data.body.storage) {
+      allText += stripHtml(rootPage.data.body.storage.value) + ' ';
+    }
+
+    spinner.text = 'Buscando páginas filhas...';
+    const children = await confluenceRequest(
+      confluenceUrl,
+      `/rest/api/content/${confluenceRef}/child/page?limit=50`,
+      user, token, 15000, allowInsecure
+    );
+    const childPages = children.data.results || [];
+
+    let demandasPage = childPages.find(p =>
+      p.title && p.title.toLowerCase().includes('demandas')
+    );
+
+    // If "Demandas" not found among children, look UP the ancestors tree.
+    // The configured page may itself live INSIDE a "Demandas" folder.
+    if (!demandasPage) {
+      spinner.text = 'Buscando "Demandas" nos ancestrais...';
+      try {
+        const ancestorRes = await confluenceRequest(
+          confluenceUrl,
+          `/rest/api/content/${confluenceRef}?expand=ancestors`,
+          user, token, 15000, allowInsecure
+        );
+        const ancestors = ancestorRes.data.ancestors || [];
+        const demandasAncestor = ancestors.find(a =>
+          a.title && a.title.toLowerCase().includes('demandas')
+        );
+        if (demandasAncestor) {
+          demandasPage = demandasAncestor;
+        }
+      } catch { /* ignore ancestor lookup failure */ }
+    }
+
+    if (demandasPage) {
+      spinner.text = 'Pasta "Demandas" encontrada — lendo todas as páginas...';
+      const demandasChildren = await confluenceRequest(
+        confluenceUrl,
+        `/rest/api/content/${demandasPage.id}/child/page?limit=50`,
+        user, token, 15000, allowInsecure
+      );
+      const demandaPages = demandasChildren.data.results || [];
+      for (const page of demandaPages) {
+        if (page.id === confluenceRef) continue;
+        try {
+          spinner.text = `Lendo: ${page.title}...`;
+          const pageData = await confluenceRequest(
+            confluenceUrl,
+            `/rest/api/content/${page.id}?expand=body.storage`,
+            user, token, 15000, allowInsecure
+          );
+          if (pageData.data.body && pageData.data.body.storage) {
+            allText += stripHtml(pageData.data.body.storage.value) + ' ';
+          }
+        } catch { /* skip pages that fail to load */ }
+      }
+    }
+
+    for (const page of childPages) {
+      if (demandasPage && page.id === demandasPage.id) continue;
+      try {
+        const pageData = await confluenceRequest(
+          confluenceUrl,
+          `/rest/api/content/${page.id}?expand=body.storage`,
+          user, token, 15000, allowInsecure
+        );
+        if (pageData.data.body && pageData.data.body.storage) {
+          allText += stripHtml(pageData.data.body.storage.value) + ' ';
+        }
+      } catch { /* skip pages that fail */ }
+    }
+
+    result.stack = detectTechInText(allText);
+    result.repos = detectRepoNames(allText);
+    result.success = true;
+  } catch {
+    result.success = false;
+  }
+
+  return result;
+}
+
+// ──────────────────────────────────────────────────────
+// Existing setup check
+// ──────────────────────────────────────────────────────
+async function checkGitExists() {
+  try {
+    await access(join(process.cwd(), '.git'));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkExistingSetup() {
+  const cwd = process.cwd();
+  const check = ['.agents', '.github/agents', 'projects.yml', '.mcp.json', '.vscode/mcp.json', '.env'];
+  const found = [];
+  for (const f of check) {
+    try {
+      await access(join(cwd, f));
+      found.push(f);
+    } catch { /* not found */ }
+  }
+  return found;
+}
+
+/**
+ * Copy a template directory tree to the target.
+ * Templates are bundled with the npm package under cli/templates/.
+ */
+async function copyTemplateDir(templateName, targetRoot) {
+  const sourceDir = join(TEMPLATES_DIR, templateName);
+  try {
+    await access(sourceDir);
+  } catch {
+    throw new Error(`Template directory not found: ${sourceDir}`);
+  }
+  const targetMap = {
+    agents: '.agents',
+    github: '.github',
+  };
+  const targetDir = join(targetRoot, targetMap[templateName] || templateName);
+  await cp(sourceDir, targetDir, { recursive: true, force: true });
+}
+
+// ──────────────────────────────────────────────────────
+// File generators
+// ──────────────────────────────────────────────────────
+function generateProjectsYml(config) {
+  const isNumeric = /^\d+$/.test(config.confluenceRef);
+  const stackYaml = config.stack.map(s => `    - ${s}`).join('\n');
+  const agentsYaml = config.agents.map(a => `    - ${a}`).join('\n');
+
+  let yml = `project:
+  name: ${config.projectName}
+  sigla: ${config.sigla}
+  domain: # Domínio de negócio
+  status: inception
+  team_size: ${config.teamSize}
+  preset: ${config.preset}
+  stack:
+${stackYaml}
+  agents:
+${agentsYaml}
+
+${config.vcs !== 'none'
+  ? `vcs: ${config.vcs}\nvcs_org: ${config.vcsOrg}`
+  : `# vcs: github        # Descomente e configure depois\n# vcs_org: sua-org`}
+
+repos:
+  # Liste os repositórios de código do projeto.
+  # - name: MeuProjeto.Api
+  #   type: api
+  #   purpose: Endpoints REST
+  #   status: planned
+  #   url: null
+
+# Agent configuration
+agents:
+  coding:
+    dotnet: dotnet-engineer
+    nodejs: nodejs-engineer
+    java: java-engineer
+    python: labs-python-engineer
+    react: frontend-expert
+    mobile: mobile-engineer
+  security: labs-secops-agent
+  code_review: labs-code-reviewer
+  design_doc: design-doc
+  principal: principal-engineer
+
+external_dependencies:
+  # - name: SistemaX
+  #   type: event-producer
+  #   description: Publica EventoY via RabbitMQ
+
+confluence:
+  ${isNumeric ? 'root_page_id' : 'space'}: ${config.confluenceRef}`;
+
+  if (config.confluenceLayout === 'page' && config.spaceKey) {
+    yml += `\n  space_key: ${config.spaceKey}`;
+  }
+
+  if (config.hasFigma && config.figmaFileUrl) {
+    yml += `\n\nfigma:\n  file_url: ${config.figmaFileUrl}`;
+  }
+
+  yml += '\n';
+  return yml;
+}
+
+function generateGitignore(config) {
+  let content = `# Secrets (nunca comitar)
+.env
+.mcp.json
+
+# Claude Code local files
+.claude/
+
+# OS files
+Thumbs.db
+.DS_Store
+
+# IDE
+.idea/
+*.swp
+`;
+
+  if (config.agents.includes('copilot')) {
+    content += `
+# VS Code (exceto MCP config compartilhada)
+.vscode/*
+!.vscode/mcp.json
+`;
+  } else {
+    content += '\n.vscode/\n';
+  }
+
+  return content;
+}
+
+function generateEnvFile(config) {
+  let content = `CONFLUENCE_URL=${config.confluenceUrl}
+CONFLUENCE_USER=${config.confluenceUser}
+CONFLUENCE_API_TOKEN=${config.confluenceToken}
+GCHAT_WEBHOOK_URL=${config.gchatWebhookUrl || ''}
+`;
+
+  if (config.hasFigma && config.figmaFileUrl) {
+    content += 'FIGMA_API_KEY=\n';
+  }
+
+  return content;
+}
+
+function generateEnvExample(config) {
+  let content = `# Confluence credentials
+# Obtenha o token em: https://id.atlassian.com/manage-profile/security/api-tokens
+CONFLUENCE_URL=https://seu-dominio.atlassian.net/wiki
+CONFLUENCE_USER=seu-email@empresa.com
+CONFLUENCE_API_TOKEN=seu-token-aqui
+
+# Google Chat webhook (opcional)
+GCHAT_WEBHOOK_URL=
+`;
+
+  if (config.hasFigma && config.figmaFileUrl) {
+    content += `
+# Figma API key
+# Obtenha em: https://www.figma.com/settings
+FIGMA_API_KEY=seu-figma-api-key
+`;
+  }
+
+  return content;
+}
+
+function generateClaudeMcp(config) {
+  const servers = {
+    confluence: {
+      command: 'mcp-atlassian',
+      args: [
+        '--confluence-url', '${CONFLUENCE_URL}',
+        '--confluence-username', '${CONFLUENCE_USER}',
+        '--confluence-token', '${CONFLUENCE_API_TOKEN}'
+      ]
+    }
+  };
+  if (config.hasFigma && config.figmaFileUrl) {
+    servers.figma = {
+      command: 'npx',
+      args: ['-y', FIGMA_MCP_PACKAGE, '--figma-api-key', '${FIGMA_API_KEY}']
+    };
+  }
+  return JSON.stringify({ mcpServers: servers }, null, 2) + '\n';
+}
+
+function generateCopilotMcp(config) {
+  const servers = {
+    confluence: {
+      type: 'stdio',
+      command: 'mcp-atlassian',
+      args: [
+        '--env-file', '.env',
+        '--no-confluence-ssl-verify'
+      ]
+    }
+  };
+  if (config.hasFigma && config.figmaFileUrl) {
+    servers.figma = {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', FIGMA_MCP_PACKAGE, '--figma-api-key', '${input:figma-api-key}']
+    };
+  }
+  return JSON.stringify({ servers }, null, 2) + '\n';
+}
+
+function generateArchitectureSkeleton(config) {
+  return `# Arquitetura — ${config.projectName}
+
+## Stack
+
+${config.stack.map(s => `- ${s}`).join('\n')}
+
+## Repositórios
+
+(Preenchido pelo /setup)
+
+## Decisões em Aberto
+
+| # | Decisão | Impacto | Bloqueia | Status |
+|---|---------|---------|----------|--------|
+
+## Diagrama
+
+(Gerado pelo /spec ou /dev)
+`;
+}
+
+// ──────────────────────────────────────────────────────
+// Main command
+// ──────────────────────────────────────────────────────
+export async function initCommand() {
+  console.log(chalk.bold('\n  open-spec-kit init\n'));
+
+  // Pre-flight: check existing setup
+  const existing = await checkExistingSetup();
+  if (existing.length > 0) {
+    console.log(chalk.yellow('  Estrutura existente detectada:'));
+    existing.forEach(f => console.log(chalk.dim(`    - ${f}`)));
+    const { proceed } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'proceed',
+      message: 'Deseja sobrescrever? (arquivos existentes serão substituídos)',
+      default: false
+    }]);
+    if (!proceed) {
+      console.log(chalk.dim('  Cancelado.'));
+      return;
+    }
+  }
+
+  // ════════════════════════════════════════════
+  // Phase 1 — Conexão
+  // ════════════════════════════════════════════
+  console.log(chalk.bold.blue('\n  ── Fase 1: Conexão ──\n'));
+
+  const phase1 = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'agents',
+      message: 'Quais AI tools você usa?',
+      choices: [
+        { name: 'Claude Code', value: 'claude', checked: true },
+        { name: 'GitHub Copilot', value: 'copilot', checked: true },
+      ],
+      validate: v => v.length > 0 || 'Selecione pelo menos uma tool'
+    },
+    {
+      type: 'list',
+      name: 'preset',
+      message: 'Preset padrão do projeto:',
+      choices: Object.entries(PRESETS).map(([key, p]) => ({
+        name: `${p.name} — ${p.description}`,
+        value: key,
+      })),
+      default: 'standard'
+    },
+    {
+      type: 'list',
+      name: 'confluenceLayout',
+      message: 'Layout do Confluence:',
+      choices: [
+        { name: '1 space = 1 projeto (space key)', value: 'space' },
+        { name: '1 space = N projetos (page ID)', value: 'page' },
+      ]
+    },
+    {
+      type: 'input',
+      name: 'confluenceRef',
+      message: 'Space key ou page ID (ex: TT  ou  1234567890):',
+      validate: v => v.trim().length > 0 || 'Obrigatório'
+    },
+    {
+      type: 'input',
+      name: 'confluenceUrl',
+      message: 'Confluence URL (ex: https://seu-dominio.atlassian.net/wiki):',
+      validate: v => {
+        const trimmed = v.trim();
+        if (!trimmed.startsWith('http://') && !trimmed.startsWith('https://')) {
+          return 'URL deve começar com http:// ou https://';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'confluenceUser',
+      message: 'Confluence username/email (ex: voce@empresa.com):',
+      validate: v => v.trim().length > 0 || 'Obrigatório'
+    },
+    {
+      type: 'password',
+      name: 'confluenceToken',
+      message: 'Confluence API token:',
+      mask: '*',
+      validate: v => v.trim().length > 0 || 'Obrigatório'
+    }
+  ]);
+
+  // Validate credentials
+  const spinner = ora('Validando credenciais do Confluence...').start();
+  let credentialsValid = false;
+  let allowInsecure = false;
+  const confluenceUrl = phase1.confluenceUrl.trim().replace(/\/$/, '');
+
+  try {
+    await confluenceRequest(
+      confluenceUrl,
+      '/rest/api/space?limit=1',
+      phase1.confluenceUser.trim(),
+      phase1.confluenceToken.trim()
+    );
+    spinner.succeed('Credenciais validadas com sucesso!');
+    credentialsValid = true;
+  } catch (err) {
+    if (err.status === 401 || err.status === 403) {
+      spinner.fail(`Autenticação falhou (HTTP ${err.status}). Verifique suas credenciais.`);
+      console.log(chalk.red('  Não é possível continuar sem acesso ao Confluence.'));
+      console.log(chalk.dim('  Gere um token em: https://id.atlassian.com/manage-profile/security/api-tokens'));
+      return;
+    }
+    if (isSslError(err)) {
+      spinner.text = 'Certificado SSL corporativo detectado — tentando sem verificação...';
+      try {
+        await confluenceRequest(
+          confluenceUrl,
+          '/rest/api/space?limit=1',
+          phase1.confluenceUser.trim(),
+          phase1.confluenceToken.trim(),
+          15000,
+          true
+        );
+        allowInsecure = true;
+        spinner.succeed('Credenciais validadas (SSL corporativo ignorado — ambiente interno).');
+        credentialsValid = true;
+      } catch (retryErr) {
+        if (retryErr.status === 401 || retryErr.status === 403) {
+          spinner.fail(`Autenticação falhou (HTTP ${retryErr.status}). Verifique suas credenciais.`);
+          console.log(chalk.red('  Não é possível continuar sem acesso ao Confluence.'));
+          console.log(chalk.dim('  Gere um token em: https://id.atlassian.com/manage-profile/security/api-tokens'));
+          return;
+        }
+        spinner.warn(`Não foi possível conectar ao Confluence: ${retryErr.message}`);
+        console.log(chalk.yellow('  Continuando sem auto-detecção...\n'));
+      }
+    } else {
+      spinner.warn(`Não foi possível conectar ao Confluence: ${err.message}`);
+      console.log(chalk.yellow('  Continuando sem auto-detecção...\n'));
+    }
+  }
+
+  // ════════════════════════════════════════════
+  // Phase 2 — Auto-detecção
+  // ════════════════════════════════════════════
+  let detected = { projectName: null, stack: [], repos: [], spaceKey: null, success: false };
+  const isNumericRef = /^\d+$/.test(phase1.confluenceRef.trim());
+
+  if (credentialsValid && isNumericRef) {
+    console.log(chalk.bold.blue('\n  ── Fase 2: Auto-detecção ──\n'));
+    const detectSpinner = ora('Analisando páginas do Confluence...').start();
+
+    try {
+      detected = await autoDetectFromConfluence(
+        confluenceUrl,
+        phase1.confluenceRef.trim(),
+        phase1.confluenceUser.trim(),
+        phase1.confluenceToken.trim(),
+        detectSpinner,
+        allowInsecure
+      );
+
+      if (detected.success && detected.stack.length > 0) {
+        detectSpinner.succeed('Auto-detecção concluída!');
+        console.log(chalk.green(`  Stack detectada: ${detected.stack.join(', ')}`));
+        if (detected.repos.length > 0) {
+          console.log(chalk.green(`  Repositórios: ${detected.repos.join(', ')}`));
+        }
+        if (detected.projectName) {
+          console.log(chalk.green(`  Projeto: ${detected.projectName}`));
+        }
+      } else {
+        detectSpinner.info('Nenhuma stack detectada automaticamente — preencha manualmente.');
+      }
+    } catch {
+      detectSpinner.info('Auto-detecção não disponível — preencha manualmente.');
+    }
+  } else if (credentialsValid && !isNumericRef) {
+    console.log(chalk.dim('\n  Auto-detecção disponível apenas com page ID numérico.\n'));
+  }
+
+  // ════════════════════════════════════════════
+  // Phase 3 — Dados do projeto
+  // ════════════════════════════════════════════
+  console.log(chalk.bold.blue('\n  ── Fase 3: Dados do projeto ──\n'));
+
+  // B3: verificar se .git já existe antes de oferecer git init
+  const gitAlreadyExists = await checkGitExists();
+  if (gitAlreadyExists) {
+    console.log(chalk.dim('  ℹ .git já existe neste diretório — etapa de git init será pulada automaticamente.\n'));
+  }
+
+  const defaultStack = detected.stack.length > 0 ? detected.stack.join(', ') : '';
+
+  const phase3 = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Nome do projeto:',
+      default: detected.projectName || undefined,
+      validate: v => v.trim().length > 0 || 'Nome obrigatório'
+    },
+    {
+      type: 'input',
+      name: 'sigla',
+      message: 'Sigla (2-4 letras maiúsculas, usada como prefixo):',
+      default: (answers) => deriveSigla(answers.projectName || detected.projectName || ''),
+      filter: v => v.toUpperCase().replace(/[^A-Z]/g, '').slice(0, 4),
+      validate: v => {
+        const clean = v.toUpperCase().replace(/[^A-Z]/g, '');
+        if (clean.length < 2 || clean.length > 4) return 'Sigla deve ter 2 a 4 letras';
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'stack',
+      message: 'Stack principal (separado por vírgula, ex: Node.js, React, PostgreSQL):',
+      default: defaultStack || undefined,
+      filter: v => v.split(',').map(s => s.trim()).filter(Boolean),
+      when: () => detected.stack.length === 0
+    },
+    {
+      type: 'list',
+      name: 'vcs',
+      message: 'Plataforma de versionamento:',
+      choices: [
+        { name: 'GitHub', value: 'github' },
+        { name: 'GitLab', value: 'gitlab' },
+        { name: 'Nenhum / configurar depois', value: 'none' },
+      ]
+    },
+    {
+      type: 'input',
+      name: 'vcsOrg',
+      message: 'Organização/grupo no VCS (ex: minha-empresa ou meu-usuario):',
+      when: (answers) => answers.vcs !== 'none',
+      validate: v => v.trim().length > 0 || 'Obrigatório'
+    },
+    {
+      type: 'input',
+      name: 'gchatWebhookUrl',
+      message: 'Google Chat Webhook URL (opcional — deixe vazio para pular notificações):',
+      default: ''
+    },
+    {
+      type: 'confirm',
+      name: 'hasFigma',
+      message: 'O projeto tem designs no Figma?',
+      default: false
+    },
+    {
+      type: 'input',
+      name: 'figmaFileUrl',
+      message: 'URL do arquivo Figma (deixe vazio para pular):',
+      when: (answers) => answers.hasFigma
+    },
+    {
+      type: 'confirm',
+      name: 'initGit',
+      message: 'Inicializar repositório Git agora?',
+      default: true,
+      when: () => !gitAlreadyExists
+    }
+  ]);
+
+  // If Figma URL is empty, treat as no Figma (BUG-026 fix)
+  if (phase3.hasFigma && (!phase3.figmaFileUrl || !phase3.figmaFileUrl.trim())) {
+    phase3.hasFigma = false;
+    phase3.figmaFileUrl = '';
+  }
+
+  // B3: se .git já existe, git init é false independente do prompt (que foi pulado)
+  const initGitFinal = gitAlreadyExists ? false : (phase3.initGit ?? false);
+
+  // Build unified config object
+  const config = {
+    agents: phase1.agents,
+    preset: phase1.preset,
+    confluenceLayout: phase1.confluenceLayout,
+    confluenceRef: phase1.confluenceRef.trim(),
+    confluenceUrl,
+    confluenceUser: phase1.confluenceUser.trim(),
+    confluenceToken: phase1.confluenceToken.trim(),
+    spaceKey: detected.spaceKey || null,
+    projectName: phase3.projectName.trim(),
+    sigla: phase3.sigla,
+    stack: phase3.stack ?? detected.stack,
+    vcs: phase3.vcs,
+    // B2: vcsOrg é undefined quando vcs='none' (prompt foi pulado)
+    vcsOrg: phase3.vcs !== 'none' ? (phase3.vcsOrg || '').trim() : '',
+    teamSize: '5',
+    gchatWebhookUrl: (phase3.gchatWebhookUrl || '').trim(),
+    hasFigma: phase3.hasFigma,
+    figmaFileUrl: (phase3.figmaFileUrl || '').trim(),
+    initGit: initGitFinal,
+  };
+
+  // ════════════════════════════════════════════
+  // Phase 4 — Revisão & Confirmação (B4)
+  // ════════════════════════════════════════════
+  console.log(chalk.bold.blue('\n  ── Fase 4: Revisão ──\n'));
+  console.log(chalk.bold('  Confira todos os dados antes de gerar os arquivos:\n'));
+
+  const vcsDisplay = config.vcs === 'none'
+    ? chalk.dim('Nenhum (configurar depois)')
+    : `${chalk.cyan(config.vcs)} — ${chalk.cyan(config.vcsOrg)}`;
+
+  console.log(`  Projeto:       ${chalk.cyan(config.projectName)}`);
+  console.log(`  Sigla:         ${chalk.cyan(config.sigla)}`);
+  console.log(`  Stack:         ${chalk.cyan(config.stack.length ? config.stack.join(', ') : '(não definida)')}`);
+  console.log(`  Preset:        ${chalk.cyan(PRESETS[config.preset].name)}`);
+  console.log(`  AI tools:      ${chalk.cyan(config.agents.map(a => AGENTS[a].name).join(', '))}`);
+  console.log(`  VCS:           ${vcsDisplay}`);
+  console.log(`  Confluence:    ${chalk.cyan(config.confluenceRef)} (${config.confluenceLayout === 'space' ? 'space key' : 'page ID'}) @ ${chalk.cyan(config.confluenceUrl)}`);
+  console.log(`  GChat:         ${chalk.cyan(config.gchatWebhookUrl ? '(webhook configurado)' : chalk.dim('Não configurado'))}`);
+  console.log(`  Figma:         ${chalk.cyan(config.hasFigma ? (config.figmaFileUrl || 'Sim (URL não informada)') : 'Não')}`);
+  if (gitAlreadyExists) {
+    console.log(`  Git init:      ${chalk.dim('Pulado (.git já existe)')}`);
+  } else {
+    console.log(`  Git init:      ${chalk.cyan(config.initGit ? 'Sim' : 'Não')}`);
+  }
+  console.log('');
+
+  const { confirmed } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirmed',
+    message: 'Confirmar e gerar arquivos?',
+    default: true
+  }]);
+
+  if (!confirmed) {
+    console.log(chalk.yellow('\n  Cancelado. Execute open-spec-kit init novamente para recomeçar.\n'));
+    return;
+  }
+
+  // ════════════════════════════════════════════
+  // File generation
+  // ════════════════════════════════════════════
+  const genSpinner = ora('Gerando estrutura...').start();
+  const cwd = process.cwd();
+
+  try {
+    // Create common directories
+    const commonDirs = ['specs', 'docs/decisions', 'docs/lessons', 'scripts'];
+    for (const dir of commonDirs) {
+      await mkdir(join(cwd, dir), { recursive: true });
+    }
+
+    // Generate .env with real credentials (GAP-03 fix)
+    genSpinner.text = '.env criado';
+    await writeFile(join(cwd, '.env'), generateEnvFile(config));
+
+    // Generate .env.example
+    genSpinner.text = '.env.example criado';
+    await writeFile(join(cwd, '.env.example'), generateEnvExample(config));
+
+    // Generate projects.yml
+    genSpinner.text = 'projects.yml criado';
+    await writeFile(join(cwd, 'projects.yml'), generateProjectsYml(config));
+
+    // Generate .gitignore
+    genSpinner.text = '.gitignore criado';
+    await writeFile(join(cwd, '.gitignore'), generateGitignore(config));
+
+    // Copy shared templates (agents source of truth)
+    genSpinner.text = 'Copiando skills e rules...';
+    await copyTemplateDir('agents', cwd);
+
+    // Copy notify scripts to scripts/ (cross-platform)
+    genSpinner.text = 'Copiando scripts de notificação...';
+    const scriptsSource = join(TEMPLATES_DIR, 'agents', 'scripts');
+    const scriptsTarget = join(cwd, 'scripts');
+    try {
+      await access(scriptsSource);
+      await cp(scriptsSource, scriptsTarget, { recursive: true, force: true });
+    } catch { /* scripts dir may not exist in older templates */ }
+
+    // Generate per-agent files
+    if (config.agents.includes('claude')) {
+      genSpinner.text = 'Configurando Claude Code...';
+      await writeFile(join(cwd, '.mcp.json'), generateClaudeMcp(config));
+    }
+
+    if (config.agents.includes('copilot')) {
+      genSpinner.text = 'Configurando GitHub Copilot...';
+      await copyTemplateDir('github', cwd);
+      await mkdir(join(cwd, '.vscode'), { recursive: true });
+      await writeFile(join(cwd, '.vscode/mcp.json'), generateCopilotMcp(config));
+    }
+
+    // Generate docs/architecture.md skeleton
+    await writeFile(join(cwd, 'docs/architecture.md'), generateArchitectureSkeleton(config));
+
+    genSpinner.succeed('Estrutura gerada com sucesso!');
+
+    // Install mcp-atlassian (BUG-024 fix)
+    const pipSpinner = ora('Verificando mcp-atlassian...').start();
+    try {
+      const pipList = execSync('pip list', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+      if (!pipList.toLowerCase().includes('mcp-atlassian')) {
+        pipSpinner.text = 'Instalando mcp-atlassian...';
+        execSync('pip install mcp-atlassian', { stdio: 'pipe', timeout: 120000 });
+        pipSpinner.succeed('mcp-atlassian instalado com sucesso!');
+      } else {
+        pipSpinner.succeed('mcp-atlassian já está instalado.');
+      }
+    } catch {
+      pipSpinner.warn('Não foi possível instalar mcp-atlassian. Instale manualmente: pip install mcp-atlassian');
+    }
+
+    // Git init
+    if (config.initGit) {
+      try {
+        execSync('git init', { cwd, stdio: 'pipe' });
+        execSync('git add .', { cwd, stdio: 'pipe' });
+        execSync('git commit -m "chore: init spec repo via open-spec-kit"', { cwd, stdio: 'pipe' });
+        console.log(chalk.green('\n  ✓ Repositório Git inicializado e commit inicial criado'));
+      } catch {
+        console.log(chalk.yellow('\n  ⚠ Git init falhou — inicialize manualmente:'));
+        console.log(chalk.dim('    git init && git add . && git commit -m "chore: init spec repo"'));
+      }
+    }
+
+    // Summary
+    console.log(chalk.bold('\n  Resumo:\n'));
+    console.log(`  Projeto:     ${chalk.cyan(config.projectName)}`);
+    console.log(`  Sigla:       ${chalk.cyan(config.sigla)}`);
+    console.log(`  Stack:       ${chalk.cyan(config.stack.join(', ') || '(não definida)')}`);
+    console.log(`  Preset:      ${chalk.cyan(PRESETS[config.preset].name)}`);
+    console.log(`  AI tools:    ${chalk.cyan(config.agents.map(a => AGENTS[a].name).join(', '))}`);
+    const vcsSummary = config.vcs === 'none'
+      ? chalk.dim('Nenhum (configurar depois)')
+      : `${chalk.cyan(config.vcs)} (${config.vcsOrg})`;
+    console.log(`  VCS:         ${vcsSummary}`);
+    console.log(`  Confluence:  ${chalk.cyan(config.confluenceRef)} (${config.confluenceLayout})`);
+    if (config.hasFigma && config.figmaFileUrl) {
+      console.log(`  Figma:       ${chalk.cyan(config.figmaFileUrl)}`);
+    }
+
+    console.log(chalk.bold('\n  Arquivos gerados:\n'));
+    console.log(chalk.dim('    .env             — credenciais reais (NÃO comitar)'));
+    console.log(chalk.dim('    .env.example     — template para o time'));
+    console.log(chalk.dim('    projects.yml     — configuração do projeto'));
+    console.log(chalk.dim('    .gitignore       — ignora .env e .mcp.json'));
+    if (config.agents.includes('claude')) {
+      console.log(chalk.dim('    .mcp.json        — MCP config para Claude Code'));
+    }
+    if (config.agents.includes('copilot')) {
+      console.log(chalk.dim('    .vscode/mcp.json — MCP config para GitHub Copilot'));
+    }
+
+    console.log(chalk.bold('\n  Próximos passos:\n'));
+    console.log('  → Execute /setup para fazer o bootstrap no Confluence');
+    console.log('  → Execute /discovery para analisar a primeira demanda');
+    console.log('');
+
+  } catch (err) {
+    genSpinner.fail(`Erro: ${err.message}`);
+    process.exit(1);
+  }
+}