/* Georama 100..900, variável, itálico incluso.
   Carregado por CSS e não por JS: a injeção antiga em script.js causava FOUC e
   travava o peso em 700. A chave "font" do mint.json não gera @font-face nesta
   versão do Mintlify (medido: family sozinho não busca do Google Fonts), por
   isso o carregamento fica aqui. Ver DESIGN-SYSTEM-PLAN.md, Fase 2. */
@import url("https://fonts.googleapis.com/css2?family=Georama:ital,wght@0,100..900;1,100..900&display=swap");

/* ============================================================
 * Tokens Tolky — derivados de tolky-design-system/colors_and_type.css
 * Ver DESIGN-SYSTEM-PLAN.md.
 *
 * Isto NÃO é uma cópia do arquivo do design system, de propósito:
 *  - a escala de deck (--display-*, --safe-pad-*, leading 0.82) é de canvas
 *    1920x1080 e não se aplica a documentação;
 *  - o CSS do DS aplica `hyphens: auto`, contra a regra dos próprios guias
 *    ("terminantemente proibida a quebra de sílabas"). Ver plano, secção 3.2.
 *
 * Divisão de responsabilidade:
 *  - mint.json  -> superfícies do próprio Mintlify (cor, fonte, fundo)
 *  - este arquivo -> só os componentes próprios (modal de busca, grades)
 * ============================================================ */

:root {
  /* Azul — monocromático, o sistema não tem matiz quente */
  --tolky-blue: #506ffd; /* assinatura: marca, botão, acento */
  --tolky-blue-600: #425cc5; /* texto/link sobre claro — 5,88:1 */
  --tolky-blue-700: #304491;
  --tolky-blue-300: #6f8af6; /* texto/link sobre escuro — 5,90:1 */
  --tolky-blue-200: #a7b6fe;
  --tolky-blue-100: #c4cefe;
  --tolky-blue-050: #e2e7ff;

  /* Ink — nunca preto puro */
  --tolky-ink-900: #0d1126;
  --tolky-ink-800: #1f2c5d;
  --tolky-ink-700: #1e2a5e; /* cor de título — 13,57:1 sobre branco */

  /* Neutros */
  --tolky-text: #71717a;
  --tolky-text-muted: #4d6a78;
  --tolky-white: #ffffff;
  --tolky-bg-soft: #f7f8fb;
  --tolky-border: #e5e7ef;

  /* Semânticos — modo claro */
  --ts-surface: var(--tolky-white);
  --ts-surface-soft: var(--tolky-bg-soft);
  --ts-fg: var(--tolky-ink-700);
  --ts-fg-muted: var(--tolky-text);
  --ts-border: var(--tolky-border);
  --ts-accent: var(--tolky-blue);
  --ts-accent-text: var(--tolky-blue-600);
  --ts-accent-soft: var(--tolky-blue-050);

  /* Tipo — escala web do DS (--text-*), não a de deck */
  --text-xs: 12px;
  --text-sm: 14px;
  --text-md: 16px;

  --w-medium: 500;
  --w-semi: 600;

  /* Leading — piso de prosa do ui-ux.md (1,3 a 1,5).
     O --leading-normal: 1.2 do DS é token de deck e fica abaixo desse piso. */
  --leading-body: 1.5;
  --leading-snug: 1.4;
  --leading-tight: 1.3;

  /* Raios */
  --r-xs: 4px;
  --r-sm: 6px;
  --r-md: 10px;
  --r-lg: 16px;

  /* Espaço */
  --space-1: 4px;
  --space-2: 8px;
  --space-3: 12px;
  --space-4: 16px;
  --space-5: 24px;
}

/* Modo escuro.
   O design system não define tema escuro (zero ocorrências de prefers-color-scheme
   no repo dele). Ver plano, secção 3.1: estes valores são autorados aqui, a partir
   de tokens legítimos do DS, e não extraídos. Contrastes conferidos sobre #0D1126. */
