mcp-lab-agent 2.1.3 → 2.1.6

package/dist/index.js

@@ -8,6 +8,7 @@ import { z } from "zod";
 import { spawn as spawn2 } from "child_process";
 import path5 from "path";
 import fs5 from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
 
 // src/core/llm-router.js
 function resolveLLMProvider(taskType = "simple") {
@@ -41,6 +42,44 @@ function resolveLLMProvider(taskType = "simple") {
 // src/core/memory.js
 import path from "path";
 import fs from "fs";
+
+// src/core/hub-client.js
+var hubUrl = null;
+function getHubUrl() {
+  if (hubUrl) return hubUrl;
+  const env = process.env.LEARNING_HUB_URL || process.env.QA_LAB_LEARNING_HUB_URL;
+  if (env) {
+    hubUrl = env.replace(/\/$/, "");
+    return hubUrl;
+  }
+  return null;
+}
+async function syncLearningsToHub(learnings) {
+  const baseUrl = getHubUrl();
+  if (!baseUrl) return;
+  const entries = Array.isArray(learnings) ? learnings : [learnings];
+  if (entries.length === 0) return;
+  const projectId = process.env.LEARNING_HUB_PROJECT_ID || process.cwd().split("/").pop() || "default";
+  const payload = entries.map((e) => ({
+    ...e,
+    projectId
+  }));
+  try {
+    const res = await fetch(`${baseUrl}/learning`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ learnings: payload })
+    });
+    if (!res.ok) {
+      const txt = await res.text();
+      console.warn(`[learning-hub] POST /learning failed ${res.status}: ${txt}`);
+    }
+  } catch (err) {
+    console.warn("[learning-hub] sync failed:", err.message);
+  }
+}
+
+// src/core/memory.js
 var PROJECT_ROOT = process.cwd();
 var MEMORY_FILE = path.join(PROJECT_ROOT, ".qa-lab-memory.json");
 var FLOWS_CONFIG_FILE2 = path.join(PROJECT_ROOT, "qa-lab-flows.json");
@@ -73,6 +112,8 @@ function saveProjectMemory(updates) {
       data.learnings = data.learnings || [];
       data.learnings.push(...updates.learnings);
       if (data.learnings.length > 200) data.learnings = data.learnings.slice(-150);
+      syncLearningsToHub(updates.learnings).catch(() => {
+      });
     }
     if (updates.execution) {
       data.executions = data.executions || [];
@@ -84,12 +125,17 @@ function saveProjectMemory(updates) {
   } catch {
   }
 }
