epa-testeprojetoia 0.1.0

package/dist/sql/generateSqlFromQuestion.js

@@ -0,0 +1,83 @@
+import OpenAI from "openai";
+import { loadSqlAgentConfig } from "./loadSqlAgentConfig.js";
+function extractSql(content) {
+    const fencedMatch = content.match(/```(?:sql)?\s*([\s\S]*?)```/i);
+    if (fencedMatch) {
+        return fencedMatch[1].trim();
+    }
+    return content.trim();
+}
+function buildHintsSummary(hints) {
+    const lines = [];
+    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, schemaSummary, hints, plan, additionalGuidance) {
+    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);
+}

package/dist/sql/generateSqlPlan.js

@@ -0,0 +1,111 @@
+import OpenAI from "openai";
+import { loadSqlAgentConfig } from "./loadSqlAgentConfig.js";
+function buildHintsSummary(hints) {
+    const lines = [];
+    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.";
+}
+function extractJson(content) {
+    const fencedMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fencedMatch) {
+        return fencedMatch[1].trim();
+    }
+    return content.trim();
+}
+function normalizePlan(rawPlan) {
+    return {
+        goal: String(rawPlan.goal ?? "").trim(),
+        mainTable: String(rawPlan.mainTable ?? "").trim(),
+        relatedTables: Array.isArray(rawPlan.relatedTables)
+            ? rawPlan.relatedTables.map((value) => String(value).trim()).filter(Boolean)
+            : [],
+        relationshipFields: Array.isArray(rawPlan.relationshipFields)
+            ? rawPlan.relationshipFields.map((value) => String(value).trim()).filter(Boolean)
+            : [],
+        selectedFields: Array.isArray(rawPlan.selectedFields)
+            ? rawPlan.selectedFields.map((value) => String(value).trim()).filter(Boolean)
+            : [],
+        filters: Array.isArray(rawPlan.filters)
+            ? rawPlan.filters.map((value) => String(value).trim()).filter(Boolean)
+            : [],
+        orderBy: Array.isArray(rawPlan.orderBy)
+            ? rawPlan.orderBy.map((value) => String(value).trim()).filter(Boolean)
+            : [],
+        limit: Number.isFinite(Number(rawPlan.limit)) && Number(rawPlan.limit) > 0
+            ? Number(rawPlan.limit)
+            : 10
+    };
+}
+export async function generateSqlPlan(question, schemaSummary, hints, additionalGuidance) {
+    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 monta um plano de consulta para MySQL/MariaDB antes da SQL.
+
+Regras obrigatorias:
+- responda somente com JSON valido
+- use apenas tabelas e colunas presentes no schema informado
+- respeite pistas explicitas do usuario como prioridade
+- quando o usuario indicar tabelas, campos ou relacionamento, reflita isso no plano
+- quando o usuario indicar filtros, ordenacao ou limite, reflita isso no plano
+- preencha o limite com 10 quando o pedido for listar registros sem quantidade especifica
+
+Formato do JSON:
+{
+  "goal": "string",
+  "mainTable": "string",
+  "relatedTables": ["string"],
+  "relationshipFields": ["string"],
+  "selectedFields": ["string"],
+  "filters": ["string"],
+  "orderBy": ["string"],
+  "limit": 10
+}
+`.trim()
+            },
+            {
+                role: "user",
+                content: `
+Schema disponivel:
+${schemaSummary}
+
+Pistas explicitas do usuario:
+${buildHintsSummary(hints)}
+
+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 um plano de consulta.");
+    }
+    const json = extractJson(content);
+    const parsedPlan = JSON.parse(json);
+    return normalizePlan(parsedPlan);
+}

package/dist/sql/getSqlAgentErrorMessage.js

