epa-testeprojetoia 0.1.0

package/src/sql/generateSqlPlan.ts

@@ -0,0 +1,133 @@
+import OpenAI from "openai"
+import { loadSqlAgentConfig } from "./loadSqlAgentConfig.js"
+import type { SqlQuestionHints } from "./parseSqlQuestionHints.js"
+import type { SqlQueryPlan } from "./sqlPlan.js"
+
+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."
+}
+
+function extractJson(content: string) {
+  const fencedMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/i)
+  if (fencedMatch) {
+    return fencedMatch[1].trim()
+  }
+
+  return content.trim()
+}
+
+function normalizePlan(rawPlan: Partial<SqlQueryPlan>): SqlQueryPlan {
+  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: string,
+  schemaSummary: string,
+  hints: SqlQuestionHints,
+  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 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) as Partial<SqlQueryPlan>
+  return normalizePlan(parsedPlan)
+}

package/src/sql/getSqlAgentErrorMessage.ts

@@ -0,0 +1,24 @@
+export function getSqlAgentErrorMessage(error: unknown): string {
+  if (!(error instanceof Error)) {
+    return `Erro ao executar SQL Agent: ${String(error)}`
+  }
+
+  const openAiError = error as Error & {
+    status?: number
+    code?: string
+    type?: string
+  }
+
+  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/src/sql/loadSqlAgentConfig.ts

@@ -0,0 +1,33 @@
+import dotenv from "dotenv"
+import { readStoredCredentials } from "../config/credentialStore.js"
+
+dotenv.config()
+
+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 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/src/sql/loadSqlConfig.ts

@@ -0,0 +1,75 @@
+import fs from "fs"
+import path from "path"
+import dotenv from "dotenv"
+
+dotenv.config()
+
+type SqlConfigFile = {
+  sql?: {
+    host?: string
+    port?: number
+    database?: string
+    user?: string
+    password?: string
+    ssl?: boolean
+  }
+}
+
+export interface SqlConfig {
+  host: string
+  port: number
+  database: string
+  user: string
+  password: string
+  ssl: boolean
+}
+
+function readSqlConfigFile(): SqlConfigFile["sql"] {
+  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) as SqlConfigFile
+  return json.sql
+}
+
+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 loadSqlConfig(): SqlConfig {
+  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/src/sql/parseSqlQuestionHints.ts

@@ -0,0 +1,46 @@
+export type SqlQuestionHints = {
+  tableNames: string[]
+  fieldNames: string[]
+  filters: string[]
+  orderBy: string[]
+  limit?: number
+}
+
+function unique(values: string[]) {
+  return [...new Set(values)]
+}
+
+function extractMatches(question: string, pattern: RegExp, captureIndex = 1) {
+  const matches: string[] = []
+
+  for (const match of question.matchAll(pattern)) {
+    const value = match[captureIndex]?.trim()
+    if (value) {
+      matches.push(value)
+    }
+  }
+
+  return matches
+}
+
+export function parseSqlQuestionHints(question: string): SqlQuestionHints {
+  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/src/sql/runSqlAgentCli.ts

@@ -0,0 +1,204 @@
+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, type RankedTable } from "./selectRelevantTables.js"
+import { validateReadOnlySql } from "./sqlGuard.js"
+import { formatSqlPlan } from "./sqlPlan.js"
+
+function askQuestion(rl: readline.Interface, question: string): Promise<string> {
+  return new Promise((resolve) => rl.question(question, resolve))
+}
+
+function normalizeQuestion(rawQuestion?: string): string {
+  return (rawQuestion ?? "").trim()
+}
+
+async function askForTableSelection(candidateTables: RankedTable[]) {
+  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?: string) {
+  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: Awaited<ReturnType<typeof createSqlConnection>> | undefined
+
+  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/src/sql/runSqlCli.ts

@@ -0,0 +1,40 @@
+import readline from "readline"
+import { createSqlConnection } from "./createSqlConnection.js"
+import { validateReadOnlySql } from "./sqlGuard.js"
+
+function askQuestion(rl: readline.Interface, question: string): Promise<string> {
+  return new Promise((resolve) => rl.question(question, resolve))
+}
+
+function normalizeQuery(rawQuery?: string): string {
+  return (rawQuery ?? "").trim()
+}
+
+export async function runSqlCli(initialQuery?: string) {
+  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()
+  }
+}