+var LEARNING_TYPES = ["selector_fix", "timing_fix", "element_not_rendered", "element_not_visible", "element_stale", "mobile_mapping_invisible"];
 function getMemoryStats() {
   const memory = loadProjectMemory();
   const learnings = memory.learnings || [];
   const successfulFixes = learnings.filter((l) => l.success);
   const selectorFixes = learnings.filter((l) => l.type === "selector_fix");
   const timingFixes = learnings.filter((l) => l.type === "timing_fix");
+  const byLearningType = {};
+  for (const t of LEARNING_TYPES) {
+    byLearningType[t] = learnings.filter((l) => l.type === t).length;
+  }
   const totalTests = learnings.filter((l) => l.type === "test_generated").length;
   const firstAttemptSuccess = learnings.filter((l) => l.type === "test_generated" && l.passedFirstTime).length;
   return {
@@ -97,6 +143,7 @@ function getMemoryStats() {
     successfulFixes: successfulFixes.length,
     selectorFixes: selectorFixes.length,
     timingFixes: timingFixes.length,
+    byLearningType,
     testsGenerated: totalTests,
     firstAttemptSuccessRate: totalTests > 0 ? Math.round(firstAttemptSuccess / totalTests * 100) : 0
   };
@@ -140,6 +187,95 @@ var FLAKY_PATTERNS = [
   { name: "network", regex: /ECONNREFUSED|network|fetch|axios|request failed|404|500/i, suggestion: "Mocke APIs ou garanta que o backend esteja rodando. Use retry ou intercept." },
   { name: "shared_state", regex: /state|cleanup|beforeEach|afterEach|isolation/i, suggestion: "Garanta beforeEach/afterEach para resetar estado. Evite vari\xE1veis globais compartilhadas." }
 ];
+var FAILURE_ANALYSIS_PATTERNS = [
+  {
+    name: "element_not_rendered",
+    regex: /timeout|not found|element not found|no such element|element.*not.*in.*dom|waiting for/i,
+    oQueAconteceu: "O elemento ainda n\xE3o foi renderizado no DOM quando o teste tentou interagir. Pode ser carregamento ass\xEDncrono, lazy load ou anima\xE7\xE3o.",
+    lesson: `Espere o elemento estar dispon\xEDvel ANTES de interagir:
+- Playwright: await element.waitFor({ state: 'attached' }) ou waitForSelector
+- Cypress: cy.get(sel).should('exist') antes de clicar
+- WDIO/Appium: $(sel).waitForDisplayed() ou waitForExist({ timeout: 10000 })
+- Use waits inteligentes: waitForDisplayed, waitForClickable, waitForExist`,
+    learningType: "element_not_rendered"
+  },
+  {
+    name: "element_not_visible",
+    regex: /element.*not.*visible|not visible|is not visible|element is not displayed|hidden|display.*none|off.?screen/i,
+    oQueAconteceu: "O elemento existe no DOM mas n\xE3o est\xE1 vis\xEDvel (display:none, off-screen, opacity:0 ou ainda carregando).",
+    lesson: `Verifique visibilidade antes de interagir:
+- Playwright: waitFor({ state: 'visible' })
+- Cypress: .should('be.visible') antes de click
+- Appium/WDIO: waitForDisplayed() ou isDisplayed()
+- Adicione wait expl\xEDcito: elemento pode estar em anima\xE7\xE3o ou carregando`,
+    learningType: "element_not_visible"
+  },
+  {
+    name: "element_stale",
+    regex: /stale element|stale element reference|element.*no longer attached/i,
+    oQueAconteceu: "O elemento foi encontrado mas a p\xE1gina/DOM mudou antes da intera\xE7\xE3o (elemento ficou obsoleto).",
+    lesson: `Re-localize o elemento antes de cada a\xE7\xE3o:
+- Evite guardar refer\xEAncia: busque novamente antes de clicar
+- Use waits que revalidam: cy.get().first().click() com retry
+- Em listas din\xE2micas: espere estabiliza\xE7\xE3o antes de interagir`,
+    learningType: "element_stale"
+  },
+  {
+    name: "mobile_mapping_invisible",
+    regex: /element not found|selector|Unable to find|no such element/i,
+    oQueAconteceu: "Em mobile: o mapeamento ficou invis\xEDvel ou os seletores n\xE3o est\xE3o estruturados. Pode ser estrutura do c\xF3digo ou seletor incorreto.",
+    lesson: `Em testes mobile (Appium/Detox), SEMPRE:
+- Mapeamento VIS\xCDVEL: const ELEMENTS = { btn: '~id' }; $(ELEMENTS.btn).click()
+- Antes de clicar: $(sel).waitForDisplayed({ timeout: 10000 })
+- Ao final: expect(await $(sel).isDisplayed()).toBe(true) \u2014 valida\xE7\xE3o expl\xEDcita para o usu\xE1rio entender que houve valida\xE7\xE3o`,
+    learningType: "mobile_mapping_invisible",
+    mobileOnly: true
+  },
+  {
+    name: "selector",
+    regex: /selector|locator|element not found|Unable to find/i,
+    oQueAconteceu: "O seletor n\xE3o encontrou o elemento. Pode ser seletor incorreto, mudan\xE7a de UI ou elemento em outro contexto (iframe, shadow DOM).",
+    lesson: "Use seletores est\xE1veis: data-testid, role+name, accessibility-id. Evite classes CSS din\xE2micas. Priorize: data-testid > role > texto vis\xEDvel.",
+    learningType: "selector_fix"
+  },
+  {
+    name: "timing",
+    regex: /timeout|timed out|exceeded|slow/i,
+    oQueAconteceu: "O teste excedeu o tempo de espera. O elemento pode demorar para aparecer ou h\xE1 race condition.",
+    lesson: "Adicione wait expl\xEDcito antes de interagir. Aumente timeout se necess\xE1rio. Use waitForDisplayed/waitForSelector.",
+    learningType: "timing_fix"
+  }
+];
+function inferFailurePattern(runOutput, framework = "") {
+  const output = (runOutput || "").toLowerCase();
+  for (const p of FAILURE_ANALYSIS_PATTERNS) {
+    if (p.mobileOnly && !/appium|detox/i.test(framework)) continue;
+    if (p.regex.test(output)) return p;
+  }
+  return null;
+}
+var MOBILE_MAPPING_LESSON = `Em testes mobile (Appium/Detox), SEMPRE inclua o mapeamento de elementos de forma VIS\xCDVEL e estruturada no c\xF3digo:
+- Use constantes ou Page Object no TOPO do spec: const ELEMENTS = { loginBtn: '~btn_login', ... };
+- No teste: $(ELEMENTS.loginBtn).click();
+- Nunca deixe seletores "invis\xEDveis" (hardcoded inline repetidos). Isso dificulta manuten\xE7\xE3o e causa falhas.`;
+var UNIVERSAL_TEST_PRACTICES = `PR\xC1TICAS OBRIGAT\xD3RIAS em todo teste gerado:
+1. Esperas inteligentes: ANTES de interagir, verifique que o elemento est\xE1 dispon\xEDvel (waitForDisplayed, waitForExist, waitForSelector)
+2. Valida\xE7\xE3o no final: SEMPRE adicione um expect/assert ao final para o usu\xE1rio entender que houve valida\xE7\xE3o (ex: expect(element).toBeVisible() ou cy.get(sel).should('be.visible'))
+3. N\xE3o assuma que o elemento est\xE1 pronto: elemento pode n\xE3o estar renderizado, vis\xEDvel ou dispon\xEDvel \u2014 use waits expl\xEDcitos`;
+function formatLearnedMessageForUser({ pattern, fixSummary, runOutput, framework }) {
+  const p = pattern || (runOutput ? inferFailurePattern(runOutput, framework) : null);
+  const oQueAconteceu = p?.oQueAconteceu || "O teste falhou por um problema de elemento ou timing.";
+  const oQueFiz = fixSummary || (p ? `Apliquei a corre\xE7\xE3o para esse tipo de falha: ${p.name}.` : "Ajustei o c\xF3digo.");
+  return `**Entendi o erro e apliquei a corre\xE7\xE3o**
+
+**O que aconteceu:** ${oQueAconteceu}
+
+**O que fiz:** ${oQueFiz}
+
+**O que aprendi:** Salvei esse cen\xE1rio no meu hist\xF3rico. Nas pr\xF3ximas gera\xE7\xF5es, vou aplicar as pr\xE1ticas corretas (waits inteligentes, valida\xE7\xE3o final) desde o in\xEDcio.
+
+Use \`mcp-lab-agent stats\` ou \`get_learning_report\` para ver a evolu\xE7\xE3o dos aprendizados.`;
+}
 function detectFlakyPatterns(runOutput) {
   const detected = [];
   for (const p of FLAKY_PATTERNS) {
@@ -213,6 +349,9 @@ function detectProjectStructure() {
       structure.hasTests = true;
       structure.hasMobile = true;
     }
+    if (deps["react-native"]) {
+      structure.hasMobile = true;
+    }
     if (deps.supertest) {
       structure.testFrameworks.push("supertest");
       structure.hasTests = true;
@@ -369,6 +508,22 @@ function detectProjectStructure() {
       }
     }
   }
+  const hints = [];
+  if (structure.hasMobile) hints.push("mobile");
+  if (structure.testFrameworks.includes("appium")) hints.push("appium");
+  if (structure.testFrameworks.includes("detox")) hints.push("detox");
+  const pkg = structure.packageJson || {};
+  const allDeps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+  if (allDeps["react-native"]) hints.push("react-native");
+  const webFrameworks = ["cypress", "playwright", "webdriverio", "selenium", "puppeteer", "testcafe"];
+  const hasWebFrameworks = structure.testFrameworks.some((f) => webFrameworks.includes(f));
+  if (hasWebFrameworks) hints.push("web");
+  if (structure.testDirs.includes("mobile")) hints.push("mobile-dir");
+  let environment = "web";
+  if (structure.hasMobile && !hasWebFrameworks) environment = "mobile";
+  else if (structure.hasMobile && hasWebFrameworks) environment = "both";
+  structure.environment = environment;
+  structure.environmentHints = [...new Set(hints)];
   return structure;
 }
 var UNIVERSAL_TEST_PATTERNS = [
@@ -573,7 +728,7 @@ var QA_AGENTS = {
   browser: { desc: "Browser mode: screenshots, network, console", tools: ["web_eval_browser"] },
   reporting: { desc: "Relat\xF3rios e m\xE9tricas", tools: ["create_bug_report", "get_business_metrics"] },
   intelligence: { desc: "An\xE1lise preditiva e insights", tools: ["qa_full_analysis", "qa_health_check", "qa_suggest_next_test", "qa_predict_flaky", "qa_compare_with_industry", "qa_time_travel"] },
-  learning: { desc: "Sistema de aprendizado", tools: ["qa_learning_stats"] },
+  learning: { desc: "Sistema de aprendizado", tools: ["qa_learning_stats", "get_learning_report"] },
   maintenance: { desc: "Linter, deps, an\xE1lise de c\xF3digo", tools: ["run_linter", "install_dependencies"] }
 };
 function getExtensionAndBaseDir(fw, structure) {
@@ -593,14 +748,20 @@ USO:
   mcp-lab-agent --help     # Mostra esta ajuda
 
 COMANDOS CLI:
-  analyze                               [NOVO] An\xE1lise completa: executa, analisa estabilidade, prev\xEA riscos e recomenda a\xE7\xF5es
+  slack-bot                             Inicia o Slack Bot (QA via @mention)
+  learning-hub                          Inicia o Learning Hub (API + Dashboard em http://localhost:3847)
+  analyze                               An\xE1lise completa: executa, analisa estabilidade, prev\xEA riscos e recomenda a\xE7\xF5es
   auto <descri\xE7\xE3o> [--max-retries N]    Modo aut\xF4nomo: gera teste, roda, corrige e aprende (default: 3 tentativas)
-  stats                                 Mostra estat\xEDsticas de aprendizado (taxa de sucesso, corre\xE7\xF5es, etc.)
+  stats                                 Estat\xEDsticas de aprendizado (taxa de sucesso, corre\xE7\xF5es, etc.)
+  report [--full]                        Relat\xF3rio de evolu\xE7\xE3o e aprendizado (--full = completo com recomenda\xE7\xF5es)
   detect [--json]                       Detecta frameworks e estrutura
   route <tarefa>                        Sugere qual ferramenta usar
   list                                  Lista ferramentas MCP dispon\xEDveis
 
 EXEMPLOS:
+  mcp-lab-agent slack-bot                       # Slack Bot
+  mcp-lab-agent learning-hub                   # Learning Hub (API + Dashboard)
+  npx mcp-lab-agent slack-bot                   # Usar sem instalar (sem clonar o projeto)
   mcp-lab-agent analyze                         # An\xE1lise completa + recomenda\xE7\xF5es
   mcp-lab-agent auto "login flow" --max-retries 5
   mcp-lab-agent stats
@@ -677,6 +838,8 @@ AMBIENTES CORPORATIVOS (APIs bloqueadas):
   }
   if (cmd === "stats") {
     const stats = getMemoryStats();
+    const byType = stats.byLearningType || {};
+    const byTypeLines = Object.entries(byType).filter(([, v]) => v > 0).map(([t, v]) => `  ${t}: ${v}`).join("\n");
     console.log(`
 \u{1F4CA} Estat\xEDsticas de Aprendizado
 
@@ -686,8 +849,47 @@ Corre\xE7\xF5es de seletores: ${stats.selectorFixes}
 Corre\xE7\xF5es de timing: ${stats.timingFixes}
 Testes gerados: ${stats.testsGenerated}
 Taxa de sucesso na 1\xAA tentativa: ${stats.firstAttemptSuccessRate}%
+${byTypeLines ? `
+Por tipo:
+${byTypeLines}` : ""}
 
 ${stats.totalLearnings === 0 ? "\u26A0\uFE0F Ainda n\xE3o h\xE1 aprendizados. Use 'mcp-lab-agent auto <descri\xE7\xE3o>' para gerar testes e aprender com erros." : ""}
+`);
+    return true;
+  }
+  if (cmd === "report") {
+    const memory = loadProjectMemory();
+    const learnings = memory.learnings || [];
+    const stats = getMemoryStats();
+    const byType = stats.byLearningType || {};
+    const format = process.argv.includes("--full") ? "full" : "summary";
+    const recommendations = [];
+    if (byType.element_not_rendered > 0 || byType.element_not_visible > 0) {
+      recommendations.push("Use waits expl\xEDcitos (waitForSelector, waitForDisplayed) ANTES de interagir com elementos.");
+    }
+    if (byType.timing_fix > 0 || byType.element_stale > 0) {
+      recommendations.push("Aumente timeouts e use re-localiza\xE7\xE3o de elementos em listas din\xE2micas.");
+    }
+    if (byType.selector_fix > 0 || byType.mobile_mapping_invisible > 0) {
+      recommendations.push("Priorize data-testid, role e seletores est\xE1veis; em mobile, use mapeamento vis\xEDvel no topo do spec.");
+    }
+    if (stats.firstAttemptSuccessRate < 70 && stats.testsGenerated > 0) {
+      recommendations.push("Aplique waits inteligentes + assert final em cada teste gerado.");
+    }
+    const byTypeStr = Object.entries(byType).filter(([, v]) => v > 0).map(([t, v]) => `  - ${t}: ${v}`).join("\n");
+    console.log(`
+\u{1F4C8} Relat\xF3rio de Evolu\xE7\xE3o e Aprendizado
+
+Resumo por tipo:
+${byTypeStr || "  Nenhum aprendizado por tipo ainda"}
+
+M\xE9tricas gerais:
+  Total de aprendizados: ${stats.totalLearnings}
+  Taxa de sucesso (1\xAA tentativa): ${stats.firstAttemptSuccessRate}%
+  Testes gerados: ${stats.testsGenerated}
+${format === "full" && recommendations.length > 0 ? `
+Recomenda\xE7\xF5es para aprimorar o c\xF3digo:
+${recommendations.map((r) => `  \u2022 ${r}`).join("\n")}` : ""}
 `);
     return true;
   }
@@ -979,7 +1181,7 @@ server.registerTool(
   "detect_project",
   {
     title: "Detectar estrutura do projeto",
-    description: "Analisa o projeto e identifica frameworks de teste, pastas, backend, frontend.",
+    description: "Analisa o projeto e identifica frameworks de teste, pastas, backend, frontend, ambiente (web/mobile) e hints para gera\xE7\xE3o de testes.",
     inputSchema: z.object({}),
     outputSchema: z.object({
       ok: z.boolean(),
@@ -990,17 +1192,22 @@ server.registerTool(
         hasBackend: z.boolean(),
         backendDir: z.string().nullable(),
         hasFrontend: z.boolean(),
-        frontendDir: z.string().nullable()
+        frontendDir: z.string().nullable(),
+        hasMobile: z.boolean().optional(),
+        environment: z.string().optional(),
+        environmentHints: z.array(z.string()).optional()
       })
     })
   },
   async () => {
     const structure = detectProjectStructure();
+    const envLine = structure.environment ? `Ambiente: ${structure.environment}${structure.environmentHints?.length ? ` (${structure.environmentHints.join(", ")})` : ""}` : "";
     const summary = [
       `Frameworks de teste: ${structure.testFrameworks.join(", ") || "nenhum"}`,
       `Pastas de teste: ${structure.testDirs.join(", ") || "nenhuma"}`,
       `Backend: ${structure.backendDir || "n\xE3o detectado"}`,
-      `Frontend: ${structure.frontendDir || "n\xE3o detectado"}`
+      `Frontend: ${structure.frontendDir || "n\xE3o detectado"}`,
+      ...envLine ? [envLine] : []
     ].join("\n");
     return {
       content: [{ type: "text", text: summary }],
@@ -1100,11 +1307,11 @@ var QA_AGENTS2 = {
   intelligence: { tools: ["qa_full_analysis", "qa_health_check", "qa_suggest_next_test", "qa_predict_flaky", "qa_compare_with_industry"], desc: "Executor + Consultor: an\xE1lise completa, diagn\xF3stico, sugest\xF5es e predi\xE7\xF5es" },
   detection: { tools: ["detect_project", "read_project", "list_test_files"], desc: "Detec\xE7\xE3o de estrutura, frameworks e arquivos" },
   execution: { tools: ["run_tests", "watch_tests", "get_test_coverage"], desc: "Execu\xE7\xE3o de testes e cobertura" },
-  generation: { tools: ["generate_tests", "write_test", "create_test_template"], desc: "Gera\xE7\xE3o de testes com LLM" },
+  generation: { tools: ["generate_tests", "write_test", "create_test_template", "map_mobile_elements"], desc: "Gera\xE7\xE3o de testes com LLM" },
   analysis: { tools: ["analyze_failures", "por_que_falhou", "suggest_fix", "suggest_selector_fix"], desc: "An\xE1lise de falhas e sugest\xF5es" },
   browser: { tools: ["web_eval_browser"], desc: "Avalia\xE7\xE3o em browser real (screenshots, network, console)" },
   reporting: { tools: ["create_bug_report", "get_business_metrics"], desc: "Relat\xF3rios e m\xE9tricas" },
-  learning: { tools: ["qa_learning_stats", "qa_time_travel"], desc: "Estat\xEDsticas de aprendizado e evolu\xE7\xE3o" },
+  learning: { tools: ["qa_learning_stats", "get_learning_report", "qa_time_travel"], desc: "Estat\xEDsticas de aprendizado e evolu\xE7\xE3o" },
   maintenance: { tools: ["run_linter", "install_dependencies", "analyze_file_methods"], desc: "Manuten\xE7\xE3o e an\xE1lise de c\xF3digo" }
 };
 server.registerTool(
@@ -1136,8 +1343,17 @@ server.registerTool(
     if (/rodar|executar|run|test|coverage|watch/i.test(t)) {
       return { content: [{ type: "text", text: "Agente: execution \u2192 run_tests, get_test_coverage" }], structuredContent: { ok: true, suggestedAgent: "execution", suggestedTools: QA_AGENTS2.execution.tools, description: QA_AGENTS2.execution.desc } };
     }
+    if (/mapear|elementos mobile|deep link|deeplink|app package|bundle.?id|appium inspector/i.test(t)) {
+      return { content: [{ type: "text", text: "Agente: generation \u2192 map_mobile_elements (mapear elementos), depois generate_tests + write_test" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: ["map_mobile_elements", "generate_tests", "write_test"], description: QA_AGENTS2.generation.desc } };
+    }
+    if (/mapear|elementos mobile|deep link|deeplink|app package|bundle.?id/i.test(t)) {
+      return { content: [{ type: "text", text: "Agente: generation \u2192 map_mobile_elements (mapear elementos), depois generate_tests + write_test" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: ["map_mobile_elements", "generate_tests", "write_test"], description: "Mapeamento de elementos mobile + gera\xE7\xE3o de testes" } };
+    }
+    if (/mobile|deeplink|deep link|elementos|mapear.*app|appium|detox/i.test(t) && !/rodar|run|executar/i.test(t)) {
+      return { content: [{ type: "text", text: "Agente: generation \u2192 map_mobile_elements, generate_tests, write_test (mobile)" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: QA_AGENTS2.generation.tools, description: QA_AGENTS2.generation.desc } };
+    }
     if (/gerar|criar|escrever|generate|write|template/i.test(t)) {
-      return { content: [{ type: "text", text: "Agente: generation \u2192 generate_tests, write_test" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: QA_AGENTS2.generation.tools, description: QA_AGENTS2.generation.desc } };
+      return { content: [{ type: "text", text: "Agente: generation \u2192 generate_tests, write_test, map_mobile_elements" }], structuredContent: { ok: true, suggestedAgent: "generation", suggestedTools: QA_AGENTS2.generation.tools, description: QA_AGENTS2.generation.desc } };
     }
     if (/analisar|por que|falhou|suggest|correção|selector|fix/i.test(t)) {
       return { content: [{ type: "text", text: "Agente: analysis \u2192 analyze_failures, por_que_falhou, suggest_fix" }], structuredContent: { ok: true, suggestedAgent: "analysis", suggestedTools: QA_AGENTS2.analysis.tools, description: QA_AGENTS2.analysis.desc } };
@@ -1461,8 +1677,15 @@ O c\xF3digo de refer\xEAncia pode estar em QUALQUER framework (Cypress, Robot, P
 - Mantenha a MESMA l\xF3gica e fluxo de teste
 - Traduza seletores, comandos e asser\xE7\xF5es para ${fw}
 - Use Page Objects se o projeto j\xE1 usa
-- Retorne SOMENTE o c\xF3digo, sem markdown` : `Voc\xEA \xE9 um engenheiro de QA especializado em ${fw}. Gere APENAS o c\xF3digo do spec, sem explica\xE7\xF5es.
+- Retorne SOMENTE o c\xF3digo, sem markdown
+
+${UNIVERSAL_TEST_PRACTICES}
+${fw === "appium" || fw === "detox" ? `
+IMPORTANTE: ${MOBILE_MAPPING_LESSON}` : ""}` : `Voc\xEA \xE9 um engenheiro de QA especializado em ${fw}. Gere APENAS o c\xF3digo do spec, sem explica\xE7\xF5es.
 Framework: ${fw}
+
+${UNIVERSAL_TEST_PRACTICES}
+
 Regras:
 - Cypress: cy.request(), cy.visit(), cy.get()
 - Playwright: test(), test.describe(), page.goto(), page.locator()
@@ -1470,7 +1693,9 @@ Regras:
 - Jest/Vitest: describe(), test(), expect()
 - Robot: Keywords, [Tags], Steps
 - pytest: def test_*, assert, fixtures
-- C\xF3digo limpo. Retorne SOMENTE o c\xF3digo, sem markdown`;
+- C\xF3digo limpo. Retorne SOMENTE o c\xF3digo, sem markdown${fw === "appium" || fw === "detox" ? `
+
+IMPORTANTE (Appium/Detox): ${MOBILE_MAPPING_LESSON}` : ""}`;
     const userPrompt = `Contexto do projeto:
 ${contextWithMemory.slice(0, 5e3)}
 
@@ -2039,6 +2264,114 @@ ${data.codigoCorrigido}
     }
   }
 );
+server.registerTool(
+  "map_mobile_elements",
+  {
+    title: "Mapear elementos mobile (estrutura para testes)",
+    description: "Gera estrutura/template de elementos para testes mobile. Aceita deep link, appPackage/appActivity (Android) ou bundleId (iOS). Retorna instru\xE7\xF5es para mapear elementos (Appium Inspector, uiautomator) e template para usar em generate_tests. Se elementsJsonPath fornecido, l\xEA arquivo e formata para contexto.",
+    inputSchema: z.object({
+      deepLink: z.string().optional().describe("Deep link do app (ex: meuapp://login). Indica ambiente mobile."),
+      appPackage: z.string().optional().describe("Android: package do app (ex: com.example.app)."),
+      appActivity: z.string().optional().describe("Android: activity principal (ex: .MainActivity)."),
+      bundleId: z.string().optional().describe("iOS: bundle identifier do app."),
+      elementsJsonPath: z.string().optional().describe("Caminho para arquivo JSON com elementos mapeados (id, text, accessibilityId, xpath).")
+    }),
+    outputSchema: z.object({
+      ok: z.boolean(),
+      environment: z.string().optional(),
+      elements: z.array(z.object({
+        id: z.string().optional(),
+        text: z.string().optional(),
+        accessibilityId: z.string().optional(),
+        xpath: z.string().optional(),
+        resourceId: z.string().optional(),
+        className: z.string().optional()
+      })).optional(),
+      instructions: z.string().optional(),
+      contextForGenerate: z.string().optional().describe("Texto formatado para passar em generate_tests como contexto."),
+      error: z.string().optional()
+    })
+  },
+  async ({ deepLink, appPackage, appActivity, bundleId, elementsJsonPath }) => {
+    const hasMobileContext = deepLink || appPackage || bundleId;
+    const elements = [];
+    let instructions = "";
+    let contextForGenerate = "";
+    if (elementsJsonPath) {
+      const fullPath = path5.join(PROJECT_ROOT5, elementsJsonPath.replace(/^\//, "").replace(/\\/g, "/"));
+      if (fs5.existsSync(fullPath)) {
+        try {
+          const raw = fs5.readFileSync(fullPath, "utf8");
+          const parsed = JSON.parse(raw);
+          const arr = Array.isArray(parsed) ? parsed : parsed.elements || parsed.items || [];
+          arr.forEach((el) => {
+            elements.push({
+              id: el.id || el.resourceId,
+              text: el.text || el.label,
+              accessibilityId: el.accessibilityId || el["content-desc"] || el.contentDesc,
+              xpath: el.xpath,
+              resourceId: el.resourceId || el.id,
+              className: el.className || el.class
+            });
+          });
+          contextForGenerate = `
+Elementos mapeados da tela (use para seletores est\xE1veis em Appium/WDIO):
+${JSON.stringify(elements, null, 2)}
+`;
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Erro ao ler ${elementsJsonPath}: ${err.message}` }],
+            structuredContent: { ok: false, error: err.message }
+          };
+        }
+      } else {
+        return {
+          content: [{ type: "text", text: `Arquivo n\xE3o encontrado: ${elementsJsonPath}` }],
+          structuredContent: { ok: false, error: "File not found" }
+        };
+      }
+    }
+    if (hasMobileContext || elementsJsonPath) {
+      instructions = [
+        "## Como mapear elementos do app mobile",
+        "",
+        "**Android (Appium):**",
+        "- Use Appium Inspector (appium.io) com appPackage/appActivity",
+        "- Ou: `adb shell uiautomator dump` \u2192 analise o XML exportado",
+        "- Priorize: accessibility-id > resource-id > xpath relativo",
+        "",
+        "**iOS (Appium):**",
+        "- Appium Inspector com bundleId",
+        "- Xcode Accessibility Inspector",
+        "- Priorize: accessibility-id > name",
+        "",
+        "**Formato esperado (elements.json):**",
+        "```json",
+        '[{"accessibilityId": "login_btn", "text": "Entrar", "resourceId": "com.app:id/btn"}]',
+        "```",
+        "",
+        "Salve em um arquivo e passe em `elementsJsonPath` na pr\xF3xima chamada."
+      ].join("\n");
+    }
+    const env = deepLink ? "mobile" : appPackage || bundleId ? "mobile" : elements.length ? "mobile" : "unknown";
+    const text = [
+      contextForGenerate && `## Contexto para generate_tests
+${contextForGenerate}`,
+      instructions && `## Instru\xE7\xF5es
+${instructions}`
+    ].filter(Boolean).join("\n\n");
+    return {
+      content: [{ type: "text", text: text || (hasMobileContext ? `Ambiente: ${env}. ${instructions}` : "Informe deepLink, appPackage ou elementsJsonPath.") }],
+      structuredContent: {
+        ok: true,
+        environment: env,
+        elements: elements.length ? elements : void 0,
+        instructions: instructions || void 0,
+        contextForGenerate: contextForGenerate || void 0
+      }
+    };
+  }
+);
 server.registerTool(
   "analyze_file_methods",
   {
@@ -3007,6 +3340,70 @@ ${stats.totalLearnings === 0 ? "\u26A0\uFE0F Ainda n\xE3o h\xE1 aprendizados. Us
     };
   }
 );
+server.registerTool(
+  "get_learning_report",
+  {
+    title: "Relat\xF3rio de evolu\xE7\xE3o e aprendizado",
+    description: "Gera relat\xF3rio de evolu\xE7\xE3o dos aprendizados: resumo por tipo, evolu\xE7\xE3o no tempo e recomenda\xE7\xF5es para aprimorar o c\xF3digo.",
+    inputSchema: z.object({
+      format: z.enum(["summary", "full"]).optional().describe("summary = resumo executivo, full = relat\xF3rio completo com recomenda\xE7\xF5es. Default: summary")
+    }),
+    outputSchema: z.object({
+      summary: z.string(),
+      byType: z.record(z.number()),
+      evolution: z.array(z.object({ date: z.string(), type: z.string(), framework: z.string() })).optional(),
+      recommendations: z.array(z.string()).optional()
+    })
+  },
+  async ({ format = "summary" }) => {
+    const memory = loadProjectMemory();
+    const learnings = memory.learnings || [];
+    const stats = getMemoryStats();
+    const byType = stats.byLearningType || {};
+    const evolution = format === "full" && learnings.length > 0 ? learnings.slice(-30).map((l) => ({
+      date: (l.timestamp || "").slice(0, 10),
+      type: l.type || "unknown",
+      framework: l.framework || "-"
+    })) : [];
+    const recommendations = [];
+    if (byType.element_not_rendered > 0 || byType.element_not_visible > 0) {
+      recommendations.push("Use waits expl\xEDcitos (waitForSelector, waitForDisplayed) ANTES de interagir com elementos.");
+    }
+    if (byType.timing_fix > 0 || byType.element_stale > 0) {
+      recommendations.push("Aumente timeouts e use re-localiza\xE7\xE3o de elementos em listas din\xE2micas.");
+    }
+    if (byType.selector_fix > 0 || byType.mobile_mapping_invisible > 0) {
+      recommendations.push("Priorize data-testid, role e seletores est\xE1veis; em mobile, use mapeamento vis\xEDvel no topo do spec.");
+    }
+    if (stats.firstAttemptSuccessRate < 70 && stats.testsGenerated > 0) {
+      recommendations.push("Aplique UNIVERSAL_TEST_PRACTICES em cada teste gerado: waits inteligentes + assert final.");
+    }
+    if (recommendations.length === 0 && learnings.length > 0) {
+      recommendations.push("Continue aplicando as pr\xE1ticas aprendidas em novos testes.");
+    }
+    const summary = `\u{1F4C8} **Relat\xF3rio de Evolu\xE7\xE3o e Aprendizado**
+
+**Resumo por tipo:**
+${Object.entries(byType).filter(([, v]) => v > 0).map(([t, v]) => `- ${t}: ${v}`).join("\n") || "- Nenhum aprendizado por tipo ainda"}
+
+**M\xE9tricas gerais:**
+- Total de aprendizados: ${stats.totalLearnings}
+- Taxa de sucesso (1\xAA tentativa): ${stats.firstAttemptSuccessRate}%
+- Testes gerados: ${stats.testsGenerated}
+
+${format === "full" && recommendations.length > 0 ? `**Recomenda\xE7\xF5es para aprimorar o c\xF3digo:**
+${recommendations.map((r) => `\u2022 ${r}`).join("\n")}` : ""}`;
+    return {
+      content: [{ type: "text", text: summary }],
+      structuredContent: {
+        summary: summary.trim(),
+        byType,
+        evolution: format === "full" ? evolution : void 0,
+        recommendations: format === "full" ? recommendations : void 0
+      }
+    };
+  }
+);
 server.registerTool(
   "qa_compare_with_industry",
   {
@@ -3299,14 +3696,16 @@ server.registerTool(
     let testFilePath = null;
     let testContent = null;
     let attempt = 0;
+    let appliedLearningFix = false;
     learnings.push({ attempt: 0, action: "detect_project", result: `${structure.testFrameworks.length} framework(s)` });
     for (attempt = 1; attempt <= maxRetries; attempt++) {
       learnings.push({ attempt, action: "generate_tests", result: "gerando..." });
       const { provider, apiKey, baseUrl, model } = llm;
-      const memoryHints = memory.learnings?.filter((l) => l.success).slice(-10).map((l) => l.fix).join("\n") || "";
+      const memoryHints = memory.learnings?.filter((l) => l.fix).slice(-10).map((l) => l.fix).join("\n") || "";
       const systemPrompt = `Voc\xEA \xE9 um engenheiro de QA especializado em ${fw}. Gere APENAS o c\xF3digo do spec, sem explica\xE7\xF5es.
-${memoryHints ? `
-Aprendizados anteriores (use como refer\xEAncia):
+${UNIVERSAL_TEST_PRACTICES}
+
+${memoryHints ? `Aprendizados anteriores (use como refer\xEAncia):
 ${memoryHints.slice(0, 1e3)}` : ""}
 Retorne SOMENTE o c\xF3digo, sem markdown.`;
       const userPrompt = `Contexto:
@@ -3374,12 +3773,15 @@ Framework: ${fw}`;
           saveProjectMemory({
             learnings: [{ type: "test_generated", request, framework: fw, success: true, passedFirstTime: attempt === 1, attempts: attempt, timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
           });
+          const learnedAppendix2 = appliedLearningFix ? `
+
+${formatLearnedMessageForUser({ runOutput: runResult?.output, fixSummary: "Ajustei o c\xF3digo aplicando waits e valida\xE7\xE3o correta.", framework: fw })}` : "";
           return {
             content: [{ type: "text", text: `\u2705 Teste passou na tentativa ${attempt}!
 
 Arquivo: ${testFilePath}
 
-Aprendizados salvos.` }],
+Aprendizados salvos.${learnedAppendix2}` }],
             structuredContent: { ok: true, testFilePath, attempts: attempt, finalStatus: "passed", learnings }
           };
         }
@@ -3389,11 +3791,14 @@ Aprendizados salvos.` }],
           saveProjectMemory({
             learnings: [{ type: "test_generated", request, framework: fw, success: false, attempts: attempt, timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
           });
+          const learnedAppendix2 = appliedLearningFix ? `
+
+${formatLearnedMessageForUser({ runOutput: runResult.output, framework: fw, fixSummary: "Tentei corrigir. Nas pr\xF3ximas execu\xE7\xF5es usarei esse aprendizado desde o in\xEDcio." })}` : "";
           return {
             content: [{ type: "text", text: `\u274C Teste falhou ap\xF3s ${attempt} tentativa(s).
 
 \xDAltimo erro:
-${runResult.output.slice(0, 500)}` }],
+${runResult.output.slice(0, 500)}${learnedAppendix2}` }],
             structuredContent: { ok: false, testFilePath, attempts: attempt, finalStatus: "max_retries", learnings }
           };
         }
@@ -3411,16 +3816,21 @@ ${runResult.output.slice(0, 500)}` }],
         fs5.writeFileSync(testFilePath, testContent, "utf8");
         learnings.push({ attempt, action: "apply_fix", result: "corre\xE7\xE3o aplicada" });
         if (flakyAnalysis.isLikelyFlaky) {
+          const inferredPattern = inferFailurePattern(runResult.output, fw);
+          const learningType = inferredPattern?.learningType || (flakyAnalysis.patterns[0]?.pattern === "selector" ? "selector_fix" : "timing_fix");
+          const learningFix = inferredPattern?.lesson || fixedCode.slice(0, 500);
           saveProjectMemory({
             learnings: [{
-              type: flakyAnalysis.patterns[0]?.pattern === "selector" ? "selector_fix" : "timing_fix",
+              type: learningType,
               request,
               framework: fw,
-              fix: fixedCode.slice(0, 500),
+              fix: learningFix,
+              pattern: inferredPattern?.name,
               success: false,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             }]
           });
+          appliedLearningFix = true;
         }
       } catch (err) {
         learnings.push({ attempt, action: "error", result: err.message });
@@ -3430,8 +3840,11 @@ ${runResult.output.slice(0, 500)}` }],
         };
       }
     }
