epa-testeprojetoia 0.1.0

package/src/agent/openaiAgent.ts

@@ -0,0 +1,205 @@
+import OpenAI from "openai"
+import readline from "readline"
+import path from "path"
+import { fileURLToPath } from "url"
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"
+import { loadConfig } from "../config/loadConfig.js"
+import { ensureCliAuth } from "../config/ensureCliAuth.js"
+import { createMcpServer } from "../server/server.js"
+import { applySlidingWindow } from "./slidingWindow.js"
+import { buildToolNameMaps, getErrorMessage, isSpawnPermissionError } from "./agentHelpers.js"
+
+const DEFAULT_MAX_NON_SYSTEM_MESSAGES = 30
+
+export async function startAgent() {
+  await ensureCliAuth()
+
+  const config = loadConfig()
+  const apiKey = process.env.OPENAI_API_KEY || config.openaiApiKey
+
+  if (!apiKey) {
+    throw new Error("OpenAI API key nao encontrada. Defina OPENAI_API_KEY ou configure via setup.")
+  }
+
+  const openai = new OpenAI({ apiKey })
+
+  const currentFilePath = fileURLToPath(import.meta.url)
+  const isDevRuntime = currentFilePath.endsWith(".ts")
+  const cliEntry = path.resolve(
+    path.dirname(currentFilePath),
+    "..",
+    "cli",
+    isDevRuntime ? "index.ts" : "index.js"
+  )
+
+  const client = new Client(
+    {
+      name: "epa-agent",
+      version: "0.1.0"
+    },
+    { capabilities: {} }
+  )
+
+  try {
+    const transport = new StdioClientTransport(
+      isDevRuntime
+        ? {
+            command: process.execPath,
+            args: ["--import", "tsx", cliEntry, "server"]
+          }
+        : {
+            command: process.execPath,
+            args: [cliEntry, "server"]
+          }
+    )
+    await client.connect(transport)
+  } catch (error) {
+    if (!isSpawnPermissionError(error)) {
+      throw error
+    }
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+    const server = await createMcpServer()
+    await server.connect(serverTransport)
+    await client.connect(clientTransport)
+    console.log("Aviso: modo in-memory ativado por restricao de spawn no ambiente.")
+  }
+
+  const toolsResponse = await client.listTools()
+  const toolNames = toolsResponse.tools.map((tool: any) => tool.name)
+  const { mcpToOpenAi, openAiToMcp } = buildToolNameMaps(toolNames)
+
+  const tools = toolsResponse.tools.map((tool: any) => ({
+    type: "function" as const,
+    function: {
+      name: mcpToOpenAi.get(tool.name) ?? tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }))
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  console.log("EPA Agent iniciado")
+
+  const messages: any[] = [
+    {
+      role: "system",
+      content: `
+Voce e um assistente que opera o sistema EPA.
+
+Sempre utilize as ferramentas disponiveis quando necessario.
+
+Fluxo recomendado para criar solicitacoes:
+
+1. consultar requests.types
+2. consultar requests.services
+3. consultar requests.priorities/requests.assignees/requests.clients
+4. executar requests.create
+
+Para listar solicitacoes por usuario e periodo, prefira requests.list com:
+- assignee_name (ex: suporte.simeon)
+- period=last_12_months para "ultimo ano"
+
+Regra para analise:
+- Se voce ja recebeu uma lista de solicitacoes no contexto atual, faca a analise diretamente desses dados.
+- Nao chame analytics.teamReport para analisar dados que ja estao no contexto.
+- So use analytics.teamReport quando o usuario pedir explicitamente para buscar analise de um usuario especifico ou da equipe (ex: "analise da equipe", "relatorio do usuario X").
+- Se analytics.teamReport nao for necessario, responda sem chamar tools.
+`
+    }
+  ]
+  const configuredMax = Number(process.env.AGENT_MAX_CONTEXT_MESSAGES)
+  const maxNonSystemMessages = Number.isFinite(configuredMax) && configuredMax > 0
+    ? configuredMax
+    : DEFAULT_MAX_NON_SYSTEM_MESSAGES
+
+  rl.on("line", async (input) => {
+
+    try {
+      messages.push({
+        role: "user",
+        content: input
+      })
+      applySlidingWindow(messages, maxNonSystemMessages)
+
+      let running = true
+
+      while (running) {
+        const completion = await openai.chat.completions.create({
+          model: "gpt-4o-mini",
+          messages,
+          tools,
+          tool_choice: "auto"
+        })
+
+        const message = completion.choices[0].message
+
+        messages.push(message)
+        applySlidingWindow(messages, maxNonSystemMessages)
+
+        if (!message.tool_calls) {
+          console.log("\n[agent]", message.content, "\n")
+          running = false
+          break
+        }
+
+        for (const toolCall of message.tool_calls) {
+          const openAiToolName = toolCall.function.name
+          const toolName = openAiToMcp.get(openAiToolName) ?? openAiToolName
+
+          let args: unknown
+          try {
+            args = JSON.parse(toolCall.function.arguments || "{}")
+          } catch (error) {
+            const errorMessage = getErrorMessage(error)
+            console.error(`\n[erro] Argumentos invalidos para ${toolName}: ${errorMessage}\n`)
+            messages.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: JSON.stringify([{ type: "text", text: `Erro: argumentos invalidos (${errorMessage})` }])
+            })
+            applySlidingWindow(messages, maxNonSystemMessages)
+            continue
+          }
+
+          console.log(`\n[tool] Executando: ${toolName}`)
+
+          try {
+            const result = await client.callTool({
+              name: toolName,
+              arguments: args as Record<string, unknown>
+            })
+
+            messages.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: JSON.stringify(result.content)
+            })
+            applySlidingWindow(messages, maxNonSystemMessages)
+          } catch (error) {
+            const errorMessage = getErrorMessage(error)
+            console.error(`\n[erro] Falha ao executar ${toolName}: ${errorMessage}\n`)
+            messages.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: JSON.stringify([{ type: "text", text: `Erro ao executar tool: ${errorMessage}` }])
+            })
+            applySlidingWindow(messages, maxNonSystemMessages)
+          }
+        }
+      }
+    } catch (error) {
+      const errorMessage = getErrorMessage(error)
+      console.error(`\n[erro] Falha no processamento da mensagem: ${errorMessage}\n`)
+    }
+
+  })
+
+}

