epa-testeprojetoia 0.1.0

package/src/sql/selectRelevantTables.ts

@@ -0,0 +1,184 @@
+export type RankedTable = {
+  name: string
+  score: number
+}
+
+type TableSelection = {
+  candidateTables: RankedTable[]
+  suggestedTables: string[]
+  requiresConfirmation: boolean
+}
+
+const QUESTION_STOP_WORDS = new Set([
+  "a",
+  "as",
+  "ao",
+  "aos",
+  "com",
+  "da",
+  "das",
+  "de",
+  "do",
+  "dos",
+  "e",
+  "em",
+  "na",
+  "nas",
+  "no",
+  "nos",
+  "o",
+  "os",
+  "ou",
+  "para",
+  "por",
+  "quais",
+  "qual",
+  "quero",
+  "traga",
+  "trazer",
+  "listar",
+  "liste",
+  "mostrar",
+  "mostre",
+  "me",
+  "uma",
+  "um"
+])
+
+function normalizeText(value: string) {
+  return value
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+}
+
+function buildTokenVariants(token: string) {
+  const variants = new Set([token])
+
+  if (token.endsWith("es") && token.length > 4) {
+    variants.add(token.slice(0, -2))
+  }
+
+  if (token.endsWith("s") && token.length > 3) {
+    variants.add(token.slice(0, -1))
+  }
+
+  return [...variants]
+}
+
+function extractRelevantTerms(question: string) {
+  const normalizedQuestion = normalizeText(question)
+  const rawTokens = normalizedQuestion.match(/[a-z0-9_]+/g) ?? []
+
+  return rawTokens
+    .filter((token) => token.length >= 3)
+    .filter((token) => !QUESTION_STOP_WORDS.has(token))
+    .flatMap(buildTokenVariants)
+}
+
+function scoreTableName(tableName: string, terms: string[]) {
+  if (terms.length === 0) {
+    return 0
+  }
+
+  const normalizedTableName = normalizeText(tableName)
+  let score = 0
+
+  for (const term of terms) {
+    if (normalizedTableName === term) {
+      score += 100
+      continue
+    }
+
+    if (normalizedTableName.startsWith(`${term}_`) || normalizedTableName.endsWith(`_${term}`)) {
+      score += 70
+      continue
+    }
+
+    if (normalizedTableName.includes(`_${term}_`)) {
+      score += 60
+      continue
+    }
+
+    if (normalizedTableName.includes(term)) {
+      score += 40
+    }
+  }
+
+  return score
+}
+
+function shouldAskForConfirmation(candidateTables: RankedTable[]) {
+  if (candidateTables.length <= 1) {
+    return false
+  }
+
+  const [topCandidate, secondCandidate] = candidateTables
+
+  if (!topCandidate || !secondCandidate) {
+    return false
+  }
+
+  if (topCandidate.score === 0) {
+    return true
+  }
+
+  if (topCandidate.score < 100) {
+    return true
+  }
+
+  return secondCandidate.score >= topCandidate.score - 30
+}
+
+function resolveExplicitTableNames(tableNames: string[], explicitTableNames: string[]) {
+  if (explicitTableNames.length === 0) {
+    return []
+  }
+
+  const normalizedMap = new Map(
+    tableNames.map((tableName) => [normalizeText(tableName), tableName])
+  )
+
+  return explicitTableNames
+    .map((tableName) => normalizedMap.get(normalizeText(tableName)) ?? tableName)
+    .filter((tableName, index, values) => values.indexOf(tableName) === index)
+}
+
+export function selectRelevantTables(
+  question: string,
+  tableNames: string[],
+  maxRelevantTables = 12,
+  explicitTableNames: string[] = []
+): TableSelection {
+  const terms = extractRelevantTerms(question)
+  const resolvedExplicitTables = resolveExplicitTableNames(tableNames, explicitTableNames)
+
+  const rankedTables: RankedTable[] = tableNames
+    .map((name) => ({
+      name,
+      score: scoreTableName(name, terms) + (resolvedExplicitTables.includes(name) ? 1000 : 0)
+    }))
+    .sort((left, right) => right.score - left.score || left.name.localeCompare(right.name))
+
+  const candidateTables = rankedTables
+    .filter((table) => table.score > 0)
+    .slice(0, maxRelevantTables)
+
+  const rankedSuggestedTables =
+    candidateTables.length > 0
+      ? candidateTables.map((table) => table.name)
+      : rankedTables.slice(0, maxRelevantTables).map((table) => table.name)
+
+  const suggestedTables = [...resolvedExplicitTables]
+  for (const tableName of rankedSuggestedTables) {
+    if (!suggestedTables.includes(tableName)) {
+      suggestedTables.push(tableName)
+    }
+  }
+
+  return {
+    candidateTables,
+    suggestedTables: suggestedTables.slice(0, maxRelevantTables),
+    requiresConfirmation: resolvedExplicitTables.length === 0 && shouldAskForConfirmation(candidateTables)
+  }
+}

