banco-sync-cli 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,79 @@
+# banco-sync-cli
+
+`banco-sync-cli` é um utilitário CLI em Node.js projetado para manter seus arquivos locais de migração/criação SQL em perfeita sincronia com o estado atual de um banco de dados PostgreSQL. Ele utiliza a API do Gemini (`gemini-2.5-flash`) para analisar as diferenças de estrutura e atualizar os arquivos em tempo real, exibindo um diff colorido no terminal (no estilo `git diff`) antes de salvar as alterações.
+
+---
+
+## Recursos
+
+- **Suporte Exclusivo a PostgreSQL**: Coleta metadados de tabelas, colunas, tipos de dados, nulidade, chaves primárias e valores padrões.
+- **Integração com Gemini API**: Usa o modelo `gemini-2.5-flash` com saídas em JSON estruturado para garantir modificações de esquema precisas, preservando comentários, formatação e estilo dos arquivos originais.
+- **Diff Visual Colorida**: Exibe modificações em verde (adições) e vermelho (remoções) com trechos de contexto antes de aplicar as mudanças.
+- **Armazenamento Seguro**: Armazena as credenciais e chaves de API na pasta Home do usuário (`~/.banco-sync-cli/config.json`) indexadas pelo caminho absoluto do projeto, prevenindo vazamentos acidentais em repositórios Git.
+
+---
+
+## Instalação e Execução
+
+Como a ferramenta foi estruturada para ser executada via `npx`, você pode executá-la diretamente no diretório do projeto:
+
+```bash
+# Executar a CLI a partir do diretório raiz
+npx . <comando>
+```
+
+---
+
+## Comandos
+
+### 1. `login`
+
+Configura ou atualiza as credenciais do banco de dados PostgreSQL, a chave de API do Gemini e a pasta de migrações SQL.
+
+Você pode executar o login de forma **interativa** (respondendo às perguntas na tela):
+
+```bash
+npx . login
+```
+
+Ou de forma **não-interativa** passando parâmetros por linha de comando. Se todos os parâmetros obrigatórios forem fornecidos, os prompts interativos serão ignorados:
+
+```bash
+npx . login \
+  --host "meu-ip-ou-host" \
+  --port 5432 \
+  --user "meu_usuario" \
+  --password "minha_senha" \
+  --database "meu_banco" \
+  --schema "public" \
+  --gemini-api-key "MINHA_API_KEY_DO_GEMINI" \
+  --sql-folder "caminho/da/pasta/migrations"
+```
+
+#### Opções do Comando `login`:
+- `--host <host>`: IP ou Host de conexão do PostgreSQL.
+- `--port <port>`: Porta de conexão (Padrão: `5432`).
+- `--user <user>`: Usuário do banco (Padrão: `postgres`).
+- `--password <password>`: Senha de acesso ao banco.
+- `--database <database>`: Nome do banco de dados PostgreSQL.
+- `--schema <schema>`: Schema do banco a ser lido (Padrão: `public`).
+- `--ssl`: Adiciona esta flag caso a conexão precise de criptografia SSL (desabilitada por padrão).
+- `--gemini-api-key <key>`: Chave de acesso à API do Gemini.
+- `--sql-folder <folder>`: Caminho relativo ou absoluto da pasta que contém seus arquivos `.sql`.
+
+---
+
+### 2. `sync`
+
+Conecta-se ao banco de dados configurado, extrai a estrutura do banco e compara os arquivos SQL definidos.
+
+```bash
+npx . sync
+```
+
+#### Fluxo do Comando `sync`:
+1. **Seleção de arquivos:** Pergunta se você deseja sincronizar **todos** os arquivos da pasta configurada ou apenas um **específico**.
+2. **Coleta de Esquema:** Conecta ao PostgreSQL e lê a estrutura atual.
+3. **Análise do Gemini:** Compara o arquivo `.sql` com o esquema do banco de dados. O Gemini analisa e atualiza o conteúdo do arquivo mantendo apenas a sintaxe que já existia (por exemplo, adicionando uma nova coluna a uma tabela existente).
+4. **Exibição do Diff:** Mostra um preview visual no terminal das alterações propostas (linhas adicionadas e removidas).
+5. **Confirmação:** Solicita sua autorização final (`Y/n`) para escrever as atualizações diretamente no arquivo local.

