agent-master-devsecops 0.0.0-stage → 5.1.0

package/scripts/bin/bootstrap_cli.js

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+/**
+ * scripts/bin/bootstrap_cli.js
+ * 
+ * Universal One-Line Bootstrap CLI (v5.1 Enterprise).
+ * Ponto de entrada executável principal do pacote npm (agent-master-devsecops / agent-master-init).
+ * Auto-detecta IDEs instaladas (Cursor, Windsurf, VS Code, Claude Desktop, Antigravity, Ollama)
+ * e provisiona o ecossistema multiagente, governança e servidor MCP com zero configuração em < 2 segundos.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { UniversalPackager } = require('../core/universal_packager.js');
+const { runCredentialHealthcheck } = require('../integrations/credentials_guard.js');
+const { detectProjectMode, inspectProjectContext } = require('./smart_onboarding.js');
+
+// Catálogo imutável de arquivos canônicos da suíte
+const CANONICAL_FILES = Object.freeze([
+  'agents/AGENT_ORCHESTRATOR.md',
+  'agents/AGENT_UIUX.md',
+  'agents/AGENT_DEVSECOPS.md',
+  'agents/AGENT_SCRUM.md',
+  'agents/AGENT_SRE.md',
+  'agents/AGENT_QA.md',
+  'agents/AGENT_INFRA.md',
+  'docs/ENGINEERING_RULES.md',
+  'docs/ARCHITECTURE.md',
+  'docs/IDEAS.md'
+]);
+
+/**
+ * Executa checagem de existência de comando no PATH de forma protegida contra travamentos.
+ * @param {string} cmd 
+ * @returns {boolean}
+ */
+function commandExists(cmd) {
+  if (!cmd || typeof cmd !== 'string') return false;
+  try {
+    const bin = process.platform === 'win32' ? 'where' : 'which';
+    execFileSync(bin, [cmd], {
+      stdio: 'ignore',
+      timeout: 3000,
+      windowsHide: true
+    });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Auto-detecta ambientes e IDEs suportadas para o projeto alvo.
+ * @param {string} [targetDir=process.cwd()] 
+ * @param {object} [options={}] 
+ * @returns {object}
+ */
+function detectEnvironments(targetDir = process.cwd(), options = {}) {
+  const safeTargetDir = typeof targetDir === 'string' && targetDir ? targetDir : process.cwd();
+  const safeOptions = (options && typeof options === 'object') ? options : {};
+
+  const detected = {
+    cursor: false,
+    windsurf: false,
+    vscode: false,
+    claude_desktop: false,
+    ollama: false,
+    antigravity: false,
+    generic: true
+  };
+
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+
+  // 0. Se plataformas foram especificadas expressamente (options.platforms), honrar estritamente
+  if (Array.isArray(safeOptions.platforms) && safeOptions.platforms.length > 0) {
+    for (const p of safeOptions.platforms) {
+      const clean = String(p).toLowerCase().trim();
+      if (clean === 'all' || clean === 'universal') {
+        detected.cursor = true;
+        detected.windsurf = true;
+        detected.vscode = true;
+        detected.claude_desktop = true;
+        detected.antigravity = true;
+      } else if (clean === 'vscode' || clean === 'code') {
+        detected.vscode = true;
+      } else if (clean === 'antigravity' || clean === 'gemini') {
+        detected.antigravity = true;
+      } else if (clean === 'cursor') {
+        detected.cursor = true;
+      } else if (clean === 'windsurf') {
+        detected.windsurf = true;
+      } else if (clean === 'claude_desktop' || clean === 'claude') {
+        detected.claude_desktop = true;
+      } else if (clean === 'ollama') {
+        detected.ollama = true;
+      }
+    }
+    return detected;
+  }
+
+  // 1. Detectar Antigravity no targetDir ou processo ativo
+  const isRunningInAntigravity = Boolean(process.env.ANTIGRAVITY_AGENT || process.env.ANTIGRAVITY_APP_DATA_DIR);
+  if (
+    isRunningInAntigravity ||
+    fs.existsSync(path.join(safeTargetDir, '.antigravity')) ||
+    fs.existsSync(path.join(safeTargetDir, '.gemini'))
+  ) {
+    detected.antigravity = true;
+  }
+
+  // 2. Detectar Cursor no targetDir
+  if (
+    fs.existsSync(path.join(safeTargetDir, '.cursor')) ||
+    fs.existsSync(path.join(safeTargetDir, '.cursorrules'))
+  ) {
+    detected.cursor = true;
+  }
+
+  // 3. Detectar Windsurf no targetDir
+  if (
+    fs.existsSync(path.join(safeTargetDir, '.windsurf')) ||
+    fs.existsSync(path.join(safeTargetDir, '.windsurfrules'))
+  ) {
+    detected.windsurf = true;
+  }
+
+  // 4. Detectar VS Code SOMENTE se houver diretório .vscode existente no targetDir
+  if (fs.existsSync(path.join(safeTargetDir, '.vscode'))) {
+    detected.vscode = true;
+  }
+
+  // 5. Detectar Claude Desktop no targetDir
+  if (
+    fs.existsSync(path.join(safeTargetDir, '.claude')) ||
+    fs.existsSync(path.join(safeTargetDir, 'claude_desktop_config.json'))
+  ) {
+    detected.claude_desktop = true;
+  }
+
+  // 6. Detectar Ollama no targetDir
+  if (fs.existsSync(path.join(safeTargetDir, 'Modelfile'))) {
+    detected.ollama = true;
+  }
+
+  // Se nenhum arquivo de IDE foi encontrado no diretório do projeto:
+  const hasProjectLevelIde = detected.antigravity || detected.cursor || detected.windsurf || detected.vscode || detected.claude_desktop || detected.ollama;
+  if (!hasProjectLevelIde) {
+    // Se há Antigravity no ambiente do usuário, assume Antigravity por padrão
+    if (
+      (homeDir && fs.existsSync(path.join(homeDir, '.gemini', 'antigravity'))) ||
+      commandExists('antigravity') ||
+      commandExists('agy')
+    ) {
+      detected.antigravity = true;
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * Provisiona o ecossistema Agent Master DevSecOps e o servidor MCP no diretório alvo.
+ * @param {string} [targetDir=process.cwd()] 
+ * @param {object} [options={}] 
+ * @returns {object}
+ */
+function bootstrapEnvironment(targetDir = process.cwd(), options = {}) {
+  const startTime = Date.now();
+  const safeTargetDir = typeof targetDir === 'string' && targetDir ? targetDir : process.cwd();
+  const safeOptions = (options && typeof options === 'object') ? options : {};
+  const rootSource = path.resolve(__dirname, '../..');
+  const dryRun = Boolean(safeOptions.dryRun);
+
+  // 1. Auto-detectar ambientes
+  const detected = safeOptions.platforms 
+    ? detectEnvironments(safeTargetDir, { platforms: safeOptions.platforms })
+    : detectEnvironments(safeTargetDir, safeOptions);
+
+  const activePlatforms = Object.keys(detected).filter(k => detected[k]);
+  const credentialHealth = runCredentialHealthcheck(safeTargetDir);
+  const projectMode = detectProjectMode(safeTargetDir);
+  const projectContext = inspectProjectContext(safeTargetDir);
+
+  const results = {
+    onboardingMode: projectMode.mode,
+    projectContext,
+    status: 'SUCCESS',
+    targetDir: safeTargetDir,
+    dryRun,
+    detectedEnvironments: detected,
+    activePlatforms,
+    credentials: {
+      allReady: credentialHealth.allReady,
+      github: credentialHealth.github,
+      atlassian: credentialHealth.atlassian,
+      missing: credentialHealth.missing,
+      promptGuidance: credentialHealth.promptGuidance
+    },
+    copiedFiles: [],
+    configuredPlatforms: [],
+    mcpServerPath: path.resolve(rootSource, 'scripts', 'mcp_server.js'),
+    durationMs: 0
+  };
+
+  // 2. Provisionar arquivos canônicos do agente no safeTargetDir (Modo Limpo de Submódulo)
+  const isSubmoduleMode = Boolean(
+    !safeOptions.forceCopy &&
+    (
+      path.resolve(safeTargetDir, 'agent-master-devsecops') === rootSource ||
+      (fs.existsSync(path.join(safeTargetDir, '.gitmodules')) && fs.existsSync(path.join(safeTargetDir, 'agent-master-devsecops')))
+    )
+  );
+
+  results.isSubmoduleMode = isSubmoduleMode;
+
+  if (!isSubmoduleMode) {
+    const agentDir = path.join(safeTargetDir, 'agents');
+    const docDir = path.join(safeTargetDir, 'docs');
+
+    if (!dryRun) {
+      if (!fs.existsSync(agentDir)) fs.mkdirSync(agentDir, { recursive: true });
+      if (!fs.existsSync(docDir)) fs.mkdirSync(docDir, { recursive: true });
+    }
+
+    for (const relFile of CANONICAL_FILES) {
+      const src = path.join(rootSource, relFile);
+      const actualSrc = src;
+      const dest = path.join(safeTargetDir, relFile);
+
+      if (fs.existsSync(actualSrc)) {
+        if (!dryRun) {
+          const destParent = path.dirname(dest);
+          if (!fs.existsSync(destParent)) fs.mkdirSync(destParent, { recursive: true });
+          fs.copyFileSync(actualSrc, dest);
+        }
+        results.copiedFiles.push(relFile);
+      }
+    }
+  } else {
+    results.submoduleNotice = 'Submódulo detectado. Cópia redundante de agents/ e docs/ na raiz suprimida com sucesso (Modo Limpo - Regra 16).';
+  }
+
+  // 3. Gerar configurações das plataformas detectadas
+  const packager = new UniversalPackager(rootSource);
+
+  if (detected.cursor) {
+    const res = packager.generateCursorProfile(safeTargetDir, { dryRun, mcpServerPath: results.mcpServerPath });
+    results.configuredPlatforms.push({ platform: 'cursor', files: res.filesCount });
+  }
+
+  if (detected.windsurf) {
+    const res = packager.generateWindsurfProfile(safeTargetDir, { dryRun });
+    results.configuredPlatforms.push({ platform: 'windsurf', files: res.filesCount });
+  }
+
+  if (detected.vscode) {
+    const res = packager.generateVsCodeProfile(safeTargetDir, { dryRun, mcpServerPath: results.mcpServerPath });
+    results.configuredPlatforms.push({ platform: 'vscode', files: res.filesCount });
+  }
+
+  if (detected.claude_desktop) {
+    const res = packager.generateClaudeDesktopProfile(safeTargetDir, { dryRun, mcpServerPath: results.mcpServerPath });
+    results.configuredPlatforms.push({ platform: 'claude_desktop', files: res.filesCount });
+  }
+
+  if (detected.antigravity) {
+    const res = packager.generateAntigravityConfig(safeTargetDir, { dryRun, mcpServerPath: results.mcpServerPath });
+    results.configuredPlatforms.push({ platform: 'antigravity', files: res.filesCount });
+  }
+
+  if (detected.ollama) {
+    const res = packager.generateOllamaProfile(safeTargetDir, { dryRun });
+    results.configuredPlatforms.push({ platform: 'ollama', files: res.filesCount });
+  }
+
+  // Se nenhuma IDE especializada foi detectada, gera o bundle universal genérico
+  if (results.configuredPlatforms.length === 0) {
+    const res = packager.generateCursorProfile(safeTargetDir, { dryRun, mcpServerPath: results.mcpServerPath });
+    results.configuredPlatforms.push({ platform: 'universal_fallback_cursor', files: res.filesCount });
+  }
+
+  results.durationMs = Date.now() - startTime;
+  return results;
+}
+
+/**
+ * Validação de integridade estrutural modular.
+ * @param {string} baseDir 
+ * @returns {object}
+ */
+function validateModularStructure(baseDir) {
+  const safeBaseDir = typeof baseDir === 'string' && baseDir ? baseDir : process.cwd();
+  const missing = [];
+  const present = [];
+
+  for (const relPath of CANONICAL_FILES) {
+    const fullPath = path.join(safeBaseDir, relPath);
+    if (fs.existsSync(fullPath)) {
+      present.push(relPath);
+    } else {
+      missing.push(relPath);
+    }
+  }
+
+  return {
+    valid: missing.length === 0,
+    total: CANONICAL_FILES.length,
+    present,
+    missing
+  };
+}
+
+/**
+ * Função de inicialização universal com contrato do init_cli.
+ * @param {string} [targetDir=process.cwd()] 
+ * @param {object} [options={}] 
+ * @returns {object}
+ */
+function initProject(targetDir = process.cwd(), options = {}) {
+  const res = bootstrapEnvironment(targetDir, options);
+  res.rulesConfigured = res.copiedFiles.length > 0 || Boolean(options && options.dryRun) || Boolean(res.isSubmoduleMode);
+  res.mcpConfigured = true;
+  return res;
+}
+
+/**
+ * Renderiza o prompt canônico customizado com metadados do projeto.
+ * @param {object} [meta={}] 
+ * @returns {string}
+ */
+function renderCanonicalPrompt(meta = {}) {
+  const projectName = meta.projectName || 'Enterprise Software System';
+  const techStack = meta.techStack || 'Polyglot / Universal Multi-Stack';
+  const ticketSystem = meta.ticketSystem || 'Jira Cloud / GitHub Issues';
+
+  return `Você é o AGENT ORCHESTRATOR DE ENGENHARIA DE SOFTWARE, ARQUITETURA, DEVSECOPS E GOVERNANÇA do projeto "${projectName}".
+Stack Tecnológica: ${techStack}
+Sistema de Governança & Rastreabilidade: ${ticketSystem}
+
+Você opera sob a estrutura modular soberana das pastas /agents e /docs com contratos de engenharia catalogados:
+- agents/AGENT_ORCHESTRATOR.md (Orquestrador multi-persona)
+- agents/AGENT_UIUX.md (Product Designer, UX/UI, Heurísticas & WCAG 2.1 AA)
+- agents/AGENT_DEVSECOPS.md (Staff Engineer & DevSecOps Lead)
+- agents/AGENT_QA.md (Auditor adversário independente)
+- agents/AGENT_INFRA.md (Engenharia de infraestrutura, Docker & redes reais)
+- agents/AGENT_SCRUM.md (Gestão ágil, melhoria contínua e PDCA)
+- agents/AGENT_SRE.md (SRE Lead, observabilidade e telemetria)
+- docs/ENGINEERING_RULES.md (10 Princípios Canônicos de Engenharia de Software & Governança / 14 Regras Fundamentais de Engenharia)
+- README.md (Manual mestre, catálogo e MCP)
+- docs/ARCHITECTURE.md (Topologia cooperativa e matriz de handovers)
+
+Modos de Operação Disponíveis:
+- modo: orchestrator
+- modo: uiux
+- modo: devsecops
+- modo: qa
+- modo: infra
+- modo: scrum
+- modo: sre
+- modo: full-dev (loop ininterrupto de implementação autônoma)
+
+Protocolo Obrigatório: Protocolo de Resposta em Duas Camadas (relatórios densos de 15 seções externalizados no Jira/Confluence/PRs e respostas curtas com links e dupla quebra de linha (\\n\\n) no chat). Declare prontidão para atuar.`;
+}
+
+/**
+ * Formata relatório executivo em Markdown do processo de bootstrapping.
+ * @param {object} result 
+ * @returns {string}
+ */
+function formatReport(result) {
+  if (!result || typeof result !== 'object') {
+    return '# 🚀 Agent-Master DevSecOps — Bootstrap Report\n\nRelatório de bootstrapping indisponível.';
+  }
+
+  let output = '# 🚀 Agent-Master DevSecOps — Bootstrap Report\n\n';
+  output += `**Status:** ${result.status || 'SUCCESS'}\n`;
+  output += `**Diretório Alvo:** \`${result.targetDir || 'N/A'}\`\n`;
+  output += `**Modo de Onboarding (Regra 16):** \`${result.onboardingMode || 'UNKNOWN'}\`\n`;
+  output += `**Duração:** ${result.durationMs || 0}ms\n`;
+  output += `**Modo Simulado (dryRun):** ${result.dryRun ? 'SIM' : 'NÃO'}\n\n`;
+
+  output += '### 🛠️ Plataformas Configuradas\n';
+  const platforms = Array.isArray(result.configuredPlatforms) ? result.configuredPlatforms : [];
+  if (platforms.length === 0) {
+    output += '- Nenhuma plataforma especializada configurada.\n';
+  } else {
+    platforms.forEach(p => {
+      output += `- \`${p.platform}\`: ${p.files || 0} arquivos gerados (${p.configPath || 'configurado'})\n`;
+    });
+  }
+  output += '\n';
+
+  output += '### 📄 Arquivos Canônicos Injetados\n';
+  if (result.isSubmoduleMode) {
+    output += `- **Modo Submódulo Limpo:** ${result.submoduleNotice || 'Arquivos compartilhados sem duplicação na raiz'}\n`;
+  } else {
+    const copied = Array.isArray(result.copiedFiles) ? result.copiedFiles : (Array.isArray(result.filesCreated) ? result.filesCreated : []);
+    output += `- **Total de Arquivos:** ${copied.length}\n`;
+    copied.forEach(f => { output += `  - \`${f}\`\n`; });
+  }
+  output += '\n';
+
+  output += '### 🔐 Integridade de Credenciais\n';
+  if (result.credentials || result.credentialStatus) {
+    const cred = result.credentials || result.credentialStatus;
+    const isReady = cred.allReady || cred.isConfigured;
+    output += `- **Tríade Pronta:** ${isReady ? 'SIM (100% Autenticada)' : 'PENDENTE'}\n`;
+    if (cred.github) output += `- **GitHub CLI:** ${cred.github.authenticated ? 'OK' : 'Não autenticado'}\n`;
+    if (cred.atlassian) output += `- **Atlassian:** ${cred.atlassian.configured ? 'OK' : 'Pendente'}\n`;
+  }
+  return output;
+}
+
+/**
+ * Classe canônica do Universal Bootstrap CLI.
+ */
+class BootstrapCli {
+  static get CANONICAL_FILES() {
+    return CANONICAL_FILES;
+  }
+
+  constructor(options = {}) {
+    this.options = Object.freeze({ ...options });
+    this.canonicalFiles = CANONICAL_FILES;
+  }
+
+  commandExists(cmd) {
+    return commandExists(cmd);
+  }
+
+  detectEnvironments(targetDir = process.cwd(), options = {}) {
+    return detectEnvironments(targetDir, { ...this.options, ...options });
+  }
+
+  bootstrap(targetDir = process.cwd(), options = {}) {
+    return bootstrapEnvironment(targetDir, { ...this.options, ...options });
+  }
+
+  bootstrapEnvironment(targetDir = process.cwd(), options = {}) {
+    return bootstrapEnvironment(targetDir, { ...this.options, ...options });
+  }
+
+  initProject(targetDir = process.cwd(), options = {}) {
+    return initProject(targetDir, { ...this.options, ...options });
+  }
+
+  validateModularStructure(baseDir = process.cwd()) {
+    return validateModularStructure(baseDir);
+  }
+
+  renderCanonicalPrompt(meta = {}) {
+    return renderCanonicalPrompt(meta);
+  }
+
+  formatReport(result) {
+    return formatReport(result);
+  }
+}
+
+if (require.main === module) {
+  (async () => {
+    const args = process.argv.slice(2);
+    const dryRun = args.includes('--dryRun') || args.includes('-d');
+    const detectOnly = args.includes('--detectOnly');
+    const nonInteractive = args.includes('--non-interactive') || args.includes('--yes') || args.includes('-y');
+    let targetDir = process.cwd();
+
+    const targetIdx = args.findIndex(a => a === '--targetDir' || a === '-t');
+    if (targetIdx !== -1 && args[targetIdx + 1]) {
+      targetDir = path.resolve(args[targetIdx + 1]);
+    }
+
+    let requestedPlatform = null;
+    const platformIdx = args.findIndex(a => a === '--platform' || a === '-p');
+    if (platformIdx !== -1 && args[platformIdx + 1]) {
+      requestedPlatform = args[platformIdx + 1].toLowerCase().trim();
+    }
+
+    console.log('\n============================================================');
+    console.log('⚡ Agent Master DevSecOps — Universal One-Line Bootstrap CLI');
+    console.log('============================================================\n');
+
+    if (detectOnly) {
+      const detected = detectEnvironments(targetDir, { platforms: requestedPlatform ? [requestedPlatform] : undefined });
+      console.log('🔍 Ambientes Detectados em:', targetDir);
+      console.log(JSON.stringify(detected, null, 2));
+      process.exit(0);
+    }
+
+    let selectedPlatforms = requestedPlatform ? [requestedPlatform] : null;
+
+    // Se nenhuma plataforma foi passada via flag e o terminal é interativo (TTY), exibe menu de seleção
+    if (!selectedPlatforms && process.stdin.isTTY && !nonInteractive && !dryRun) {
+      const initialDetected = detectEnvironments(targetDir);
+      const hasExplicitProjectConfig = initialDetected.cursor || initialDetected.windsurf || initialDetected.vscode || initialDetected.claude_desktop;
+
+      if (!hasExplicitProjectConfig) {
+        const readline = require('node:readline/promises');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+        console.log('🛠️  Selecione a IDE / Plataforma para este projeto:');
+        console.log('  1) Google Antigravity (Padrão)');
+        console.log('  2) Cursor IDE (.cursorrules + .cursor/mcp.json)');
+        console.log('  3) Windsurf IDE (.windsurfrules)');
+        console.log('  4) VS Code (.vscode/mcp.json)');
+        console.log('  5) Claude Desktop (claude_desktop_config.json)');
+        console.log('  6) Universal (Configurar todas as plataformas)\n');
+
+        try {
+          const answer = await rl.question('👉 Escolha uma opção (1-6) [1]: ');
+          const choice = answer.trim();
+          switch (choice) {
+            case '2': selectedPlatforms = ['cursor']; break;
+            case '3': selectedPlatforms = ['windsurf']; break;
+            case '4': selectedPlatforms = ['vscode']; break;
+            case '5': selectedPlatforms = ['claude_desktop']; break;
+            case '6': selectedPlatforms = ['all']; break;
+            case '1':
+            case '':
+            default:
+              selectedPlatforms = ['antigravity']; break;
+          }
+        } catch (_) {
+          selectedPlatforms = ['antigravity'];
+        } finally {
+          rl.close();
+        }
+        console.log();
+      }
+    }
+
+    const bootOptions = { dryRun };
+    if (selectedPlatforms) {
+      bootOptions.platforms = selectedPlatforms;
+    }
+
+    const result = bootstrapEnvironment(targetDir, bootOptions);
+    console.log(`✅ Bootstrapping concluído com sucesso em ${result.durationMs}ms!`);
+    console.log(`📂 Diretório Alvo: ${result.targetDir}`);
+    console.log(`🔍 Modo de Projeto (Regra 16): [${result.onboardingMode}] (${result.onboardingMode === 'BROWNFIELD' ? 'Projeto existente mapeado' : 'Projeto novo do zero'})`);
+    if (result.projectContext && result.projectContext.stack && result.projectContext.stack.length > 0) {
+      console.log(`🛠️ Stack Mapeada: ${result.projectContext.stack.join(', ')}`);
+    }
+    if (result.isSubmoduleMode) {
+      console.log(`✨ Modo Submódulo Limpo: Os arquivos canônicos residem em 'agent-master-devsecops/'. Nenhuma pasta duplicada criada na raiz!`);
+    } else {
+      console.log(`📄 Arquivos Canônicos Injetados: ${result.copiedFiles.length}`);
+    }
+    console.log(`🛠️ Plataformas Configuradas:`, result.configuredPlatforms.map(p => p.platform).join(', '));
+    console.log(`🔌 Servidor MCP Vinculado: ${result.mcpServerPath}`);
+
+    if (!result.credentials.allReady) {
+      console.log('\n------------------------------------------------------------');
+      console.log(result.credentials.promptGuidance);
+      console.log('------------------------------------------------------------\n');
+
+      if (process.stdin.isTTY && !nonInteractive) {
+        const readline = require('node:readline/promises');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+          const ans = await rl.question('🔑 Deseja cadastrar as credenciais da Atlassian agora no .env? (s/n): ');
+          if (ans.trim().toLowerCase() === 's') {
+            const domain = await rl.question('Domínio Atlassian (ex: empresa.atlassian.net): ');
+            const email = await rl.question('Email da conta Atlassian: ');
+            const token = await rl.question('API Token Atlassian: ');
+            const jiraKey = await rl.question('Chave do Projeto no Jira (ex: AGDEV ou PROJ): ');
+            const confluenceSpace = await rl.question('Chave do Espaço no Confluence (ex: AGDEV ou DOCS): ');
+            const { configureCredentials } = require('../integrations/credentials_guard.js');
+            configureCredentials(targetDir, { domain, email, token, jiraKey, confluenceSpace });
+            console.log('\n✅ Credenciais salvas com sucesso em .env (protegido pelo .gitignore)!\n');
+          }
+        } catch (err) {
+          void err;
+        } finally {
+          rl.close();
+        }
+      }
+    } else {
+      console.log('🩺 Credenciais Atlassian & GitHub: 100% Autenticadas e Prontas!\n');
+    }
+
+    console.log('O Agent Master está pronto para uso na sua IDE e LLM!\n');
+  })();
+}
+
+module.exports = {
+  BootstrapCli,
+  detectEnvironments,
+  bootstrapEnvironment,
+  CANONICAL_FILES,
+  initProject,
+  validateModularStructure,
+  renderCanonicalPrompt,
+  formatReport,
+  commandExists
+};