@@ -0,0 +1,15 @@
+export function getSqlAgentErrorMessage(error) {
+    if (!(error instanceof Error)) {
+        return `Erro ao executar SQL Agent: ${String(error)}`;
+    }
+    const openAiError = error;
+    if (openAiError.status === 429 ||
+        openAiError.code === "insufficient_quota" ||
+        openAiError.type === "insufficient_quota") {
+        return [
+            "Nao foi possivel gerar a SQL porque a chave da OpenAI esta sem cota disponivel.",
+            'Verifique billing/limites da conta ou configure outra chave em "OPENAI_API_KEY" ou na CLI.'
+        ].join(" ");
+    }
+    return `Erro ao executar SQL Agent: ${error.message}`;
+}

package/dist/sql/loadSqlAgentConfig.js

@@ -0,0 +1,24 @@
+import dotenv from "dotenv";
+import { readStoredCredentials } from "../config/credentialStore.js";
+dotenv.config();
+function getEnvValue(...keys) {
+    for (const key of keys) {
+        const value = process.env[key];
+        if (value && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+export function loadSqlAgentConfig() {
+    const storedCredentials = readStoredCredentials();
+    const openaiApiKey = getEnvValue("OPENAI_API_KEY", "openaiApiKey") ??
+        storedCredentials.openaiApiKey;
+    if (!openaiApiKey) {
+        throw new Error('OpenAI API KEY nao encontrada. Defina "OPENAI_API_KEY" no ambiente ou configure a chave pela CLI.');
+    }
+    return {
+        openaiApiKey,
+        model: getEnvValue("SQL_AGENT_MODEL") ?? "gpt-4o-mini"
+    };
+}

package/dist/sql/loadSqlConfig.js

@@ -0,0 +1,43 @@
+import fs from "fs";
+import path from "path";
+import dotenv from "dotenv";
+dotenv.config();
+function readSqlConfigFile() {
+    const configPath = path.join(process.cwd(), "config", "config.json");
+    if (!fs.existsSync(configPath)) {
+        return undefined;
+    }
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const json = JSON.parse(raw);
+    return json.sql;
+}
+function getEnvValue(...keys) {
+    for (const key of keys) {
+        const value = process.env[key];
+        if (value && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+export function loadSqlConfig() {
+    const fileConfig = readSqlConfigFile();
+    const host = getEnvValue("DB_HOST", "MYSQL_HOST") ?? fileConfig?.host;
+    const database = getEnvValue("DB_NAME", "MYSQL_DATABASE") ?? fileConfig?.database;
+    const user = getEnvValue("DB_USER", "MYSQL_USER") ?? fileConfig?.user;
+    const password = getEnvValue("DB_PASSWORD", "MYSQL_PASSWORD") ?? fileConfig?.password;
+    const portRaw = getEnvValue("DB_PORT", "MYSQL_PORT") ?? String(fileConfig?.port ?? "3306");
+    const sslRaw = String(getEnvValue("DB_SSL", "MYSQL_SSL") ?? fileConfig?.ssl ?? "false").toLowerCase();
+    const port = Number(portRaw);
+    if (!host || !database || !user || !password) {
+        throw new Error('Configuracao SQL incompleta. Defina DB_HOST, DB_NAME, DB_USER e DB_PASSWORD nas variaveis de ambiente ou preencha o bloco "sql" em config/config.json.');
+    }
+    return {
+        host,
+        port: Number.isFinite(port) && port > 0 ? port : 3306,
+        database,
+        user,
+        password,
+        ssl: sslRaw === "true" || sslRaw === "1"
+    };
+}

package/dist/sql/parseSqlQuestionHints.js

@@ -0,0 +1,29 @@
+function unique(values) {
+    return [...new Set(values)];
+}
+function extractMatches(question, pattern, captureIndex = 1) {
+    const matches = [];
+    for (const match of question.matchAll(pattern)) {
+        const value = match[captureIndex]?.trim();
+        if (value) {
+            matches.push(value);
+        }
+    }
+    return matches;
+}
+export function parseSqlQuestionHints(question) {
+    const explicitTables = extractMatches(question, /tabela\s*:\s*([a-zA-Z0-9_]+)/gi);
+    const relationshipTables = extractMatches(question, /(vincular com tabela|relacionar com tabela|join com tabela)\s*:?\s*([a-zA-Z0-9_]+)/gi, 2);
+    const explicitFields = extractMatches(question, /campo\s*:\s*([a-zA-Z0-9_]+)/gi);
+    const explicitFilters = extractMatches(question, /filtro\s*:\s*([^\n\r]+)/gi);
+    const explicitOrderBy = extractMatches(question, /ordenar por\s*:\s*([^\n\r]+)/gi);
+    const explicitLimitRaw = extractMatches(question, /limite\s*:\s*(\d+)/gi);
+    const explicitLimit = explicitLimitRaw.length > 0 ? Number(explicitLimitRaw[0]) : undefined;
+    return {
+        tableNames: unique([...explicitTables, ...relationshipTables]),
+        fieldNames: unique(explicitFields),
+        filters: unique(explicitFilters),
+        orderBy: unique(explicitOrderBy),
+        limit: Number.isFinite(explicitLimit) && explicitLimit && explicitLimit > 0 ? explicitLimit : undefined
+    };
+}

package/dist/sql/runSqlAgentCli.js

@@ -0,0 +1,163 @@
+import readline from "readline";
+import { createSqlConnection } from "./createSqlConnection.js";
+import { fetchAvailableTableNames, fetchSchemaSummary } from "./fetchSchemaSummary.js";
+import { generateSqlPlan } from "./generateSqlPlan.js";
+import { generateSqlFromQuestion } from "./generateSqlFromQuestion.js";
+import { getSqlAgentErrorMessage } from "./getSqlAgentErrorMessage.js";
+import { parseSqlQuestionHints } from "./parseSqlQuestionHints.js";
+import { selectRelevantTables } from "./selectRelevantTables.js";
+import { validateReadOnlySql } from "./sqlGuard.js";
+import { formatSqlPlan } from "./sqlPlan.js";
+function askQuestion(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+function normalizeQuestion(rawQuestion) {
+    return (rawQuestion ?? "").trim();
+}
+async function askForTableSelection(candidateTables) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        console.log("Encontrei mais de uma tabela possivel para esse pedido:");
+        candidateTables.forEach((table, index) => {
+            console.log(`${index + 1}. ${table.name}`);
+        });
+        console.log("M. Informar manualmente o nome da tabela");
+        console.log("");
+        while (true) {
+            const answer = (await askQuestion(rl, "Escolha o numero da tabela correta ou M para informar manualmente: ")).trim();
+            if (answer.toLowerCase() === "m") {
+                const manualTableName = (await askQuestion(rl, "Digite o nome exato da tabela: ")).trim();
+                if (manualTableName) {
+                    return manualTableName;
+                }
+                console.log("Informe um nome de tabela valido.");
+                continue;
+            }
+            const selectedIndex = Number(answer);
+            if (Number.isInteger(selectedIndex) && selectedIndex >= 1 && selectedIndex <= candidateTables.length) {
+                return candidateTables[selectedIndex - 1].name;
+            }
+            console.log("Opcao invalida. Informe um numero da lista.");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askForPlanAction() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        console.log("");
+        console.log("1. Executar esse plano");
+        console.log("2. Corrigir o plano");
+        console.log("3. Cancelar");
+        console.log("");
+        while (true) {
+            const answer = (await askQuestion(rl, "Escolha uma opcao: ")).trim();
+            if (answer === "1" || answer === "2" || answer === "3") {
+                return answer;
+            }
+            console.log("Opcao invalida. Escolha 1, 2 ou 3.");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askForPlanCorrection() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        return normalizeQuestion(await askQuestion(rl, "Descreva a correcao do plano: "));
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runSqlAgentCli(initialQuestion) {
+    let question = normalizeQuestion(initialQuestion);
+    let additionalGuidance = "";
+    if (!question) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        try {
+            question = normalizeQuestion(await askQuestion(rl, "Pergunta para o SQL Agent: "));
+        }
+        finally {
+            rl.close();
+        }
+    }
+    let connection;
+    try {
+        if (!question) {
+            throw new Error("Informe uma pergunta para o SQL Agent.");
+        }
+        connection = await createSqlConnection();
+        const allTableNames = await fetchAvailableTableNames(connection);
+        if (allTableNames.length === 0) {
+            throw new Error("Nenhuma tabela foi encontrada no schema configurado.");
+        }
+        while (true) {
+            const composedQuestion = additionalGuidance
+                ? `${question}\nOrientacoes adicionais do usuario:\n${additionalGuidance}`
+                : question;
+            const hints = parseSqlQuestionHints(composedQuestion);
+            const tableSelection = selectRelevantTables(composedQuestion, allTableNames, 12, hints.tableNames);
+            const selectedTableNames = tableSelection.requiresConfirmation
+                ? [await askForTableSelection(tableSelection.candidateTables)]
+                : tableSelection.suggestedTables;
+            const schemaSummary = await fetchSchemaSummary(connection, selectedTableNames);
+            const plan = await generateSqlPlan(question, schemaSummary, hints, additionalGuidance);
+            console.log("");
+            console.log(formatSqlPlan(plan));
+            const action = await askForPlanAction();
+            if (action === "3") {
+                console.log("Execucao cancelada.");
+                return;
+            }
+            if (action === "2") {
+                const correction = await askForPlanCorrection();
+                if (!correction) {
+                    console.log("Nenhuma correcao informada. Mantendo plano atual.");
+                    continue;
+                }
+                additionalGuidance = additionalGuidance
+                    ? `${additionalGuidance}\n${correction}`
+                    : correction;
+                continue;
+            }
+            const generatedSql = await generateSqlFromQuestion(question, schemaSummary, hints, plan, additionalGuidance);
+            const sql = validateReadOnlySql(generatedSql);
+            const [rows] = await connection.query(sql);
+            console.log("");
+            console.log("Pergunta:");
+            console.log(question);
+            console.log("");
+            console.log("SQL gerada:");
+            console.log(sql);
+            console.log("");
+            console.log("Resultado:");
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+    }
+    catch (error) {
+        console.error(getSqlAgentErrorMessage(error));
+        process.exitCode = 1;
+    }
+    finally {
+        if (connection) {
+            await connection.end();
+        }
+    }
+}

package/dist/sql/runSqlCli.js

@@ -0,0 +1,34 @@
+import readline from "readline";
+import { createSqlConnection } from "./createSqlConnection.js";
+import { validateReadOnlySql } from "./sqlGuard.js";
+function askQuestion(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+function normalizeQuery(rawQuery) {
+    return (rawQuery ?? "").trim();
+}
+export async function runSqlCli(initialQuery) {
+    const query = normalizeQuery(initialQuery);
+    let finalQuery = query;
+    if (!finalQuery) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        try {
+            finalQuery = normalizeQuery(await askQuestion(rl, "SQL (somente SELECT): "));
+        }
+        finally {
+            rl.close();
+        }
+    }
+    validateReadOnlySql(finalQuery);
+    const connection = await createSqlConnection();
+    try {
+        const [rows] = await connection.query(finalQuery);
+        console.log(JSON.stringify(rows, null, 2));
+    }
+    finally {
+        await connection.end();
+    }
+}

package/dist/sql/selectRelevantTables.js

@@ -0,0 +1,136 @@
+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) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase();
+}
+function buildTokenVariants(token) {
+    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) {
+    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, terms) {
+    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) {
+    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, explicitTableNames) {
+    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, tableNames, maxRelevantTables = 12, explicitTableNames = []) {
+    const terms = extractRelevantTerms(question);
+    const resolvedExplicitTables = resolveExplicitTableNames(tableNames, explicitTableNames);
+    const rankedTables = 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/dist/sql/sqlGuard.js

@@ -0,0 +1,21 @@
+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) {
+    return query.trim().replace(/;\s*$/, "");
+}
+export function validateReadOnlySql(query) {
+    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/dist/sql/sqlPlan.js

@@ -0,0 +1,16 @@
+function formatList(values) {
+    return values.length > 0 ? values.join(", ") : "-";
+}
+export function formatSqlPlan(plan) {
+    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");
+}