epa-testeprojetoia 0.1.0

package/src/config/setup.ts

@@ -0,0 +1,35 @@
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+
+export async function setupConfig() {
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const ask = (q: string) =>
+    new Promise<string>((resolve) => rl.question(q, resolve));
+
+  const apiUrl = await ask("EPA API URL: ");
+
+  rl.close();
+
+  const config = {
+    epaApiUrl: apiUrl,
+    epaApiTimeoutMs: 15000
+  };
+
+  const configDir = path.join(process.cwd(), "config");
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir);
+  }
+
+  const configPath = path.join(configDir, "config.json");
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  console.log("Config salvo em:", configPath);
+}

package/src/core/createReferenceTool.ts

@@ -0,0 +1,17 @@
+import { createTool } from "./createTool.js"
+import { EpaApiClient } from "../api/epaApiClient.js"
+
+const api = new EpaApiClient()
+
+export function createReferenceTool(name:string, endpoint:string) {
+
+  return createTool({
+    name,
+    description: `Lista dados de referência: ${name}`,
+    handler: async () => {
+      return api.get(endpoint)
+    }
+
+  })
+
+}

package/src/core/createTool.ts

@@ -0,0 +1,51 @@
+import { ZodTypeAny } from "zod"
+
+export interface ToolDefinition {
+  name: string
+  description: string
+  schema?: any
+  validator?: ZodTypeAny
+  handler: (args: any) => Promise<any>
+}
+
+export function createTool(def: ToolDefinition) {
+
+  return {
+    name: def.name,
+    description: def.description,
+    inputSchema: {
+      type: "object",
+      properties: def.schema || {},
+    },
+    async execute(args: any) {
+
+      let parsedArgs = args ?? {}
+
+      if (def.validator) {
+        const parsed = def.validator.safeParse(parsedArgs)
+
+        if (!parsed.success) {
+          const issues = parsed.error.issues
+            .map((issue) => `${issue.path.join(".") || "args"}: ${issue.message}`)
+            .join("; ")
+          throw new Error(`Parametros invalidos para "${def.name}": ${issues}`)
+        }
+
+        parsedArgs = parsed.data
+      }
+
+      const result = await def.handler(parsedArgs);
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      }
+
+    }
+  }
+
+}

package/src/mocks/requestMocks.ts

@@ -0,0 +1,52 @@
+export const OS_TIPO = [
+    { "id": 1009, "descricao": "Abrir Lojas" },
+    { "id": 1005, "descricao": "Apoio Tecnológico" },
+    { "id": 1008, "descricao": "Chamados de TI" },
+    { "id": 1003, "descricao": "Desenvolvimento de Software" },
+    { "id": 1019, "descricao": "Engenharia Clínica" },
+    { "id": 999, "descricao": "Gestão da Qualidade" },
+    { "id": 1013, "descricao": "Gestão de Pessoas / DP" },
+    { "id": 1012, "descricao": "Instalação" },
+    { "id": 1010, "descricao": "Manutenção" },
+    { "id": 1002, "descricao": "Manutenção Preventiva" },
+    { "id": 1001, "descricao": "Ouvidoria" },
+    { "id": 1020, "descricao": "Qualidade - envio de documentos" },
+    { "id": 2, "descricao": "Reclamação" },
+    { "id": 1000, "descricao": "Recursos Humanos" },
+    { "id": 1015, "descricao": "Reembolso de despesas" },
+    { "id": 1007, "descricao": "Reembolso de Despesa_" },
+    { "id": 1018, "descricao": "Suporte Técnico de TI" },
+    { "id": 1014, "descricao": "Teste" },
+    { "id": 1017, "descricao": "teste" },
+    { "id": 1016, "descricao": "teste 123" },
+    { "id": 1, "descricao": "TI" }
+  ]
+  
+  export const OS_TIPO_SERVICO = [
+    { "id": 1005, "descricao": "Analisar documento" },
+    { "id": 1007, "descricao": "Formatar padrão" },
+    { "id": 1016, "descricao": "Adicionar Campo" },
+    { "id": 1015, "descricao": "Criar Formulário" },
+    { "id": 1017, "descricao": "Criar Função" },
+    { "id": 995, "descricao": "Geração de Backup" }
+  ]
+  
+  export const UNIDADE_GERENCIAL = [
+    { "id": 18, "descricao": "DESEMPENHO PLANEJAMENTO > TI" }
+  ]
+  
+  export const RESPONSAVEL = [
+    { "id": 1, "descricao": "suporte.simeon" },
+    { "id": 577, "descricao": "maely.superusuario - Maely Teste Super Usuário" }
+  ]
+  
+  export const CLIENTE = [
+    { "id": 1, "descricao": "Suporte Simeon" },
+    { "id": 349, "descricao": "Comercial-Simeon" }
+  ]
+  
+  export const PRIORIDADE = [
+    { "id": 6, "descricao": "Média" },
+    { "id": 7, "descricao": "Alta" },
+    { "id": 8, "descricao": "Baixa" }
+  ]