package/src/sql/sqlGuard.ts

@@ -0,0 +1,28 @@
+const READ_ONLY_SQL_PATTERN = /^\s*select\b/i
+const FORBIDDEN_SQL_PATTERN = /\b(insert|update|delete|alter|drop|truncate|create|replace|grant|revoke|execute|call)\b/i
+
+export function normalizeReadOnlySql(query: string) {
+  return query.trim().replace(/;\s*$/, "")
+}
+
+export function validateReadOnlySql(query: string) {
+  const normalizedQuery = normalizeReadOnlySql(query)
+
+  if (!normalizedQuery) {
+    throw new Error("Informe uma consulta SQL.")
+  }
+
+  if (!READ_ONLY_SQL_PATTERN.test(normalizedQuery)) {
+    throw new Error("Somente consultas SELECT sao permitidas neste modo tecnico.")
+  }
+
+  if (FORBIDDEN_SQL_PATTERN.test(normalizedQuery)) {
+    throw new Error("A consulta contem comandos nao permitidos para modo read-only.")
+  }
+
+  if (normalizedQuery.includes(";")) {
+    throw new Error("Envie apenas uma consulta por vez.")
+  }
+
+  return normalizedQuery
+}

package/src/sql/sqlPlan.ts

@@ -0,0 +1,28 @@
+export type SqlQueryPlan = {
+  goal: string
+  mainTable: string
+  relatedTables: string[]
+  relationshipFields: string[]
+  selectedFields: string[]
+  filters: string[]
+  orderBy: string[]
+  limit: number
+}
+
+function formatList(values: string[]) {
+  return values.length > 0 ? values.join(", ") : "-"
+}
+
+export function formatSqlPlan(plan: SqlQueryPlan) {
+  return [
+    "Plano de consulta:",
+    `- objetivo: ${plan.goal || "-"}`,
+    `- tabela principal: ${plan.mainTable || "-"}`,
+    `- tabelas relacionadas: ${formatList(plan.relatedTables)}`,
+    `- campos de relacionamento: ${formatList(plan.relationshipFields)}`,
+    `- colunas de saida: ${formatList(plan.selectedFields)}`,
+    `- filtros: ${formatList(plan.filters)}`,
+    `- ordenacao: ${formatList(plan.orderBy)}`,
+    `- limite: ${plan.limit}`
+  ].join("\n")
+}

package/src/tests/requestService.test.ts

