banco-sync-cli 1.0.0

package/bin/index.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+
+import { getConfig, saveConfig } from '../lib/config.js';
+import { fetchSchema } from '../lib/db.js';
+import { syncSqlWithGemini } from '../lib/gemini.js';
+import { printDiff } from '../lib/diff.js';
+
+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');
+
+// 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'));
+
+    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 projectConfig = {
+        dbType: answers.dbType,
+        dbConfig: {
+          host: answers.host,
+          port: parseInt(answers.port, 10),
+          user: answers.user,
+          password: answers.password,
+          database: answers.database,
+          ssl: answers.ssl || false
+        },
+        geminiApiKey: answers.geminiApiKey,
+        sqlFolder: answers.sqlFolder
+      };
+
+      saveConfig(projectConfig);
+      console.log(chalk.bold.green('\nConfiguration saved successfully!\n'));
+    } catch (error) {
+      console.error(chalk.red('\nConfiguration failed:'), error.message);
+    }
+  });
+
+// Sync Command
+program
+  .command('sync')
+  .description('Sync SQL file(s) with the current database schema')
+  .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`);
+      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}`));
+      process.exit(1);
+    }
+
+    // Get all SQL files in the directory
+    let sqlFiles = [];
+    try {
+      sqlFiles = fs.readdirSync(absoluteSqlFolder)
+        .filter(file => file.toLowerCase().endsWith('.sql'));
+    } catch (err) {
+      console.error(chalk.red(`\nError reading directory: ${err.message}`));
+      process.exit(1);
+    }
+
+    if (sqlFiles.length === 0) {
+      console.log(chalk.yellow(`\nNo .sql files found in directory: ${absoluteSqlFolder}\n`));
+      process.exit(0);
+    }
+
+    try {
+      // 1. Ask what to sync
+      const { syncScope } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'syncScope',
+          message: 'What would you like to sync?',
+          choices: [
+            { name: 'All SQL files in the folder', value: 'all' },
+            { name: 'Select a specific SQL file', value: 'single' }
+          ]
+        }
+      ]);
+
+      let filesToSync = [];
+      if (syncScope === 'all') {
+        filesToSync = sqlFiles;
+      } else {
+        const { selectedFile } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'selectedFile',
+            message: 'Select the SQL file to sync:',
+            choices: sqlFiles
+          }
+        ]);
+        filesToSync = [selectedFile];
+      }
+
+      // 2. Connect to database and fetch schema
+      const dbSpinner = ora('Connecting to database and fetching schema...').start();
+      let schema;
+      try {
+        schema = await fetchSchema(config.dbType, config.dbConfig);
+        dbSpinner.succeed('Database schema fetched successfully!');
+      } catch (err) {
+        dbSpinner.fail(`Failed to fetch database schema: ${err.message}`);
+        process.exit(1);
+      }
+
+      // 3. Process each file
+      for (const fileName of filesToSync) {
+        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();
+        
+        try {
+          const result = await syncSqlWithGemini(
+            config.geminiApiKey,
+            schema,
+            originalContent,
+            fileName
+          );
+
+          geminiSpinner.succeed(`Analysis completed for ${fileName}`);
+
+          const { updatedSql, changes } = result;
+
+          // 4. Print visual diff
+          const hasChanges = printDiff(fileName, originalContent, updatedSql);
+
+          if (!hasChanges) {
+            continue;
+          }
+
+          // Print changes summary
+          console.log(chalk.bold('Summary of proposed changes:'));
+          changes.forEach(change => console.log(` - ${change}`));
+          console.log();
+
+          // 5. Ask to apply changes
+          const { confirmSave } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirmSave',
+              message: `Do you want to apply these changes to ${chalk.cyan(fileName)}?`,
+              default: true
+            }
+          ]);
+
+          if (confirmSave) {
+            fs.writeFileSync(filePath, updatedSql, 'utf-8');
+            console.log(chalk.green(`\nSaved updates to ${fileName} successfully!\n`));
+          } else {
+            console.log(chalk.yellow(`\nSkipped updates for ${fileName}.\n`));
+          }
+
+        } catch (err) {
+          geminiSpinner.fail(`Failed to sync ${fileName}: ${err.message}`);
+          console.error(err);
+        }
+      }
+
+      console.log(chalk.bold.green('Sync process finished!\n'));
+
+    } catch (err) {
+      console.error(chalk.red('\nSync command failed:'), err.message);
+    }
+  });
+
+program.parse(process.argv);