package/bin/index.js

@@ -16,137 +16,189 @@ const program = new Command();
 
 program
   .name('banco-sync-cli')
-  .description('CLI tool to sync SQL files with database schemas using Gemini API')
-  .version('1.0.0');
+  .description('Ferramenta CLI para sincronizar arquivos SQL com a estrutura do banco usando a API do Gemini')
+  .version('1.0.0', '-V, --version', 'Exibe a versão atual')
+  .helpOption('-h, --help', 'Exibe a ajuda do comando')
+  .addHelpCommand('help [comando]', 'Exibe a ajuda do comando');
 
 // Login Command
 program
   .command('login')
-  .description('Configure database credentials, Gemini API key, and SQL folder')
-  .action(async () => {
-    console.log(chalk.bold.cyan('\n--- Configure banco-sync-cli ---\n'));
+  .description('Configura as credenciais do banco PostgreSQL, a chave de API do Gemini e a pasta de arquivos SQL')
+  .option('--host <host>', 'Host/IP do banco de dados')
+  .option('--port <port>', 'Porta do banco de dados')
+  .option('--user <user>', 'Usuário do banco de dados')
+  .option('--password <password>', 'Senha do banco de dados')
+  .option('--database <database>', 'Nome do banco de dados')
+  .option('--schema <schema>', 'Schema do banco de dados (padrão: public)')
+  .option('--ssl', 'Habilitar conexão SSL (rejectUnauthorized=false)')
+  .option('--gemini-api-key <key>', 'Chave de API do Gemini')
+  .option('--sql-folder <folder>', 'Caminho da pasta com os arquivos SQL')
+  .action(async (options) => {
+    console.log(chalk.bold.cyan('\n--- Configurar banco-sync-cli (PostgreSQL) ---\n'));
 
     const currentConfig = getConfig() || {};
     const currentDb = currentConfig.dbConfig || {};
 
-    try {
-      const answers = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'dbType',
-          message: 'Select database type:',
-          choices: ['postgres', 'mysql'],
-          default: currentConfig.dbType || 'postgres'
-        },
-        {
-          type: 'input',
-          name: 'host',
-          message: 'Database host:',
-          default: answers => {
-            return currentDb.host || 'localhost';
-          }
-        },
-        {
-          type: 'input',
-          name: 'port',
-          message: 'Database port:',
-          default: (answers) => {
-            if (currentDb.port) return currentDb.port.toString();
-            return answers.dbType === 'postgres' ? '5432' : '3306';
-          }
-        },
-        {
-          type: 'input',
-          name: 'user',
-          message: 'Database user:',
-          default: (answers) => {
-            if (currentDb.user) return currentDb.user;
-            return answers.dbType === 'postgres' ? 'postgres' : 'root';
-          }
-        },
-        {
-          type: 'password',
-          name: 'password',
-          message: 'Database password:',
-          mask: '*',
-          default: currentDb.password || ''
-        },
-        {
-          type: 'input',
-          name: 'database',
-          message: 'Database name:',
-          default: currentDb.database || '',
-          validate: input => input.trim() !== '' ? true : 'Database name is required'
-        },
-        {
-          type: 'confirm',
-          name: 'ssl',
-          message: 'Enable SSL (rejectUnauthorized=false)?',
-          default: currentDb.ssl || false,
-          when: (answers) => answers.dbType === 'postgres'
-        },
-        {
-          type: 'password',
-          name: 'geminiApiKey',
-          message: 'Gemini API Key:',
-          mask: '*',
-          default: currentConfig.geminiApiKey || '',
-          validate: input => input.trim() !== '' ? true : 'Gemini API Key is required'
-        },
-        {
-          type: 'input',
-          name: 'sqlFolder',
-          message: 'Path to the folder with SQL files:',
-          default: currentConfig.sqlFolder || './',
-          validate: input => {
-            const resolved = path.resolve(process.cwd(), input);
-            if (!fs.existsSync(resolved)) {
-              return `Directory does not exist: ${resolved}`;
-            }
-            if (!fs.statSync(resolved).isDirectory()) {
-              return `Path is not a directory: ${resolved}`;
-            }
-            return true;
-          }
-        }
-      ]);
+    const host = options.host || currentDb.host;
+    const port = options.port || currentDb.port;
+    const user = options.user || currentDb.user;
+    const password = options.password || currentDb.password;
+    const database = options.database || currentDb.database;
+    const schema = options.schema || currentDb.schema;
+    const ssl = options.ssl !== undefined ? options.ssl : currentDb.ssl;
+    const geminiApiKey = options.geminiApiKey || currentConfig.geminiApiKey;
+    const sqlFolder = options.sqlFolder || currentConfig.sqlFolder;
+
+    const hasRequiredOptions = 
+      host &&
+      port &&
+      user &&
+      password !== undefined &&
+      database &&
+      geminiApiKey &&
+      sqlFolder;
 
-      const projectConfig = {
-        dbType: answers.dbType,
+    let projectConfig;
+
+    if (hasRequiredOptions) {
+      console.log(chalk.gray('Configuração fornecida via opções de linha de comando. Ignorando prompts interativos.'));
+      const resolved = path.resolve(process.cwd(), sqlFolder);
+      if (!fs.existsSync(resolved)) {
+        console.error(chalk.red(`\nO diretório não existe: ${resolved}`));
+        process.exit(1);
+      }
+
+      projectConfig = {
+        dbType: 'postgres',
         dbConfig: {
-          host: answers.host,
-          port: parseInt(answers.port, 10),
-          user: answers.user,
-          password: answers.password,
-          database: answers.database,
-          ssl: answers.ssl || false
+          host,
+          port: parseInt(port, 10),
+          user,
+          password,
+          database,
+          schema: schema || 'public',
+          ssl: !!ssl
         },
-        geminiApiKey: answers.geminiApiKey,
-        sqlFolder: answers.sqlFolder
+        geminiApiKey,
+        sqlFolder
       };
+    } else {
+      try {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'host',
+            message: 'Host do banco de dados:',
+            default: () => host || 'localhost'
+          },
+          {
+            type: 'input',
+            name: 'port',
+            message: 'Porta do banco de dados:',
+            default: () => port?.toString() || '5432'
+          },
+          {
+            type: 'input',
+            name: 'user',
+            message: 'Usuário do banco de dados:',
+            default: () => user || 'postgres'
+          },
+          {
+            type: 'password',
+            name: 'password',
+            message: 'Senha do banco de dados:',
+            mask: '*',
+            default: password || ''
+          },
+          {
+            type: 'input',
+            name: 'database',
+            message: 'Nome do banco de dados:',
+            default: database || '',
+            validate: input => input.trim() !== '' ? true : 'O nome do banco de dados é obrigatório'
+          },
+          {
+            type: 'input',
+            name: 'schema',
+            message: 'Schema do banco de dados:',
+            default: schema || 'public'
+          },
+          {
+            type: 'confirm',
+            name: 'ssl',
+            message: 'Habilitar SSL (rejectUnauthorized=false)?',
+            default: ssl || false
+          },
+          {
+            type: 'password',
+            name: 'geminiApiKey',
+            message: 'Chave de API do Gemini:',
+            mask: '*',
+            default: geminiApiKey || '',
+            validate: input => input.trim() !== '' ? true : 'A chave de API do Gemini é obrigatória'
+          },
+          {
+            type: 'input',
+            name: 'sqlFolder',
+            message: 'Caminho da pasta com os arquivos SQL:',
+            default: sqlFolder || './',
+            validate: input => {
+              const resolved = path.resolve(process.cwd(), input);
+              if (!fs.existsSync(resolved)) {
+                return `O diretório não existe: ${resolved}`;
+              }
+              if (!fs.statSync(resolved).isDirectory()) {
+                return `O caminho não é um diretório: ${resolved}`;
+              }
+              return true;
+            }
+          }
+        ]);
+
+        projectConfig = {
+          dbType: 'postgres',
+          dbConfig: {
+            host: answers.host,
+            port: parseInt(answers.port, 10),
+            user: answers.user,
+            password: answers.password,
+            database: answers.database,
+            schema: answers.schema || 'public',
+            ssl: answers.ssl || false
+          },
+          geminiApiKey: answers.geminiApiKey,
+          sqlFolder: answers.sqlFolder
+        };
+      } catch (error) {
+        console.error(chalk.red('\nFalha nos prompts de configuração:'), error.message);
+        return;
+      }
+    }
 
