epa-testeprojetoia 0.1.0

package/dist/tests/requestService.test.js

@@ -0,0 +1,110 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { RequestService } from "../services/requestService.js";
+import { resolveAssigneeId } from "../utils/resolveAssigneeId.js";
+class FakeApiClient {
+    getCalls = [];
+    postCalls = [];
+    getResult;
+    postResult;
+    constructor(results) {
+        this.getResult = results.getResult;
+        this.postResult = results.postResult;
+    }
+    async get(endpoint, params) {
+        this.getCalls.push({ endpoint, params });
+        return this.getResult;
+    }
+    async post(endpoint, body = {}, params) {
+        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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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/dist/tools/analytics/teamReport.draft.js

@@ -0,0 +1,16 @@
+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/dist/tools/loadTools.js

@@ -0,0 +1,40 @@
+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 = [];
+    async function scan(dir) {
+        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/dist/tools/requests/assignees.js

@@ -0,0 +1,50 @@
+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/dist/tools/requests/clients.draft.js

@@ -0,0 +1,10 @@
+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/dist/tools/requests/create.draft.js

@@ -0,0 +1,51 @@
+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/dist/tools/requests/list.js

@@ -0,0 +1,50 @@
+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/dist/tools/requests/priorities.js

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

package/dist/tools/requests/services.draft.js

@@ -0,0 +1,20 @@
+import { createTool } from "../../core/createTool.js";
+import { RequestService } from "../../services/requestService.js";
+const service = new RequestService();
+export default createTool({
+    name: "requests.services",
+    description: `
+    Lista serviços disponíveis para um tipo de solicitação.
+
+    Este endpoint depende de um tipo_id retornado
+    pela ferramenta "requests.types".
+  `,
+    schema: {
+        tipo_id: {
+            type: "number"
+        }
+    },
+    handler: async ({ tipo_id }) => {
+        return service.getServices(tipo_id);
+    }
+});

package/dist/tools/requests/types.js

@@ -0,0 +1,16 @@
+import { createTool } from "../../core/createTool.js";
+import { RequestService } from "../../services/requestService.js";
+const service = new RequestService();
+export default createTool({
+    name: "requests.types",
+    description: `
+    Lista os tipos de solicitação disponíveis no EPA.
+
+    Este é o primeiro passo para criar uma solicitação.
+    Após escolher um tipo, use o tipo_id retornado
+    para buscar os serviços usando "requests.services".
+  `,
+    handler: async () => {
+        return service.getTypes();
+    }
+});

package/dist/tools/requests/units.draft.js

@@ -0,0 +1,10 @@
+import { createTool } from "../../core/createTool.js";
+import { RequestService } from "../../services/requestService.js";
+const service = new RequestService();
+export default createTool({
+    name: "requests.units",
+    description: "Lista unidades gerenciais executoras",
+    handler: async () => {
+        return service.getUnits();
+    }
+});

package/dist/tools/requests/view.draft.js

@@ -0,0 +1,20 @@
+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.view",
+    description: "Visualiza uma solicitacao especifica",
+    schema: {
+        id: {
+            type: "number",
+            description: "ID da solicitacao"
+        }
+    },
+    validator: z.object({
+        id: z.number().int().positive()
+    }).strict(),
+    handler: async ({ id }) => {
+        return service.view(id);
+    }
+});

package/dist/utils/buildDateRange.js

@@ -0,0 +1,18 @@
+function formatDateTime(date, endOfDay = false) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = endOfDay ? "23" : String(date.getHours()).padStart(2, "0");
+    const minutes = endOfDay ? "59" : String(date.getMinutes()).padStart(2, "0");
+    const seconds = endOfDay ? "59" : String(date.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+export function buildDateRange(period = "current_year", now = new Date()) {
+    if (period === "last_12_months") {
+        const start = new Date(now);
+        start.setFullYear(now.getFullYear() - 1);
+        return `${formatDateTime(start)}to${formatDateTime(now, true)}`;
+    }
+    const year = now.getFullYear();
+    return `${year}-01-01 00:00:00to${year}-12-31 23:59:59`;
+}

package/dist/utils/findIdByDescription.js

@@ -0,0 +1,4 @@
+export function findIdByDescription(list, description) {
+    const item = list.find((i) => i.descricao.toLowerCase() === description.toLowerCase());
+    return item ? item.id : null;
+}

package/dist/utils/resolveAssigneeId.js

@@ -0,0 +1,14 @@
+export function resolveAssigneeId(assignees, assigneeName) {
+    if (!Array.isArray(assignees) || assignees.length === 0) {
+        return null;
+    }
+    const normalizedName = assigneeName.trim().toLowerCase();
+    const exact = assignees.find((item) => {
+        const text = String(item?.text ?? "").toLowerCase();
+        const login = text.split(" - ")[0]?.trim();
+        return login === normalizedName || text.startsWith(`${normalizedName} -`);
+    });
+    const selected = exact ?? assignees[0];
+    const id = Number(selected?.id);
+    return Number.isFinite(id) && id > 0 ? id : null;
+}

package/dist/utils/toolNameMaps.js

@@ -0,0 +1,23 @@
+function sanitizeToolName(name, maxLength) {
+    const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return sanitized.slice(0, maxLength);
+}
+export function buildToolNameMaps(toolNames, options = {}) {
+    const maxLength = Number.isFinite(options.maxLength) && (options.maxLength ?? 0) > 0
+        ? Number(options.maxLength)
+        : 64;
+    const internalToExternal = new Map();
+    const externalToInternal = new Map();
+    const usageCount = new Map();
+    for (const internalName of toolNames) {
+        const base = sanitizeToolName(internalName, maxLength);
+        const count = usageCount.get(base) ?? 0;
+        usageCount.set(base, count + 1);
+        const suffix = count === 0 ? "" : `_${count + 1}`;
+        const maxBaseLength = Math.max(1, maxLength - suffix.length);
+        const externalName = `${base.slice(0, maxBaseLength)}${suffix}`;
+        internalToExternal.set(internalName, externalName);
+        externalToInternal.set(externalName, internalName);
+    }
+    return { internalToExternal, externalToInternal };
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "epa-testeprojetoia",
+    "version": "0.1.0",
+    "description": "EPA MCP Server",
+    "type": "module",
+    "bin": {
+        "epa-mcp": "./dist/server/stdioServer.js",
+        "epa-mcp-cli": "./dist/cli/index.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsx src/cli/index.ts",
+        "mcp:server": "node dist/server/stdioServer.js",
+        "start": "node dist/cli/index.js",
+        "test": "npm run build && node dist/tests/requestService.test.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^0.5.0",
+        "axios": "^1.6.0",
+        "commander": "^12.0.0",
+        "dotenv": "^16.4.0",
+        "mysql2": "^3.22.3",
+        "openai": "^4.0.0",
+        "zod": "^4.3.6"
+    },
+    "devDependencies": {
+        "@types/node": "^20.0.0",
+        "tsx": "^4.7.0",
+        "typescript": "^5.4.0"
+    }
+}

package/src/agent/agentHelpers.ts

@@ -0,0 +1,25 @@
+import { buildToolNameMaps as buildBaseToolNameMaps } from "../utils/toolNameMaps.js"
+
+export function buildToolNameMaps(toolNames: string[]) {
+  const { internalToExternal, externalToInternal } = buildBaseToolNameMaps(toolNames)
+  return {
+    mcpToOpenAi: internalToExternal,
+    openAiToMcp: externalToInternal
+  }
+}
+
+export function isSpawnPermissionError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false
+  }
+
+  const maybeCode = (error as any).code
+  return maybeCode === "EPERM" && error.message.includes("spawn")
+}
+
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message
+  }
+  return String(error)
+}