:root[class*="dark"],
.dark {
  --ts-surface: var(--tolky-ink-900);
  --ts-surface-soft: var(--tolky-ink-800);
  --ts-fg: var(--tolky-white);
  --ts-fg-muted: var(--tolky-blue-200); /* 9,57:1 */
  --ts-border: rgba(255, 255, 255, 0.1);
  --ts-accent-text: var(--tolky-blue-300); /* 5,90:1 */
  --ts-accent-soft: rgba(80, 111, 253, 0.12);
}

/* ─── Tipografia base ──────────────────────────────────────────────────────── */

/* O DS manda Georama e nada mais. O fallback segue o do design system.
   Proibições de tipografia dos guias, que o CSS do próprio DS viola: palavra
   quebra inteira ou não quebra, nunca hifeniza. Ver plano, secção 3.2. */
body {
  font-family: "Georama", ui-sans-serif, system-ui, -apple-system, "Helvetica Neue", Arial,
    sans-serif;
  hyphens: none;
  -webkit-hyphens: none;
  word-break: keep-all;
  overflow-wrap: break-word;
}

/* ─── Títulos ──────────────────────────────────────────────────────────────── */

/* O padrão do Mintlify é #111827, um cinza-quase-preto neutro. O DS pede navy ink
   (#1E2A5E) e diz "nunca preto puro". No escuro o valor coincide com o padrão
   (branco), então a regra só muda o modo claro.
   Sobre o !important: o Mintlify colore heading via classe Tailwind
   (especificidade 0,1,0), e um seletor de elemento nunca vence. A única
   alternativa seria acoplar ao nome da classe interna deles, o que quebra em
   upgrade do mesmo jeito e é menos legível. Diferente do override anterior
   (#6F8AF6 fixo, igual nos dois modos, 3,16:1 no claro = reprova AA), este é
   tokenizado, ciente de modo e passa AA. Ver DESIGN-SYSTEM-PLAN.md, Fase 3. */
h1,
h2,
h3,
h4 {
  color: var(--ts-fg) !important;
}

/* ─── Grades de conteúdo ───────────────────────────────────────────────────── */

.two-columns {
  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: var(--space-3);
}

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

.avatar-sample {
  display: grid;
  grid-template-columns: 1fr 1fr 1fr;
  gap: var(--space-3);
}

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

/* ─── Modal de busca (dirigido por script.js) ──────────────────────────────── */

#ts-overlay {
  display: none;
  position: fixed;
  inset: 0;
  z-index: 99999;
  background: rgba(13, 17, 38, 0.55); /* véu em navy, nunca preto */
  align-items: flex-start;
  justify-content: center;
  padding-top: 12vh;
}

#ts-modal {
  background: var(--ts-surface);
  border-radius: var(--r-lg);
  width: 100%;
  max-width: 620px;
  margin: 0 var(--space-4);
  border: 1px solid var(--ts-border);
  overflow: hidden;
  font-family: inherit;
}

#ts-input-row {
  display: flex;
  align-items: center;
  gap: var(--space-2);
  padding: var(--space-3) var(--space-4);
  border-bottom: 1px solid var(--ts-border);
}

#ts-icon {
  width: 18px;
  height: 18px;
  flex-shrink: 0;
  color: var(--ts-fg-muted);
}

#ts-input {
  flex: 1;
  border: none;
  outline: none;
  background: transparent;
  font-size: var(--text-md);
  color: var(--ts-fg);
  font-family: inherit;
}

#ts-input::placeholder {
  color: var(--ts-fg-muted);
}

#ts-esc-badge {
  font-size: var(--text-xs);
  padding: 2px 6px;
  border-radius: var(--r-sm);
  background: var(--ts-surface-soft);
  color: var(--ts-fg-muted);
  border: 1px solid var(--ts-border);
  flex-shrink: 0;
}

#ts-results {
  max-height: 360px;
  overflow-y: auto;
  padding: var(--space-1) 0;
}