+    try {
       saveConfig(projectConfig);
-      console.log(chalk.bold.green('\nConfiguration saved successfully!\n'));
+      console.log(chalk.bold.green('\nConfiguração salva com sucesso!\n'));
     } catch (error) {
-      console.error(chalk.red('\nConfiguration failed:'), error.message);
+      console.error(chalk.red('\nFalha ao salvar a configuração:'), error.message);
     }
   });
 
 // Sync Command
 program
   .command('sync')
-  .description('Sync SQL file(s) with the current database schema')
+  .description('Sincroniza arquivo(s) SQL com a estrutura atual do banco de dados')
   .action(async () => {
     const config = getConfig();
     if (!config) {
-      console.log(chalk.bold.red('\nNo configuration found for this folder.'));
-      console.log(`Please run the login command first:\n  ${chalk.cyan('npx banco-sync-cli login')}\n`);
+      console.log(chalk.bold.red('\nNenhuma configuração encontrada para esta pasta.'));
+      console.log(`Por favor, execute o comando de login primeiro:\n  ${chalk.cyan('npx banco-sync-cli login')}\n`);
       process.exit(1);
     }
 
     const absoluteSqlFolder = path.resolve(process.cwd(), config.sqlFolder);
     if (!fs.existsSync(absoluteSqlFolder)) {
-      console.error(chalk.red(`\nSQL folder not found at: ${absoluteSqlFolder}`));
+      console.error(chalk.red(`\nPasta de arquivos SQL não encontrada em: ${absoluteSqlFolder}`));
       process.exit(1);
     }
 
@@ -156,12 +208,12 @@ program
       sqlFiles = fs.readdirSync(absoluteSqlFolder)
         .filter(file => file.toLowerCase().endsWith('.sql'));
     } catch (err) {
-      console.error(chalk.red(`\nError reading directory: ${err.message}`));
+      console.error(chalk.red(`\nErro ao ler o diretório: ${err.message}`));
       process.exit(1);
     }
 
     if (sqlFiles.length === 0) {
-      console.log(chalk.yellow(`\nNo .sql files found in directory: ${absoluteSqlFolder}\n`));
+      console.log(chalk.yellow(`\nNenhum arquivo .sql encontrado na pasta: ${absoluteSqlFolder}\n`));
       process.exit(0);
     }
 
@@ -171,10 +223,10 @@ program
         {
           type: 'list',
           name: 'syncScope',
-          message: 'What would you like to sync?',
+          message: 'O que você deseja sincronizar?',
           choices: [
-            { name: 'All SQL files in the folder', value: 'all' },
-            { name: 'Select a specific SQL file', value: 'single' }
+            { name: 'Todos os arquivos SQL da pasta', value: 'all' },
+            { name: 'Selecionar um arquivo SQL específico', value: 'single' }
           ]
         }
       ]);