package/src/server/server.ts

@@ -0,0 +1,61 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { loadTools } from "../tools/loadTools.js";
+import { buildToolNameMaps } from "../utils/toolNameMaps.js";
+
+export async function createMcpServer() {
+
+  const server = new Server(
+    {
+      name: "epa-mcp",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+
+  const tools = await loadTools();
+  const toolNames = tools.map((tool) => tool.name);
+  const { internalToExternal, externalToInternal } = buildToolNameMaps(toolNames);
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+
+    return {
+      tools: tools.map((tool) => ({
+        name: internalToExternal.get(tool.name) ?? tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      }))
+    };
+
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+
+    const internalName = externalToInternal.get(request.params.name) ?? request.params.name;
+    const tool = tools.find((t) => t.name === internalName);
+
+    if (!tool) {
+      throw new Error("Tool não encontrada");
+    }
+
+    return await tool.execute(request.params.arguments);
+
+  });
+
+  return server;
+}
+
+export async function startServer() {
+
+  const server = await createMcpServer()
+
+  const transport = new StdioServerTransport();
+
+  await server.connect(transport);
+
+}

package/src/server/stdioServer.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { startServer } from "./server.js"
+
+await startServer()

package/src/services/request/requestFilters.ts

@@ -0,0 +1,12 @@
+export type AssigneeSearchOptions = {
+  q?: string
+  unitType?: string
+  unitValue?: number | string
+}
+
+export type ListPeriod = "current_year" | "last_12_months"
+
+export type ListFilters = {
+  assigneeId?: number
+  period?: ListPeriod
+}

package/src/services/requestService.ts

@@ -0,0 +1,126 @@
+import { EpaApiClient } from "../api/epaApiClient.js"
+import type { AssigneeSearchOptions, ListFilters } from "./request/requestFilters.js"
+import { buildDateRange } from "../utils/buildDateRange.js"
+
+export class RequestService {
+
+  private api: EpaApiClient
+
+  constructor(apiClient?: EpaApiClient) {
+    this.api = apiClient ?? new EpaApiClient()
+  }
+
+  async getTypes() {
+    return this.api.get("/epa_os/ajax.php", {
+      action: "get",
+      controller: "TipoSolicitacao"
+    })
+  }
+
+  async getServices(typeId: number) {
+    return this.api.get("/api/tipos_servico", {
+      tipo_id: typeId
+    })
+  }
+
+  async getAssignees(term: string, options: AssigneeSearchOptions = {}) {
+
+    const params: Record<string, string | number> = {
+      term,
+      _type: "query",
+      q: options.q ?? term
+    }
+
+    if (options.unitValue !== undefined && options.unitValue !== null) {
+      params["filters[unidade_gerencial][type]"] = options.unitType ?? "pertenco"
+      params["filters[unidade_gerencial][value]"] = options.unitValue
+    }
+
+    const response = await this.api.get("/api/api/usuarios/search", params)
+
+    if (response && Array.isArray((response as any).results)) {
+      return (response as any).results
+    }
+
+    return response
+  }
+
+  async getClients() {
+    return this.api.get("/api/clientes")
+  }
+
+  async getUnits() {
+    return this.api.get("/api/unidades_gerenciais")
+  }
+
+  async list(filters: number | ListFilters = {}) {
+
+    const normalizedFilters: ListFilters =
+      typeof filters === "number" ? { assigneeId: filters } : filters
+
+    const params: any = {
+      data_inclusao: buildDateRange(normalizedFilters.period)
+    }
+
+    if (normalizedFilters.assigneeId) {
+      params.responsavel = normalizedFilters.assigneeId
+    }
+
+    const response = await this.api.post(
+      "/api/api/os/listar",
+      {},
+      params
+    )
+
+    if (!response || response.length === 0) {
+      return "Nenhuma solicitacao encontrada."
+    }
+
+    return response
+
+  }
+
+  async view(id: number) {
+
+    const response = await this.api.post(
+      "/api/api/os/listar",
+      {},
+      { codigo: id }
+    )
+
+    if (!response || response.length === 0) {
+      return `Solicitacao ${id} nao encontrada.`
+    }
+
+    if (Array.isArray(response)) {
+      const found = response.find((item: any) => Number(item.codigo ?? item.id) === id)
+      return found ?? response[0]
+    }
+
+    return response
+
+  }
+
+  async create(data: any) {
+
+    const payload = {
+      os_tipo: data.os_tipo,
+      os_tipo_servico: data.os_tipo_servico,
+      unidade_gerencial_executora: data.unidade_gerencial_executora,
+      responsavel: data.responsavel,
+      titulo: data.titulo,
+      cliente: data.cliente,
+      data_desejavel: data.data_desejavel,
+      prioridade: data.prioridade,
+      observacao: data.observacao
+    }
+
+    const result = await this.api.post(
+      "/api/api/solicitacao_rapida",
+      payload
+    )
+
+    return result
+  }
+
+}