package/lib/config.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.banco-sync-cli');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Loads the global configuration store.
+ * @returns {Object} The complete config store.
+ */
+function loadStore() {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch (error) {
+    console.error('Error reading configuration file:', error.message);
+    return {};
+  }
+}
+
+/**
+ * Saves the global configuration store.
+ * @param {Object} store The complete config store.
+ */
+function saveStore(store) {
+  ensureConfigDir();
+  try {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(store, null, 2), 'utf-8');
+  } catch (error) {
+    console.error('Error writing configuration file:', error.message);
+  }
+}
+
+/**
+ * Loads configuration specifically for the current working directory.
+ * @returns {Object|null} The configuration for the current project, or null if it doesn't exist.
+ */
+export function getConfig() {
+  const cwd = process.cwd();
+  const store = loadStore();
+  return store[cwd] || null;
+}
+
+/**
+ * Saves or updates configuration for the current working directory.
+ * @param {Object} projectConfig The config object to save.
+ */
+export function saveConfig(projectConfig) {
+  const cwd = process.cwd();
+  const store = loadStore();
+  
+  // Merge if exists, otherwise write new
+  store[cwd] = {
+    ...(store[cwd] || {}),
+    ...projectConfig
+  };
+  
+  saveStore(store);
+}

package/lib/db.js

@@ -0,0 +1,166 @@
+import pg from 'pg';
+import mysql from 'mysql2/promise';
+
+/**
+ * Fetches the database schema and returns it in a structured JSON format.
+ * @param {string} dbType 'postgres' or 'mysql'
+ * @param {Object} config Database connection credentials
+ * @returns {Promise<Object>} Unified schema description
+ */
+export async function fetchSchema(dbType, config) {
+  if (dbType === 'postgres') {
+    return fetchPostgresSchema(config);
+  } else if (dbType === 'mysql') {
+    return fetchMysqlSchema(config);
+  } else {
+    throw new Error(`Unsupported database type: ${dbType}`);
+  }
+}
+
+/**
+ * Connects to PostgreSQL and retrieves the schema.
+ */
+async function fetchPostgresSchema(config) {
+  const client = new pg.Client({
+    host: config.host,
+    port: parseInt(config.port, 10) || 5432,
+    user: config.user,
+    password: config.password,
+    database: config.database,
+    // Add SSL support if needed, defaulting to rejectUnauthorized false for local dev/flexible environments
+    ssl: config.ssl ? { rejectUnauthorized: false } : false
+  });
+
+  try {
+    await client.connect();
+
+    // 1. Get columns and details
+    const columnsQuery = `
+      SELECT 
+        table_name, 
+        column_name, 
+        data_type, 
+        is_nullable, 
+        column_default,
+        character_maximum_length
+      FROM 
+        information_schema.columns 
+      WHERE 
+        table_schema = 'public'
+      ORDER BY 
+        table_name, ordinal_position;
+    `;
+    const colsResult = await client.query(columnsQuery);
+
+    // 2. Get primary keys
+    const pkQuery = `
+      SELECT
+        tc.table_name, 
+        kcu.column_name
+      FROM 
+        information_schema.table_constraints AS tc 
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+      WHERE 
+        tc.table_schema = 'public' 
+        AND tc.constraint_type = 'PRIMARY KEY';
+    `;
+    const pkResult = await client.query(pkQuery);
+
+    // Create a set of primary keys for lookup "tableName.columnName"
+    const primaryKeys = new Set(
+      pkResult.rows.map(row => `${row.table_name}.${row.column_name}`)
+    );
+
+    // Structure the result
+    const schema = { tables: {} };
+    for (const col of colsResult.rows) {
+      const { table_name, column_name, data_type, is_nullable, column_default, character_maximum_length } = col;
+      
+      if (!schema.tables[table_name]) {
+        schema.tables[table_name] = { columns: [] };
+      }
+
+      schema.tables[table_name].columns.push({
+        name: column_name,
+        type: data_type,
+        nullable: is_nullable,
+        default: column_default,
+        maxLength: character_maximum_length,
+        isPrimaryKey: primaryKeys.has(`${table_name}.${column_name}`)
+      });
+    }
+
+    return schema;
+  } finally {
+    await client.end().catch(() => {});
+  }
+}
+
+/**
+ * Connects to MySQL and retrieves the schema.
+ */
+async function fetchMysqlSchema(config) {
+  const connection = await mysql.createConnection({
+    host: config.host,
+    port: parseInt(config.port, 10) || 3306,
+    user: config.user,
+    password: config.password,
+    database: config.database
+  });
+
+  try {
+    const columnsQuery = `
+      SELECT 
+        table_name, 
+        column_name, 
+        data_type, 
+        is_nullable, 
+        column_default,
+        character_maximum_length,
+        column_key
+      FROM 
+        information_schema.columns 
+      WHERE 
+        table_schema = ?
+      ORDER BY 
+        table_name, ordinal_position;
+    `;
+    
+    const [rows] = await connection.execute(columnsQuery, [config.database]);
+
+    const schema = { tables: {} };
+    for (const col of rows) {
+      const { 
+        TABLE_NAME, 
+        COLUMN_NAME, 
+        DATA_TYPE, 
+        IS_NULLABLE, 
+        COLUMN_DEFAULT, 
+        CHARACTER_MAXIMUM_LENGTH, 
+        COLUMN_KEY 
+      } = col;
+
+      const tableName = TABLE_NAME;
+      const columnName = COLUMN_NAME;
+
+      if (!schema.tables[tableName]) {
+        schema.tables[tableName] = { columns: [] };
+      }
+
+      schema.tables[tableName].columns.push({
+        name: columnName,
+        type: DATA_TYPE,
+        nullable: IS_NULLABLE,
+        default: COLUMN_DEFAULT,
+        maxLength: CHARACTER_MAXIMUM_LENGTH,
+        isPrimaryKey: COLUMN_KEY === 'PRI'
+      });
+    }
+
+    return schema;
+  } finally {
+    await connection.end().catch(() => {});
+  }
+}