@@ -0,0 +1,152 @@
+import test from "node:test"
+import assert from "node:assert/strict"
+import { RequestService } from "../services/requestService.js"
+import { resolveAssigneeId } from "../utils/resolveAssigneeId.js"
+
+type PostCall = {
+  endpoint: string
+  body: any
+  params?: any
+}
+
+type GetCall = {
+  endpoint: string
+  params?: any
+}
+
+class FakeApiClient {
+  public getCalls: GetCall[] = []
+  public postCalls: PostCall[] = []
+  private getResult: any
+  private postResult: any
+
+  constructor(results: { getResult?: any; postResult?: any }) {
+    this.getResult = results.getResult
+    this.postResult = results.postResult
+  }
+
+  async get(endpoint: string, params?: any) {
+    this.getCalls.push({ endpoint, params })
+    return this.getResult
+  }
+
+  async post(endpoint: string, body: any = {}, params?: any) {
+    this.postCalls.push({ endpoint, body, params })
+    return this.postResult
+  }
+}
+
+test("list usa /api/api/os/listar e aplica filtro de responsavel", async () => {
+  const fakeApi = new FakeApiClient({ postResult: [{ id: 1 }] })
+  const service = new RequestService(fakeApi as any)
+
+  await service.list(123)
+
+  assert.equal(fakeApi.postCalls.length, 1)
+  const call = fakeApi.postCalls[0]
+
+  assert.equal(call.endpoint, "/api/api/os/listar")
+  assert.deepEqual(call.body, {})
+  assert.equal(call.params?.responsavel, 123)
+  assert.match(
+    String(call.params?.data_inclusao),
+    /^\d{4}-01-01 00:00:00to\d{4}-12-31 23:59:59$/
+  )
+})
+
+test("list com last_12_months envia data_inclusao em formato valido", async () => {
+  const fakeApi = new FakeApiClient({ postResult: [{ id: 1 }] })
+  const service = new RequestService(fakeApi as any)
+
+  await service.list({ assigneeId: 1, period: "last_12_months" })
+
+  assert.equal(fakeApi.postCalls.length, 1)
+  const call = fakeApi.postCalls[0]
+  assert.equal(call.endpoint, "/api/api/os/listar")
+  assert.match(
+    String(call.params?.data_inclusao),
+    /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}to\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/
+  )
+})
+
+test("view usa /api/api/os/listar com codigo", async () => {
+  const fakeApi = new FakeApiClient({ postResult: [{ codigo: 999, titulo: "OS 999" }] })
+  const service = new RequestService(fakeApi as any)
+
+  const result = await service.view(999)
+
+  assert.equal(fakeApi.postCalls.length, 1)
+  const call = fakeApi.postCalls[0]
+  assert.equal(call.endpoint, "/api/api/os/listar")
+  assert.deepEqual(call.body, {})
+  assert.deepEqual(call.params, { codigo: 999 })
+  assert.deepEqual(result, { codigo: 999, titulo: "OS 999" })
+})
+
+test("create usa /api/api/solicitacao_rapida com payload mapeado", async () => {
+  const fakeApi = new FakeApiClient({ postResult: { id: 321 } })
+  const service = new RequestService(fakeApi as any)
+
+  const payload = {
+    os_tipo: 1,
+    os_tipo_servico: 2,
+    unidade_gerencial_executora: 3,
+    responsavel: 4,
+    titulo: "Nova solicitacao",
+    cliente: 5,
+    data_desejavel: "10/03/2026",
+    prioridade: 6,
+    observacao: "observacao de teste"
+  }
+
+  const result = await service.create(payload)
+
+  assert.equal(fakeApi.postCalls.length, 1)
+  const call = fakeApi.postCalls[0]
+  assert.equal(call.endpoint, "/api/api/solicitacao_rapida")
+  assert.deepEqual(call.body, payload)
+  assert.deepEqual(result, { id: 321 })
+})
+
+test("getTypes usa endpoint real com action/controller", async () => {
+  const fakeApi = new FakeApiClient({ getResult: [{ codigo: 1009, descricao: "Abrir Lojas" }] })
+  const service = new RequestService(fakeApi as any)
+
+  const result = await service.getTypes()
+
+  assert.equal(fakeApi.getCalls.length, 1)
+  const call = fakeApi.getCalls[0]
+  assert.equal(call.endpoint, "/epa_os/ajax.php")
+  assert.deepEqual(call.params, { action: "get", controller: "TipoSolicitacao" })
+  assert.deepEqual(result, [{ codigo: 1009, descricao: "Abrir Lojas" }])
+})
+
+test("getAssignees monta payload obrigatorio e filtro opcional", async () => {
+  const fakeApi = new FakeApiClient({
+    getResult: { results: [{ id: 1, text: "suporte.simeon - Suporte Simeon" }] }
+  })
+  const service = new RequestService(fakeApi as any)
+
+  const result = await service.getAssignees("suporte", { unitValue: 18 })
+
+  assert.equal(fakeApi.getCalls.length, 1)
+  const call = fakeApi.getCalls[0]
+  assert.equal(call.endpoint, "/api/api/usuarios/search")
+  assert.deepEqual(call.params, {
+    term: "suporte",
+    _type: "query",
+    q: "suporte",
+    "filters[unidade_gerencial][type]": "pertenco",
+    "filters[unidade_gerencial][value]": 18
+  })
+  assert.deepEqual(result, [{ id: 1, text: "suporte.simeon - Suporte Simeon" }])
+})
+
+test("resolveAssigneeId resolve login com match exato", () => {
+  const assignees = [
+    { id: 10, text: "suporte.outro - Outro" },
+    { id: 1, text: "suporte.simeon - Suporte Simeon" }
+  ]
+  const id = resolveAssigneeId(assignees, "suporte.simeon")
+  assert.equal(id, 1)
+})