package/src/services/teamService.ts

@@ -0,0 +1,27 @@
+import { EpaApiClient } from "../api/epaApiClient.js";
+
+export class TeamService {
+
+  private api: EpaApiClient;
+
+  constructor() {
+    this.api = new EpaApiClient();
+  }
+
+  async teamReport(name: string) {
+
+    const requests = await this.api.get("/solicitacoes", { responsavel: name });
+
+    const total = requests.length;
+
+    const overdue = requests.filter((request: any) => request.vencida);
+
+    return {
+      desenvolvedor: name,
+      total,
+      vencidas: overdue.length,
+      solicitacoes: requests
+    };
+  }
+
+}

package/src/sql/createSqlConnection.ts

@@ -0,0 +1,15 @@
+import mysql from "mysql2/promise"
+import { loadSqlConfig } from "./loadSqlConfig.js"
+
+export async function createSqlConnection() {
+  const sqlConfig = loadSqlConfig()
+
+  return mysql.createConnection({
+    host: sqlConfig.host,
+    port: sqlConfig.port,
+    database: sqlConfig.database,
+    user: sqlConfig.user,
+    password: sqlConfig.password,
+    ssl: sqlConfig.ssl ? {} : undefined
+  })
+}

package/src/sql/fetchSchemaSummary.ts

@@ -0,0 +1,64 @@
+import type { RowDataPacket } from "mysql2"
+import type { Connection } from "mysql2/promise"
+import { loadSqlConfig } from "./loadSqlConfig.js"
+
+type TableRow = RowDataPacket & {
+  TABLE_NAME: string
+}
+
+type ColumnRow = RowDataPacket & {
+  TABLE_NAME: string
+  COLUMN_NAME: string
+  DATA_TYPE: string
+}
+
+const MAX_COLUMNS_PER_TABLE = 20
+
+export async function fetchAvailableTableNames(connection: Connection): Promise<string[]> {
+  const sqlConfig = loadSqlConfig()
+
+  const [tableRows] = await connection.query<TableRow[]>(
+    `
+      SELECT TABLE_NAME
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_TYPE = 'BASE TABLE'
+      ORDER BY TABLE_NAME
+    `,
+    [sqlConfig.database]
+  )
+
+  return tableRows.map((row) => row.TABLE_NAME)
+}
+
+export async function fetchSchemaSummary(connection: Connection, tableNames: string[]): Promise<string> {
+  const sqlConfig = loadSqlConfig()
+  const placeholders = tableNames.map(() => "?").join(", ")
+  const [columnRows] = await connection.query<ColumnRow[]>(
+    `
+      SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME IN (${placeholders})
+      ORDER BY TABLE_NAME, ORDINAL_POSITION
+    `,
+    [sqlConfig.database, ...tableNames]
+  )
+
+  const columnsByTable = new Map<string, string[]>()
+
+  for (const row of columnRows) {
+    const columns = columnsByTable.get(row.TABLE_NAME) ?? []
+    if (columns.length < MAX_COLUMNS_PER_TABLE) {
+      columns.push(`${row.COLUMN_NAME} (${row.DATA_TYPE})`)
+    }
+    columnsByTable.set(row.TABLE_NAME, columns)
+  }
+
+  return tableNames
+    .map((tableName) => {
+      const columns = columnsByTable.get(tableName) ?? []
+      return `Tabela ${tableName}: ${columns.join(", ")}`
+    })
+    .join("\n")
+}

