body {
    font-family: Georama;
}

h1 {
    color: #6F8AF6 !important;
}

h2 {
    color: #6F8AF6 !important;
}

h3 {
    color: #6F8AF6 !important;
}

h4 {
    color: #6F8AF6 !important;
}

.two-columns {
    display: grid; 
    grid-template-columns: 1fr 1fr;
    gap: 10px
}

.two-columns h4 {
    margin-top: 0 !important;
}

.group {
    line-height: 140% !important;
}

.avatar-sample {
    grid-template-columns: 1fr 1fr 1fr;
    display: grid;
    gap: 10px;
}

@media only screen and (max-width: 600px) {
    .avatar-sample {
        grid-template-columns: 1fr;
    }
}

/* ─── Search modal ─────────────────────────────────────────────────────────── */

#ts-overlay {
    display: none;
    position: fixed;
    inset: 0;
    z-index: 99999;
    background: rgba(0, 0, 0, 0.55);
    align-items: flex-start;
    justify-content: center;
    padding-top: 12vh;
    backdrop-filter: blur(2px);
}

#ts-modal {
    background: #ffffff;
    border-radius: 14px;
    width: 100%;
    max-width: 620px;
    margin: 0 16px;
    box-shadow: 0 24px 64px rgba(0, 0, 0, 0.28);
    overflow: hidden;
    font-family: Georama, system-ui, sans-serif;
}

:root[class*="dark"] #ts-modal,
.dark #ts-modal {
    background: #1c1c1e;
    border: 1px solid rgba(255, 255, 255, 0.1);
}

#ts-input-row {
    display: flex;
    align-items: center;
    gap: 10px;
    padding: 14px 18px;
    border-bottom: 1px solid #ebebeb;
}

:root[class*="dark"] #ts-input-row,
.dark #ts-input-row {
    border-bottom-color: rgba(255, 255, 255, 0.08);
}

#ts-icon {
    width: 18px;
    height: 18px;
    flex-shrink: 0;
    color: #9ca3af;
}

#ts-input {
    flex: 1;
    border: none;
    outline: none;
    background: transparent;
    font-size: 15px;
    color: #111827;
    font-family: inherit;
}

:root[class*="dark"] #ts-input,
.dark #ts-input {
    color: #f3f4f6;
}

#ts-input::placeholder {
    color: #9ca3af;
}

#ts-esc-badge {
    font-size: 11px;
    padding: 2px 6px;
    border-radius: 5px;
    background: #f3f4f6;
    color: #6b7280;
    border: 1px solid #e5e7eb;
    flex-shrink: 0;
}

:root[class*="dark"] #ts-esc-badge,
.dark #ts-esc-badge {
    background: #2d2d2f;
    color: #9ca3af;
    border-color: rgba(255, 255, 255, 0.1);
}

#ts-results {
    max-height: 360px;
    overflow-y: auto;
    padding: 6px 0;
}

.ts-result {
    display: flex;
    flex-direction: column;
    gap: 2px;
    padding: 10px 18px;
    text-decoration: none;
    cursor: pointer;
    transition: background 0.1s;
    border-left: 3px solid transparent;
}

.ts-result:hover,
.ts-result-active {
    background: #f0f4ff;
    border-left-color: #6F8AF6;
}

:root[class*="dark"] .ts-result:hover,
:root[class*="dark"] .ts-result-active,
.dark .ts-result:hover,
.dark .ts-result-active {
    background: rgba(111, 138, 246, 0.12);
    border-left-color: #889EF8;
}

.ts-result-title {
    font-size: 14px;
    font-weight: 600;
    color: #111827;
    line-height: 1.3;
}

:root[class*="dark"] .ts-result-title,
.dark .ts-result-title {
    color: #f3f4f6;
}

.ts-result-desc {
    font-size: 12px;
    color: #6b7280;
    line-height: 1.4;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
}

#ts-footer {
    display: flex;
    gap: 16px;
    padding: 8px 18px;
    border-top: 1px solid #ebebeb;
    font-size: 11px;
    color: #9ca3af;
}

:root[class*="dark"] #ts-footer,
.dark #ts-footer {
    border-top-color: rgba(255, 255, 255, 0.08);
}

#ts-footer kbd {
    display: inline-block;
    padding: 1px 5px;
    border-radius: 4px;
    background: #f3f4f6;
    border: 1px solid #e5e7eb;
    color: #374151;
    font-size: 10px;
    margin-right: 2px;
}

:root[class*="dark"] #ts-footer kbd,
.dark #ts-footer kbd {
    background: #2d2d2f;
    border-color: rgba(255, 255, 255, 0.1);
    color: #d1d5db;
}

@media (max-width: 600px) {
    #ts-overlay {
        padding-top: 0;
        align-items: flex-end;
    }
    #ts-modal {
        border-radius: 14px 14px 0 0;
        margin: 0;
        max-width: 100%;
    }
}


.changelog-table {
  width: 100%;
  border-collapse: collapse;
  margin: 1rem 0;
}

.changelog-table th,
.changelog-table td {
  padding: 0.75rem;
  text-align: left;
  border-bottom: 1px solid var(--mint-border-color);
}

