agent-master-devsecops 0.0.0-stage → 5.1.0

package/scripts/integrations/confluence_sync.js

@@ -0,0 +1,684 @@
+#!/usr/bin/env node
+/**
+ * scripts/integrations/confluence_sync.js
+ * 
+ * Sincronizador Automático Universal de ADRs, SPECs e Governança no Confluence em Tempo Real.
+ * Lê arquivos Markdown em docs/adr/*.md, docs/specs/*.md e docs/governance/*.md,
+ * converte para Confluence Storage Format (XHTML) e cria/atualiza páginas hierarquicamente.
+ * 
+ * Governança: Tríade Git + Jira + Confluence (Regra 11 e Regra 15).
+ * Conformidade: OASIS SARIF v2.1.0, Programação Defensiva e Clean Code.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+  getAtlassianCredentials,
+  requestAtlassian,
+  AtlassianClient
+} = require('./atlassian_client.js');
+
+const {
+  extractIssueKeys,
+  linkConfluencePageToJira
+} = require('./atlassian_sync_action.js');
+
+const { createSarifReport } = require('../core/sarif_engine.js');
+
+const CONFLUENCE_CONFIG = {
+  spaceKey: process.env.CONFLUENCE_SPACE_KEY || process.env.ATLASSIAN_SPACE_KEY || 'DOCS',
+  adrParentId: process.env.CONFLUENCE_ADR_PARENT_ID || null,
+  specParentId: process.env.CONFLUENCE_SPEC_PARENT_ID || null,
+  govParentId: process.env.CONFLUENCE_GOV_PARENT_ID || null
+};
+
+/**
+ * Escapa caracteres especiais HTML para gerar XML/XHTML válido para Confluence Storage Format.
+ * @param {string|any} text 
+ * @returns {string}
+ */
+function escapeHtml(text) {
+  if (text === null || text === undefined) return '';
+  return String(text)
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+/**
+ * Converte links no formato markdown [label](url) para tags HTML <a> seguras.
+ * @param {string} text 
+ * @returns {string}
+ */
+function parseLinks(text) {
+  if (!text || typeof text !== 'string') return '';
+  let result = '';
+  let i = 0;
+  while (i < text.length) {
+    const openBracket = text.indexOf('[', i);
+    if (openBracket === -1) {
+      result += text.slice(i);
+      break;
+    }
+    result += text.slice(i, openBracket);
+    const closeBracket = text.indexOf(']', openBracket + 1);
+    if (closeBracket !== -1 && text[closeBracket + 1] === '(') {
+      const closeParen = text.indexOf(')', closeBracket + 2);
+      if (closeParen !== -1) {
+        const label = text.slice(openBracket + 1, closeBracket);
+        const url = text.slice(closeBracket + 2, closeParen);
+        result += `<a href="${url}">${label}</a>`;
+        i = closeParen + 1;
+        continue;
+      }
+    }
+    result += '[';
+    i = openBracket + 1;
+  }
+  return result;
+}
+
+/**
+ * Converte texto Markdown em XHTML compatível com o Confluence Storage Format v2.
+ * Suporta headers, blocos de código com CDATA, blockquotes, listas ordenadas e não ordenadas,
+ * tabelas completas (th/td), negrito, itálico, código inline e links.
+ * @param {string} markdown 
+ * @returns {string}
+ */
+function markdownToConfluenceStorage(markdown) {
+  if (!markdown || typeof markdown !== 'string') return '';
+
+  const lines = markdown.split(/\r?\n/);
+  const elements = [];
+  let inCodeBlock = false;
+  let codeBuffer = [];
+  let codeLanguage = 'text';
+  let inList = false;
+  let inOrderedList = false;
+  let inTable = false;
+  let isFirstTableRow = false;
+
+  for (let idx = 0; idx < lines.length; idx++) {
+    const rawLine = lines[idx];
+
+    // Fenced Code Blocks (```lang)
+    if (rawLine.trim().startsWith('```')) {
+      if (inCodeBlock) {
+        inCodeBlock = false;
+        const codeContent = codeBuffer.join('\n').replace(/\]\]>/g, ']]]]><![CDATA[>');
+        elements.push(
+          `<ac:structured-macro ac:name="code" ac:schema-version="1">` +
+          `<ac:parameter ac:name="language">${codeLanguage}</ac:parameter>` +
+          `<ac:parameter ac:name="linenumbers">true</ac:parameter>` +
+          `<ac:plain-text-body><![CDATA[${codeContent}]]></ac:plain-text-body>` +
+          `</ac:structured-macro>`
+        );
+        codeBuffer = [];
+        codeLanguage = 'text';
+      } else {
+        if (inList) { elements.push('</ul>'); inList = false; }
+        if (inOrderedList) { elements.push('</ol>'); inOrderedList = false; }
+        if (inTable) { elements.push('</tbody></table>'); inTable = false; }
+        inCodeBlock = true;
+        const match = rawLine.trim().match(/^```([a-zA-Z0-9_-]*)/);
+        codeLanguage = match && match[1] ? match[1] : 'text';
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeBuffer.push(rawLine);
+      continue;
+    }
+
+    const trimmed = rawLine.trim();
+
+    // Linha vazia
+    if (!trimmed) {
+      if (inList) { elements.push('</ul>'); inList = false; }
+      if (inOrderedList) { elements.push('</ol>'); inOrderedList = false; }
+      if (inTable) { elements.push('</tbody></table>'); inTable = false; }
+      continue;
+    }
+
+    // Tabelas Markdown (| col1 | col2 |)
+    if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+      if (inList) { elements.push('</ul>'); inList = false; }
+      if (inOrderedList) { elements.push('</ol>'); inOrderedList = false; }
+      if (!inTable) {
+        elements.push('<table><tbody>');
+        inTable = true;
+        isFirstTableRow = true;
+      }
+
+      // Separador de cabeçalho (| --- | --- |)
+      if (/^\|(\s*:?-+:?\s*\|)+$/.test(trimmed)) {
+        isFirstTableRow = false;
+        continue;
+      }
+
+      const rawCells = trimmed.slice(1, -1).split('|').map(c => c.trim());
+      const cellTag = isFirstTableRow ? 'th' : 'td';
+      const cellsHtml = rawCells
+        .map(cell => {
+          const formatted = escapeHtml(cell)
+            .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+            .replace(/`([^`]+)`/g, '<code>$1</code>');
+          return `<${cellTag}>${parseLinks(formatted)}</${cellTag}>`;
+        })
+        .join('');
+
+      elements.push(`<tr>${cellsHtml}</tr>`);
+      isFirstTableRow = false;
+      continue;
+    } else if (inTable) {
+      elements.push('</tbody></table>');
+      inTable = false;
+    }
+
+    // Separador horizontal
+    if (/^(\-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+      if (inList) { elements.push('</ul>'); inList = false; }
+      if (inOrderedList) { elements.push('</ol>'); inOrderedList = false; }
+      elements.push('<hr />');
+      continue;
+    }
+
+    // Blockquote
+    if (trimmed.startsWith('>')) {
+      if (inList) { elements.push('</ul>'); inList = false; }
+      if (inOrderedList) { elements.push('</ol>'); inOrderedList = false; }
+      const quoteText = escapeHtml(trimmed.replace(/^>\s*/, ''))
+        .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+        .replace(/\*(.*?)\*/g, '<em>$1</em>')
+        .replace(/`([^`]+)`/g, '<code>$1</code>');
+      elements.push(`<blockquote><p>${parseLinks(quoteText)}</p></blockquote>`);
+      continue;
+    }
+
+    // Cabeçalhos (h1 - h6)
+    const headerMatch = trimmed.match(/^(#{1,6})\s+(.*)$/);
+    if (headerMatch) {
+      if (inList) { elements.push('</ul>'); inList = false; }
+      if (inOrderedList) { elements.push('</ol>'); inOrderedList = false; }
+      const level = headerMatch[1].length;
+      const text = escapeHtml(headerMatch[2]);
+      elements.push(`<h${level}>${parseLinks(text)}</h${level}>`);
+      continue;
+    }
+
+    // Itens de lista ordenada (1. item)
+    const orderedMatch = trimmed.match(/^(\d+)\.\s+(.*)$/);
+    if (orderedMatch) {
+      if (inList) { elements.push('</ul>'); inList = false; }
+      if (!inOrderedList) {
+        elements.push('<ol>');
+        inOrderedList = true;
+      }
+      const itemText = escapeHtml(orderedMatch[2]);
+      const formatted = itemText
+        .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+        .replace(/`([^`]+)`/g, '<code>$1</code>');
+      elements.push(`<li>${parseLinks(formatted)}</li>`);
+      continue;
+    } else if (inOrderedList) {
+      elements.push('</ol>');
+      inOrderedList = false;
+    }
+
+    // Itens de lista com marcadores (* ou -)
+    const listMatch = trimmed.match(/^[-*]\s+(.*)$/);
+    if (listMatch) {
+      if (!inList) {
+        elements.push('<ul>');
+        inList = true;
+      }
+      const itemText = escapeHtml(listMatch[1]);
+      const formatted = itemText
+        .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+        .replace(/`([^`]+)`/g, '<code>$1</code>');
+      elements.push(`<li>${parseLinks(formatted)}</li>`);
+      continue;
+    } else if (inList) {
+      elements.push('</ul>');
+      inList = false;
+    }
+
+    // Parágrafo comum
+    const formattedPara = escapeHtml(trimmed)
+      .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+      .replace(/\*(.*?)\*/g, '<em>$1</em>')
+      .replace(/`([^`]+)`/g, '<code>$1</code>');
+
+    elements.push(`<p>${parseLinks(formattedPara)}</p>`);
+  }
+
+  if (inList) elements.push('</ul>');
+  if (inOrderedList) elements.push('</ol>');
+  if (inTable) elements.push('</tbody></table>');
+
+  return elements.join('');
+}
+
+/**
+ * Extrai o título H1 do markdown ou utiliza fallback.
+ * @param {string} markdown 
+ * @param {string} [fallback='Documento Sem Título'] 
+ * @returns {string}
+ */
+function extractTitle(markdown, fallback = 'Documento Sem Título') {
+  if (!markdown || typeof markdown !== 'string') return fallback;
+  const lines = markdown.split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/^#\s+(.*)$/);
+    if (match) {
+      return match[1].trim();
+    }
+  }
+  return fallback;
+}
+
+/**
+ * Busca página no Confluence por título ou provisiona pasta estrutural se não existir.
+ * @param {object} creds 
+ * @param {string} spaceKey 
+ * @param {string} title 
+ * @param {string|null} [parentId=null] 
+ * @returns {Promise<object|null>}
+ */
+async function findOrCreatePage(creds, spaceKey, title, parentId = null) {
+  const encodedTitle = encodeURIComponent(title);
+  const pathUrl = `/wiki/rest/api/content?spaceKey=${spaceKey}&title=${encodedTitle}&expand=version,ancestors`;
+  const searchRes = await requestAtlassian(creds, 'GET', pathUrl);
+
+  if (searchRes.status === 200 && searchRes.body && Array.isArray(searchRes.body.results) && searchRes.body.results.length > 0) {
+    return searchRes.body.results[0];
+  }
+
+  // Se não existir e for pasta estrutural, cria
+  if (parentId !== undefined) {
+    const createPayload = {
+      type: 'page',
+      title,
+      space: { key: spaceKey },
+      body: {
+        storage: {
+          value: `<p>Seção de documentação gerada automaticamente pela Tríade Multiagente.</p>`,
+          representation: 'storage'
+        }
+      },
+      ...(parentId ? { ancestors: [{ id: parentId }] } : {})
+    };
+
+    const createRes = await requestAtlassian(creds, 'POST', '/wiki/rest/api/content', createPayload);
+    if (createRes.status === 200 || createRes.status === 201) {
+      return createRes.body;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Sincroniza um documento Markdown específico no Confluence (cria ou atualiza versão).
+ * @param {object} creds 
+ * @param {string} filePath 
+ * @param {string|null} [parentId=null] 
+ * @param {object} [options={}] 
+ * @returns {Promise<object>}
+ */
+async function syncDocument(creds, filePath, parentId = null, options = {}) {
+  if (!fs.existsSync(filePath)) {
+    return { success: false, error: `Arquivo não encontrado: ${filePath}` };
+  }
+
+  const rawMarkdown = fs.readFileSync(filePath, 'utf8');
+  const filename = path.basename(filePath, '.md');
+  const title = extractTitle(rawMarkdown, filename);
+  const storageHtml = markdownToConfluenceStorage(rawMarkdown);
+  const spaceKey = options.spaceKey || CONFLUENCE_CONFIG.spaceKey;
+
+  const existingPage = await findOrCreatePage(creds, spaceKey, title);
+  let action = 'created';
+  let pageId = null;
+  let res = null;
+
+  if (existingPage) {
+    action = 'updated';
+    pageId = existingPage.id;
+    const currentVersion = (existingPage.version && existingPage.version.number) ? existingPage.version.number : 1;
+    const nextVersion = currentVersion + 1;
+    const updatePayload = {
+      version: { number: nextVersion },
+      title,
+      type: 'page',
+      space: { key: spaceKey },
+      body: {
+        storage: {
+          value: storageHtml,
+          representation: 'storage'
+        }
+      },
+      ...(parentId ? { ancestors: [{ id: parentId }] } : {})
+    };
+
+    res = await requestAtlassian(creds, 'PUT', `/wiki/rest/api/content/${existingPage.id}`, updatePayload);
+  } else {
+    action = 'created';
+    const createPayload = {
+      type: 'page',
+      title,
+      space: { key: spaceKey },
+      body: {
+        storage: {
+          value: storageHtml,
+          representation: 'storage'
+        }
+      },
+      ...(parentId ? { ancestors: [{ id: parentId }] } : {})
+    };
+
+    res = await requestAtlassian(creds, 'POST', '/wiki/rest/api/content', createPayload);
+    if (res.body && res.body.id) {
+      pageId = res.body.id;
+    }
+  }
+
+  const isSuccess = res && (res.status === 200 || res.status === 201);
+  if (isSuccess) {
+    const id = pageId || (res.body && res.body.id);
+    console.log(`[Confluence Sync] ✔ ${action === 'created' ? '🚀 Criada' : 'Atualizada'}: "${title}" (ID: ${id})`);
+    const pageUrl = `https://${creds.domain}/wiki/spaces/${spaceKey}/pages/${id}`;
+    const keys = [...new Set([...extractIssueKeys(title), ...extractIssueKeys(rawMarkdown)])];
+    for (const key of keys) {
+      await linkConfluencePageToJira(key, pageUrl, title, `Página do Confluence ${action}: ${title}`);
+    }
+    return { success: true, id, action, title, filePath, linkedKeys: keys };
+  } else {
+    console.error(`[Confluence Sync] ✖ Falha ao salvar "${title}": HTTP ${res ? res.status : 'ERR'}`);
+    return { success: false, action, title, filePath, error: res ? res.body : 'Sem resposta' };
+  }
+}
+
+/**
+ * Executa a sincronização completa de todos os diretórios padrão de documentação (ADRs, SPECs, Governança).
+ * @param {object} [options={}] 
+ * @returns {Promise<object>}
+ */
+async function runSync(options = {}) {
+  const targetDir = options.targetDir || process.cwd();
+  const creds = options.credentials || getAtlassianCredentials(targetDir);
+  const spaceKey = options.spaceKey || CONFLUENCE_CONFIG.spaceKey;
+
+  if (!creds || !creds.isConfigured) {
+    console.error('[Confluence Sync] ✖ Credenciais Atlassian não configuradas. Sincronização ignorada.');
+    return {
+      synced: false,
+      reason: 'Credenciais Atlassian não configuradas no ambiente.',
+      processed: 0,
+      results: []
+    };
+  }
+
+  console.log(`[Confluence Sync] Espaço alvo: "${spaceKey}".`);
+
+  // Descoberta dinâmica de pastas estruturais
+  let adrParent = options.adrParentId || CONFLUENCE_CONFIG.adrParentId;
+  let specParent = options.specParentId || CONFLUENCE_CONFIG.specParentId;
+  let govParent = options.govParentId || CONFLUENCE_CONFIG.govParentId;
+
+  if (!adrParent) {
+    const p = await findOrCreatePage(creds, spaceKey, 'Decisões de Arquitetura (ADRs)');
+    if (p) adrParent = p.id;
+  }
+  if (!specParent) {
+    const p = await findOrCreatePage(creds, spaceKey, 'Especificações Técnicas (SPECs)');
+    if (p) specParent = p.id;
+  }
+  if (!govParent) {
+    const p = await findOrCreatePage(creds, spaceKey, 'Governança & Padrões Multiagente');
+    if (p) govParent = p.id;
+  }
+
+  const targets = [
+    { dir: path.resolve(targetDir, 'docs/adr'), parentId: adrParent, category: 'ADR' },
+    { dir: path.resolve(targetDir, 'docs/specs'), parentId: specParent, category: 'SPEC' },
+    { dir: path.resolve(targetDir, 'docs/governance'), parentId: govParent, category: 'GOVERNANCE' }
+  ];
+
+  const results = [];
+  for (const target of targets) {
+    if (fs.existsSync(target.dir)) {
+      const files = fs.readdirSync(target.dir).filter(f => f.endsWith('.md'));
+      for (const f of files) {
+        const fullPath = path.join(target.dir, f);
+        const res = await syncDocument(creds, fullPath, target.parentId, { spaceKey });
+        results.push({
+          file: f,
+          category: target.category,
+          ...res
+        });
+      }
+    }
+  }
+
+  console.log(`[Confluence Sync] Finalizado: ${results.length} documentos processados.`);
+  return {
+    synced: true,
+    spaceKey,
+    processed: results.length,
+    results
+  };
+}
+
+/**
+ * Formata relatório executivo em Markdown sobre o status da sincronização do Confluence.
+ * @param {object} [syncOutcome={}] 
+ * @returns {string}
+ */
+function formatReport(syncOutcome = {}) {
+  let md = '# 📘 Confluence Sync — Status Report de Documentação\n\n';
+
+  const processed = syncOutcome.processed || (syncOutcome.results ? syncOutcome.results.length : 0);
+  const spaceKey = syncOutcome.spaceKey || 'DOCS';
+  const results = syncOutcome.results || [];
+
+  md += `**Espaço Confluence:** \`${spaceKey}\`\n`;
+  md += `**Documentos Processados:** \`${processed}\`\n\n`;
+
+  if (results.length === 0) {
+    md += syncOutcome.reason
+      ? `*Observação:* ${syncOutcome.reason}\n`
+      : '*Nenhum documento encontrado para sincronização.*\n';
+    return md;
+  }
+
+  md += '| Categoria | Arquivo | Título | Ação | Status |\n';
+  md += '| :--- | :--- | :--- | :--- | :--- |\n';
+  for (const r of results) {
+    const statusIcon = r.success ? '✅' : '❌';
+    const actionText = r.action || (r.success ? 'synced' : 'failed');
+    md += `| \`${r.category || 'DOC'}\` | \`${r.file || 'unknown'}\` | ${r.title || 'Sem título'} | \`${actionText}\` | ${statusIcon} |\n`;
+  }
+
+  return md;
+}
+
+/**
+ * Audita a prontidão e resultado da sincronização do Confluence emitindo relatório OASIS SARIF v2.1.0.
+ * @param {object} [syncOutcome={}] 
+ * @returns {object} SARIF v2.1.0 JSON object
+ */
+function auditSyncToSarif(syncOutcome = {}) {
+  const rules = [
+    {
+      id: 'RULE-CONF-001',
+      name: 'ConfluenceCredentialsMissing',
+      severity: 'WARNING',
+      message: 'Credenciais Atlassian ou espaço Confluence não configurados.',
+      remediation: 'Configure ATLASSIAN_API_TOKEN, ATLASSIAN_EMAIL, ATLASSIAN_DOMAIN e CONFLUENCE_SPACE_KEY.',
+      cwe: 'CWE-200'
+    },
+    {
+      id: 'RULE-CONF-002',
+      name: 'ConfluencePageSyncFailed',
+      severity: 'ERROR',
+      message: 'Falha ao sincronizar documento Markdown para o Confluence Storage Format.',
+      remediation: 'Verifique permissões de escrita no espaço Confluence e validade do conteúdo XHTML.',
+      cwe: 'CWE-287'
+    },
+    {
+      id: 'RULE-CONF-003',
+      name: 'ConfluenceDocsDirNotFound',
+      severity: 'NOTE',
+      message: 'Diretório padrão de documentação (docs/adr, docs/specs, docs/governance) não encontrado.',
+      remediation: 'Crie a pasta de documentação e versione arquivos Markdown.',
+      cwe: 'CWE-Unknown'
+    }
+  ];
+
+  const findings = [];
+  const results = syncOutcome.results || [];
+
+  if (syncOutcome.synced === false) {
+    findings.push({
+      ruleId: 'RULE-CONF-001',
+      severity: 'WARNING',
+      message: syncOutcome.reason || 'Credenciais Confluence não configuradas no ambiente.',
+      filename: '.env',
+      line: 1,
+      column: 1
+    });
+  }
+
+  for (const r of results) {
+    if (!r.success) {
+      findings.push({
+        ruleId: 'RULE-CONF-002',
+        severity: 'ERROR',
+        message: `Falha na sincronização do documento ${r.file || r.title}: ${JSON.stringify(r.error || 'Erro desconhecido')}`,
+        filename: r.file || 'docs',
+        line: 1,
+        column: 1
+      });
+    }
+  }
+
+  return createSarifReport({
+    toolName: 'agent-master-confluence-sync',
+    toolVersion: '5.1.0',
+    rules,
+    findings,
+    properties: {
+      category: 'Governance & Documentation Sync',
+      spaceKey: syncOutcome.spaceKey || 'DOCS',
+      processedCount: results.length
+    }
+  });
+}
+
+/**
+ * Classe Canônica ConfluenceSync.
+ * Provedor orientado a objetos para conversão de Markdown e sincronização com Confluence Cloud.
+ */
+class ConfluenceSync {
+  constructor(options = {}) {
+    const safeOptions = (options && typeof options === 'object') ? options : {};
+    this.targetDir = safeOptions.targetDir || process.cwd();
+    this.spaceKey = safeOptions.spaceKey || process.env.CONFLUENCE_SPACE_KEY || process.env.ATLASSIAN_SPACE_KEY || 'DOCS';
+    this.adrParentId = safeOptions.adrParentId || process.env.CONFLUENCE_ADR_PARENT_ID || null;
+    this.specParentId = safeOptions.specParentId || process.env.CONFLUENCE_SPEC_PARENT_ID || null;
+    this.govParentId = safeOptions.govParentId || process.env.CONFLUENCE_GOV_PARENT_ID || null;
+    this.atlassianClient = new AtlassianClient(this.targetDir, { timeout: safeOptions.timeout || 30000 });
+  }
+
+  convertMarkdown(markdown) {
+    return markdownToConfluenceStorage(markdown);
+  }
+
+  extractDocTitle(markdown, fallback) {
+    return extractTitle(markdown, fallback);
+  }
+
+  async syncDoc(filePath, parentId = null) {
+    const creds = this.atlassianClient.getCredentials();
+    return syncDocument(creds, filePath, parentId, { spaceKey: this.spaceKey });
+  }
+
+  async syncAll() {
+    return runSync({
+      targetDir: this.targetDir,
+      spaceKey: this.spaceKey,
+      adrParentId: this.adrParentId,
+      specParentId: this.specParentId,
+      govParentId: this.govParentId,
+      credentials: this.atlassianClient.getCredentials()
+    });
+  }
+
+  formatReport(syncOutcome = {}) {
+    return formatReport(syncOutcome);
+  }
+
+  auditToSarif(syncOutcome = {}) {
+    return auditSyncToSarif(syncOutcome);
+  }
+
+  // Métodos Estáticos Canônicos
+  static escapeHtml(text) {
+    return escapeHtml(text);
+  }
+
+  static parseLinks(text) {
+    return parseLinks(text);
+  }
+
+  static markdownToConfluenceStorage(markdown) {
+    return markdownToConfluenceStorage(markdown);
+  }
+
+  static extractTitle(markdown, fallback) {
+    return extractTitle(markdown, fallback);
+  }
+
+  static async syncDocument(creds, filePath, parentId, options) {
+    return syncDocument(creds, filePath, parentId, options);
+  }
+
+  static async runSync(options) {
+    return runSync(options);
+  }
+
+  static formatReport(syncOutcome) {
+    return formatReport(syncOutcome);
+  }
+
+  static auditToSarif(syncOutcome) {
+    return auditSyncToSarif(syncOutcome);
+  }
+}
+
+if (require.main === module) {
+  runSync().catch(err => {
+    console.error('[Confluence Sync] Erro fatal:', err);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  ConfluenceSync,
+  escapeHtml,
+  parseLinks,
+  markdownToConfluenceStorage,
+  extractTitle,
+  findOrCreatePage,
+  syncDocument,
+  runSync,
+  formatReport,
+  auditSyncToSarif
+};