package/src/sql/generateSqlFromQuestion.ts

@@ -0,0 +1,105 @@
+import OpenAI from "openai"
+import { loadSqlAgentConfig } from "./loadSqlAgentConfig.js"
+import type { SqlQuestionHints } from "./parseSqlQuestionHints.js"
+import type { SqlQueryPlan } from "./sqlPlan.js"
+
+function extractSql(content: string): string {
+  const fencedMatch = content.match(/```(?:sql)?\s*([\s\S]*?)```/i)
+  if (fencedMatch) {
+    return fencedMatch[1].trim()
+  }
+
+  return content.trim()
+}
+
+function buildHintsSummary(hints: SqlQuestionHints) {
+  const lines: string[] = []
+
+  if (hints.tableNames.length > 0) {
+    lines.push(`Tabelas indicadas pelo usuario: ${hints.tableNames.join(", ")}`)
+  }
+
+  if (hints.fieldNames.length > 0) {
+    lines.push(`Campos indicados pelo usuario: ${hints.fieldNames.join(", ")}`)
+  }
+
+  if (hints.filters.length > 0) {
+    lines.push(`Filtros indicados pelo usuario: ${hints.filters.join(", ")}`)
+  }
+
+  if (hints.orderBy.length > 0) {
+    lines.push(`Ordenacao indicada pelo usuario: ${hints.orderBy.join(", ")}`)
+  }
+
+  if (hints.limit) {
+    lines.push(`Limite indicado pelo usuario: ${hints.limit}`)
+  }
+
+  return lines.length > 0 ? lines.join("\n") : "Nenhuma pista explicita informada."
+}
+
+export async function generateSqlFromQuestion(
+  question: string,
+  schemaSummary: string,
+  hints: SqlQuestionHints,
+  plan: SqlQueryPlan,
+  additionalGuidance?: string
+) {
+  const sqlAgentConfig = loadSqlAgentConfig()
+  const openai = new OpenAI({ apiKey: sqlAgentConfig.openaiApiKey })
+
+  const completion = await openai.chat.completions.create({
+    model: sqlAgentConfig.model,
+    temperature: 0,
+    messages: [
+      {
+        role: "system",
+        content: `
+Voce e um assistente tecnico que gera SQL para MySQL/MariaDB.
+
+Regras obrigatorias:
+- gere apenas uma consulta SQL
+- responda somente com SQL, sem explicacoes
+- use apenas SELECT
+- nao finalize a resposta com ponto e virgula
+- nunca use INSERT, UPDATE, DELETE, ALTER, DROP, TRUNCATE, CREATE, REPLACE, GRANT, REVOKE, EXECUTE ou CALL
+- quando o pedido for listar registros e o usuario nao informar quantidade, aplique LIMIT 10
+- use somente tabelas e colunas presentes no schema informado
+- priorize tabelas com nome diretamente relacionado ao pedido do usuario
+- se houver tabela com nome muito proximo ao termo pedido, prefira essa tabela em vez de nomes genericos ou sem relacao clara
+- quando o usuario informar explicitamente nomes de tabelas ou campos, trate essa informacao como instrucao prioritaria
+- quando o usuario indicar um campo de relacionamento e outra tabela para vinculo, gere o JOIN usando essas pistas, desde que as colunas existam no schema informado
+- quando o usuario indicar filtros, ordenacao ou limite, respeite essas instrucoes na SQL final
+- siga o plano de consulta aprovado pelo usuario
+`.trim()
+      },
+      {
+        role: "user",
+        content: `
+Schema disponivel:
+${schemaSummary}
+
+Pistas explicitas do usuario:
+${buildHintsSummary(hints)}
+
+Plano aprovado:
+${JSON.stringify(plan, null, 2)}
+
+Orientacoes adicionais:
+${additionalGuidance?.trim() || "Nenhuma orientacao adicional."}
+
+Pedido do usuario:
+${question}
+`.trim()
+      }
+    ]
+  })
+
+  const content = completion.choices[0]?.message?.content ?? ""
+
+  if (!content.trim()) {
+    throw new Error("A LLM nao retornou SQL para o pedido informado.")
+  }
+
+  return extractSql(content)
+}