@@ -187,7 +239,7 @@ program
           {
             type: 'list',
             name: 'selectedFile',
-            message: 'Select the SQL file to sync:',
+            message: 'Selecione o arquivo SQL para sincronizar:',
             choices: sqlFiles
           }
         ]);
@@ -195,13 +247,13 @@ program
       }
 
       // 2. Connect to database and fetch schema
-      const dbSpinner = ora('Connecting to database and fetching schema...').start();
+      const dbSpinner = ora('Conectando ao banco de dados e obtendo estrutura...').start();
       let schema;
       try {
         schema = await fetchSchema(config.dbType, config.dbConfig);
-        dbSpinner.succeed('Database schema fetched successfully!');
+        dbSpinner.succeed('Estrutura do banco de dados obtida com sucesso!');
       } catch (err) {
-        dbSpinner.fail(`Failed to fetch database schema: ${err.message}`);
+        dbSpinner.fail(`Falha ao obter estrutura do banco de dados: ${err.message}`);
         process.exit(1);
       }
 
@@ -210,7 +262,7 @@ program
         const filePath = path.join(absoluteSqlFolder, fileName);
         const originalContent = fs.readFileSync(filePath, 'utf-8');
 
-        const geminiSpinner = ora(`Analyzing and comparing ${chalk.bold(fileName)} with Gemini...`).start();
+        const geminiSpinner = ora(`Analisando e comparando ${chalk.bold(fileName)} com o Gemini...`).start();
         
         try {
           const result = await syncSqlWithGemini(
@@ -220,7 +272,7 @@ program
             fileName
           );
 
-          geminiSpinner.succeed(`Analysis completed for ${fileName}`);
+          geminiSpinner.succeed(`Análise concluída para ${fileName}`);
 
           const { updatedSql, changes } = result;
 
@@ -232,7 +284,7 @@ program
           }
 
           // Print changes summary