package/src/agent/slidingWindow.ts

@@ -0,0 +1,17 @@
+export function applySlidingWindow(messages: any[], maxNonSystemMessages: number) {
+  if (!Number.isFinite(maxNonSystemMessages) || maxNonSystemMessages < 1) {
+    return
+  }
+
+  const systemMessage = messages.find((message) => message?.role === "system")
+  const nonSystemMessages = messages.filter((message) => message?.role !== "system")
+  const trimmedNonSystem = nonSystemMessages.slice(-maxNonSystemMessages)
+
+  messages.length = 0
+
+  if (systemMessage) {
+    messages.push(systemMessage)
+  }
+
+  messages.push(...trimmedNonSystem)
+}

package/src/api/epaApiClient.ts

@@ -0,0 +1,82 @@
+import axios, { AxiosInstance } from "axios"
+import { loadConfig } from "../config/loadConfig.js"
+
+export class EpaApiClient {
+
+  private client: AxiosInstance
+
+  constructor() {
+
+    const config = loadConfig()
+
+    const timeoutMs = Number(
+      config.epaApiTimeoutMs ??
+      process.env.EPA_API_TIMEOUT_MS ??
+      15000
+    )
+
+    this.client = axios.create({
+      baseURL: config.epaApiUrl,
+      timeout: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 15000,
+      headers: {
+        Authorization: `Bearer ${config.epaApiToken}`
+      }
+    })
+
+  }
+
+  async get(endpoint: string, params?: any) {
+
+    try {
+      const response = await this.client.get(endpoint, { params })
+      return response.data
+    } catch (error) {
+      throw this.formatError(error, "GET", endpoint)
+    }
+
+  }
+
+  async post(endpoint: string, body: any = {}, params?: any) {
+
+    try {
+      const response = await this.client.post(endpoint, body, { params })
+      return response.data
+    } catch (error) {
+      throw this.formatError(error, "POST", endpoint)
+    }
+  
+  }
+
+  private formatError(error: unknown, method: string, endpoint: string): Error {
+
+    if (axios.isAxiosError(error)) {
+      const status = error.response?.status
+      const apiMessage = this.extractApiMessage(error.response?.data)
+      const suffix = status ? `status ${status}` : "sem status HTTP"
+      return new Error(`[EPA API] ${method} ${endpoint} falhou (${suffix}): ${apiMessage}`)
+    }
+
+    const message = error instanceof Error ? error.message : String(error)
+    return new Error(`[EPA API] ${method} ${endpoint} falhou: ${message}`)
+
+  }
+
+  private extractApiMessage(data: unknown): string {
+
+    if (typeof data === "string" && data.trim()) {
+      return data
+    }
+
+    if (data && typeof data === "object") {
+      const maybeMessage = (data as any).message ?? (data as any).error
+      if (typeof maybeMessage === "string" && maybeMessage.trim()) {
+        return maybeMessage
+      }
+      return JSON.stringify(data)
+    }
+
+    return "erro sem detalhes retornados pela API"
+
+  }
+
+}

