agent-master-devsecops 0.0.0-stage → 3.9.0

package/scripts/jira_manager.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+/**
+ * scripts/jira_manager.js
+ * 
+ * Gerenciador Unificado do Jira: Padronização de Kanban, WIP Limits, Sprints e Time-Tracking.
+ * Consolida o controle de fluxo ágil dos 3 Kanbans canônicos ("A fazer", "Em andamento", "Concluído")
+ * com o registro automatizado de worklogs e timetracking durante o ciclo de desenvolvimento.
+ * 
+ * Governança: Tríade Git + Jira + Confluence (Regra 11 e AGENT_SCRUM).
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+  getAtlassianCredentials,
+  requestAtlassian,
+  getGitMetadata
+} = require('./atlassian_client.js');
+
+// ==========================================
+// 1. KANBAN CANÔNICO & PADRONIZAÇÃO DE QUADRO
+// ==========================================
+
+const CANONICAL_KANBANS = Object.freeze({
+  TODO: 'A fazer',
+  IN_PROGRESS: 'Em andamento',
+  DONE: 'Concluído'
+});
+
+const CANONICAL_COLUMNS_LIST = [
+  CANONICAL_KANBANS.TODO,
+  CANONICAL_KANBANS.IN_PROGRESS,
+  CANONICAL_KANBANS.DONE
+];
+
+/**
+ * Sanitiza o summary de um card do Jira, removendo chaves redundantes do título.
+ * Exemplo: "[PROJ-123] Deploy de Produção" -> "Deploy de Produção"
+ */
+function sanitizeIssueSummary(summary = '') {
+  if (!summary) return '';
+  return summary.replace(/^\s*\[[A-Z]{2,10}-\d+\]\s*[:-]?\s*/i, '').trim();
+}
+
+/**
+ * Valida o limite de trabalho em progresso (WIP Limit).
+ */
+function checkWipLimit(inProgressCount = 0, maxWip = 2) {
+  return {
+    inProgressCount,
+    maxWip,
+    isSaturated: inProgressCount >= maxWip,
+    canPullNewTask: inProgressCount < maxWip,
+    alertMessage: inProgressCount >= maxWip
+      ? `WIP SATURADO: ${inProgressCount} tarefas ativas em andamento (limite máximo: ${maxWip}). Conclua tarefas antes de puxar novas.`
+      : null
+  };
+}
+
+/**
+ * Mapeia qualquer status ou nome de coluna legado do Jira para uma das 3 colunas canônicas.
+ */
+function resolveCanonicalColumn(statusName = '', statusCategory = '') {
+  const normName = String(statusName).trim().toLowerCase();
+  const normCat = String(statusCategory).trim().toLowerCase();
+
+  // 1. Concluído / Done
+  if (
+    normName.includes('concl') ||
+    normName.includes('done') ||
+    normName.includes('finaliz') ||
+    normName.includes('resolv') ||
+    normCat.includes('conclu') ||
+    normCat.includes('done') ||
+    normCat.includes('complete')
+  ) {
+    return CANONICAL_KANBANS.DONE;
+  }
+
+  // 2. Em andamento / In Progress
+  if (
+    normName.includes('andamento') ||
+    normName.includes('progress') ||
+    normName.includes('desenvolv') ||
+    normName.includes('análise') ||
+    normName.includes('analise') ||
+    normCat.includes('andamento') ||
+    normCat.includes('progress') ||
+    normCat.includes('indeterminate')
+  ) {
+    return CANONICAL_KANBANS.IN_PROGRESS;
+  }
+
+  // 3. A fazer / To Do / Backlog
+  return CANONICAL_KANBANS.TODO;
+}
+
+/**
+ * Normaliza e consolida as colunas de uma configuração de Board do Jira para os 3 Kanbans padrão.
+ */
+function standardizeBoardColumns(boardConfig = {}) {
+  const rawColumns = (boardConfig && boardConfig.columnConfig && boardConfig.columnConfig.columns) || [];
+  
+  const standardized = {
+    canonicalColumns: [...CANONICAL_COLUMNS_LIST],
+    columns: [
+      { name: CANONICAL_KANBANS.TODO, statuses: [] },
+      { name: CANONICAL_KANBANS.IN_PROGRESS, statuses: [] },
+      { name: CANONICAL_KANBANS.DONE, statuses: [] }
+    ],
+    remappedCount: 0
+  };
+
+  const todoCol = standardized.columns[0];
+  const inProgCol = standardized.columns[1];
+  const doneCol = standardized.columns[2];
+
+  for (const col of rawColumns) {
+    const canonicalTarget = resolveCanonicalColumn(col.name);
+    const statuses = col.statuses || [];
+
+    if (canonicalTarget === CANONICAL_KANBANS.DONE) {
+      doneCol.statuses.push(...statuses);
+    } else if (canonicalTarget === CANONICAL_KANBANS.IN_PROGRESS) {
+      inProgCol.statuses.push(...statuses);
+    } else {
+      todoCol.statuses.push(...statuses);
+    }
+
+    if (col.name !== canonicalTarget) {
+      standardized.remappedCount++;
+    }
+  }
+
+  return standardized;
+}
+
+/**
+ * Constrói a consulta JQL padronizada para uma das 3 colunas canônicas no Jira.
+ */
+function buildCanonicalJql(projectKey, canonicalColumn) {
+  if (!projectKey) throw new Error('projectKey é obrigatório para construir JQL.');
+
+  switch (canonicalColumn) {
+    case CANONICAL_KANBANS.TODO:
+      return `project = "${projectKey}" AND statusCategory in ("To Do", "Undefined") ORDER BY rank ASC, created ASC`;
+    case CANONICAL_KANBANS.IN_PROGRESS:
+      return `project = "${projectKey}" AND statusCategory in ("In Progress") ORDER BY rank ASC, updated DESC`;
+    case CANONICAL_KANBANS.DONE:
+      return `project = "${projectKey}" AND statusCategory in ("Done") ORDER BY updated DESC`;
+    default:
+      throw new Error(`Coluna desconhecida: "${canonicalColumn}". Use: ${CANONICAL_COLUMNS_LIST.join(', ')}`);
+  }
+}
+
+/**
+ * Valida se há pelo menos um sprint ativo na esteira para evitar "quadro de sprints ativo vazio".
+ */
+function validateSprintHealth(sprints = []) {
+  const activeSprints = sprints.filter(s => s.state === 'active');
+  const futureSprints = sprints.filter(s => s.state === 'future');
+  const closedSprints = sprints.filter(s => s.state === 'closed');
+
+  return {
+    totalSprints: sprints.length,
+    activeCount: activeSprints.length,
+    futureCount: futureSprints.length,
+    closedCount: closedSprints.length,
+    hasActiveSprint: activeSprints.length > 0,
+    warning: activeSprints.length === 0
+      ? 'ALERTA DE FLUXO: Nenhuma sprint está ativa no Jira. A tela de Sprints Ativos ficará em branco até que uma sprint seja iniciada.'
+      : null
+  };
+}
+
+/**
+ * Avalia candidato do backlog com base no contexto do projeto (Regra 14).
+ */
+function evaluateFullDevCandidate(candidate, projectContext = {}) {
+  const { title = '', description = '' } = candidate;
+  const { stack = 'generic', domain = 'general' } = projectContext;
+
+  const text = `${title} ${description}`.toLowerCase();
+  const evaluation = {
+    valid: true,
+    candidateTitle: sanitizeIssueSummary(title),
+    reasons: [],
+    recommendedAction: 'PROCEED_TO_IN_PROGRESS'
+  };
+
+  const overengineeringKeywords = ['blockchain', 'smart contract', 'quantum computing', 'microservices mesh'];
+  const matchedOver = overengineeringKeywords.filter(k => text.includes(k));
+  if (matchedOver.length > 0 && !String(domain).toLowerCase().includes('crypto')) {
+    evaluation.valid = false;
+    evaluation.reasons.push(`Overengineering ou desconexão com domínio (${domain}): detectado [${matchedOver.join(', ')}]`);
+    evaluation.recommendedAction = 'DROP_OR_REJECT';
+  }
+
+  if (text.includes('kubernetes') && (stack.includes('cli') || stack.includes('desktop'))) {
+    evaluation.valid = false;
+    evaluation.reasons.push(`Incompatibilidade com stack (${stack}): infraestrutura desproporcional`);
+    evaluation.recommendedAction = 'DROP_OR_REJECT';
+  }
+
+  return evaluation;
+}
+
+/**
+ * Orquestra o ciclo do Modo Full Developer baseado nos 3 Kanbans canônicos.
+ */
+function processFullDevPipeline(tasks = [], projectContext = {}, maxWip = 2) {
+  const todoTasks = tasks.filter(t => resolveCanonicalColumn(t.status || t.statusName, t.statusCategory) === CANONICAL_KANBANS.TODO);
+  const inProgressTasks = tasks.filter(t => resolveCanonicalColumn(t.status || t.statusName, t.statusCategory) === CANONICAL_KANBANS.IN_PROGRESS);
+  const doneTasks = tasks.filter(t => resolveCanonicalColumn(t.status || t.statusName, t.statusCategory) === CANONICAL_KANBANS.DONE);
+
+  const wipStatus = checkWipLimit(inProgressTasks.length, maxWip);
+
+  const results = {
+    totalTasks: tasks.length,
+    counts: {
+      todo: todoTasks.length,
+      inProgress: inProgressTasks.length,
+      done: doneTasks.length
+    },
+    wipStatus,
+    activeTask: inProgressTasks[0] || null,
+    activeTasks: inProgressTasks,
+    nextApprovedTask: null,
+    rejectedTasks: [],
+    lifecyclePlan: []
+  };
+
+  if (wipStatus.isSaturated) {
+    results.lifecyclePlan.push({
+      step: 'CONCLUDE_ACTIVE_TASKS',
+      message: wipStatus.alertMessage
+    });
+    return results;
+  }
+
+  for (const candidate of todoTasks) {
+    const evalRes = evaluateFullDevCandidate(candidate, projectContext);
+    if (evalRes.valid && !results.nextApprovedTask) {
+      results.nextApprovedTask = candidate;
+      results.lifecyclePlan.push({
+        step: 'TRANSITION_AND_START',
+        taskKey: candidate.key || candidate.id,
+        cleanSummary: evalRes.candidateTitle,
+        from: CANONICAL_KANBANS.TODO,
+        to: CANONICAL_KANBANS.IN_PROGRESS,
+        message: 'Ideia/tarefa aprovada pelo filtro de sanidade (Regra 14). Transicionar para "Em andamento" e iniciar ciclo.'
+      });
+    } else if (!evalRes.valid) {
+      results.rejectedTasks.push({
+        taskKey: candidate.key || candidate.id,
+        reasons: evalRes.reasons
+      });
+    }
+  }
+
+  return results;
+}
+
+// ==========================================
+// 2. TIME TRACKING & WORKLOGS
+// ==========================================
+
+function extractIssueKeys(text) {
+  if (!text) return [];
+  const matches = text.match(/\b[A-Z]{2,10}-\d+\b/g) || [];
+  return [...new Set(matches.map(k => k.toUpperCase()))];
+}
+
+async function getExistingWorklogs(credentials, issueKey) {
+  const res = await requestAtlassian(credentials, 'GET', `/rest/api/3/issue/${issueKey}/worklog`);
+  if (res.status === 200 && res.body?.worklogs) {
+    return res.body.worklogs;
+  }
+  return [];
+}
+
+async function logWorkTime(credentials, issueKey, timeSpentSeconds, commentText) {
+  const startedTime = new Date().toISOString().replace('Z', '+0000');
+  const payload = {
+    timeSpentSeconds,
+    started: startedTime,
+    comment: {
+      type: 'doc',
+      version: 1,
+      content: [
+        {
+          type: 'paragraph',
+          content: [{ type: 'text', text: commentText }]
+        }
+      ]
+    }
+  };
+
+  return requestAtlassian(credentials, 'POST', `/rest/api/3/issue/${issueKey}/worklog`, payload);
+}
+
+async function ensureInProgress(credentials, issueKey) {
+  try {
+    const issueRes = await requestAtlassian(credentials, 'GET', `/rest/api/3/issue/${issueKey}?fields=status`);
+    if (issueRes.status === 200 && issueRes.body?.fields?.status) {
+      const currentStatus = issueRes.body.fields.status.name.toLowerCase();
+      if (currentStatus.includes('backlog') || currentStatus.includes('fazer') || currentStatus.includes('to do')) {
+        await requestAtlassian(credentials, 'POST', `/rest/api/3/issue/${issueKey}/transitions`, {
+          transition: { id: '31' }
+        });
+        console.log(`[Jira Manager] 🔄 Card ${issueKey} transicionado para "Em andamento".`);
+      }
+    }
+  } catch (err) {
+    console.warn(`[Jira Manager] Aviso ao checar status de ${issueKey}:`, err.message);
+  }
+}
+
+async function trackIssueTime(credentials, key, gitMeta) {
+  await ensureInProgress(credentials, key);
+
+  const existing = await getExistingWorklogs(credentials, key);
+  const tag = `[commit:${gitMeta.shortSha}]`;
+  const alreadyLogged = existing.some(wl => {
+    const text = JSON.stringify(wl.comment || {});
+    return text.includes(tag);
+  });
+
+  if (alreadyLogged) {
+    console.log(`[Jira Manager] ℹ Tempo já registrado anteriormente para o commit ${gitMeta.shortSha} no card ${key}.`);
+    return { key, status: 'already_logged' };
+  }
+
+  const timeSpentSeconds = 900; // 15 minutos padrão
+  const comment = `Tempo de andamento registrado automaticamente via esteira de CI/CD.\nAutor: ${gitMeta.authorName || 'DevSecOps Bot'}\nCommit: ${gitMeta.shortSha} (${gitMeta.commitMessage.split('\n')[0]})\n${tag}`;
+
+  const res = await logWorkTime(credentials, key, timeSpentSeconds, comment);
+  if (res.status === 201) {
+    console.log(`[Jira Manager] ✅ 15m de andamento registrados no Jira para ${key} (Commit ${gitMeta.shortSha}).`);
+    return { key, status: 'logged', timeSpentSeconds };
+  } else {
+    console.warn(`[Jira Manager] ⚠️ Falha ao registrar tempo para ${key}: HTTP ${res.status}`);
+    return { key, status: 'failed', code: res.status };
+  }
+}
+
+async function runTimeTracking() {
+  console.log('--- Início da Execução do Jira Time Tracking Automático ---');
+  const credentials = getAtlassianCredentials();
+  if (!credentials.isConfigured) {
+    console.log('[Jira Manager] ℹ Credenciais Atlassian não configuradas. Pulando registro de tempo.');
+    return;
+  }
+
+  const gitMeta = getGitMetadata();
+  const keys = [
+    ...extractIssueKeys(gitMeta.branch),
+    ...extractIssueKeys(gitMeta.commitMessage)
+  ];
+
+  const uniqueKeys = [...new Set(keys)];
+  if (uniqueKeys.length === 0) {
+    console.log('[Jira Manager] ℹ Nenhuma chave Jira identificada na branch ou mensagem de commit.');
+    return;
+  }
+
+  console.log(`[Jira Manager] Chaves detectadas: ${uniqueKeys.join(', ')}`);
+  for (const key of uniqueKeys) {
+    try {
+      await trackIssueTime(credentials, key, gitMeta);
+    } catch (err) {
+      console.error(`[Jira Manager] ❌ Erro ao processar tempo para ${key}:`, err.message);
+    }
+  }
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.includes('--track')) {
+    runTimeTracking().catch(console.error);
+  } else {
+    console.log('Jira Manager operacional. Use --track para executar apontamento de horas.');
+  }
+}
+
+module.exports = {
+  // Kanban
+  CANONICAL_KANBANS,
+  CANONICAL_COLUMNS_LIST,
+  sanitizeIssueSummary,
+  checkWipLimit,
+  resolveCanonicalColumn,
+  standardizeBoardColumns,
+  buildCanonicalJql,
+  validateSprintHealth,
+  evaluateFullDevCandidate,
+  processFullDevPipeline,
+  // Time Tracking
+  extractIssueKeys,
+  getExistingWorklogs,
+  logWorkTime,
+  ensureInProgress,
+  trackIssueTime,
+  runTimeTracking
+};