-          console.log(chalk.bold('Summary of proposed changes:'));
+          console.log(chalk.bold('Resumo das alterações propostas:'));
           changes.forEach(change => console.log(` - ${change}`));
           console.log();
 
@@ -241,28 +293,28 @@ program
             {
               type: 'confirm',
               name: 'confirmSave',
-              message: `Do you want to apply these changes to ${chalk.cyan(fileName)}?`,
+              message: `Deseja aplicar estas alterações no arquivo ${chalk.cyan(fileName)}?`,
               default: true
             }
           ]);
 
           if (confirmSave) {
             fs.writeFileSync(filePath, updatedSql, 'utf-8');
-            console.log(chalk.green(`\nSaved updates to ${fileName} successfully!\n`));
+            console.log(chalk.green(`\nAlterações salvas com sucesso em ${fileName}!\n`));
           } else {
-            console.log(chalk.yellow(`\nSkipped updates for ${fileName}.\n`));
+            console.log(chalk.yellow(`\nAlterações ignoradas para ${fileName}.\n`));
           }
 
         } catch (err) {
-          geminiSpinner.fail(`Failed to sync ${fileName}: ${err.message}`);
+          geminiSpinner.fail(`Falha ao sincronizar ${fileName}: ${err.message}`);
           console.error(err);
         }
       }
 
-      console.log(chalk.bold.green('Sync process finished!\n'));
+      console.log(chalk.bold.green('Processo de sincronização concluído!\n'));
 
     } catch (err) {
-      console.error(chalk.red('\nSync command failed:'), err.message);
+      console.error(chalk.red('\nO comando de sincronização falhou:'), err.message);
     }
   });
 

package/lib/config.js

@@ -24,7 +24,7 @@ function loadStore() {
     const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
     return JSON.parse(data);
   } catch (error) {
-    console.error('Error reading configuration file:', error.message);
+    console.error('Erro ao ler o arquivo de configuração:', error.message);
     return {};
   }
 }
@@ -38,7 +38,7 @@ function saveStore(store) {
   try {
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(store, null, 2), 'utf-8');
   } catch (error) {
-    console.error('Error writing configuration file:', error.message);
+    console.error('Erro ao gravar o arquivo de configuração:', error.message);
   }
 }
 

package/lib/db.js

