epa-testeprojetoia 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,47 @@
+#!/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) => {
+    await runSqlCli(query);
+});
+program
+    .command("sql-agent [question]")
+    .description("Usa LLM para gerar e executar SQL read-only no MySQL/MariaDB")
+    .action(async (question) => {
+    await runSqlAgentCli(question);
+});
+program.parse();

package/dist/config/credentialStore.js

@@ -0,0 +1,92 @@
+import fs from "fs";
+import path from "path";
+function parseEnvFile(raw) {
+    const result = {};
+    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) {
+    return Object.entries(values)
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\n");
+}
+export function resolveCredentialStorePath() {
+    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() {
+    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);
+    return {
+        epaApiUrl: json.epaApiUrl,
+        epaApiToken: json.epaApiToken,
+        openaiApiKey: json.openaiApiKey,
+        epaApiTimeoutMs: json.epaApiTimeoutMs
+    };
+}
+export function writeCredentials(values) {
+    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"))
+        : {};
+    const next = {
+        ...current,
+        ...values
+    };
+    fs.writeFileSync(store.path, JSON.stringify(next, null, 2));
+}

package/dist/config/ensureCliAuth.js

@@ -0,0 +1,127 @@
+import axios from "axios";
+import readline from "readline";
+import { readStoredCredentials, writeCredentials } from "./credentialStore.js";
+function askQuestion(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+function askHiddenQuestion(question) {
+    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) => {
+            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, token) {
+    try {
+        await axios.get(`${baseURL}/api/api/prioridade`, {
+            headers: { Authorization: `Bearer ${token}` },
+            timeout: 15000
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loginToEpa(baseURL, login, senha) {
+    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/dist/config/loadConfig.js

@@ -0,0 +1,40 @@
+import fs from "fs";
+import path from "path";
+import dotenv from "dotenv";
+dotenv.config();
+function readConfigFile() {
+    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);
+}
+function getEnvValue(...keys) {
+    for (const key of keys) {
+        const value = process.env[key];
+        if (value && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+export function loadConfig() {
+    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
+    };
+}

package/dist/config/setup.js

@@ -0,0 +1,23 @@
+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) => new Promise((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/dist/core/createReferenceTool.js

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

package/dist/core/createTool.js

@@ -0,0 +1,32 @@
+export function createTool(def) {
+    return {
+        name: def.name,
+        description: def.description,
+        inputSchema: {
+            type: "object",
+            properties: def.schema || {},
+        },
+        async execute(args) {
+            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/dist/mocks/requestMocks.js

@@ -0,0 +1,47 @@
+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/dist/server/server.js

@@ -0,0 +1,41 @@
+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/dist/server/stdioServer.js

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

package/dist/services/request/requestFilters.js

@@ -0,0 +1 @@
+export {};

package/dist/services/requestService.js

@@ -0,0 +1,81 @@
+import { EpaApiClient } from "../api/epaApiClient.js";
+import { buildDateRange } from "../utils/buildDateRange.js";
+export class RequestService {
+    api;
+    constructor(apiClient) {
+        this.api = apiClient ?? new EpaApiClient();
+    }
+    async getTypes() {
+        return this.api.get("/epa_os/ajax.php", {
+            action: "get",
+            controller: "TipoSolicitacao"
+        });
+    }
+    async getServices(typeId) {
+        return this.api.get("/api/tipos_servico", {
+            tipo_id: typeId
+        });
+    }
+    async getAssignees(term, options = {}) {
+        const params = {
+            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.results)) {
+            return response.results;
+        }
+        return response;
+    }
+    async getClients() {
+        return this.api.get("/api/clientes");
+    }
+    async getUnits() {
+        return this.api.get("/api/unidades_gerenciais");
+    }
+    async list(filters = {}) {
+        const normalizedFilters = typeof filters === "number" ? { assigneeId: filters } : filters;
+        const params = {
+            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) {
+        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) => Number(item.codigo ?? item.id) === id);
+            return found ?? response[0];
+        }
+        return response;
+    }
+    async create(data) {
+        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/dist/services/teamService.js

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

package/dist/sql/createSqlConnection.js

@@ -0,0 +1,13 @@
+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/dist/sql/fetchSchemaSummary.js

@@ -0,0 +1,38 @@
+import { loadSqlConfig } from "./loadSqlConfig.js";
+const MAX_COLUMNS_PER_TABLE = 20;
+export async function fetchAvailableTableNames(connection) {
+    const sqlConfig = loadSqlConfig();
+    const [tableRows] = await connection.query(`
+      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, tableNames) {
+    const sqlConfig = loadSqlConfig();
+    const placeholders = tableNames.map(() => "?").join(", ");
+    const [columnRows] = await connection.query(`
+      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();
+    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");
+}