package/src/tools/analytics/teamReport.draft.ts

@@ -0,0 +1,25 @@
+import { createTool } from "../../core/createTool.js"
+import { TeamService } from "../../services/teamService.js"
+
+const service = new TeamService()
+
+export default createTool({
+
+  name: "analytics.teamReport",
+
+  description: "Gera relatório de tarefas de um desenvolvedor",
+
+  schema: {
+    name: {
+      type: "string",
+      description: "Nome do desenvolvedor"
+    }
+  },
+
+  handler: async ({ name }) => {
+
+    return service.teamReport(name)
+
+  }
+
+})

package/src/tools/loadTools.ts

@@ -0,0 +1,59 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+const currentFilePath = fileURLToPath(import.meta.url);
+const toolsDir = path.dirname(currentFilePath);
+
+export async function loadTools() {
+
+  const tools: any[] = [];
+
+  async function scan(dir: string) {
+
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+
+      const full = path.join(dir, file);
+      const stat = fs.statSync(full);
+
+      if (stat.isDirectory()) {
+        await scan(full);
+        continue;
+      }
+
+      if (!file.endsWith(".ts") && !file.endsWith(".js")) {
+        continue;
+      }
+
+      if (file.endsWith(".draft.ts") || file.endsWith(".draft.js")) {
+        continue;
+      }
+
+      if (file === "loadTools.ts" || file === "loadTools.js") {
+        continue;
+      }
+
+      const tool = await import(pathToFileURL(full).href);
+
+      if (tool.default) {
+        tools.push(tool.default);
+      }
+
+      if (tool.tool) {
+        tools.push(tool.tool);
+      }
+
+      if (tool.teamReportTool) {
+        tools.push(tool.teamReportTool);
+      }
+
+    }
+
+  }
+
+  await scan(toolsDir);
+
+  return tools;
+}

package/src/tools/requests/assignees.ts

@@ -0,0 +1,59 @@
+import { z } from "zod"
+import { createTool } from "../../core/createTool.js"
+import { RequestService } from "../../services/requestService.js"
+
+const service = new RequestService()
+
+export default createTool({
+
+  name: "requests.assignees",
+
+  description: `
+    Busca responsáveis no EPA.
+
+    Campos obrigatórios:
+    - term: texto de pesquisa
+    - _type: sempre "query" (preenchido automaticamente)
+    - q: texto de pesquisa (usa term por padrão)
+
+    Filtro opcional preparado:
+    - unit_value: ID da unidade gerencial
+    - unit_type: padrão "pertenco"
+  `,
+
+  schema: {
+    term: {
+      type: "string",
+      description: "Texto de pesquisa (ex: suporte)"
+    },
+    q: {
+      type: "string",
+      description: "Texto de pesquisa alternativo (opcional; padrão: term)"
+    },
+    unit_value: {
+      type: "number",
+      description: "ID da unidade gerencial para filtro opcional"
+    },
+    unit_type: {
+      type: "string",
+      description: "Tipo do filtro de unidade (opcional; padrao: pertenco)"
+    }
+  },
+  validator: z.object({
+    term: z.string().min(1),
+    q: z.string().min(1).optional(),
+    unit_value: z.number().int().positive().optional(),
+    unit_type: z.string().min(1).optional()
+  }).strict(),
+
+  handler: async ({ term, q, unit_value, unit_type }) => {
+
+    return service.getAssignees(term, {
+      q,
+      unitValue: unit_value,
+      unitType: unit_type
+    })
+
+  }
+
+})

package/src/tools/requests/clients.draft.ts

@@ -0,0 +1,18 @@
+import { createTool } from "../../core/createTool.js"
+import { RequestService } from "../../services/requestService.js"
+
+const service = new RequestService()
+
+export default createTool({
+
+  name: "requests.clients",
+
+  description: "Lista clientes disponíveis",
+
+  handler: async () => {
+
+    return service.getClients()
+
+  }
+
+})

package/src/tools/requests/create.draft.ts

