@guilhermefsousa/open-spec-kit 0.0.9 → 0.0.11

package/src/commands/init.js

@@ -1,20 +1,15 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
-import { writeFile, mkdir, access, cp } from 'fs/promises';
+import { writeFile, mkdir, access } from 'fs/promises';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
-import { detectMcpRunner, detectNpxRunner, tryInstallMcpAtlassian, getInstallInstructions } from '../utils/mcp-detect.js';
-import { confluenceRequest, figmaRequest, isSslError } from '../utils/http.js';
+import { detectMcpRunner, detectNpxRunner } from '../utils/mcp-detect.js';
+import { confluenceRequest, isSslError } from '../utils/http.js';
+import { GLOBAL_DIR, getGlobalEnvPath, readGlobalEnv } from '../utils/global-path.js';
 
 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';
 
@@ -147,8 +142,6 @@ async function autoDetectFromConfluence(confluenceUrl, confluenceRef, user, toke
       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 {
@@ -229,7 +222,7 @@ async function checkGitExists() {
 
 async function checkExistingSetup() {
   const cwd = process.cwd();
-  const check = ['.agents', '.github/agents', 'projects.yml', '.mcp.json', '.vscode/mcp.json', '.env'];
+  const check = ['projects.yml', '.mcp.json', '.vscode/mcp.json'];
   const found = [];
   for (const f of check) {
     try {
@@ -240,32 +233,12 @@ async function checkExistingSetup() {
   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}
@@ -276,8 +249,6 @@ function generateProjectsYml(config) {
   preset: ${config.preset}
   stack:
 ${stackYaml}
-  agents:
-${agentsYaml}
 
 ${config.vcs !== 'none'
   ? `vcs: ${config.vcs}\nvcs_org: ${config.vcsOrg}`
@@ -285,11 +256,13 @@ ${config.vcs !== 'none'
 
 repos:
   # Liste os repositórios de código do projeto.
+  # O /osk-build usa 'status' e 'url' pra saber se precisa criar o repo.
+  #
   # - name: MeuProjeto.Api
   #   type: api
   #   purpose: Endpoints REST
-  #   status: planned
-  #   url: null
+  #   status: planned    # planned | active | deprecated
+  #   url: null           # preenchido pelo /osk-build ao criar o repo
 
 # Agent configuration
 agents:
@@ -325,9 +298,8 @@ confluence:
   return yml;
 }
 
-function generateGitignore(config) {
-  let content = `# Secrets (nunca comitar)
-.env
+function generateGitignore() {
+  return `# Secrets (nunca comitar)
 .mcp.json
 
 # Claude Code local files
@@ -340,47 +312,8 @@ Thumbs.db
 # IDE
 .idea/
 *.swp
+.vscode/
 `;
-
-  content += '\n.vscode/\n';
-
-  return content;
-}
-
-function generateEnvFile(config) {
-  let content = `CONFLUENCE_URL=${config.confluenceUrl}
-CONFLUENCE_USERNAME=${config.confluenceUser}
-CONFLUENCE_API_TOKEN=${config.confluenceToken}
-GCHAT_WEBHOOK_URL=${config.gchatWebhookUrl || ''}
-`;
-
-  if (config.hasFigma && config.figmaFileUrl) {
-    content += `FIGMA_API_KEY=${config.figmaToken}\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_USERNAME=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 buildMcpServers(config, { stdio = false } = {}) {
@@ -426,7 +359,7 @@ ${config.stack.map(s => `- ${s}`).join('\n')}
 
 ## Repositórios
 
-(Preenchido pelo /setup)
+(Preenchido pelo /osk-init)
 
 ## Decisões em Aberto
 
@@ -435,7 +368,7 @@ ${config.stack.map(s => `- ${s}`).join('\n')}
 
 ## Diagrama
 
-(Gerado pelo /spec ou /dev)
+(Gerado pelo /osk-spec ou /osk-build)
 `;
 }
 
@@ -445,7 +378,40 @@ ${config.stack.map(s => `- ${s}`).join('\n')}
 export async function initCommand() {
   console.log(chalk.bold('\n  open-spec-kit init\n'));
 
-  // Pre-flight: check existing setup
+  // Pre-flight: check global installation
+  try {
+    await access(GLOBAL_DIR);
+    await access(getGlobalEnvPath());
+  } catch {
+    console.log(chalk.red('  Skills globais não encontrados.'));
+    console.log(chalk.yellow(`  Execute ${chalk.bold('open-spec-kit install')} primeiro.\n`));
+    return;
+  }
+
+  // Read credentials from global .env
+  let globalEnv;
+  try {
+    globalEnv = await readGlobalEnv();
+  } catch {
+    console.log(chalk.red('  Não foi possível ler ~/.open-spec-kit/.env'));
+    console.log(chalk.yellow(`  Execute ${chalk.bold('open-spec-kit install')} para configurar credenciais.\n`));
+    return;
+  }
+
+  const confluenceUrl = (globalEnv.CONFLUENCE_URL || '').replace(/\/$/, '');
+  const confluenceUser = globalEnv.CONFLUENCE_USERNAME || '';
+  const confluenceToken = globalEnv.CONFLUENCE_API_TOKEN || '';
+
+  if (!confluenceUrl || !confluenceUser || !confluenceToken) {
+    console.log(chalk.red('  Credenciais Confluence incompletas em ~/.open-spec-kit/.env'));
+    console.log(chalk.yellow(`  Execute ${chalk.bold('open-spec-kit install --force')} para reconfigurar.\n`));
+    return;
+  }
+
+  console.log(chalk.dim(`  Credenciais: ${getGlobalEnvPath()}`));
+  console.log(chalk.dim(`  Skills:      ${GLOBAL_DIR}\n`));
+
+  // Pre-flight: check existing project setup
   const existing = await checkExistingSetup();
   if (existing.length > 0) {
     console.log(chalk.yellow('  Estrutura existente detectada:'));
@@ -463,21 +429,11 @@ export async function initCommand() {
   }
 
   // ════════════════════════════════════════════
-  // Phase 1 — Conexão
+  // Phase 1 — Projeto
   // ════════════════════════════════════════════
-  console.log(chalk.bold.blue('\n  ── Fase 1: Conexão ──\n'));
+  console.log(chalk.bold.blue('\n  ── Fase 1: Projeto ──\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',
@@ -503,103 +459,39 @@ export async function initCommand() {
       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();
+  // ════════════════════════════════════════════
+  // Phase 2 — Auto-detecção
+  // ════════════════════════════════════════════
+  let detected = { projectName: null, stack: [], repos: [], spaceKey: null, success: false };
+  const isNumericRef = /^\d+$/.test(phase1.confluenceRef.trim());
   let credentialsValid = false;
   let allowInsecure = false;
-  const confluenceUrl = phase1.confluenceUrl.trim().replace(/\/$/, '');
 
+  // Validate credentials silently
   try {
-    await confluenceRequest(
-      confluenceUrl,
-      '/rest/api/space?limit=1',
-      phase1.confluenceUser.trim(),
-      phase1.confluenceToken.trim()
-    );
-    spinner.succeed('Credenciais validadas com sucesso!');
+    await confluenceRequest(confluenceUrl, '/rest/api/space?limit=1', confluenceUser, confluenceToken);
     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).');
+        await confluenceRequest(confluenceUrl, '/rest/api/space?limit=1', confluenceUser, confluenceToken, 15000, true);
         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'));
+        allowInsecure = true;
+      } catch { /* ignore */ }
     }
   }
 
-  // ════════════════════════════════════════════
-  // 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'));
+    console.log(chalk.bold.blue('\n  ── 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
+        confluenceUrl, phase1.confluenceRef.trim(),
+        confluenceUser, confluenceToken,
+        detectSpinner, allowInsecure
       );
 
       if (detected.success && detected.stack.length > 0) {
@@ -612,24 +504,21 @@ export async function initCommand() {
           console.log(chalk.green(`  Projeto: ${detected.projectName}`));
         }
       } else {
-        detectSpinner.info('Nenhuma stack detectada automaticamente — preencha manualmente.');
+        detectSpinner.info('Nenhuma stack detectada automaticamente.');
       }
     } catch {
-      detectSpinner.info('Auto-detecção não disponível — preencha manualmente.');
+      detectSpinner.info('Auto-detecção não disponível.');
     }
-  } 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'));
+  console.log(chalk.bold.blue('\n  ── 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'));
+    console.log(chalk.dim('  .git já existe — git init será pulado.\n'));
   }
 
   const defaultStack = detected.stack.length > 0 ? detected.stack.join(', ') : '';
@@ -645,7 +534,7 @@ export async function initCommand() {
     {
       type: 'input',
       name: 'sigla',
-      message: 'Sigla (2-4 letras maiúsculas, usada como prefixo):',
+      message: 'Sigla (2-4 letras maiúsculas):',
       default: (answers) => deriveSigla(answers.projectName || detected.projectName || ''),
       filter: v => v.toUpperCase().replace(/[^A-Z]/g, '').slice(0, 4),
       validate: v => {
@@ -657,7 +546,7 @@ export async function initCommand() {
     {
       type: 'input',
       name: 'stack',
-      message: 'Stack principal (separado por vírgula, ex: Node.js, React, PostgreSQL):',
+      message: 'Stack principal (separado por vírgula):',
       default: defaultStack || undefined,
       filter: v => v.split(',').map(s => s.trim()).filter(Boolean),
       when: () => detected.stack.length === 0
@@ -675,16 +564,10 @@ export async function initCommand() {
     {
       type: 'input',
       name: 'vcsOrg',
-      message: 'Organização/grupo no VCS (ex: minha-empresa ou meu-usuario):',
+      message: 'Organização/grupo no VCS:',
       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',
@@ -694,23 +577,15 @@ export async function initCommand() {
     {
       type: 'input',
       name: 'figmaFileUrl',
-      message: 'URL do arquivo Figma (ex: https://www.figma.com/design/ABC123/Nome):',
+      message: 'URL do arquivo Figma:',
       when: (answers) => answers.hasFigma,
       validate: v => {
         const trimmed = v.trim();
-        if (!trimmed) return 'Obrigatório — se não tem URL, responda "Não" na pergunta anterior';
-        if (!trimmed.includes('figma.com')) return 'URL deve ser do Figma (figma.com)';
+        if (!trimmed) return 'Obrigatório';
+        if (!trimmed.includes('figma.com')) return 'URL deve ser do Figma';
         return true;
       }
     },
-    {
-      type: 'password',
-      name: 'figmaToken',
-      message: 'Figma API token (Personal Access Token):',
-      mask: '*',
-      when: (answers) => answers.hasFigma && answers.figmaFileUrl?.trim(),
-      validate: v => v.trim().length > 0 || 'Obrigatório — gere em: Figma > Account Settings > Personal Access Tokens'
-    },
     {
       type: 'confirm',
       name: 'initGit',
@@ -720,86 +595,39 @@ export async function initCommand() {
     }
   ]);
 
-  // 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 = '';
   }
 
-  // Validate Figma token
-  let figmaTokenValidated = false;
-  if (phase3.hasFigma && phase3.figmaToken) {
-    const figmaSpinner = ora('Validando token do Figma...').start();
-    try {
-      const result = await figmaRequest(phase3.figmaToken.trim());
-      figmaSpinner.succeed(`Token Figma validado — usuário: ${result.data.handle || result.data.email || 'OK'}`);
-      figmaTokenValidated = true;
-    } catch (err) {
-      if (err.status === 401 || err.status === 403) {
-        figmaSpinner.fail(`Token Figma inválido (HTTP ${err.status}). Verifique o Personal Access Token.`);
-        console.log(chalk.dim('  Gere em: Figma > Account Settings > Personal Access Tokens'));
-        console.log(chalk.yellow('  Continuando sem Figma...\n'));
-        phase3.hasFigma = false;
-        phase3.figmaFileUrl = '';
-        phase3.figmaToken = '';
-      } else if (isSslError(err)) {
-        figmaSpinner.text = 'Certificado SSL corporativo detectado — tentando sem verificação...';
-        try {
-          const result = await figmaRequest(phase3.figmaToken.trim(), 15000, true);
-          figmaSpinner.succeed(`Token Figma validado (SSL corporativo ignorado) — usuário: ${result.data.handle || result.data.email || 'OK'}`);
-          figmaTokenValidated = true;
-        } catch (retryErr) {
-          if (retryErr.status === 401 || retryErr.status === 403) {
-            figmaSpinner.fail(`Token Figma inválido (HTTP ${retryErr.status}). Verifique o Personal Access Token.`);
-            console.log(chalk.dim('  Gere em: Figma > Account Settings > Personal Access Tokens'));
-            console.log(chalk.yellow('  Continuando sem Figma...\n'));
-            phase3.hasFigma = false;
-            phase3.figmaFileUrl = '';
-            phase3.figmaToken = '';
-          } else {
-            figmaSpinner.warn(`Não foi possível validar o token Figma: ${retryErr.message}`);
-            console.log(chalk.yellow('  Token será salvo, mas verifique com "open-spec-kit doctor".\n'));
-          }
-        }
-      } else {
-        figmaSpinner.warn(`Não foi possível validar o token Figma: ${err.message}`);
-        console.log(chalk.yellow('  Token será salvo, mas verifique com "open-spec-kit doctor".\n'));
-      }
-    }
-  }
-
-  // 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
+  // Build config (credentials from global .env)
   const config = {
-    agents: phase1.agents,
     preset: phase1.preset,
     confluenceLayout: phase1.confluenceLayout,
     confluenceRef: phase1.confluenceRef.trim(),
     confluenceUrl,
-    confluenceUser: phase1.confluenceUser.trim(),
-    confluenceToken: phase1.confluenceToken.trim(),
+    confluenceUser,
+    confluenceToken,
     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(),
+    gchatWebhookUrl: globalEnv.GCHAT_WEBHOOK_URL || '',
     hasFigma: phase3.hasFigma,
     figmaFileUrl: (phase3.figmaFileUrl || '').trim(),
-    figmaToken: (phase3.figmaToken || '').trim(),
+    figmaToken: globalEnv.FIGMA_API_KEY || '',
     initGit: initGitFinal,
   };
 
   // ════════════════════════════════════════════
-  // Phase 4 — Revisão & Confirmação (B4)
+  // Revisão & Confirmação
   // ════════════════════════════════════════════
-  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'));
+  console.log(chalk.bold.blue('\n  ── Revisão ──\n'));
 
   const vcsDisplay = config.vcs === 'none'
     ? chalk.dim('Nenhum (configurar depois)')
@@ -809,14 +637,11 @@ export async function initCommand() {
   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'))}`);
-  const figmaStatus = config.hasFigma
-    ? `${config.figmaFileUrl} (${figmaTokenValidated ? 'token validado' : 'token salvo, não validado'})`
-    : 'Não';
-  console.log(`  Figma:         ${chalk.cyan(figmaStatus)}`);
+  console.log(`  Confluence:    ${chalk.cyan(config.confluenceRef)} @ ${chalk.cyan(config.confluenceUrl)}`);
+  if (config.hasFigma) {
+    console.log(`  Figma:         ${chalk.cyan(config.figmaFileUrl)}`);
+  }
   if (gitAlreadyExists) {
     console.log(`  Git init:      ${chalk.dim('Pulado (.git já existe)')}`);
   } else {
@@ -832,81 +657,43 @@ export async function initCommand() {
   }]);
 
   if (!confirmed) {
-    console.log(chalk.yellow('\n  Cancelado. Execute open-spec-kit init novamente para recomeçar.\n'));
+    console.log(chalk.yellow('\n  Cancelado.\n'));
     return;
   }
 
   // ════════════════════════════════════════════
-  // File generation
+  // File generation — projeto limpo
   // ════════════════════════════════════════════
   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) {
+    // Create directories
+    for (const dir of ['specs', 'docs/decisions', 'docs/lessons']) {
       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';
+    // projects.yml
+    genSpinner.text = 'projects.yml';
     await writeFile(join(cwd, 'projects.yml'), generateProjectsYml(config));
 
-    // Generate .gitignore
-    genSpinner.text = '.gitignore criado';
-    await writeFile(join(cwd, '.gitignore'), generateGitignore(config));
+    // .gitignore
+    genSpinner.text = '.gitignore';
+    await writeFile(join(cwd, '.gitignore'), generateGitignore());
 
-    // Copy shared templates (agents source of truth)
-    genSpinner.text = 'Copiando skills e rules...';
-    await copyTemplateDir('agents', cwd);
+    // MCP configs (credentials from global .env)
+    genSpinner.text = '.mcp.json (Claude Code)';
+    await writeFile(join(cwd, '.mcp.json'), generateClaudeMcp(config));
 
-    // 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));
-    }
+    genSpinner.text = '.vscode/mcp.json (Copilot)';
+    await mkdir(join(cwd, '.vscode'), { recursive: true });
+    await writeFile(join(cwd, '.vscode/mcp.json'), generateCopilotMcp(config));
 
-    // Generate docs/architecture.md skeleton
+    // docs/architecture.md
+    genSpinner.text = 'docs/architecture.md';
     await writeFile(join(cwd, 'docs/architecture.md'), generateArchitectureSkeleton(config));
 
-    genSpinner.succeed('Estrutura gerada com sucesso!');
-
-    // Install mcp-atlassian — cross-platform detection (uvx > pipx > pip)
-    const mcpSpinner = ora('Verificando mcp-atlassian...').start();
-    const installResult = tryInstallMcpAtlassian();
-    if (installResult.installed) {
-      mcpSpinner.succeed(`mcp-atlassian disponível via ${installResult.method}`);
-    } else {
-      mcpSpinner.warn(`${installResult.message}. Instale manualmente:`);
-      for (const line of getInstallInstructions()) {
-        console.log(chalk.dim(`    ${line}`));
-      }
-    }
+    genSpinner.succeed('Estrutura gerada!');
 
     // Git init
     if (config.initGit) {
@@ -914,44 +701,24 @@ export async function initCommand() {
         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'));
+        console.log(chalk.green('\n  Repositório Git inicializado'));
       } 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"'));
+        console.log(chalk.yellow('\n  Git init falhou — inicialize manualmente'));
       }
     }
 
     // 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.dim('    .mcp.json        — MCP config (Claude Code)'));
+    console.log(chalk.dim('    .vscode/mcp.json — MCP config (Copilot)'));
+    console.log(chalk.dim('    .gitignore'));
+    console.log(chalk.dim('    docs/            — arquitetura, decisões, lições'));
+    console.log(chalk.dim('    specs/           — (vazio, preenchido pelo /osk-spec)'));
 
     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('  → Execute /osk-init para fazer o bootstrap no Confluence');
+    console.log('  → Execute /osk-discover para analisar a primeira demanda');
     console.log('');
 
   } catch (err) {
@@ -967,8 +734,6 @@ export {
   detectRepoNames,
   deriveSigla,
   generateProjectsYml,
-  generateEnvFile,
-  generateEnvExample,
   generateGitignore,
   generateArchitectureSkeleton,
 };