.changelog-table th {
  font-weight: 600;
  background-color: var(--mint-bg-color);
}

.changelog-table tr:hover {
  background-color: var(--mint-bg-color);
} 

// ─── Search modal ────────────────────────────────────────────────────────────

(function initDocSearch() {
  var fuseInstance = null;
  var modalOpen = false;
  var selectedIndex = -1;

  function loadScript(src, onLoad) {
    var s = document.createElement("script");
    s.src = src;
    s.onload = onLoad;
    document.head.appendChild(s);
  }

  function fetchSearchIndex(onReady) {
    fetch("/search-index.json")
      .then(function (r) { return r.json(); })
      .then(function (data) { onReady(data); })
      .catch(function (err) {
        console.warn("[tolky-search] index not available:", err);
      });
  }

  function buildFuse(data) {
    fuseInstance = new Fuse(data, {
      keys: [
        { name: "title", weight: 0.6 },
        { name: "description", weight: 0.3 },
        { name: "text", weight: 0.1 },
      ],
      threshold: 0.4,
      includeScore: true,
      minMatchCharLength: 2,
    });
  }

  function createModal() {
    var overlay = document.createElement("div");
    overlay.id = "ts-overlay";
    overlay.setAttribute("role", "dialog");
    overlay.setAttribute("aria-modal", "true");
    overlay.setAttribute("aria-label", "Buscar na documentação");
    overlay.innerHTML =
      '<div id="ts-modal">' +
        '<div id="ts-input-row">' +
          '<svg id="ts-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>' +
          '<input id="ts-input" type="text" placeholder="Buscar na documentação…" autocomplete="off" spellcheck="false" />' +
          '<kbd id="ts-esc-badge">Esc</kbd>' +
        "</div>" +
        '<div id="ts-results"></div>' +
        '<div id="ts-footer">' +
          "<span><kbd>↵</kbd> abrir</span>" +
          "<span><kbd>↑</kbd><kbd>↓</kbd> navegar</span>" +
          "<span><kbd>Esc</kbd> fechar</span>" +
        "</div>" +
      "</div>";

    overlay.addEventListener("click", function (e) {
      if (e.target === overlay) closeModal();
    });

    document.body.appendChild(overlay);

    document.getElementById("ts-input").addEventListener("input", onInput);
    document.getElementById("ts-input").addEventListener("keydown", onKeydown);
  }

  function onInput(e) {
    var query = e.target.value.trim();
    selectedIndex = -1;
    renderResults(query ? fuseInstance && fuseInstance.search(query, { limit: 8 }) : []);
  }

  function renderResults(results) {
    var container = document.getElementById("ts-results");
    if (!results || !results.length) {
      container.innerHTML = "";
      return;
    }
    container.innerHTML = results.map(function (r, i) {
      return (
        '<a class="ts-result" href="' + r.item.url + '" data-idx="' + i + '">' +
          '<span class="ts-result-title">' + escapeHtml(r.item.title) + "</span>" +
          (r.item.description
            ? '<span class="ts-result-desc">' + escapeHtml(r.item.description) + "</span>"
            : "") +
        "</a>"
      );
    }).join("");

    container.querySelectorAll(".ts-result").forEach(function (el) {
      el.addEventListener("click", closeModal);
    });
  }

  function escapeHtml(str) {
    return str.replace(/[&<>"']/g, function (c) {
      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
    });
  }

  function onKeydown(e) {
    var results = document.querySelectorAll(".ts-result");
    if (e.key === "ArrowDown") {
      e.preventDefault();
      selectedIndex = Math.min(selectedIndex + 1, results.length - 1);
      highlightSelected(results);
    } else if (e.key === "ArrowUp") {
      e.preventDefault();
      selectedIndex = Math.max(selectedIndex - 1, 0);
      highlightSelected(results);
    } else if (e.key === "Enter" && selectedIndex >= 0) {
      e.preventDefault();
      if (results[selectedIndex]) results[selectedIndex].click();
    } else if (e.key === "Escape") {
      closeModal();
    }
  }

  function highlightSelected(results) {
    results.forEach(function (el, i) {
      el.classList.toggle("ts-result-active", i === selectedIndex);
    });
    if (results[selectedIndex]) {
      results[selectedIndex].scrollIntoView({ block: "nearest" });
    }
  }

  function openModal() {
    if (modalOpen) return;
    modalOpen = true;
    var overlay = document.getElementById("ts-overlay");
    if (!overlay) createModal();
    document.getElementById("ts-overlay").style.display = "flex";
    document.getElementById("ts-results").innerHTML = "";
    document.getElementById("ts-input").value = "";
    selectedIndex = -1;
    setTimeout(function () {
      var input = document.getElementById("ts-input");
      if (input) input.focus();
    }, 50);
  }

  function closeModal() {
    modalOpen = false;
    var overlay = document.getElementById("ts-overlay");
    if (overlay) overlay.style.display = "none";
  }

  function interceptNativeSearchButton() {
    var selectors = [
      'button[id*="search"]',
      'button[class*="search"]',
      '[role="search"] button',
      'button[aria-label*="search" i]',
      'button[aria-label*="busca" i]',
      'button[aria-label*="buscar" i]',
    ];
    for (var i = 0; i < selectors.length; i++) {
      var btn = document.querySelector(selectors[i]);
      if (btn) {
        btn.addEventListener("click", function (e) {
          e.stopPropagation();
          e.preventDefault();
          openModal();
        }, true);
        return true;
      }
    }
    var allButtons = document.querySelectorAll("button");
    for (var j = 0; j < allButtons.length; j++) {
      var text = allButtons[j].textContent || "";
      if (text.indexOf("⌘K") !== -1 || text.indexOf("Ctrl K") !== -1 || text.indexOf("Search") !== -1) {
        allButtons[j].addEventListener("click", function (e) {
          e.stopPropagation();
          e.preventDefault();
          openModal();
        }, true);
        return true;
      }
    }
    return false;
  }

  document.addEventListener("keydown", function (e) {
    if ((e.metaKey || e.ctrlKey) && e.key === "k") {
      e.preventDefault();
      e.stopPropagation();
      openModal();
    }
    if (e.key === "Escape" && modalOpen) closeModal();
  }, true);

  loadScript(
    "https://cdn.jsdelivr.net/npm/fuse.js@7.0.0/dist/fuse.min.js",
    function () {
      fetchSearchIndex(function (data) {
        buildFuse(data);
        if (!interceptNativeSearchButton()) {
          var observer = new MutationObserver(function () {
            if (interceptNativeSearchButton()) observer.disconnect();
          });
          observer.observe(document.body, { childList: true, subtree: true });
        }
      });
    }
  );
})();