.ts-result {
  display: flex;
  flex-direction: column;
  gap: 2px;
  padding: var(--space-2) var(--space-4);
  text-decoration: none;
  cursor: pointer;
  transition: background 0.15s ease-out; /* 150–250ms, sem bounce */
  border-left: 3px solid transparent;
}

.ts-result:hover,
.ts-result-active {
  background: var(--ts-accent-soft);
  border-left-color: var(--ts-accent);
}

.ts-result-title {
  font-size: var(--text-sm);
  font-weight: var(--w-semi);
  color: var(--ts-fg);
  line-height: var(--leading-tight);
}

.ts-result-desc {
  font-size: var(--text-xs);
  color: var(--ts-fg-muted);
  line-height: var(--leading-snug);
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

#ts-footer {
  display: flex;
  gap: var(--space-4);
  padding: var(--space-2) var(--space-4);
  border-top: 1px solid var(--ts-border);
  font-size: var(--text-xs);
  color: var(--ts-fg-muted);
}

#ts-footer kbd {
  display: inline-block;
  padding: 1px 5px;
  border-radius: var(--r-xs);
  background: var(--ts-surface-soft);
  border: 1px solid var(--ts-border);
  color: var(--ts-fg-muted);
  font-size: 10px;
  margin-right: 2px;
}

@media (max-width: 600px) {
  #ts-overlay {
    padding-top: 0;
    align-items: flex-end;
  }
  #ts-modal {
    border-radius: var(--r-lg) var(--r-lg) 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?'
    }
};

// A fonte Georama é carregada por @import no topo de style.css.
// Não reintroduzir a injeção por JS aqui: ela causava FOUC (o texto renderizava
// na fonte de fallback e trocava depois do parse do JS) e travava o peso em 700,
// enquanto o Georama é variável e serve 100..900.

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

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