package/src/cli/index.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { startServer } from "../server/server.js";
+import { setupConfig } from "../config/setup.js";
+import { ensureCliAuth } from "../config/ensureCliAuth.js";
+import { startAgent } from "../agent/openaiAgent.js"
+import { runSqlCli } from "../sql/runSqlCli.js";
+import { runSqlAgentCli } from "../sql/runSqlAgentCli.js";
+
+const program = new Command();
+
+program
+  .command("setup")
+  .description("Configurar URL da API do EPA")
+  .action(async () => {
+    await setupConfig();
+  });
+
+program
+  .command("login")
+  .description("Realiza login na API do EPA e salva token para CLI")
+  .action(async () => {
+    await ensureCliAuth();
+  });
+
+program
+  .command("server")
+  .description("Iniciar MCP Server")
+  .action(async () => {
+
+    console.error("Iniciando EPA MCP Server...");
+
+    await startServer();
+
+  });
+
+program
+  .command("agent")
+  .description("Inicia agente OpenAI conectado ao MCP")
+  .action(async () => {
+
+    await startAgent()
+
+  });
+
+program
+  .command("sql [query]")
+  .description("Executa consulta SQL técnica read-only no MySQL/MariaDB")
+  .action(async (query?: string) => {
+    await runSqlCli(query)
+  });
+
+program
+  .command("sql-agent [question]")
+  .description("Usa LLM para gerar e executar SQL read-only no MySQL/MariaDB")
+  .action(async (question?: string) => {
+    await runSqlAgentCli(question)
+  });
+
+program.parse();

package/src/config/credentialStore.ts

@@ -0,0 +1,130 @@
+import fs from "fs"
+import path from "path"
+
+type ConfigJson = {
+  epaApiUrl?: string
+  epaApiToken?: string
+  epaApiTimeoutMs?: number
+  openaiApiKey?: string
+}
+
+function parseEnvFile(raw: string): Record<string, string> {
+  const result: Record<string, string> = {}
+  const lines = raw.split(/\r?\n/)
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue
+    }
+
+    const index = trimmed.indexOf("=")
+    if (index < 0) {
+      continue
+    }
+
+    const key = trimmed.slice(0, index).trim()
+    const value = trimmed.slice(index + 1).trim()
+    result[key] = value
+  }
+
+  return result
+}
+
+function stringifyEnv(values: Record<string, string>): string {
+  return Object.entries(values)
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n")
+}
+
+export function resolveCredentialStorePath(): { kind: "env" | "config"; path: string } {
+  const envPath = path.join(process.cwd(), ".env")
+  if (fs.existsSync(envPath)) {
+    return { kind: "env", path: envPath }
+  }
+
+  const configPath = path.join(process.cwd(), "config", "config.json")
+  return { kind: "config", path: configPath }
+}
+
+export function readStoredCredentials(): {
+  epaApiUrl?: string
+  epaApiToken?: string
+  openaiApiKey?: string
+  epaApiTimeoutMs?: number
+} {
+  const store = resolveCredentialStorePath()
+
+  if (store.kind === "env") {
+    const raw = fs.readFileSync(store.path, "utf-8")
+    const values = parseEnvFile(raw)
+    const timeout = Number(values.EPA_API_TIMEOUT_MS ?? values.epaApiTimeoutMs)
+
+    return {
+      epaApiUrl: values.EPA_API_URL ?? values.epaApiUrl,
+      epaApiToken: values.EPA_API_TOKEN ?? values.epaApiToken,
+      openaiApiKey: values.OPENAI_API_KEY ?? values.openaiApiKey,
+      epaApiTimeoutMs: Number.isFinite(timeout) && timeout > 0 ? timeout : undefined
+    }
+  }
+
+  if (!fs.existsSync(store.path)) {
+    return {}
+  }
+
+  const raw = fs.readFileSync(store.path, "utf-8")
+  const json = JSON.parse(raw) as ConfigJson
+  return {
+    epaApiUrl: json.epaApiUrl,
+    epaApiToken: json.epaApiToken,
+    openaiApiKey: json.openaiApiKey,
+    epaApiTimeoutMs: json.epaApiTimeoutMs
+  }
+}
+
+export function writeCredentials(values: {
+  epaApiUrl?: string
+  epaApiToken?: string
+  openaiApiKey?: string
+  epaApiTimeoutMs?: number
+}) {
+  const store = resolveCredentialStorePath()
+
+  if (store.kind === "env") {
+    const existing = fs.existsSync(store.path)
+      ? parseEnvFile(fs.readFileSync(store.path, "utf-8"))
+      : {}
+
+    if (values.epaApiUrl) {
+      existing.EPA_API_URL = values.epaApiUrl
+    }
+    if (values.epaApiToken) {
+      existing.EPA_API_TOKEN = values.epaApiToken
+    }
+    if (values.openaiApiKey) {
+      existing.OPENAI_API_KEY = values.openaiApiKey
+    }
+    if (values.epaApiTimeoutMs !== undefined) {
+      existing.EPA_API_TIMEOUT_MS = String(values.epaApiTimeoutMs)
+    }
+
+    fs.writeFileSync(store.path, `${stringifyEnv(existing)}\n`)
+    return
+  }
+
+  const configDir = path.dirname(store.path)
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir)
+  }
+
+  const current = fs.existsSync(store.path)
+    ? (JSON.parse(fs.readFileSync(store.path, "utf-8")) as ConfigJson)
+    : {}
+
+  const next: ConfigJson = {
+    ...current,
+    ...values
+  }
+
+  fs.writeFileSync(store.path, JSON.stringify(next, null, 2))
+}