// ─────────────────────────────────────────────────────────────────────────────

// Cria um novo elemento link para o CSS
var link = document.createElement('link');
link.rel = 'stylesheet';
link.href = 'https://minichat.tolky.to/css/style.css';

// Adiciona o elemento link ao head do documento
document.head.appendChild(link);


// Cria um novo elemento script para o JavaScript
var script = document.createElement('script');
script.type = 'module';
script.async = true;
script.src = 'https://minichat.tolky.to/main.js';

// Adiciona o elemento script ao documento
document.body.appendChild(script);


// Configura o objeto tolky no window
window.tolky = window.tolky || {
    config: {
        slug: 'us',
        firstMessage: 'Olá, em que posso ajudá-lo?'
    }
};

// Cria um novo elemento link para o CSS
var font = document.createElement('link');
font.rel = 'stylesheet';
font.href = 'https://fonts.googleapis.com/css2?family=Georama:ital,wght@0,100..700;1,100..700&display=swap';


// Adiciona o elemento link ao head do documento
document.head.appendChild(font);

/*
  Build a search index JSON from all MDX files in the project.
  Output: public/search-index.json
  Run: node scripts/build-search-index.js
*/

const fs = require("fs");
const path = require("path");

const PROJECT_ROOT = path.join(__dirname, "..");
const OUTPUT_FILE = path.join(PROJECT_ROOT, "public", "search-index.json");

const INDEXED_DIRS = ["content", "changelog", "essentials", "documents"];
const INDEXED_ROOT_FILES = ["introduction.mdx"];

function collectMdxFiles(dir) {
  if (!fs.existsSync(dir)) return [];

  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
    if (entry.name.startsWith(".") || entry.name.startsWith("_")) return [];
    const fullPath = path.join(dir, entry.name);
    if (entry.isDirectory()) return collectMdxFiles(fullPath);
    if (entry.name.endsWith(".mdx") || entry.name.endsWith(".md"))
      return [fullPath];
    return [];
  });
}