@@ -0,0 +1,59 @@
+import { z } from "zod"
+import { createTool } from "../../core/createTool.js"
+import { RequestService } from "../../services/requestService.js"
+
+const service = new RequestService()
+
+export default createTool({
+  name: "requests.create",
+  description: `
+      Cria uma nova solicitacao no EPA.
+
+      Antes de usar esta tool e recomendado consultar:
+
+      1. requests.types
+      2. requests.services
+      3. requests.units
+      4. requests.assignees
+      5. requests.clients
+      6. requests.priorities
+
+      Use os IDs retornados por essas ferramentas.
+  `,
+  schema: {
+    os_tipo: { type: "number", description: "ID do tipo retornado pela tool requests.types" },
+    os_tipo_servico: { type: "number", description: "ID de servico retornado pela tool requests.services" },
+    unidade_gerencial_executora: { type: "number", description: "ID da unidade retornado pela tool requests.units" },
+    responsavel: { type: "number", description: "ID do responsavel retornado pela tool requests.assignees" },
+    cliente: { type: "number", description: "ID do cliente retornado pela tool requests.clients" },
+    prioridade: { type: "number", description: "ID da prioridade retornado pela tool requests.priorities" },
+
+    titulo: { type: "string" },
+    observacao: { type: "string" },
+    data_desejavel: { type: "string", description: "Formato dd/mm/yyyy" }
+  },
+  validator: z.object({
+    os_tipo: z.number().int().positive(),
+    os_tipo_servico: z.number().int().positive(),
+    unidade_gerencial_executora: z.number().int().positive(),
+    responsavel: z.number().int().positive(),
+    cliente: z.number().int().positive(),
+    prioridade: z.number().int().positive(),
+    titulo: z.string().min(3),
+    observacao: z.string().optional(),
+    data_desejavel: z.string().regex(/^\d{2}\/\d{2}\/\d{4}$/)
+  }).strict(),
+
+  handler: async (args) => {
+
+    const result = await service.create(args)
+
+    return {
+      message: "Solicitacao criada com sucesso",
+      codigo: result.id,
+      link: `/exibir_solicitacao.php?codigo=${result.id}`
+    }
+
+  }
+
+})

package/src/tools/requests/list.ts

@@ -0,0 +1,57 @@
+import { z } from "zod"
+import { createTool } from "../../core/createTool.js"
+import { RequestService } from "../../services/requestService.js"
+import { resolveAssigneeId } from "../../utils/resolveAssigneeId.js"
+
+const service = new RequestService()
+
+export default createTool({
+  name: "requests.list",
+  description: `
+    Lista solicitacoes do EPA.
+
+    Pode filtrar por ID do responsavel ou pelo nome/login do responsavel.
+    Tambem permite definir periodo.
+
+    Para descobrir os responsaveis disponiveis use:
+    requests.assignees
+  `,
+  schema: {
+    assignee_id: {
+      type: "number",
+      description: "ID do responsavel (retornado por requests.assignees)"
+    },
+    assignee_name: {
+      type: "string",
+      description: "Nome/login do responsavel (ex: suporte.simeon)"
+    },
+    period: {
+      type: "string",
+      description: "Periodo de busca: current_year (padrao) ou last_12_months"
+    }
+  },
+  validator: z.object({
+    assignee_id: z.number().int().positive().optional(),
+    assignee_name: z.string().min(1).optional(),
+    period: z.enum(["current_year", "last_12_months"]).optional()
+  }).strict(),
+
+  handler: async ({ assignee_id, assignee_name, period }) => {
+
+    if (assignee_id) {
+      return service.list({ assigneeId: assignee_id, period })
+    }
+
+    if (assignee_name) {
+      const assignees = await service.getAssignees(assignee_name, { q: assignee_name })
+      const assigneeId = resolveAssigneeId(assignees, assignee_name)
+      if (!assigneeId) {
+        return `Responsavel "${assignee_name}" nao encontrado.`
+      }
+      return service.list({ assigneeId, period })
+    }
+
+    return service.list({ period })
+  }
+
+})

package/src/tools/requests/priorities.ts

@@ -0,0 +1,6 @@
+import { createReferenceTool } from "../../core/createReferenceTool.js"
+
+export default createReferenceTool(
+  "requests.priorities",
+  "/api/api/prioridade"
+)