@@ -13,7 +13,7 @@ export async function fetchSchema(dbType, config) {
   } else if (dbType === 'mysql') {
     return fetchMysqlSchema(config);
   } else {
-    throw new Error(`Unsupported database type: ${dbType}`);
+    throw new Error(`Tipo de banco de dados não suportado: ${dbType}`);
   }
 }
 
@@ -46,11 +46,11 @@ async function fetchPostgresSchema(config) {
       FROM 
         information_schema.columns 
       WHERE 
-        table_schema = 'public'
+        table_schema = $1
       ORDER BY 
         table_name, ordinal_position;
     `;
-    const colsResult = await client.query(columnsQuery);
+    const colsResult = await client.query(columnsQuery, [config.schema || 'public']);
 
     // 2. Get primary keys
     const pkQuery = `
@@ -63,10 +63,10 @@ async function fetchPostgresSchema(config) {
           ON tc.constraint_name = kcu.constraint_name
           AND tc.table_schema = kcu.table_schema
       WHERE 
-        tc.table_schema = 'public' 
+        tc.table_schema = $1 
         AND tc.constraint_type = 'PRIMARY KEY';
     `;
-    const pkResult = await client.query(pkQuery);
+    const pkResult = await client.query(pkQuery, [config.schema || 'public']);
 
     // Create a set of primary keys for lookup "tableName.columnName"
     const primaryKeys = new Set(

package/lib/diff.js

@@ -12,11 +12,11 @@ export function printDiff(filename, oldStr, newStr) {
   const patch = structuredPatch(filename, filename, oldStr, newStr, '', '', { context: 3 });
   
   if (patch.hunks.length === 0) {
-    console.log(chalk.gray(`No changes detected for ${filename}.`));
+    console.log(chalk.gray(`Nenhuma alteração detectada para ${filename}.`));
     return false;
   }
 
-  console.log(chalk.bold(`\nDiff for ${chalk.cyan(filename)}:`));
+  console.log(chalk.bold(`\nDiff para ${chalk.cyan(filename)}:`));
   console.log(chalk.gray('--------------------------------------------------'));
   
   for (const hunk of patch.hunks) {

package/lib/gemini.js

@@ -13,36 +13,36 @@ import { GoogleGenerativeAI } from '@google/generative-ai';
 export async function syncSqlWithGemini(apiKey, dbSchema, sqlContent, fileName) {
   const genAI = new GoogleGenerativeAI(apiKey);
   
-  // Using gemini-1.5-flash as it is fast, highly accurate, and supports structured JSON outputs
   const model = genAI.getGenerativeModel({
-    model: 'gemini-1.5-flash',
-    systemInstruction: `You are an expert SQL engineer. Your task is to compare a provided SQL file containing database table definitions (such as schema setups, migrations, or DDL scripts) against the actual database schema (provided as a JSON representation of current tables, columns, types, defaults, and constraints).
+    model: 'gemini-2.5-flash',
+    systemInstruction: `Você é um engenheiro de SQL especialista. Sua tarefa é comparar um arquivo SQL fornecido contendo definições de tabelas de banco de dados (como configurações de esquema, migrações ou scripts DDL) com o esquema real do banco de dados (fornecido como uma representação JSON de tabelas, colunas, tipos, valores padrão e restrições atuais).
 
-You must modify the SQL file so that the definitions of any tables, columns, and properties in the file match the actual state of the database. 
+Você deve modificar o arquivo SQL para que as definições de quaisquer tabelas, colunas e propriedades no arquivo correspondam ao estado real do banco de dados.
 
-Rules:
-1. ONLY modify structures (tables, columns, data types, constraints, defaults) that are already defined or referenced in the SQL file. Do not add completely new tables to the file that are not already present there, unless the SQL file is completely empty.
-2. If a table defined in the SQL file has columns in the actual database schema that are missing in the SQL file, add those columns to the table definition in the SQL file.
-3. If a column in the SQL file has a different data type, nullability, or default value than the database schema, update it to match the database schema.
-4. Keep the original style, syntax, capitalization, formatting, comments, and structure of the SQL file as much as possible. Only change the column definitions or constraints that need updating.
-5. Return the full updated SQL code in the JSON response under 'updatedSql'.
-6. Do not include markdown code block formatting (like \`\`\`sql) inside the JSON string return values. Return raw text.`
+Regras:
+1. Modifique APENAS as estruturas (tabelas, colunas, tipos de dados, restrições, valores padrão) que já estão definidas ou referenciadas no arquivo SQL. Não adicione tabelas completamente novas ao arquivo que já não estejam presentes lá, a menos que o arquivo SQL esteja completamente vazio.
+2. Se uma tabela definida no arquivo SQL possuir colunas no esquema real do banco de dados que estão ausentes no arquivo SQL, adicione essas colunas à definição da tabela no arquivo SQL.
+3. Se uma coluna no arquivo SQL tiver um tipo de dados, nulidade ou valor padrão diferente do esquema do banco de dados, atualize-a para corresponder ao esquema do banco de dados.
+4. Mantenha o estilo original, sintaxe, capitalização, formatação, comentários e estrutura do arquivo SQL o máximo possível. Altere apenas as definições de coluna ou restrições que precisam de atualização.
+5. Retorne o código SQL atualizado completo na resposta JSON sob a chave 'updatedSql'.
+6. Não inclua formatação de bloco de código markdown (como \`\`\`sql) dentro dos valores de string retornados no JSON. Retorne texto puro.
+7. O resumo das alterações ('changes') DEVE ser gerado em português do Brasil.`
   });
 
   const prompt = `
-SQL File Name: ${fileName}
+Nome do Arquivo SQL: ${fileName}
 
-Current SQL File Content:
+Conteúdo Atual do Arquivo SQL:
 ---
 ${sqlContent}
 ---
 
-Actual Database Schema (JSON):
+Esquema Real do Banco de Dados (JSON):
 ---
 ${JSON.stringify(dbSchema, null, 2)}
 ---
 
-Compare the SQL file content with the actual database schema. Generate the updated SQL file contents to align it with the database schema, and list the changes made.
+Compare o conteúdo do arquivo SQL com o esquema real do banco de dados. Gere o conteúdo atualizado do arquivo SQL para alinhá-lo com o esquema do banco de dados e liste as alterações feitas.
 `;
 
   const generationConfig = {
@@ -52,14 +52,14 @@ Compare the SQL file content with the actual database schema. Generate the updat
       properties: {
         updatedSql: {
           type: 'string',
-          description: 'The complete, updated SQL file content with all style and formatting preserved but with structural adjustments to match the database schema.'
+          description: 'O conteúdo do arquivo SQL atualizado completo, mantendo todo o estilo e formatação originais, mas com os ajustes estruturais para corresponder ao esquema do banco de dados.'
         },
         changes: {
           type: 'array',
           items: {
             type: 'string'
           },
-          description: 'A list of short sentences describing the modifications made (e.g., "Added age column to users table", "Changed email column type to varchar(255)").'
+          description: 'Uma lista de frases curtas em português descrevendo as modificações realizadas (ex: "Adicionada coluna idade à tabela usuarios", "Alterado tipo da coluna email para varchar(255)").'
         }
       },
       required: ['updatedSql', 'changes']
@@ -77,6 +77,6 @@ Compare the SQL file content with the actual database schema. Generate the updat
     
     return JSON.parse(responseText);
   } catch (error) {
-    throw new Error(`Gemini API call failed: ${error.message}`);
+    throw new Error(`Falha na chamada da API do Gemini: ${error.message}`);
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "banco-sync-cli",
-  "version": "1.0.0",
-  "description": "CLI tool to sync SQL files with database schemas using Gemini API",
+  "version": "1.0.1",
+  "description": "Ferramenta CLI para sincronizar arquivos SQL com a estrutura do banco usando a API do Gemini",
   "type": "module",
   "main": "bin/index.js",
   "bin": {