function parseFrontmatter(content) {
  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
  if (!match) return {};

  const result = {};
  for (const line of match[1].split("\n")) {
    const colonIndex = line.indexOf(":");
    if (colonIndex === -1) continue;
    const key = line.slice(0, colonIndex).trim();
    const value = line
      .slice(colonIndex + 1)
      .trim()
      .replace(/^["']|["']$/g, "");
    if (key) result[key] = value;
  }

  return result;
}

function extractPlainText(content) {
  return content
    .replace(/^---[\s\S]*?---\r?\n/, "")
    .replace(/^import\s+.*$/gm, "")
    .replace(/^export\s+.*$/gm, "")
    .replace(/```[\s\S]*?```/g, "")
    .replace(/`[^`]+`/g, "")
    .replace(/<[^>]+>/g, " ")
    .replace(/^#{1,6}\s+/gm, "")
    .replace(/\[([^\]]+)\]$[^)]+$/g, "$1")
    .replace(/[*_]{1,2}([^*_\n]+)[*_]{1,2}/g, "$1")
    .replace(/^\s*[-*+>]\s+/gm, "")
    .replace(/\s+/g, " ")
    .trim()
    .slice(0, 400);
}

function filePathToUrl(filePath) {
  return (
    "/" +
    path
      .relative(PROJECT_ROOT, filePath)
      .replace(/\\/g, "/")
      .replace(/\.mdx?$/, "")
  );
}

function buildEntry(filePath) {
  const content = fs.readFileSync(filePath, "utf-8");
  const frontmatter = parseFrontmatter(content);
  const text = extractPlainText(content);
  const url = filePathToUrl(filePath);
  const title =
    frontmatter.title ||
    path.basename(filePath, path.extname(filePath)).replace(/-/g, " ");

  return {
    title,
    description: frontmatter.description || "",
    url,
    text,
  };
}

function run() {
  const allFiles = [
    ...INDEXED_ROOT_FILES.map((f) => path.join(PROJECT_ROOT, f)).filter((f) =>
      fs.existsSync(f)
    ),
    ...INDEXED_DIRS.flatMap((dir) =>
      collectMdxFiles(path.join(PROJECT_ROOT, dir))
    ),
  ];

  const entries = allFiles.map(buildEntry);

  fs.mkdirSync(path.dirname(OUTPUT_FILE), { recursive: true });
  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(entries));

  console.log(
    `Search index built: ${entries.length} pages → ${path.relative(PROJECT_ROOT, OUTPUT_FILE)}`
  );
}

run();


#!/usr/bin/env node
/**
 * Script para capturar screenshots do Dashboard v2 (https://v2.gestao.tolky.to)
 * e salvar em docs/images/ para atualização da documentação.
 *
 * Uso:
 *   npm run capture-dashboard
 *
 * Com login automático (credenciais via variáveis de ambiente):
 *   DASHBOARD_EMAIL=seu@email.com DASHBOARD_PASSWORD=sua_senha npm run capture-dashboard
 *
 * Sem credenciais: o script abre o navegador e aguarda login manual + Enter.
 */

const fs = require('fs');
const path = require('path');

const DASHBOARD_URL = 'https://v2.gestao.tolky.to';
const IMAGES_DIR = path.join(__dirname, '..', 'images');
const SCREENSHOT_DELAY_MS = 2000;

const SECTION_IDS = [
  'insights',
  'barra-creditos',
  'funil',
  'satisfacao',
  'assuntos',
  'top10',
];

const EMAIL = process.env.DASHBOARD_EMAIL;
const PASSWORD = process.env.DASHBOARD_PASSWORD;
const AUTO_LOGIN = Boolean(EMAIL && PASSWORD);

function ensureImagesDir() {
  if (!fs.existsSync(IMAGES_DIR)) {
    fs.mkdirSync(IMAGES_DIR, { recursive: true });
  }
}

async function performLogin(page) {
  const emailInput =
    (await page.$('input[type="email"]')) ||
    (await page.$('input[name="email"]')) ||
    (await page.$('input[autocomplete="email"]'));
  const passwordInput =
    (await page.$('input[type="password"]')) ||
    (await page.$('input[name="password"]'));

  if (!emailInput || !passwordInput) {
    console.log('Formulário de login não encontrado. Faça login manualmente.');
    return false;
  }

  await emailInput.type(EMAIL, { delay: 50 });
  await passwordInput.type(PASSWORD, { delay: 50 });
  await new Promise((r) => setTimeout(r, 300));

  const submit =
    (await page.$('button[type="submit"]')) ||
    (await page.$('form button')) ||
    (await page.$('button'));
  if (submit) {
    await submit.click();
    await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 15000 }).catch(() => {});
    await new Promise((r) => setTimeout(r, 3000));
    return true;
  }
  return false;
}

async function captureWithPuppeteer() {
  let puppeteer;
  try {
    puppeteer = require('puppeteer');
  } catch {
    console.error('Puppeteer não encontrado. Instale com: npm install -D puppeteer');
    process.exit(1);
  }

  ensureImagesDir();

  const browser = await puppeteer.launch({
    headless: false,
    defaultViewport: { width: 1920, height: 1080 },
    args: ['--start-maximized'],
  });

  const page = await browser.newPage();
  await page.goto(DASHBOARD_URL, { waitUntil: 'networkidle2', timeout: 30000 });

  if (AUTO_LOGIN) {
    console.log('\n=== Tentando login automático ===');
    const loggedIn = await performLogin(page);
    if (!loggedIn) {
      console.log('Login automático falhou. Faça login manualmente e pressione Enter...\n');
      await new Promise((resolve) => process.stdin.once('data', resolve));
    } else {
      console.log('Login realizado. Aguardando carregamento do dashboard...\n');
      await new Promise((r) => setTimeout(r, 4000));
    }
  } else {
    console.log('\n=== Dashboard aberto ===');
    console.log('Faça login manualmente na janela do navegador.');
    console.log('Quando o dashboard estiver visível, pressione Enter para capturar...\n');
    await new Promise((resolve) => process.stdin.once('data', resolve));
  }

  console.log('Capturando screenshots...\n');

  const fullPath = path.join(IMAGES_DIR, 'dashboard-full.png');
  await page.screenshot({ path: fullPath, fullPage: true });
  console.log('  ✓ dashboard-full.png (página completa)');

  await new Promise((r) => setTimeout(r, SCREENSHOT_DELAY_MS));

  const viewportPath = path.join(IMAGES_DIR, 'dashboard-viewport.png');
  await page.screenshot({ path: viewportPath });
  console.log('  ✓ dashboard-viewport.png (viewport)');

  const skipInteractive = process.env.SKIP_INTERACTIVE === '1' || process.env.CI === 'true';
  if (skipInteractive) {
    console.log('\nModo automático: extraindo seções da página completa...');
    const bodyHeight = await page.evaluate(() => document.body.scrollHeight);
    const viewportHeight = 1080;
    const sectionHeight = Math.floor(bodyHeight / SECTION_IDS.length);
    for (let i = 0; i < SECTION_IDS.length; i++) {
      const scrollY = Math.min(i * sectionHeight, bodyHeight - viewportHeight);
      await page.evaluate((y) => window.scrollTo(0, y), scrollY);
      await new Promise((r) => setTimeout(r, 800));
      const sectionPath = path.join(IMAGES_DIR, `${SECTION_IDS[i]}.png`);
      await page.screenshot({ path: sectionPath });
      console.log(`  ✓ ${SECTION_IDS[i]}.png`);
    }
  } else {
    console.log('\nPara capturar seções individuais, role a página até cada seção');
    console.log('e pressione Enter. Os arquivos serão sobrescritos na ordem:');
    SECTION_IDS.forEach((id, i) => console.log(`  ${i + 1}. ${id}.png`));
    console.log('\nPressione Enter para cada seção (ou Ctrl+C para encerrar).\n');
    for (const id of SECTION_IDS) {
      await new Promise((resolve) => process.stdin.once('data', resolve));
      const sectionPath = path.join(IMAGES_DIR, `${id}.png`);
      await page.screenshot({ path: sectionPath });
      console.log(`  ✓ ${id}.png salvo`);
    }
  }

  console.log('\nScreenshots salvos em:', IMAGES_DIR);
  await browser.close();
}

captureWithPuppeteer().catch((err) => {
  console.error('Erro:', err);
  process.exit(1);
});


const { chromium } = require('playwright');
const path = require('path');

const IMAGES_DIR = path.join(__dirname, '..', 'images');
const LOGIN_URL = 'https://v2.gestao.tolky.to';

const SECTIONS = [
  {
    filename: 'relatorios-atendimentos.png',
    titleText: 'Atendimentos',
    excludeTitleText: 'Histórico',
    label: 'Atendimentos',
  },
  {
    filename: 'relatorios-horas-economizadas.png',
    titleText: 'Horas Economizadas',
    label: 'Horas Economizadas',
  },
  {
    filename: 'relatorios-respostas.png',
    titleText: 'Respostas',
    excludeTitleText: 'fora',
    label: 'Respostas',
  },
  {
    filename: 'relatorios-fora-horario.png',
    titleText: 'fora do horário',
    label: 'Respostas fora do horário',
  },
  {
    filename: 'relatorios-historico.png',
    titleText: 'Histórico de Atendimentos',
    label: 'Histórico de Atendimentos',
  },
  {
    filename: 'relatorios-tickets.png',
    titleText: 'Distribuição de Tickets',
    label: 'Distribuição de Tickets',
  },
  {
    filename: 'relatorios-campanhas.png',
    titleText: 'Mensagens Enviadas',
    label: 'Campanhas',
  },
  {
    filename: 'relatorios-satisfacao.png',
    titleText: 'Satisfação dos Atendimentos',
    label: 'Satisfação dos Atendimentos',
  },
  {
    filename: 'relatorios-assuntos.png',
    titleText: 'Assuntos mais Relevantes',
    label: 'Assuntos mais Relevantes',
  },
  {
    filename: 'relatorios-smart-tags.png',
    titleText: 'Smart Tags',
    label: 'Smart Tags',
  },
];

async function login(page) {
  await page.goto(LOGIN_URL, { waitUntil: 'networkidle' });

  const emailInput = page.locator('input[type="email"], input[name="email"], input[placeholder*="mail" i]').first();
  await emailInput.waitFor({ timeout: 10000 });
  await emailInput.fill('patrick@tolky.to');

  const passwordInput = page.locator('input[type="password"]').first();
  await passwordInput.fill('Patrick@1234');

  await page.keyboard.press('Enter');
  await page.waitForNavigation({ waitUntil: 'networkidle', timeout: 15000 }).catch(() => {});
  await page.waitForTimeout(2000);
}

const CARD_MAX_WIDTH_RATIO = 0.7;

async function findCardElement(page, titleText, excludeTitleText) {
  const handle = await page.evaluateHandle(
    ({ titleText, excludeTitleText, maxWidthRatio }) => {
      const viewportWidth = window.innerWidth;
      const sidebarMaxX = 180;

      const allText = Array.from(document.querySelectorAll('p, h1, h2, h3, h4, h5, h6, span, div, a'));

      const titleNodes = allText.filter((el) => {
        if (el.children.length > 2) return false;
        const ownText = el.textContent.trim();
        if (!ownText.includes(titleText)) return false;
        if (excludeTitleText && ownText.includes(excludeTitleText)) return false;

        const rect = el.getBoundingClientRect();
        if (rect.x < sidebarMaxX) return false;

        return true;
      });

      for (const node of titleNodes) {
        let candidate = node.parentElement;
        for (let i = 0; i < 10; i++) {
          if (!candidate || candidate === document.body) break;
          const rect = candidate.getBoundingClientRect();
          const widthRatio = rect.width / viewportWidth;
          if (rect.width > 100 && rect.height > 60 && widthRatio < maxWidthRatio) {
            return candidate;
          }
          candidate = candidate.parentElement;
        }
      }
      return null;
    },
    { titleText, excludeTitleText, maxWidthRatio: CARD_MAX_WIDTH_RATIO }
  );

  return handle.asElement();
}

async function screenshotSection(page, section) {
  const outputPath = path.join(IMAGES_DIR, section.filename);

  try {
    const element = await findCardElement(page, section.titleText, section.excludeTitleText);

    if (!element) {
      console.warn(`⚠️  ${section.label}: elemento não encontrado`);
      return;
    }

    await page.evaluate((el) => el.scrollIntoView({ block: 'center' }), element);
    await page.waitForTimeout(400);

    await element.screenshot({ path: outputPath, type: 'png' });
    console.log(`✅ ${section.label} → ${section.filename}`);
  } catch (err) {
    console.warn(`⚠️  ${section.label}: erro → ${err.message}`);
  }
}

async function run() {
  const browser = await chromium.launch({ headless: true });
  const page = await browser.newPage();
  await page.setViewportSize({ width: 1440, height: 900 });

  try {
    console.log('🔐 Fazendo login...');
    await login(page);
    console.log('✅ Login realizado\n');

    for (const section of SECTIONS) {
      await screenshotSection(page, section);
    }

    console.log('\n✅ Todos os screenshots salvos em', IMAGES_DIR);
  } finally {
    await browser.close();
  }
}

run().catch(console.error);


/*
  Generate changelog/index.mdx from files in changelog/ directory.
  - Reads all files matching v*.mdx
  - Extracts frontmatter title/description if present
  - Derives version and date from content when possible
  - Sorts by semantic-ish version (desc) then by file mtime
*/

const fs = require("fs");
const path = require("path");

const CHANGELOG_DIR = path.join(process.cwd(), "changelog");
const INDEX_FILE = path.join(CHANGELOG_DIR, "index.mdx");

function readFileSafe(filePath) {
  try {
    return fs.readFileSync(filePath, "utf8");
  } catch (e) {
    return "";
  }
}

function parseFrontmatter(content) {
  const fmMatch = content.match(/^---[\s\S]*?---/);
  if (!fmMatch) return {};
  const fm = fmMatch[0].replace(/^---\n?|\n?---$/g, "");
  const result = {};
  for (const line of fm.split("\n")) {
    const m = line.match(/^([a-zA-Z0-9_\-]+):\s*(.*)$/);
    if (m) {
      const key = m[1].trim();
      let value = m[2].trim();
      value = value.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
      result[key] = value;
    }
  }
  return result;
}

function extractVersionFromFilename(filename) {
  const base = path.basename(filename, ".mdx");
  return base; // e.g., v3.0.31 or v1.0.418-prod
}

function extractDateFromContent(content) {
  // Look for patterns like 03 de Agosto, 2025 or 15 de Janeiro, 2025 etc.
  const dateMatch = content.match(
    /\b(\d{1,2})\s+de\s+[A-Za-zçáéíóúãõ]+,\s+(\d{4})/
  );
  if (dateMatch) return dateMatch[0];
  // Or YYYY-MM-DD-ish
  const isoMatch = content.match(/\b\d{4}-\d{2}-\d{2}\b/);
  if (isoMatch) return isoMatch[0];
  return null;
}

function toSortableVersion(ver) {
  // Extract numeric parts from vX.Y.Z[-label]
  const m = ver.match(/^v?(\d+)\.(\d+)\.(\d+)/);
  if (!m) return [-1, -1, -1];
  return [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)];
}

function generateIndex(items) {
  const header =
    `---\n` +
    `title: "Novidades no Tolky"\n` +
    `description: "Acompanhe todas as atualizações e melhorias do Tolky"\n` +
    `icon: "star"\n` +
    `---\n\n` +
    `## Índice de Versões\n\n`;

  const rows = [
    "| Versão      | Descrição                               | Data de Publicação  | Detalhes                           |",
    "| ----------- | --------------------------------------- | ------------------- | ---------------------------------- |",
  ];

  for (const it of items) {
    const version = `**${it.version}**`;
    const description = it.description || it.title || "";
    const date = it.date || "";
    const link = `[Ver detalhes](/changelog/${it.slug})`;
    rows.push(`| ${version} | ${description} | ${date} | ${link} |`);
  }

  const sections = items
    .map((it) => {
      const title = it.title || it.version;
      const dateLine = it.date ? `**Data:** ${it.date}  ` : "";
      return `\n### ${title}\n\n${dateLine}\n**Principais melhorias:**\n\n- Consulte os detalhes completos no documento desta versão.\n\n[Ver detalhes completos →](/changelog/${it.slug})\n\n---\n`;
    })
    .join("\n");

  return (
    header +
    rows.join("\n") +
    "\n\n" +
    sections +
    "\n" +
    "_Para mais informações sobre cada versão, clique nos links acima para acessar os detalhes completos de cada atualização._\n"
  );
}

function run() {
  if (!fs.existsSync(CHANGELOG_DIR)) {
    console.error("Changelog directory not found:", CHANGELOG_DIR);
    process.exit(1);
  }

  const files = fs
    .readdirSync(CHANGELOG_DIR)
    .filter(
      (f) =>
        f.endsWith(".mdx") && f !== "index.mdx" && /^v[0-9].*\.mdx$/.test(f)
    );

  const items = files.map((f) => {
    const full = path.join(CHANGELOG_DIR, f);
    const content = readFileSafe(full);
    const fm = parseFrontmatter(content);
    const version = extractVersionFromFilename(f);
    const date = extractDateFromContent(content);
    const title = fm.title || "";
    const description = fm.description || "";
    const stats = fs.statSync(full);
    return {
      slug: version,
      version,
      title,
      description,
      date,
      mtimeMs: stats.mtimeMs,
      sortKey: toSortableVersion(version),
    };
  });

  items.sort((a, b) => {
    // Sort by semantic version desc; fallback to mtime desc
    for (let i = 0; i < 3; i++) {
      if (a.sortKey[i] !== b.sortKey[i]) return b.sortKey[i] - a.sortKey[i];
    }
    return b.mtimeMs - a.mtimeMs;
  });

  const output = generateIndex(items);
  fs.writeFileSync(INDEX_FILE, output, "utf8");
  console.log(
    `Generated ${path.relative(process.cwd(), INDEX_FILE)} with ${
      items.length
    } entries.`
  );
}

run();


Converse com o Tolky

Comunidade

tolky

Suporte do Tolky

Retorna o schema JSON completo de um formulário, incluindo campos e estratégias de captura

Schema de um Catálogo

Plataforma de IA conversacional omnicanal para automatizar relacionamentos e transformar o atendimento da sua empresa.

Bem-vindo ao Tolky

Entenda a arquitetura, os conceitos e as boas práticas que fazem o Tolky entregar interações inteligentes, seguras e personalizadas.

Como funciona?

Exemplos de Uso

Compreenda como funcionam os Modelos de Linguagem de Grande Escala (LLM) e como utilizá-los de forma estratégica no Tolky.

Modelos de Linguagem

Veja como é a jornada de integração e configuração do Tolky para garantir máximo aproveitamento da plataforma.

Entenda a Implantação

A primeira e mais importante etapa para alinhar a implantação do Tolky às metas do seu negócio.

Definição de Objetivo

Personalize o comportamento, a comunicação e a identidade visual do Avatar para representar sua marca.

Configuração dos Avatares

Etapa crucial para transformar conteúdo em interações inteligentes e alinhadas à identidade da marca.

Treinamento de Avatares

Capacitação da equipe para operar, manter e evoluir os avatares no Tolky de forma estratégica e eficiente.

Treinamento dos Colaboradores

Etapa essencial para validar e otimizar o Tolky antes do lançamento oficial.

Testes e Ajustes

Fase de testes com público controlado para validar o Tolky em condições reais antes do lançamento completo.

Soft Launch (Pré-Lançamento)

Ative o Tolky para todos os usuários e comunique o lançamento oficial.

Go Live (Lançamento)

Processo pós-lançamento que garante evolução constante, alinhamento com as necessidades dos usuários e inovação contínua.

Monitoramento e Melhoria Contínua

Etapa contínua de coleta, análise e aplicação de melhorias no Tolky, baseada na voz dos usuários.

Feedback e Ajustes

Etapa para medir o sucesso da implantação do Tolky e identificar oportunidades de melhoria.

Análise de Resultados

Guia rápido para acessar o painel de administração do Tolky e gerenciar seus avatares e conteúdos.

Ambiente de Gestão

Painel de monitoramento e análise para acompanhar, comprovar e evoluir a performance da IA conversacional do Tolky.

Dashboard

Inbox centralizado para monitorar, filtrar e interagir com todas as conversas do avatar em tempo real.

Atendimentos

Gerenciamento de solicitações de atendimento humano com fila, estágios e métricas de operadores.

Tickets

Criação e acompanhamento de campanhas de disparo de mensagens personalizadas via WhatsApp.

Campanhas

Editor visual de fluxos de automação para orquestrar ações, agentes e integrações sem código.

Automações

Dashboard de satisfação com análise automática de sentimentos, insights gerados por IA e acompanhamento de NPS.

Feedbacks e NPS

Etiquetas aplicadas automaticamente pela IA para segmentar e identificar padrões nos atendimentos.

Smart Tags

Boas práticas para criar e estruturar conteúdo no Tolky, garantindo relevância e eficiência nas respostas do avatar.

Antes de começar

Conjuntos de conteúdo usados para treinar e personalizar os avatares do Tolky.

Datasets

Guia para criar, editar e excluir blocos de conteúdo nos datasets do Tolky.

Adicionando Novos Conteúdos

Guia prático para aplicar formatação Markdown nos blocos de conteúdo do Tolky.

Formatando os Blocos

Guia para incorporar imagens e vídeos em blocos de conteúdo do Tolky utilizando Markdown.

Imagens e Vídeos

Como o Tolky entende significado e contexto nas buscas.

Busca Semântica

Boas práticas para gerenciar conteúdo e datasets no Tolky.

Dicas

Monitorar e interagir com conversas no painel do Tolky.

Gerenciando Mensagens

O widget interativo do Tolky para sites e aplicativos, com personalização total e integração fluida.

Minichat

Guia passo a passo para instalar e configurar o minichat do Tolky no seu site, incluindo a inserção de código HTML e CSS, e o registro de domínios autorizados para uso.

Integrar minichat com meu site

Benefícios de integrar o Tolky ao WhatsApp.

Objetivo da Integração

Como obter chip físico ou número VoIP para WhatsApp Business.

Adquirindo um Chip

Como criar conta na Meta e vincular número ao WhatsApp Business.

Criando Conta na Meta

Instruções detalhadas para conectar sua conta do WhatsApp Business à plataforma Tolky, desde o login até o teste de funcionamento.

Conectando ao Tolky

Lista de verificação para confirmar que todas as etapas de configuração e integração do Tolky com o WhatsApp foram concluídas com sucesso.

Checklist

Como integrar seu sistema ao Power CRM via Power API.

Power CRM

Guia para criar conta no Facebook, configurar Business e conectar WhatsApp ao Tolky.

Manual de Integração WhatsApp

Configuração e exemplos para integração do HubSpot com o Tolky, recebendo dados de tickets, deals e objetos personalizados via API.

Integração HubSpot (Recebimento)

Guia rápido de integração com a API Tolky Reasoning em uma página

Quick Start - API Tolky Reasoning

Obtenha tokens de acesso para hosts associados ao seu domínio.

Obter Tokens de Acesso

Processa perguntas usando a inteligência do Tolky, mantendo o contexto das conversas e retornando respostas personalizadas

Visão Geral

Dispara mensagens com contexto personalizado e instruções específicas para processamento pela IA

Mensagens com IA

Dispara mensagens com texto pré-definido e substituição de variáveis dinâmicas para um ou mais destinatários

Mensagem Fixa

Dispara notificações via WhatsApp usando templates pré-aprovados pela Meta

Mensagem Fixa com Template

Cria uma conversação e retorna os IDs de lead, conversação e sessão para uso com o Tolky Reasoning

Criar ID de Conversação

Atualiza campos de tickets e move entre estágios do pipeline

Atualizar Ticket

Busca tickets por ticketId, leadId ou conversationId com filtros opcionais

Obter Tickets

Como autenticar, consultar, atualizar e resetar a configuração de followup via API pública

API Pública de Followup

Análise em tempo real e recomendações para melhorar a qualidade de decisions, smart tags e chunks

Advisor

Área dedicada a gerenciar mídias, links e outros assets com verificação de saúde, encurtamento e controle de ciclo de vida.

Buscar Asset

Usa captura via LLM (schema) para normalizar campos de data/tempo a partir do diálogo e resolve a data absoluta ou recorrência com validações e timezone.

Crono Resolver (Utils)

Valida URLs em um texto e substitui links quebrados por um marcador

Validar Links em Texto (Utils)

Gera um token criptografado (hash) a partir de um objeto arbitrário

Gerar Hash (Crypto)

Processa um texto e substitui marcadores {{hash:...}} por tokens {{kripto:...}}

Criptografar Marcadores em Texto (Crypto)

Descriptografa um token (hash) e retorna o objeto original

Recuperar Objeto do Hash (Crypto)

Processa um texto e substitui tokens {{kripto:...}} por seus valores descriptografados

Descriptografar Marcadores em Texto (Crypto)

Endpoint interno para executar a suíte de testes e obter um resumo.

Executar Testes (Jest)

Como o Tolky detecta e trata URLs inválidas em textos e conteúdos.

Verificação de Links Quebrados

Sistema inteligente de captura dinâmica de dados estruturados a partir de conversas

FormFlow

Eventos em tempo real para captura, valores e progresso de execução do FormFlow via Socket.IO

WebSocket

Como usar o MCP de raciocínio sequencial para planejar e executar operações complexas no FormFlow

Sequential Thinking

Motor genérico que transforma instruções em plano executável, com persistência, retry, auditoria e eventos em tempo real

O que o Sequential Thinking faz, quando usar e exemplos práticos de uso

Retorna o catálogo de ações que o motor pode planejar e executar ao usar runWithAgents

Listar Ações Disponíveis

Executa o motor com ações de sandbox para testes locais, sem efeitos colaterais externos

Executar com Sandbox

Executa o motor com agentes reais do sistema (ragSearch, respondToUser) em produção

Executar com Agentes Reais

Documentação completa do serviço de Visão Computacional do Tolky, que utiliza tecnologias como a de OCR para extrair informações de imagens, vídeos, áudios e páginas web.

Visão Computacional

Repositório central de busca híbrida sobre conversations, leads e tickets com FTS, trigram e busca numérica

Sistema OmniSearch

Baixa e processa um feed XML (ex.: 123i) via streaming, realizando upsert em properties.

Ingestão de Feed XML de Imóveis

Analisa conversas em lote com JSON Schema e instruções; armazena resultados em conversations_reports

Código	Descrição
`400`	`catalogId` ausente ou inválido
`401`	Token inválido ou ausente
`404`	Formulário não encontrado para o host
`500`	Erro interno do servidor

Início

Entendendo o Tolky

Implantando o Tolky

Gerenciando o Avatar

Canais e Integrações

Referência da API

Novidades

Essenciais

Schema de um Catálogo

Endpoint

Parâmetros

Exemplo

Resposta

Campos da Resposta

Erros