const PROJECT_ROOT = path.resolve(__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
/**
 * Captura screenshots de referência do site local (mintlify dev) nos modos claro
 * e escuro, para comparação antes/depois durante a refatoração do design system.
 *
 * Ver DESIGN-SYSTEM-PLAN.md, Fase 0.
 *
 * Uso:
 *   npm run dev                      # em outro terminal, precisa estar no ar
 *   node scripts/docs/capture-theme-baseline.js
 *
 * Saída (rótulo distingue a rodada):
 *   OUT_DIR=/caminho LABEL=depois node scripts/docs/capture-theme-baseline.js
 */

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

const BASE_URL = process.env.BASE_URL || 'http://localhost:8080';
const LABEL = process.env.LABEL || 'antes';
const OUT_DIR = process.env.OUT_DIR || path.resolve(__dirname, '..', '..', '.theme-baseline');
const VIEWPORT = { width: 1440, height: 900 };
const SETTLE_MS = 2500;

/** Páginas escolhidas por cobrirem vocabulários visuais distintos. */
const PAGES = [
  { slug: 'landing', url: '/introduction' },
  { slug: 'api-responsefield', url: '/content/apis/tolky-reasoning/quick-start' },
  { slug: 'frame-imagens', url: '/content/knowing/cases' },
  { slug: 'markdown-divs', url: '/content/management/content-management/formatting' },
];

const MODES = ['light', 'dark'];

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

/**
 * Resolve um Chrome utilizável. O postinstall do puppeteer costuma ser bloqueado
 * (npm allow-scripts), e o cache pode conter versões extraídas pela metade, então
 * não confiamos na resolução automática: procuramos um chrome.exe que exista de fato.
 * Ordem: CHROME_PATH, cache do puppeteer (mais recente primeiro), Edge do sistema.
 */
function resolveChrome() {
  if (process.env.CHROME_PATH && fs.existsSync(process.env.CHROME_PATH)) {
    return process.env.CHROME_PATH;
  }

  const cache = path.join(require('os').homedir(), '.cache', 'puppeteer', 'chrome');
  if (fs.existsSync(cache)) {
    const builds = fs
      .readdirSync(cache)
      .filter((d) => fs.statSync(path.join(cache, d)).isDirectory())
      .sort()
      .reverse();
    for (const b of builds) {
      const exe = path.join(cache, b, 'chrome-win64', 'chrome.exe');
      if (fs.existsSync(exe)) return exe;
    }
  }

  const edge = 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe';
  if (fs.existsSync(edge)) return edge;

  return undefined; // deixa o puppeteer tentar por conta própria
}

/**
 * O Mintlify guarda o tema em localStorage e aplica a classe no <html>.
 * Setamos os dois: o storage sobrevive ao reload, a classe cobre o caso de
 * a chave ter outro nome nesta versão.
 */
async function applyMode(page, mode) {
  await page.evaluateOnNewDocument((m) => {
    try {
      localStorage.setItem('theme', m);
      localStorage.setItem('isDarkMode', String(m === 'dark'));
    } catch (e) {
      /* storage indisponível: a classe abaixo ainda resolve */
    }
  }, mode);
}

async function forceClass(page, mode) {
  await page.evaluate((m) => {
    const el = document.documentElement;
    el.classList.toggle('dark', m === 'dark');
    el.classList.toggle('light', m === 'light');
    el.style.colorScheme = m;
  }, mode);
}

async function waitForServer(page) {
  try {
    await page.goto(BASE_URL, { waitUntil: 'domcontentloaded', timeout: 20000 });
    return true;
  } catch (e) {
    console.error(`Servidor não respondeu em ${BASE_URL}. Rode "npm run dev" antes.`);
    return false;
  }
}

async function main() {
  let puppeteer;
  try {
    puppeteer = require('puppeteer');
  } catch (e) {
    console.error('Puppeteer não encontrado. Rode: npm install');
    process.exit(1);
  }

  ensureOutDir();
  const executablePath = resolveChrome();
  if (executablePath) console.log(`chrome: ${executablePath}\n`);
  const browser = await puppeteer.launch({ headless: 'new', executablePath });
  const probe = await browser.newPage();
  if (!(await waitForServer(probe))) {
    await browser.close();
    process.exit(1);
  }
  await probe.close();

  const captured = [];
  for (const mode of MODES) {
    for (const { slug, url } of PAGES) {
      const page = await browser.newPage();
      await page.setViewport(VIEWPORT);
      await applyMode(page, mode);
      try {
        await page.goto(`${BASE_URL}${url}`, { waitUntil: 'networkidle2', timeout: 45000 });
        await forceClass(page, mode);
        await new Promise((r) => setTimeout(r, SETTLE_MS));
        const file = path.join(OUT_DIR, `${LABEL}-${slug}-${mode}.png`);
        await page.screenshot({ path: file, fullPage: false });
        captured.push(path.basename(file));
        console.log(`ok  ${path.basename(file)}`);
      } catch (e) {
        console.error(`falhou  ${slug} (${mode}): ${e.message}`);
      }
      await page.close();
    }
  }

  await browser.close();
  console.log(`\n${captured.length}/${MODES.length * PAGES.length} capturas em ${OUT_DIR}`);
}

main().catch((e) => {
  console.error(e);
  process.exit(1);
});


/*
  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();



#!/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.resolve(__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.resolve(__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);



Converse com o Tolky

Comunidade

tolky

Suporte do Tolky

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?

Cenários reais de aplicação do tolky por segmento: o que o avatar assume, quais perguntas resolve sozinho e onde entra o time humano.

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

Entenda os 5 pilares que sustentam um avatar realmente inteligente: identidade & comportamento, base de conhecimento, automações, integrações e busca na internet.

Os 5 Pilares da Inteligência Conversacional

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

Definição de Objetivo

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

Análise de Resultados

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

Defina a identidade, o envelope e o comportamento permanente do Avatar.

Identidade e Comportamento

Estruture listas e conteúdos que o Avatar utilizará como base de conhecimento nas conversas.

Base de Conhecimento

Configure fluxos de automação e decisões para o Avatar.

Visão geral

Boas práticas para o gatilho das automações (Decisions): condição observável, sem comando para o avatar

Como escrever o QUANDO

Conecte o avatar a APIs, MCP e outras ferramentas externas.

Integrações

Use a web para ampliar o repertório do avatar com informações vivas e atualizadas.

Busca na Internet

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

Guia funcional e técnico da área de Tickets para operação diária, configuração e integração

Tickets

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

Campanhas

Fluxo de distribuição de operadores em atendimentos criados por campanhas: pré-atribuição, distribuição automática e quebra de conversa.

Distribuição em Campanhas

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

Feedbacks e NPS

Etiquetas aplicadas pela IA para segmentar atendimentos — o gestor define o critério no campo Quando

Smart Tags

Boas práticas para o critério das Smart Tags: condição observável, sem overlap e sem comando para o avatar

Como escrever o Quando da Smart Tag

Criar e publicar workflows em clusters com fluxos, gatilhos, nós e webhooks

Automações (Workflows)

Triagem de aprendizados do gestor, promoção para a base de conhecimento e supervisão de operadores

Content Aware

Testar envelope e decisions em ambientes isolados antes de promover para produção

Ambientes (versionamento de avatar)

Guia simples para entender para que serve cada botão e campo da tela de follow-up

Follow-up no Painel

Estrutura prática para treinar o avatar com os três pilares principais

Treinamento do Avatar

Organize e evolua a base de conteúdo que guia as respostas do avatar

Pilar 1 - Chunks

Defina fluxos de decisão para transformar intenção em ação com controle

Pilar 2 - Decisions

Padronize instruções de follow-up para retomadas consistentes e seguras

Pilar 3 - Envelope Instrucional

Boas praticas para reduzir alucinacao operacional com falha segura e contrato deterministico entre API e LLM

Confiabilidade no Envelope Instrucional

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: o código de instalação, as opções de aparência e comportamento, e o registro de domínios autorizados.

Integrar minichat com meu site

Guia para instalar e configurar o Tolky Voice Widget: script, namespace tolkyVoice, callbacks, segurança e compatibilidade de navegador

Integrar o widget de voz no seu 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

Guia passo a passo para vincular um número WhatsApp da Gupshup a um avatar na Tolky — coleta de dados, chamada de API e validação.

Vinculando via Gupshup

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

Conectar o canal Microsoft Teams e operar atendimentos com as restrições do Bot Framework

Microsoft Teams

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

Verifica, antes do disparo, se cada número já existe como lead — exato ou irmão (variante com/sem o nono dígito) — e sinaliza cruzamentos fixo × celular para evitar leads duplicados

Consulta de Leads (com/sem o 9)

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

Dispara notificações via WhatsApp usando templates pré-aprovados da Meta com parâmetros gerados por IA

IA 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

Registro de funcionalidades da plataforma com busca semântica integrada

Tolky Features

Registra uma nova funcionalidade da plataforma e a torna disponível para busca semântica

Criar feature

Retorna as funcionalidades da plataforma com filtros opcionais por módulo e status

Listar features

Atualiza parcialmente uma funcionalidade existente

Atualizar feature

Desativa uma funcionalidade e a remove da busca semântica

Deletar feature

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

API Pública de Follow-up

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

Advisor

Microserviço de criação de assets, verificação de URLs e download por ID

Assets Handler

Interpreta expressões em português e devolve datas e horários concretos para agendamentos, reagendamentos e lembretes.

Crono — Guia de Uso

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

Capture e organize dados estruturados de conversas com IA em formulários reutilizáveis

FormFlow

Guia prático para escolher, chamar e combinar captura estruturada e análise de diálogo

FormFlow e Doc Analyzer

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

WebSocket

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

Início

Entendendo o Tolky

Primeiros Passos

Gerenciando o Avatar

Canais e Integrações

Referência da API

Novidades

Essenciais

V1.0.683

Melhorias e Novos Recursos

Sincronização de Conversas e Tickets