package/scripts/magic_prompt_generator.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * scripts/magic_prompt_generator.js
+ * 
+ * Magic Prompt Generator & Web Bookmarklet (AGDEV-27 / I-13).
+ * Gera prompt autocontido de ativação instantânea (< 900 tokens) e bookmarklet
+ * web para injeção em 1 clique no ChatGPT, Claude.ai, Gemini e DeepSeek Web.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+class MagicPromptGenerator {
+  constructor(baseDir = path.resolve(__dirname, '..')) {
+    this.baseDir = baseDir;
+  }
+
+  generateMagicPrompt(target = 'generic') {
+    const prompt = `=== AGENT ORCHESTRATOR & SUÍTE MULTI-AGENTE (UNIVERSAL INSTANT ACTIVATION) ===
+[DIRECTIVE]: You are now running the canonical Agent Suite (Orchestrator, DevSecOps, QA, Scrum, SRE & UI/UX). Assume 100% adherence to the rules below for all responses:
+
+[THE 14 GOLDEN ENGINEERING RULES & RULE 15 INVIOLABILITY]:
+1. TDD First: Write/verify unit tests BEFORE modifying production code.
+2. Branch by Card & Strict Commit: Dedicated branch <TICKET>. Commit strictly [<TICKET>] - <Ação em português>. Conventional Commits e commits sem ticket banidos.
+3. Formal PR & CI: Every merge requires a formal Pull Request with 100% green CI checks.
+4. Zero Secrets (TruffleHog): Never commit credentials, .env files, private keys or tokens.
+5. DevSecOps OWASP: Strictly prevent CWE-78 (Cmd Injection), CWE-79 (XSS), CWE-89 (SQLi), CWE-116, CWE-1333 (ReDoS).
+6. Native Telemetry: Expose standard Prometheus metrics /metrics (CPU, RSS, Heap, latency).
+7. Dual-Layer Output Protocol: Keep chat output concise, short bullet points separated by a DOUBLE BLANK LINE (\\n\\n) with clickable markdown links. Externalize 15-section dense reports to tickets/ADRs.
+8. Central Knowledge: Record architectural decisions in ADRs. Keep project documentation living and 100% faithful to production.
+9. Issue Tracker: Move card to 'In progress' before starting; close with dense technical summary.
+10. Zero Assumptions: Clarify ambiguities or inspect code before proposing solutions.
+11. Doc Integrity: Preserve existing docstrings, comments and public API contracts.
+12. Operational Safety: Never execute destructive unconfirmed commands (rm -rf, hard reset).
+13. Cold Review (AGENT_QA.md): Independently audit diffs with cold skepticism; provide breaking tests.
+14. Ideation Sanity Filter: Every suggested idea in docs/IDEAS.md must strictly match the project's actual stack, domain, and architecture.
+15. Rule 15 Inviolability: Zero silent failures. Requirements and credentials (GitHub CLI, Jira, Confluence) are mandatory.
+
+[OPERATIONAL MODES]:
+- modo: orchestrator (central coordination, triage and multi-agent dispatch)
+- modo: devsecops (secure, robust code, clean architecture and CI/CD)
+- modo: qa (adversarial cold review, bug hunting and breaking tests)
+- modo: scrum (Kaizen/PDCA continuous improvement without overengineering)
+- modo: sre (SRE, telemetry, incident diagnosis and self-healing)
+- modo: uiux (design system, accessibility WCAG 2.1 AA, UX ergonomics, design tokens)
+- modo: full-dev (autonomous sequential idea implementation loop)
+
+[ACTIVATION ACKNOWLEDGEMENT]:
+Acknowledge activation with a 2-line executive greeting:
+"⚡ Suíte Multi-Agente universalmente ativada e pronta para qualquer demanda.
+Informe a stack e solicite credenciais Atlassian (Jira/Confluence) e GitHub CLI se for nova máquina ou projeto."`;
+
+    return prompt;
+  }
+
+  generateBookmarklet() {
+    const rawPrompt = this.generateMagicPrompt();
+    const encodedPrompt = JSON.stringify(rawPrompt);
+
+    // Bookmarklet inline seguro que detecta o campo de chat e copia para o clipboard
+    const script = `javascript:(function(){
+  var promptText = ${encodedPrompt};
+  
+  if (navigator.clipboard && navigator.clipboard.writeText) {
+    navigator.clipboard.writeText(promptText).then(function() {
+      showToast("⚡ Suíte Multi-Agente copiada! Cole (Ctrl+V) no chat da IA.");
+    }).catch(function() {
+      fallbackPrompt(promptText);
+    });
+  } else {
+    fallbackPrompt(promptText);
+  }
+
+  var inputEl = document.querySelector('#prompt-textarea') || 
+                 document.querySelector('div[contenteditable="true"]') || 
+                 document.querySelector('textarea');
+  if (inputEl) {
+    if (inputEl.tagName === 'TEXTAREA') {
+      inputEl.value = promptText;
+      inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+    } else if (inputEl.isContentEditable) {
+      inputEl.innerText = promptText;
+      inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+  }
+
+  function showToast(msg) {
+    var toast = document.createElement('div');
+    toast.innerText = msg;
+    toast.style.position = 'fixed';
+    toast.style.top = '20px';
+    toast.style.right = '20px';
+    toast.style.backgroundColor = '#0f172a';
+    toast.style.color = '#38bdf8';
+    toast.style.padding = '14px 20px';
+    toast.style.borderRadius = '8px';
+    toast.style.boxShadow = '0 10px 25px rgba(0,0,0,0.5)';
+    toast.style.zIndex = '999999';
+    toast.style.fontFamily = 'system-ui, sans-serif';
+    toast.style.fontSize = '14px';
+    toast.style.border = '1px solid #38bdf8';
+    document.body.appendChild(toast);
+    setTimeout(function() { toast.remove(); }, 3500);
+  }
+
+  function fallbackPrompt(text) {
+    window.prompt("Copie o Magic Prompt abaixo:", text);
+  }
+})();`.replace(/\n\s*/g, '');
+
+    return script;
+  }
+
+  estimateTokens(text) {
+    // Estimativa canônica de ~4 caracteres por token
+    return Math.ceil(text.length / 4);
+  }
+
+  exportArtifacts(targetDir = path.join(this.baseDir, 'dist', 'magic_prompt'), options = {}) {
+    const dryRun = Boolean(options.dryRun);
+    const magicPrompt = this.generateMagicPrompt();
+    const bookmarklet = this.generateBookmarklet();
+    const tokens = this.estimateTokens(magicPrompt);
+
+    const htmlContent = `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <title>Suíte Multi-Agente — Magic Prompt & Bookmarklet</title>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; background: #0f172a; color: #f8fafc; padding: 40px; line-height: 1.6; }
+    .card { background: #1e293b; border: 1px solid #334155; border-radius: 12px; padding: 24px; max-width: 800px; margin: 0 auto 30px; box-shadow: 0 10px 25px rgba(0,0,0,0.3); }
+    h1 { color: #38bdf8; margin-top: 0; }
+    pre { background: #090d16; padding: 16px; border-radius: 8px; overflow-x: auto; font-size: 13px; color: #cbd5e1; border: 1px solid #1e293b; }
+    .btn { display: inline-block; background: #0284c7; color: white; padding: 12px 20px; border-radius: 8px; text-decoration: none; font-weight: bold; cursor: grab; }
+    .btn:hover { background: #0369a1; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>⚡ Suíte Multi-Agente — Ativação Instantânea</h1>
+    <p>Arraste o botão abaixo para a sua <strong>Barra de Favoritos</strong> do navegador. Ao clicar nele em qualquer aba do ChatGPT, Claude, Gemini ou DeepSeek, a suíte de agentes será ativada instantaneamente!</p>
+    <p style="margin: 30px 0;">
+      <a class="btn" href="${bookmarklet}">⚡ Ativar Suíte Multi-Agente</a>
+    </p>
+    <small style="color: #94a3b8;">Dica: você também pode clicar com o botão direito e selecionar "Adicionar aos favoritos".</small>
+  </div>
+
+  <div class="card">
+    <h2>📋 Magic Prompt (Cópia Manual — ~${tokens} tokens)</h2>
+    <pre id="promptText">${magicPrompt.replace(/</g, '&lt;').replace(/>/g, '&gt;')}</pre>
+  </div>
+</body>
+</html>`;
+
+    const mdContent = `# ⚡ Magic Prompt — Ativação Instantânea da Suíte Multi-Agente
+
+Copie o bloco abaixo e cole como primeira mensagem em **qualquer LLM** (ChatGPT, Claude.ai, Gemini, DeepSeek Web, Ollama ou LeChat) para assumir imediatamente 100% das 14 regras de engenharia:
+
+\`\`\`text
+${magicPrompt}
+\`\`\`
+
+---
+*Orçamento semântico: ~${tokens} tokens (limite de 1.000 tokens respeitado com 100% de conformidade).*
+`;
+
+    const files = [
+      { path: path.join(targetDir, 'MAGIC_PROMPT.md'), content: mdContent },
+      { path: path.join(targetDir, 'bookmarklet.html'), content: htmlContent }
+    ];
+
+    if (!dryRun) {
+      if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+      files.forEach(f => fs.writeFileSync(f.path, f.content, 'utf8'));
+    }
+
+    return {
+      status: 'SUCCESS',
+      targetDir,
+      tokens,
+      dryRun,
+      filesCount: files.length,
+      files: files.map(f => f.path),
+      magicPrompt,
+      bookmarklet
+    };
+  }
+}
+
+if (require.main === module) {
+  const generator = new MagicPromptGenerator();
+  const res = generator.exportArtifacts();
+  console.log('\n============================================================');
+  console.log('⚡ Magic Prompt Generator & Web Bookmarklet (AGDEV-27)');
+  console.log('============================================================\n');
+  console.log(`✅ Arquivos exportados com sucesso em: ${res.targetDir}`);
+  console.log(`📊 Orçamento de Tokens Estimado: ~${res.tokens} tokens (< 1.000 tokens)`);
+  console.log(`📄 Arquivos gerados:`, res.files.join(', '));
+  console.log('\nO bookmarklet HTML e o MAGIC_PROMPT.md estão prontos para uso!\n');
+}
+
+module.exports = {
+  MagicPromptGenerator
+};