+    const learnedAppendix = appliedLearningFix ? `
+
+${formatLearnedMessageForUser({ fixSummary: "Tentei corrigir. Nas pr\xF3ximas execu\xE7\xF5es usarei esse aprendizado desde o in\xEDcio." })}` : "";
     return {
-      content: [{ type: "text", text: `\u274C Falhou ap\xF3s ${maxRetries} tentativa(s).` }],
+      content: [{ type: "text", text: `\u274C Falhou ap\xF3s ${maxRetries} tentativa(s).${learnedAppendix}` }],
       structuredContent: { ok: false, testFilePath, attempts: maxRetries, finalStatus: "max_retries", learnings }
     };
   }
@@ -3483,6 +3896,21 @@ test.describe('${type.toUpperCase()} Test', () => {
   }
 );
 async function main() {
+  const cmd = process.argv[2];
+  if (cmd === "learning-hub") {
+    const __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+    const hubPath = path5.join(__dirname2, "..", "learning-hub", "src", "server.js");
+    const hubUrl2 = pathToFileURL(hubPath).href;
+    await import(hubUrl2);
+    return;
+  }
+  if (cmd === "slack-bot") {
+    const __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+    const slackBotPath = path5.join(__dirname2, "..", "slack-bot", "src", "index.js");
+    const slackBotUrl = pathToFileURL(slackBotPath).href;
+    await import(slackBotUrl);
+    return;
+  }
   const handled = await handleCLI();
   if (handled) {
     process.exit(0);