package/lib/diff.js

@@ -0,0 +1,38 @@
+import { structuredPatch } from 'diff';
+import chalk from 'chalk';
+
+/**
+ * Computes and prints a git-like colored diff of the modifications to the terminal.
+ * @param {string} filename Name of the file being compared
+ * @param {string} oldStr Original content of the file
+ * @param {string} newStr Updated content of the file
+ * @returns {boolean} True if differences were found and printed, false otherwise.
+ */
+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}.`));
+    return false;
+  }
+
+  console.log(chalk.bold(`\nDiff for ${chalk.cyan(filename)}:`));
+  console.log(chalk.gray('--------------------------------------------------'));
+  
+  for (const hunk of patch.hunks) {
+    console.log(
+      chalk.cyan(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`)
+    );
+    for (const line of hunk.lines) {
+      if (line.startsWith('+')) {
+        console.log(chalk.green(line));
+      } else if (line.startsWith('-')) {
+        console.log(chalk.red(line));
+      } else {
+        console.log(line);
+      }
+    }
+  }
+  console.log(chalk.gray('--------------------------------------------------\n'));
+  return true;
+}

package/lib/gemini.js

@@ -0,0 +1,82 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+/**
+ * Compares an SQL file's content against the database schema using Gemini API.
+ * Updates the SQL file content to match the database schema.
+ * 
+ * @param {string} apiKey Gemini API Key
+ * @param {Object} dbSchema The database schema object
+ * @param {string} sqlContent The current SQL file content
+ * @param {string} fileName The name/path of the SQL file for context
+ * @returns {Promise<{ updatedSql: string, changes: string[] }>} Updated SQL content and list of changes
+ */
+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).
+
+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. 
+
+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.`
+  });
+
+  const prompt = `
+SQL File Name: ${fileName}
+
+Current SQL File Content:
+---
+${sqlContent}
+---
+
+Actual Database Schema (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.
+`;
+
+  const generationConfig = {
+    responseMimeType: 'application/json',
+    responseSchema: {
+      type: 'object',
+      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.'
+        },
+        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)").'
+        }
+      },
+      required: ['updatedSql', 'changes']
+    }
+  };
+
+  try {
+    const result = await model.generateContent({
+      contents: [{ role: 'user', parts: [{ text: prompt }] }],
+      generationConfig
+    });
+
+    const response = await result.response;
+    const responseText = response.text();
+    
+    return JSON.parse(responseText);
+  } catch (error) {
+    throw new Error(`Gemini API call failed: ${error.message}`);
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "banco-sync-cli",
+  "version": "1.0.0",
+  "description": "CLI tool to sync SQL files with database schemas using Gemini API",
+  "type": "module",
+  "main": "bin/index.js",
+  "bin": {
+    "banco-sync-cli": "./bin/index.js"
+  },
+  "scripts": {
+    "start": "node bin/index.js"
+  },
+  "keywords": [
+    "cli",
+    "database",
+    "sync",
+    "gemini",
+    "sql",
+    "postgres",
+    "mysql"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@google/generative-ai": "^0.11.4",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "diff": "^5.2.0",
+    "inquirer": "^9.2.22",
+    "mysql2": "^3.9.8",
+    "ora": "^8.0.1",
+    "pg": "^8.12.0"
+  }
+}