diff --git a/logic/cache.js b/logic/cache.js index b82a1d9..2c22872 100644 --- a/logic/cache.js +++ b/logic/cache.js @@ -5,4 +5,13 @@ function needsReanalysis({ memory, currentHash, now }) { return { needsAi: false, reason: 'cache_valid' }; } -module.exports = { needsReanalysis }; +// Chave de cache composta (conteudo do chamado + versao do classificador). Guardada no MESMO +// campo last_context_hash que ja existia -- sem migracao de schema na Data Table. Uma classe +// derivada e valida SE E SOMENTE SE contextHash bate E classifierVersion bate: bump de versao +// (logic/classification.js -> AI_CLASSIFIER_VERSION) forca cache miss em todo chamado, sem +// precisar apagar a Data Table na mao (missao "finalizacao para producao", secao 12). +function buildCacheKey(contextHash, classifierVersion) { + return `${contextHash}:v${classifierVersion}`; +} + +module.exports = { needsReanalysis, buildCacheKey }; diff --git a/logic/cache.test.js b/logic/cache.test.js index d37d186..4a48688 100644 --- a/logic/cache.test.js +++ b/logic/cache.test.js @@ -1,6 +1,6 @@ const { test } = require('node:test'); const assert = require('node:assert/strict'); -const { needsReanalysis } = require('./cache'); +const { needsReanalysis, buildCacheKey } = require('./cache'); test('sem memoria previa, sempre precisa de IA', () => { const result = needsReanalysis({ memory: null, currentHash: 'abc', now: 1000 }); @@ -28,3 +28,25 @@ test('next_review_at vencido forca reavaliacao mesmo com hash igual', () => { assert.equal(result.needsAi, true); assert.equal(result.reason, 'review_due'); }); + +test('buildCacheKey combina hash de conteudo e versao do classificador', () => { + assert.equal(buildCacheKey('abc123', 3), 'abc123:v3'); + assert.equal(buildCacheKey('abc123', 4), 'abc123:v4'); +}); + +test('mudanca de AI_CLASSIFIER_VERSION invalida o cache mesmo com conteudo identico -- missao secao 12', () => { + const contentHash = 'abc123'; + const oldCacheKey = buildCacheKey(contentHash, 2); + const newCacheKey = buildCacheKey(contentHash, 3); + const memory = { last_context_hash: oldCacheKey, next_review_at: null }; + const result = needsReanalysis({ memory, currentHash: newCacheKey, now: 1000 }); + assert.equal(result.needsAi, true, 'bump de versao deve forcar reclassificacao mesmo com o mesmo conteudo'); +}); + +test('mesma versao + mesmo hash de conteudo usa cache normalmente -- missao secao 12', () => { + const cacheKey = buildCacheKey('abc123', 3); + const memory = { last_context_hash: cacheKey, next_review_at: null }; + const result = needsReanalysis({ memory, currentHash: cacheKey, now: 1000 }); + assert.equal(result.needsAi, false); + assert.equal(result.reason, 'cache_valid'); +}); diff --git a/logic/classification.js b/logic/classification.js index a0db42e..885eb9a 100644 --- a/logic/classification.js +++ b/logic/classification.js @@ -4,6 +4,11 @@ const VALID_CLASSIFICATIONS = [ 'PROJECT_LONG_TERM', 'DUPLICATE_OR_OBSOLETE', 'INSUFFICIENT_CONTEXT', ]; +// Versao do prompt/classificador. Bump manual sempre que o system prompt ou as regras de +// validacao mudarem de forma que mudaria o julgamento da IA -- forca cache miss em TODO +// chamado (ver logic/cache.js -> buildCacheKey), sem precisar apagar a Data Table na mao. +const AI_CLASSIFIER_VERSION = 3; + // O modelo, apesar do schema permitir null de verdade em blocker_type/waiting_for, as vezes // devolve a STRING "null" (ou variantes equivalentes) em vez do valor JSON null. Normaliza // aqui, na camada de validacao -- unico lugar que toca a resposta crua da IA. @@ -16,7 +21,43 @@ function normalizeNullableString(value) { return trimmed; } -function validateAiClassification(raw) { +// next_action generico nao prova acionabilidade nenhuma -- ver missao "finalizacao para +// producao", secao 9. So se aplica a ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE: nessas duas +// classes o next_action E a evidencia de que existe um proximo passo concreto sob controle +// do suporte; nas demais classes o campo descreve o que se espera de terceiros, entao uma +// frase curta ("aguardar resposta") e legitima ali. +const ACTIONABLE_CLASSES_REQUIRING_CONCRETE_NEXT_ACTION = new Set(['ACTIONABLE_NOW', 'UNASSIGNED_ACTIONABLE']); +const GENERIC_NEXT_ACTION_PHRASES = new Set([ + 'revisar chamado', 'revisar o chamado', 'dar andamento', 'dar andamento no chamado', + 'analisar situacao', 'analisar a situacao', 'verificar chamado', 'verificar o chamado', + 'acompanhar', 'acompanhar chamado', 'acompanhar o chamado', +]); + +function normalizeForComparison(text) { + return String(text || '') + .trim() + .toLowerCase() + .normalize('NFD') + .replace(/[̀-ͯ]/g, '') // remove acentos (combining marks) p/ comparar "situação" == "situacao" + .replace(/[.!]+$/g, ''); +} + +function isGenericNextAction(nextAction) { + return GENERIC_NEXT_ACTION_PHRASES.has(normalizeForComparison(nextAction)); +} + +// Guarda deterministica: tecnico interno (aparece no campo TECNICO do proprio chamado) nunca +// pode ser tratado como fornecedor externo (WAITING_VENDOR). Ver missao "finalizacao para +// producao", secao 6. Isso nao depende do prompt se comportar bem -- e verificado aqui. +function isWaitingForInternalTechnician(waitingFor, ticket) { + if (!waitingFor || !ticket || !ticket.tecnico_atribuido) return false; + const tecnico = normalizeForComparison(ticket.tecnico_atribuido); + const alvo = normalizeForComparison(waitingFor); + if (!alvo || tecnico === 'sem tecnico atribuido') return false; + return tecnico.includes(alvo); +} + +function validateAiClassification(raw, ticket) { const errors = []; if (!raw || typeof raw !== 'object') { return { valid: false, data: null, errors: ['resposta nao e um objeto JSON'] }; @@ -27,10 +68,22 @@ function validateAiClassification(raw) { if (typeof raw.actionable_today !== 'boolean') errors.push('actionable_today deve ser boolean'); const confidence = Number(raw.confidence); if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) errors.push('confidence deve estar entre 0 e 1'); - if (typeof raw.next_action !== 'string' || raw.next_action.trim().length === 0 || raw.next_action.length > 200) errors.push('next_action invalido (vazio ou muito longo)'); + if (typeof raw.next_action !== 'string' || raw.next_action.trim().length === 0 || raw.next_action.length > 200) { + errors.push('next_action invalido (vazio ou muito longo)'); + } else if ( + ACTIONABLE_CLASSES_REQUIRING_CONCRETE_NEXT_ACTION.has(raw.classification) + && isGenericNextAction(raw.next_action) + ) { + errors.push(`next_action generico demais para ${raw.classification}: "${raw.next_action}"`); + } if (raw.evidence != null && !Array.isArray(raw.evidence)) errors.push('evidence deve ser array'); if (typeof raw.reason !== 'string') errors.push('reason deve ser string'); + const waitingFor = normalizeNullableString(raw.waiting_for); + if (raw.classification === 'WAITING_VENDOR' && isWaitingForInternalTechnician(waitingFor, ticket)) { + errors.push(`waiting_for ("${waitingFor}") corresponde a tecnico interno do chamado, nao pode ser WAITING_VENDOR`); + } + if (errors.length) return { valid: false, data: null, errors }; return { @@ -41,7 +94,7 @@ function validateAiClassification(raw) { actionable_today: raw.actionable_today, confidence, blocker_type: normalizeNullableString(raw.blocker_type), - waiting_for: normalizeNullableString(raw.waiting_for), + waiting_for: waitingFor, next_action: raw.next_action, suggested_action_type: raw.suggested_action_type ?? 'technical_action', business_risk: raw.business_risk ?? 'medium', @@ -49,8 +102,16 @@ function validateAiClassification(raw) { evidence: Array.isArray(raw.evidence) ? raw.evidence.slice(0, 5) : [], is_fallback: false, fallback_reason: null, + classifier_version: AI_CLASSIFIER_VERSION, }, }; } -module.exports = { VALID_CLASSIFICATIONS, validateAiClassification, normalizeNullableString }; +module.exports = { + VALID_CLASSIFICATIONS, + AI_CLASSIFIER_VERSION, + validateAiClassification, + normalizeNullableString, + isGenericNextAction, + isWaitingForInternalTechnician, +}; diff --git a/logic/classification.test.js b/logic/classification.test.js index 321533d..43b102a 100644 --- a/logic/classification.test.js +++ b/logic/classification.test.js @@ -1,6 +1,6 @@ const { test } = require('node:test'); const assert = require('node:assert/strict'); -const { validateAiClassification, VALID_CLASSIFICATIONS } = require('./classification'); +const { validateAiClassification, VALID_CLASSIFICATIONS, AI_CLASSIFIER_VERSION } = require('./classification'); function validRaw(overrides) { return Object.assign({ @@ -80,3 +80,56 @@ test('blocker_type/waiting_for com valor real nao sao afetados pela normalizacao assert.equal(result.data.blocker_type, 'fornecedor'); assert.equal(result.data.waiting_for, 'Patricia'); }); + +test('AI_CLASSIFIER_VERSION esta definida e e carimbada em toda classificacao valida', () => { + assert.equal(typeof AI_CLASSIFIER_VERSION, 'number'); + const result = validateAiClassification(validRaw({})); + assert.equal(result.data.classifier_version, AI_CLASSIFIER_VERSION); +}); + +test('tecnico interno (aparece em TECNICO do chamado) nunca vira WAITING_VENDOR -- missao secao 6', () => { + const ticket = { tecnico_atribuido: 'Rafael Brito' }; + const result = validateAiClassification( + validRaw({ classification: 'WAITING_VENDOR', waiting_for: 'Rafael Brito', actionable_today: false }), + ticket, + ); + assert.equal(result.valid, false); + assert.ok(result.errors.some((e) => e.includes('tecnico interno'))); +}); + +test('WAITING_VENDOR com fornecedor externo de verdade (nao aparece em TECNICO) continua valido', () => { + const ticket = { tecnico_atribuido: 'Rafael Brito' }; + const result = validateAiClassification( + validRaw({ classification: 'WAITING_VENDOR', waiting_for: 'fornecimento de baterias', actionable_today: false }), + ticket, + ); + assert.equal(result.valid, true); +}); + +test('WAITING_VENDOR sem ticket informado (uso legado/sem contexto) nao quebra a validacao', () => { + const result = validateAiClassification( + validRaw({ classification: 'WAITING_VENDOR', waiting_for: 'fornecedor XPTO', actionable_today: false }), + ); + assert.equal(result.valid, true); +}); + +test('next_action generico ("Revisar chamado") e rejeitado para ACTIONABLE_NOW -- missao secao 9', () => { + const result = validateAiClassification(validRaw({ classification: 'ACTIONABLE_NOW', next_action: 'Revisar chamado' })); + assert.equal(result.valid, false); + assert.ok(result.errors.some((e) => e.includes('generico'))); +}); + +test('next_action generico ("Acompanhar") e rejeitado para UNASSIGNED_ACTIONABLE', () => { + const result = validateAiClassification(validRaw({ classification: 'UNASSIGNED_ACTIONABLE', next_action: 'Acompanhar', actionable_today: true })); + assert.equal(result.valid, false); +}); + +test('next_action concreto ("Realizar inventario das maquinas") passa para ACTIONABLE_NOW', () => { + const result = validateAiClassification(validRaw({ classification: 'ACTIONABLE_NOW', next_action: 'Realizar inventário das máquinas' })); + assert.equal(result.valid, true); +}); + +test('next_action curto tipo "aguardar resposta" e permitido em classes WAITING_* (nao exige verbo de acao do suporte)', () => { + const result = validateAiClassification(validRaw({ classification: 'WAITING_REQUESTER', next_action: 'Aguardar resposta do cliente', actionable_today: false })); + assert.equal(result.valid, true); +}); diff --git a/logic/config.js b/logic/config.js index 804a723..60cab4b 100644 --- a/logic/config.js +++ b/logic/config.js @@ -15,7 +15,11 @@ function parseConfig(env) { aiProvider: e.AI_PROVIDER || 'openai', aiModel: e.AI_MODEL || 'gpt-4o-mini', candidatePoolSize: toNumber(e.CANDIDATE_POOL_SIZE, 60), - aiMaxCandidates: toNumber(e.AI_MAX_CANDIDATES, 30), + // Igual a candidatePoolSize por padrao -- nenhum candidato elegivel deve ficar sem + // analise semantica por um cap artificial (missao "finalizacao para producao", secao + // 13). AI_FALLBACK fica reservado para falha real de provider/timeout, nao para + // economia de chamadas dentro de um pool que o cache ja deixou barato de repetir. + aiMaxCandidates: toNumber(e.AI_MAX_CANDIDATES, 60), topN: Math.min(toNumber(e.TOP_N, 10), 10), cooldownDays: toNumber(e.COOLDOWN_DAYS, 1), aiConfidenceThreshold: toNumber(e.AI_CONFIDENCE_THRESHOLD, 0.6), @@ -24,6 +28,11 @@ function parseConfig(env) { shadowMode: toBool(e.SHADOW_MODE, true), diasSemInteracaoAlerta: toNumber(e.DIAS_SEM_INTERACAO_ALERTA, 2), horasSlaRisco: toNumber(e.HORAS_SLA_RISCO, 8), + // Gate explicito de envio real -- nunca depende de editar codigo pra habilitar/desabilitar + // (missao "finalizacao para producao", secao 22). Default false: so quem liga + // explicitamente no Config node manda mensagem de verdade. + environment: e.ENVIRONMENT || 'dev', + sendEnabled: toBool(e.SEND_ENABLED, false), }; } diff --git a/logic/config.test.js b/logic/config.test.js index 1610a50..5780119 100644 --- a/logic/config.test.js +++ b/logic/config.test.js @@ -7,11 +7,24 @@ test('valores padrao quando env vazio', () => { assert.equal(config.aiEnabled, true); assert.equal(config.aiProvider, 'openai'); assert.equal(config.candidatePoolSize, 60); - assert.equal(config.aiMaxCandidates, 30); + assert.equal(config.aiMaxCandidates, 60); assert.equal(config.topN, 10); assert.equal(config.aiConfidenceThreshold, 0.6); assert.equal(config.shadowMode, true); assert.equal(config.devMode, true); + assert.equal(config.environment, 'dev'); + assert.equal(config.sendEnabled, false); +}); + +test('aiMaxCandidates default e igual a candidatePoolSize default -- nenhum candidato elegivel fica de fora por cap artificial (missao secao 13)', () => { + const config = parseConfig({}); + assert.equal(config.aiMaxCandidates, config.candidatePoolSize); +}); + +test('SEND_ENABLED=true liga o envio real; ENVIRONMENT=production e respeitado', () => { + const config = parseConfig({ SEND_ENABLED: 'true', ENVIRONMENT: 'production' }); + assert.equal(config.sendEnabled, true); + assert.equal(config.environment, 'production'); }); test('AI_ENABLED=false desliga a IA', () => { diff --git a/n8n/nodes/decide-needs-ai.node.js b/n8n/nodes/decide-needs-ai.node.js index f11fb8d..dd0c3fb 100644 --- a/n8n/nodes/decide-needs-ai.node.js +++ b/n8n/nodes/decide-needs-ai.node.js @@ -1,4 +1,4 @@ -// @requires config.js cache.js +// @requires config.js cache.js classification.js // Instancia bloqueia $env em Code nodes -- config vem do node "Config - Coordenador GLPI v2". const config = parseConfig($('Config - Coordenador GLPI v2').first().json); const now = Date.now(); @@ -12,8 +12,14 @@ for (const row of memoryRows) memoryByTicket[String(row.ticket_id)] = row; const withDecision = items.map((item) => { const memory = memoryByTicket[String(item.ticket.id)] || null; - const analysis = needsReanalysis({ memory, currentHash: item.contextHash, now }); - return { ticket: item.ticket, contextHash: item.contextHash, memory, needsAiReason: analysis.reason, needsAiRaw: analysis.needsAi }; + // Chave de cache = conteudo do chamado + versao do classificador (logic/cache.js). Bump de + // AI_CLASSIFIER_VERSION forca cache miss em TODO chamado, mesmo sem nenhuma mudanca real no + // GLPI -- sem precisar apagar a Data Table na mao (missao "finalizacao para producao", secao 12). + const cacheKey = buildCacheKey(item.contextHash, AI_CLASSIFIER_VERSION); + const analysis = needsReanalysis({ memory, currentHash: cacheKey, now }); + return { + ticket: item.ticket, contextHash: item.contextHash, cacheKey, memory, needsAiReason: analysis.reason, needsAiRaw: analysis.needsAi, + }; }); const needingAi = withDecision @@ -35,6 +41,7 @@ return withDecision.map((item) => { json: { ticket: item.ticket, contextHash: item.contextHash, + cacheKey: item.cacheKey, memory: item.memory, needsAiReason: item.needsAiReason, resolucao, diff --git a/n8n/nodes/prepare-ai-prompt.node.js b/n8n/nodes/prepare-ai-prompt.node.js index fef63fe..fe8e701 100644 --- a/n8n/nodes/prepare-ai-prompt.node.js +++ b/n8n/nodes/prepare-ai-prompt.node.js @@ -11,9 +11,36 @@ const systemPrompt = [ 'Distinga evidencia (o que esta escrito no chamado) de inferencia (sua conclusao).', 'SLA vencido sozinho NAO e evidencia de que existe uma acao executavel agora.', 'Idade do chamado sozinha NAO e evidencia de acionabilidade.', - 'Identifique: existe acao executavel hoje? quem pode executar? existe bloqueio? quem segura o bloqueio? qual a proxima acao concreta? existe data conhecida para revisao? existe evidencia nos apontamentos que justifique a conclusao?', - 'Se a informacao for insuficiente para decidir com confianca, use a classificacao INSUFFICIENT_CONTEXT e confidence baixo -- nao invente uma acao.', - `Responda em JSON estrito com os campos: classification (uma de: ${VALID_CLASSIFICATIONS.join(', ')}), actionable_today (boolean), confidence (0 a 1), blocker_type, waiting_for, next_action (curto, poucas palavras, sem paragrafo), suggested_action_type, business_risk (low|medium|high), reason (uma frase), evidence (lista curta de evidencias textuais encontradas).`, + '', + '=== O QUE SIGNIFICA ACIONAVEL (ACTIONABLE_NOW / UNASSIGNED_ACTIONABLE) ===', + 'ACTIONABLE_NOW significa: existe pelo menos uma acao concreta que um integrante do suporte pode executar AGORA para fazer o chamado avancar. NAO precisa significar que o chamado sera resolvido integralmente hoje -- precisa significar que o suporte consegue fazer algo util agora.', + 'Isso INCLUI, entre outras: executar diagnostico; testar equipamento; verificar configuracao; solicitar informacao ao cliente (quando ainda NAO foi solicitada); entrar em contato com fornecedor (quando ainda NAO foi contatado); marcar/agendar visita; combinar horario; atribuir tecnico; realizar inventario; validar cenario; executar instalacao; iniciar migracao; cobrar informacao que ainda NAO foi solicitada; atualizar configuracao; reproduzir problema; levantar requisitos; ou qualquer outro proximo passo concreto sob controle do suporte.', + '', + '=== CONTATAR != AGUARDAR (diferenca critica) ===', + 'Precisar contatar alguem (cliente ou fornecedor) que AINDA NAO foi contatado e ACIONAVEL AGORA: ex. "Precisamos perguntar ao cliente qual horario pode realizar a manutencao" -> ACTIONABLE_NOW, next_action "Contatar cliente para combinar horario". "Precisamos pedir orcamento ao fornecedor" -> ACTIONABLE_NOW.', + 'Ja ter contatado e estar esperando resposta e WAITING_*: ex. "Cliente ja foi contatado em 23/08 e estamos aguardando resposta" -> WAITING_REQUESTER. "Orcamento ja solicitado; aguardando retorno do fornecedor" -> WAITING_VENDOR.', + 'So classifique WAITING_REQUESTER, WAITING_VENDOR ou WAITING_APPROVAL quando existir evidencia POSITIVA no historico de que (1) a acao necessaria ja foi executada pelo suporte E (2) existe uma dependencia externa ainda aberta. Sem essa evidencia dupla, NAO assuma espera -- procure se existe uma acao ainda nao realizada primeiro.', + '', + '=== TECNICO INTERNO NAO E FORNECEDOR ===', + 'O campo TECNICO do chamado lista responsaveis/tecnicos internos da equipe de suporte. Se uma pendencia depende de alguem listado nesse campo, NUNCA classifique como WAITING_VENDOR (fornecedor externo) -- normalmente e ACTIONABLE_NOW (se o proprio suporte pode agir) ou UNASSIGNED_ACTIONABLE (se depende de atribuicao). WAITING_VENDOR e reservado para fornecedores/terceiros genuinamente externos a equipe.', + '', + '=== STATUS "PLANEJADO" NAO SIGNIFICA BLOQUEADO ===', + 'STATUS Planejado sozinho NAO significa WAITING_REQUESTER, WAITING_VENDOR nem SCHEDULED. Se existe tarefa ou apontamento descrevendo um passo operacional disponivel agora, o chamado pode ser ACTIONABLE_NOW mesmo estando "Planejado".', + 'Use SCHEDULED apenas quando existir data, horario, janela ou evento futuro explicito no chamado (ou evidencia inequivoca de que nenhuma acao pode/deve ocorrer antes dessa data).', + '', + '=== CRONOLOGIA E OBRIGATORIA ===', + 'Interprete os apontamentos em ordem temporal -- o mais recente relevante prevalece sobre um bloqueio antigo ja superado. Exemplo: "20/08 aguardando fornecedor" seguido de "22/08 pecas chegaram" seguido de "23/08 falta instalar" -> ACTIONABLE_NOW (instalar pecas), NAO WAITING_VENDOR. Nao se prenda a um estado antigo se um apontamento mais novo o superou.', + '', + '=== NEXT_ACTION DEVE SER CONCRETO ===', + 'Para ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE, next_action precisa nomear a acao real: "Realizar inventario das maquinas", "Contatar cliente para combinar recolha", "Testar nobreak com carga", "Atribuir tecnico para visita", "Iniciar migracao dos e-mails", "Validar configuracao da impressora", "Solicitar dados de acesso ao cliente".', + 'NUNCA aceite como next_action frases genericas que nao provam acionabilidade nenhuma: "Revisar chamado", "Dar andamento", "Analisar situacao", "Verificar chamado", "Acompanhar". Se voce so consegue pensar numa frase generica dessas, reconsidere a classificacao -- provavelmente falta evidencia concreta.', + '', + '=== QUANDO USAR INSUFFICIENT_CONTEXT ===', + 'Antes de classificar como INSUFFICIENT_CONTEXT, pergunte-se: existe alguma acao concreta que o suporte consegue executar mesmo sem informacao completa? Falta de diagnostico nao significa falta de acao -- ex. "nao sabemos por que o notebook nao conecta" ainda pode ser ACTIONABLE_NOW com next_action "Realizar diagnostico de conectividade".', + 'Use INSUFFICIENT_CONTEXT somente quando realmente nao for possivel determinar um proximo passo razoavelmente especifico -- nem mesmo um passo de diagnostico/investigacao.', + '', + 'Identifique sempre: existe acao executavel hoje? quem pode executar? existe bloqueio? quem segura o bloqueio (interno ou externo)? qual a proxima acao concreta? existe data conhecida para revisao? existe evidencia nos apontamentos, em ordem cronologica, que justifique a conclusao?', + `Responda em JSON estrito com os campos: classification (uma de: ${VALID_CLASSIFICATIONS.join(', ')}), actionable_today (boolean), confidence (0 a 1), blocker_type, waiting_for, next_action (curto, poucas palavras, sem paragrafo, deve ser uma acao concreta quando ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE), suggested_action_type, business_risk (low|medium|high), reason (uma frase), evidence (lista curta de evidencias textuais encontradas, em ordem cronologica quando relevante).`, ].join('\n'); return $input.all().map((item) => { diff --git a/n8n/nodes/prepare-ai-prompt.node.test.js b/n8n/nodes/prepare-ai-prompt.node.test.js new file mode 100644 index 0000000..11020bd --- /dev/null +++ b/n8n/nodes/prepare-ai-prompt.node.test.js @@ -0,0 +1,69 @@ +const { test } = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); + +// O prompt em si nao pode ser testado deterministicamente sem chamar a IA de verdade -- estes +// testes garantem que as REGRAS exigidas pela missao "finalizacao para producao" continuam +// escritas no prompt (nao foram removidas/reescritas por acidente numa edicao futura). A prova +// comportamental real fica nas execucoes reais contra o GLPI (Run com AI_CLASSIFIER_VERSION +// nova), inspecionadas manualmente no relatorio. +function readPrompt() { + return fs.readFileSync(path.join(__dirname, 'prepare-ai-prompt.node.js'), 'utf8'); +} + +test('prompt define acionabilidade de forma pratica ("suporte consegue fazer algo util agora")', () => { + const src = readPrompt(); + assert.ok(/suporte consegue fazer algo util agora/i.test(src)); +}); + +test('prompt distingue contatar (ainda nao feito) de aguardar (ja feito) -- teste obrigatorio #2/#3', () => { + const src = readPrompt(); + assert.ok(/AINDA NAO foi contatado/.test(src)); + assert.ok(/ja foi contatado/i.test(src) || /Ja ter contatado/.test(src)); +}); + +test('prompt exige evidencia dupla (acao ja executada + dependencia externa aberta) pra WAITING_*', () => { + const src = readPrompt(); + assert.ok(/evidencia POSITIVA/.test(src)); + assert.ok(/dependencia externa ainda aberta/.test(src)); +}); + +test('prompt instrui que tecnico interno (campo TECNICO) nunca vira WAITING_VENDOR -- teste obrigatorio #1', () => { + const src = readPrompt(); + assert.ok(/NUNCA classifique como WAITING_VENDOR/.test(src)); + assert.ok(/tecnicos internos da equipe de suporte/.test(src)); +}); + +test('prompt instrui que STATUS Planejado sozinho nao significa bloqueio -- teste obrigatorio #6', () => { + const src = readPrompt(); + assert.ok(/Planejado sozinho NAO significa/.test(src)); +}); + +test('prompt exige data/horario/janela explicita para SCHEDULED', () => { + const src = readPrompt(); + assert.ok(/SCHEDULED apenas quando existir data, horario, janela/.test(src)); +}); + +test('prompt exige interpretacao cronologica (apontamento mais recente prevalece) -- teste obrigatorio #8', () => { + const src = readPrompt(); + assert.ok(/ordem temporal/.test(src)); + assert.ok(/mais recente relevante prevalece/.test(src)); +}); + +test('prompt rejeita next_action generico com exemplos explicitos', () => { + const src = readPrompt(); + for (const frase of ['Revisar chamado', 'Dar andamento', 'Analisar situacao', 'Verificar chamado', 'Acompanhar']) { + assert.ok(src.includes(frase), `prompt deveria citar "${frase}" como exemplo generico rejeitado`); + } +}); + +test('prompt pede para considerar acao de diagnostico antes de usar INSUFFICIENT_CONTEXT -- teste obrigatorio #7', () => { + const src = readPrompt(); + assert.ok(/Falta de diagnostico nao significa falta de acao/.test(src)); +}); + +test('prompt continua exigindo resposta em JSON estrito com o dominio de classes correto', () => { + const src = readPrompt(); + assert.ok(src.includes('VALID_CLASSIFICATIONS.join')); +}); diff --git a/n8n/nodes/prepare-memoria-analise-record.node.js b/n8n/nodes/prepare-memoria-analise-record.node.js index 627c422..36c387c 100644 --- a/n8n/nodes/prepare-memoria-analise-record.node.js +++ b/n8n/nodes/prepare-memoria-analise-record.node.js @@ -11,7 +11,10 @@ return items.map((data) => { json: { ticket_id: data.ticket.id, last_analyzed_at: data.contextChanged ? data.now : (data.memory ? data.memory.last_analyzed_at : data.now), - last_context_hash: data.contextHash, + // Guarda a chave composta (hash de conteudo + AI_CLASSIFIER_VERSION), nao o hash puro -- + // e o que faz o cache invalidar sozinho quando o prompt/classificador muda de versao, + // sem precisar apagar a Data Table na mao. Ver logic/cache.js -> buildCacheKey. + last_context_hash: data.cacheKey, last_meaningful_change_at: data.contextChanged ? data.now : (data.memory ? data.memory.last_meaningful_change_at : data.now), ai_classification: cls, ai_confidence: data.aiClassification.confidence, diff --git a/n8n/nodes/validate-ai-response.node.js b/n8n/nodes/validate-ai-response.node.js index 45f72d5..53383a5 100644 --- a/n8n/nodes/validate-ai-response.node.js +++ b/n8n/nodes/validate-ai-response.node.js @@ -18,8 +18,17 @@ return responseItems.map((responseItem, index) => { raw = null; } - const validation = validateAiClassification(raw); - const aiClassification = validation.valid ? validation.data : buildFallbackClassification('invalid_json'); + // Passa o ticket pra validacao poder aplicar a guarda deterministica "tecnico interno nunca + // vira WAITING_VENDOR" (logic/classification.js -> isWaitingForInternalTechnician). Sem + // isso a validacao so olha o JSON cru, nunca os fatos do proprio chamado. + const validation = validateAiClassification(raw, original.ticket); + let aiClassification; + if (validation.valid) { + aiClassification = validation.data; + } else { + const isSemanticConflict = validation.errors.some((e) => e.includes('tecnico interno')); + aiClassification = buildFallbackClassification(isSemanticConflict ? 'ai_semantic_conflict' : 'invalid_json'); + } return { json: { ...original, aiClassification } }; });