package/src/config/ensureCliAuth.ts

@@ -0,0 +1,152 @@
+import axios from "axios"
+import readline from "readline"
+import { readStoredCredentials, writeCredentials } from "./credentialStore.js"
+
+function askQuestion(rl: readline.Interface, question: string): Promise<string> {
+  return new Promise((resolve) => rl.question(question, resolve))
+}
+
+function askHiddenQuestion(question: string): Promise<string> {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close()
+        resolve(answer)
+      })
+    })
+  }
+
+  return new Promise((resolve, reject) => {
+    let value = ""
+    const stdin = process.stdin
+    const stdout = process.stdout
+    const canSetRawMode = typeof stdin.setRawMode === "function"
+
+    stdout.write(question)
+    stdout.write("\x1B[8m")
+    stdin.setEncoding("utf8")
+    if (canSetRawMode) {
+      stdin.setRawMode(true)
+    }
+    stdin.resume()
+
+    const onData = (char: string) => {
+
+      if (char === "\u0003") {
+        cleanup()
+        reject(new Error("Entrada cancelada pelo usuário."))
+        return
+      }
+
+      if (char === "\r" || char === "\n") {
+        stdout.write("\n")
+        cleanup()
+        resolve(value)
+        return
+      }
+
+      if (char === "\u0008" || char === "\u007F") {
+        if (value.length > 0) {
+          value = value.slice(0, -1)
+          stdout.write("\b \b")
+        }
+        return
+      }
+
+      const sanitized = char.replace(/[\r\n]/g, "")
+      if (!sanitized) {
+        return
+      }
+
+      value += sanitized
+      stdout.write("*".repeat(sanitized.length))
+    }
+
+    const cleanup = () => {
+      stdin.off("data", onData)
+      if (canSetRawMode) {
+        stdin.setRawMode(false)
+      }
+      stdout.write("\x1B[28m")
+      stdin.pause()
+    }
+
+    stdin.on("data", onData)
+  })
+}
+
+async function isTokenValid(baseURL: string, token: string): Promise<boolean> {
+  try {
+    await axios.get(`${baseURL}/api/api/prioridade`, {
+      headers: { Authorization: `Bearer ${token}` },
+      timeout: 15000
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function loginToEpa(baseURL: string, login: string, senha: string): Promise<string> {
+  const response = await axios.post(
+    `${baseURL}/api/api/novo/login`,
+    { login, senha },
+    { timeout: 15000 }
+  )
+
+  const token = response?.data?.access_token
+  if (!token || typeof token !== "string") {
+    throw new Error("Login realizado, mas access_token nao foi retornado pela API.")
+  }
+
+  return token
+}
+
+export async function ensureCliAuth() {
+  const stored = readStoredCredentials()
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  try {
+    let epaApiUrl = process.env.EPA_API_URL || process.env.epaApiUrl || stored.epaApiUrl
+    let epaApiToken = process.env.EPA_API_TOKEN || process.env.epaApiToken || stored.epaApiToken
+    const openaiApiKey = process.env.OPENAI_API_KEY || process.env.openaiApiKey || stored.openaiApiKey
+    const epaApiTimeoutMs = stored.epaApiTimeoutMs ?? 15000
+
+    if (!epaApiUrl) {
+      epaApiUrl = (await askQuestion(rl, "EPA API URL: ")).trim()
+    }
+
+    let tokenValid = false
+    if (epaApiUrl && epaApiToken) {
+      tokenValid = await isTokenValid(epaApiUrl, epaApiToken)
+    }
+
+    if (!epaApiToken || !tokenValid) {
+      console.log("Token EPA ausente ou invalido. Realizando login...")
+      const login = (await askQuestion(rl, "Login EPA: ")).trim()
+      rl.pause()
+      const senha = (await askHiddenQuestion("Senha EPA: ")).trim()
+      rl.resume()
+      epaApiToken = await loginToEpa(epaApiUrl, login, senha)
+      console.log("Login realizado com sucesso.")
+    }
+
+    let nextOpenAi = openaiApiKey
+    if (!nextOpenAi) {
+      nextOpenAi = (await askQuestion(rl, "OpenAI API KEY (CLI): ")).trim()
+    }
+
+    writeCredentials({
+      epaApiUrl,
+      epaApiToken,
+      openaiApiKey: nextOpenAi || undefined,
+      epaApiTimeoutMs
+    })
+  } finally {
+    rl.close()
+  }
+}

package/src/config/loadConfig.ts

@@ -0,0 +1,62 @@
+import fs from "fs"
+import path from "path"
+import dotenv from "dotenv"
+
+dotenv.config()
+
+export interface AppConfig {
+  epaApiUrl: string
+  epaApiToken: string
+  openaiApiKey?: string
+  epaApiTimeoutMs?: number
+}
+
+function readConfigFile(): Partial<AppConfig> {
+  const configPath = path.join(process.cwd(), "config", "config.json")
+
+  if (!fs.existsSync(configPath)) {
+    return {}
+  }
+
+  const raw = fs.readFileSync(configPath, "utf-8")
+  return JSON.parse(raw) as Partial<AppConfig>
+}
+
+function getEnvValue(...keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = process.env[key]
+    if (value && value.trim()) {
+      return value.trim()
+    }
+  }
+
+  return undefined
+}
+
+export function loadConfig(): AppConfig {
+  const fileConfig = readConfigFile()
+
+  const epaApiUrl = getEnvValue("EPA_API_URL", "epaApiUrl") ?? fileConfig.epaApiUrl
+  const epaApiToken = getEnvValue("EPA_API_TOKEN", "epaApiToken") ?? fileConfig.epaApiToken
+  const openaiApiKey = getEnvValue("OPENAI_API_KEY", "openaiApiKey") ?? fileConfig.openaiApiKey
+
+  const timeoutRaw =
+    getEnvValue("EPA_API_TIMEOUT_MS", "epaApiTimeoutMs") ??
+    (fileConfig.epaApiTimeoutMs !== undefined ? String(fileConfig.epaApiTimeoutMs) : undefined)
+
+  const timeout = timeoutRaw ? Number(timeoutRaw) : undefined
+  const epaApiTimeoutMs = Number.isFinite(timeout) && Number(timeout) > 0 ? Number(timeout) : undefined
+
+  if (!epaApiUrl || !epaApiToken) {
+    throw new Error(
+      'Configuracao incompleta. Defina "EPA_API_URL" e "EPA_API_TOKEN" nas variaveis de ambiente ou em config/config.json.'
+    )
+  }
+
+  return {
+    epaApiUrl,
+    epaApiToken,
+    openaiApiKey,
+    epaApiTimeoutMs
+  }
+}