crushdataai 1.2.7 → 1.2.8

package/assets/antigravity/data-analyst.md

@@ -30,11 +30,15 @@ Before writing any code, ask the user:
 6. **Reports**: Save all validation/profiling outputs to `reports/` folder. Create if missing.
 
 ### 2. Secure Data Access
+
+> **Credentials are stored in `.env`** - never hardcoded.
+
 - **Check Connections**: Run `npx crushdataai connections` first.
-- **Missing Data?**: If the data source is not listed (e.g. on Desktop/Database), **INSTRUCT** the user to run:
-  `npx crushdataai connect`
-- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` to get loading code.
-- **Security**: **DO NOT** ask user to copy/move files to `data/`. Treat connected data as read-only.
+- **Missing Data?**: Run `npx crushdataai connect` to add.
+- **Discover Schema**: `npx crushdataai schema <connection> [table]`
+- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` (uses env vars).
+- **Load .env**: Ensure `python-dotenv` loads `.env`. Scripts use `os.environ["VAR"]`.
+- **Security**: Treat connected data as read-only.
 
 ---
 

package/assets/claude/SKILL.md

@@ -45,10 +45,15 @@ When user requests data analysis work (analyze, query, dashboard, metrics, EDA,
 ```
 
 ### 1b. Secure Data Access
+
+> **Credentials are stored in the project's `.env` file** - never hardcoded.
+
 - **Check Connections**: Run `npx crushdataai connections` first.
-- **Missing Data?**: If the data source is not listed (e.g. on Desktop/Database), **INSTRUCT** the user to run:
+- **Missing Data?**: If the data source is not listed, **INSTRUCT** the user to run:
   `npx crushdataai connect`
-- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` to get loading code.
+- **Discover Schema**: Use `npx crushdataai schema <connection> [table]` to see available tables and columns.
+- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` to get loading code (uses env vars).
+- **Load .env**: Scripts use `os.environ["VAR"]`. Ensure `python-dotenv` is installed and `.env` is loaded.
 - **Security**: **DO NOT** ask user to copy/move files to `data/`. Treat connected data as read-only.
 
 ### Step 2: Search Relevant Domains

package/assets/copilot/data-analyst.prompt.md

@@ -23,11 +23,15 @@ Before coding, ask:
 - **Reports**: Save all outputs to `reports/` folder (profiling, validation).
 
 ### 2. Secure Data Access
+
+> **Credentials are stored in `.env`** - never hardcoded.
+
 - **Check Connections**: Run `npx crushdataai connections` first.
-- **Missing Data?**: If the data source is not listed (e.g. on Desktop/Database), **INSTRUCT** the user to run:
-  `npx crushdataai connect`
-- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` to get loading code.
-- **Security**: **DO NOT** ask user to copy/move files to `data/`. Treat connected data as read-only.
+- **Missing Data?**: Run `npx crushdataai connect` to add.
+- **Discover Schema**: `npx crushdataai schema <connection> [table]`
+- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` (uses env vars).
+- **Load .env**: Ensure `python-dotenv` loads `.env`. Scripts use `os.environ["VAR"]`.
+- **Security**: Treat connected data as read-only.
 
 ### 3. Search Knowledge Base
 ```bash

package/assets/cursor/data-analyst.md

@@ -20,11 +20,15 @@ Before coding, ask:
 - **Reports**: Save all outputs to `reports/` folder (profiling, validation).
 
 ### 2. Secure Data Access
+
+> **Credentials are stored in `.env`** - never hardcoded.
+
 - **Check Connections**: Run `npx crushdataai connections` first.
-- **Missing Data?**: If the data source is not listed (e.g. on Desktop/Database), **INSTRUCT** the user to run:
-  `npx crushdataai connect`
-- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` to get loading code.
-- **Security**: **DO NOT** ask user to copy/move files to `data/`. Treat connected data as read-only.
+- **Missing Data?**: Run `npx crushdataai connect` to add.
+- **Discover Schema**: `npx crushdataai schema <connection> [table]`
+- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` (uses env vars).
+- **Load .env**: Ensure `python-dotenv` loads `.env`. Scripts use `os.environ["VAR"]`.
+- **Security**: Treat connected data as read-only.
 
 ### 2. Search Knowledge Base
 ```bash

package/assets/kiro/data-analyst.md

@@ -19,11 +19,15 @@ Before writing code, gather:
 - **Reports**: Save all outputs to `reports/` folder (profiling, validation).
 
 ### 2. Secure Data Access
+
+> **Credentials are stored in `.env`** - never hardcoded.
+
 - **Check Connections**: Run `npx crushdataai connections` first.
-- **Missing Data?**: If the data source is not listed (e.g. on Desktop/Database), **INSTRUCT** the user to run:
-  `npx crushdataai connect`
-- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` to get loading code.
-- **Security**: **DO NOT** ask user to copy/move files to `data/`. Treat connected data as read-only.
+- **Missing Data?**: Run `npx crushdataai connect` to add.
+- **Discover Schema**: `npx crushdataai schema <connection> [table]`
+- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` (uses env vars).
+- **Load .env**: Ensure `python-dotenv` loads `.env`. Scripts use `os.environ["VAR"]`.
+- **Security**: Treat connected data as read-only.
 
 ### 3. Search Before Implementing
 ```bash

package/assets/windsurf/data-analyst.md

@@ -17,11 +17,15 @@ Ask before coding:
 - **Reports**: Save all outputs to `reports/` folder (profiling, validation).
 
 ### 2. Secure Data Access
+
+> **Credentials are stored in `.env`** - never hardcoded.
+
 - **Check Connections**: Run `npx crushdataai connections` first.
-- **Missing Data?**: If the data source is not listed (e.g. on Desktop/Database), **INSTRUCT** the user to run:
-  `npx crushdataai connect`
-- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` to get loading code.
-- **Security**: **DO NOT** ask user to copy/move files to `data/`. Treat connected data as read-only.
+- **Missing Data?**: Run `npx crushdataai connect` to add.
+- **Discover Schema**: `npx crushdataai schema <connection> [table]`
+- **Get Code**: **ALWAYS** use `npx crushdataai snippet <name>` (uses env vars).
+- **Load .env**: Ensure `python-dotenv` loads `.env`. Scripts use `os.environ["VAR"]`.
+- **Security**: Treat connected data as read-only.
 
 ### 3. Search Knowledge
 ```bash

package/dist/commands/schema.d.ts

@@ -0,0 +1 @@
+export declare function schema(connectionName: string, tableName?: string): Promise<void>;

package/dist/commands/schema.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = schema;
+const connections_1 = require("../connections");
+const connectors_1 = require("../connectors");
+async function schema(connectionName, tableName) {
+    const connection = (0, connections_1.getConnection)(connectionName);
+    if (!connection) {
+        console.error(`❌ Connection '${connectionName}' not found.`);
+        console.error(`   Run 'crushdataai connections' to see available connections.`);
+        process.exit(1);
+    }
+    try {
+        const connector = connectors_1.ConnectorRegistry.get(connection.type);
+        if (!connector) {
+            console.error(`❌ No connector found for type: ${connection.type}`);
+            process.exit(1);
+        }
+        // If no table specified, list all tables
+        if (!tableName) {
+            console.log(`\n📊 Tables in '${connectionName}':\n`);
+            const tables = await connector.getTables(connection);
+            if (tables.length === 0) {
+                console.log('   No tables found.');
+            }
+            else {
+                tables.forEach(table => {
+                    const rowInfo = table.rowCount != null ? ` (~${table.rowCount.toLocaleString()} rows)` : '';
+                    console.log(`   └─ ${table.name}${rowInfo}`);
+                });
+            }
+            console.log(`\n   Run 'crushdataai schema ${connectionName} <table>' for column details.\n`);
+            return;
+        }
+        // Get schema for specific table
+        console.log(`\n📊 Schema for '${tableName}' in '${connectionName}':\n`);
+        const columns = await connector.getSchema(connection, tableName);
+        if (columns.length === 0) {
+            console.log('   No columns found.');
+        }
+        else {
+            columns.forEach((col, idx) => {
+                const prefix = idx === columns.length - 1 ? '└─' : '├─';
+                const nullInfo = col.nullable ? 'NULL' : 'NOT NULL';
+                console.log(`   ${prefix} ${col.name} (${col.type}, ${nullInfo})`);
+            });
+        }
+        console.log('');
+    }
+    catch (error) {
+        console.error(`❌ Error fetching schema: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/connections.d.ts

@@ -1,4 +1,4 @@
-export type ConnectionType = 'mysql' | 'postgresql' | 'bigquery' | 'snowflake' | 'shopify' | 'csv';
+export type ConnectionType = 'mysql' | 'postgresql' | 'bigquery' | 'snowflake' | 'shopify' | 'csv' | 'custom' | 'sqlserver' | 'redshift' | 'databricks' | 'clickhouse' | 'mongodb';
 export interface Connection {
     name: string;
     type: ConnectionType;
@@ -15,6 +15,7 @@ export interface Connection {
     apiKey?: string;
     apiSecret?: string;
     filePath?: string;
+    connectionString?: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -26,6 +27,7 @@ export declare function encrypt(text: string): string;
 export declare function decrypt(encryptedText: string): string;
 export declare function loadConnections(): ConnectionsConfig;
 export declare function saveConnections(config: ConnectionsConfig): void;
+export declare function writeToEnvFile(connection: Connection): void;
 export declare function saveConnection(connection: Connection): void;
 export declare function getConnection(name: string): Connection | null;
 export declare function deleteConnection(name: string): boolean;

package/dist/connections.js

@@ -37,6 +37,7 @@ exports.encrypt = encrypt;
 exports.decrypt = decrypt;
 exports.loadConnections = loadConnections;
 exports.saveConnections = saveConnections;
+exports.writeToEnvFile = writeToEnvFile;
 exports.saveConnection = saveConnection;
 exports.getConnection = getConnection;
 exports.deleteConnection = deleteConnection;
@@ -110,6 +111,124 @@ function saveConnections(config) {
         fs.chmodSync(configPath, 0o600);
     }
 }
+// Get the current working directory (project root)
+function getProjectDir() {
+    return process.cwd();
+}
+// Create environment variable name from connection name
+function toEnvVarName(connectionName, field) {
+    const sanitized = connectionName.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+    return `${sanitized}_${field.toUpperCase()}`;
+}
+// Write credentials to .env file in project directory
+function writeToEnvFile(connection) {
+    const projectDir = getProjectDir();
+    const envPath = path.join(projectDir, '.env');
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    // Read existing .env or create empty
+    let envContent = '';
+    if (fs.existsSync(envPath)) {
+        envContent = fs.readFileSync(envPath, 'utf8');
+    }
+    // Build env vars based on connection type
+    const envVars = {};
+    const prefix = connection.name;
+    switch (connection.type) {
+        case 'mysql':
+        case 'postgresql':
+        case 'sqlserver':
+        case 'redshift':
+        case 'clickhouse':
+            if (connection.host)
+                envVars[toEnvVarName(prefix, 'HOST')] = connection.host;
+            if (connection.port)
+                envVars[toEnvVarName(prefix, 'PORT')] = String(connection.port);
+            if (connection.user)
+                envVars[toEnvVarName(prefix, 'USER')] = connection.user;
+            if (connection.password)
+                envVars[toEnvVarName(prefix, 'PASSWORD')] = connection.password;
+            if (connection.database)
+                envVars[toEnvVarName(prefix, 'DATABASE')] = connection.database;
+            break;
+        case 'bigquery':
+            if (connection.projectId)
+                envVars[toEnvVarName(prefix, 'PROJECT_ID')] = connection.projectId;
+            if (connection.keyFile)
+                envVars[toEnvVarName(prefix, 'KEY_FILE')] = connection.keyFile;
+            break;
+        case 'snowflake':
+            if (connection.account)
+                envVars[toEnvVarName(prefix, 'ACCOUNT')] = connection.account;
+            if (connection.user)
+                envVars[toEnvVarName(prefix, 'USER')] = connection.user;
+            if (connection.password)
+                envVars[toEnvVarName(prefix, 'PASSWORD')] = connection.password;
+            if (connection.warehouse)
+                envVars[toEnvVarName(prefix, 'WAREHOUSE')] = connection.warehouse;
+            if (connection.database)
+                envVars[toEnvVarName(prefix, 'DATABASE')] = connection.database;
+            break;
+        case 'databricks':
+            if (connection.host)
+                envVars[toEnvVarName(prefix, 'HOST')] = connection.host;
+            if (connection.connectionString)
+                envVars[toEnvVarName(prefix, 'HTTP_PATH')] = connection.connectionString;
+            if (connection.apiKey)
+                envVars[toEnvVarName(prefix, 'TOKEN')] = connection.apiKey;
+            break;
+        case 'mongodb':
+            if (connection.host)
+                envVars[toEnvVarName(prefix, 'HOST')] = connection.host;
+            if (connection.user)
+                envVars[toEnvVarName(prefix, 'USER')] = connection.user;
+            if (connection.password)
+                envVars[toEnvVarName(prefix, 'PASSWORD')] = connection.password;
+            if (connection.database)
+                envVars[toEnvVarName(prefix, 'DATABASE')] = connection.database;
+            if (connection.connectionString)
+                envVars[toEnvVarName(prefix, 'CONNECTION_STRING')] = connection.connectionString;
+            break;
+        case 'shopify':
+            if (connection.store)
+                envVars[toEnvVarName(prefix, 'STORE')] = connection.store;
+            if (connection.apiKey)
+                envVars[toEnvVarName(prefix, 'API_KEY')] = connection.apiKey;
+            if (connection.apiSecret)
+                envVars[toEnvVarName(prefix, 'API_SECRET')] = connection.apiSecret;
+            break;
+        case 'csv':
+            if (connection.filePath)
+                envVars[toEnvVarName(prefix, 'FILE_PATH')] = connection.filePath;
+            break;
+        case 'custom':
+            if (connection.connectionString)
+                envVars[toEnvVarName(prefix, 'CONNECTION_STRING')] = connection.connectionString;
+            break;
+    }
+    // Update or append each env var
+    for (const [key, value] of Object.entries(envVars)) {
+        const regex = new RegExp(`^${key}=.*$`, 'm');
+        const newLine = `${key}="${value}"`;
+        if (regex.test(envContent)) {
+            envContent = envContent.replace(regex, newLine);
+        }
+        else {
+            envContent = envContent.trimEnd() + (envContent ? '\n' : '') + newLine + '\n';
+        }
+    }
+    fs.writeFileSync(envPath, envContent, 'utf8');
+    console.log(`✅ Credentials saved to .env file`);
+    // Update .gitignore if needed
+    let gitignoreContent = '';
+    if (fs.existsSync(gitignorePath)) {
+        gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+    }
+    if (!gitignoreContent.includes('.env')) {
+        gitignoreContent = gitignoreContent.trimEnd() + (gitignoreContent ? '\n' : '') + '\n# Environment variables\n.env\n';
+        fs.writeFileSync(gitignorePath, gitignoreContent, 'utf8');
+        console.log(`✅ Added .env to .gitignore`);
+    }
+}
 // Add or update a connection
 function saveConnection(connection) {
     const config = loadConnections();
@@ -124,6 +243,9 @@ function saveConnection(connection) {
     if (secureConnection.apiSecret) {
         secureConnection.apiSecret = encrypt(secureConnection.apiSecret);
     }
+    if (secureConnection.connectionString) {
+        secureConnection.connectionString = encrypt(secureConnection.connectionString);
+    }
     // Update or add
     const existingIndex = config.connections.findIndex(c => c.name === connection.name);
     if (existingIndex >= 0) {
@@ -151,6 +273,9 @@ function getConnection(name) {
     if (decrypted.apiSecret) {
         decrypted.apiSecret = decrypt(decrypted.apiSecret);
     }
+    if (decrypted.connectionString) {
+        decrypted.connectionString = decrypt(decrypted.connectionString);
+    }
     return decrypted;
 }
 // Delete a connection

package/dist/connectors/additional/index.d.ts

@@ -0,0 +1,42 @@
+import { Connector, Table, TableData, ColumnInfo } from '../index';
+import { Connection } from '../../connections';
+export declare class SQLServerConnector implements Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
+    getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
+    getSnippet(connection: Connection, lang: string): string;
+}
+export declare class RedshiftConnector implements Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
+    getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
+    getSnippet(connection: Connection, lang: string): string;
+}
+export declare class DatabricksConnector implements Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
+    getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
+    getSnippet(connection: Connection, lang: string): string;
+}
+export declare class ClickHouseConnector implements Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
+    getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
+    getSnippet(connection: Connection, lang: string): string;
+}
+export declare class MongoDBConnector implements Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
+    getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
+    getSnippet(connection: Connection, lang: string): string;
+}

package/dist/connectors/additional/index.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDBConnector = exports.ClickHouseConnector = exports.DatabricksConnector = exports.RedshiftConnector = exports.SQLServerConnector = void 0;
+// SQL Server Connector - uses mssql package or Custom connection string
+class SQLServerConnector {
+    constructor() {
+        this.type = 'sqlserver';
+    }
+    async test(connection) {
+        console.log(`[SQLServer] Testing connection for ${connection.name}`);
+        if (!connection.host?.trim() || !connection.user?.trim() || !connection.database?.trim()) {
+            throw new Error('Host, username, and database are required');
+        }
+        // For now, we validate inputs and trust the user
+        // Full implementation would use mssql package
+        console.log(`[SQLServer] Connection parameters validated for ${connection.name}`);
+        return true;
+    }
+    async getTables(connection) {
+        console.log(`[SQLServer] getTables called for ${connection.name}`);
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        throw new Error('Use the snippet to query SQL Server directly.');
+    }
+    async getSchema(connection, tableName) {
+        return [];
+    }
+    getSnippet(connection, lang) {
+        const prefix = connection.name.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        if (lang === 'python') {
+            return `import os
+import pyodbc
+import pandas as pd
+
+# Connection: ${connection.name}
+# Type: sqlserver
+# Credentials loaded from environment variables (set in .env file)
+conn_str = (
+    f"DRIVER={{ODBC Driver 17 for SQL Server}};"
+    f"SERVER={os.environ['${prefix}_HOST']};"
+    f"DATABASE={os.environ['${prefix}_DATABASE']};"
+    f"UID={os.environ['${prefix}_USER']};"
+    f"PWD={os.environ['${prefix}_PASSWORD']}"
+)
+
+connection = pyodbc.connect(conn_str)
+
+try:
+    query = "SELECT TOP 100 * FROM your_table"
+    df = pd.read_sql(query, connection)
+    print(f"Successfully loaded {len(df)} rows from ${connection.name}")
+    print(df.head())
+finally:
+    connection.close()
+`;
+        }
+        return `# Language ${lang} not supported for SQL Server connector yet.`;
+    }
+}
+exports.SQLServerConnector = SQLServerConnector;
+// Redshift Connector - PostgreSQL compatible with redshift_connector
+class RedshiftConnector {
+    constructor() {
+        this.type = 'redshift';
+    }
+    async test(connection) {
+        console.log(`[Redshift] Testing connection for ${connection.name}`);
+        if (!connection.host?.trim() || !connection.user?.trim() || !connection.database?.trim()) {
+            throw new Error('Host, username, and database are required');
+        }
+        console.log(`[Redshift] Connection parameters validated for ${connection.name}`);
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        throw new Error('Use the snippet to query Redshift directly.');
+    }
+    async getSchema(connection, tableName) {
+        return [];
+    }
+    getSnippet(connection, lang) {
+        const prefix = connection.name.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        if (lang === 'python') {
+            return `import os
+import redshift_connector
+import pandas as pd
+
+# Connection: ${connection.name}
+# Type: redshift
+# Credentials loaded from environment variables (set in .env file)
+conn = redshift_connector.connect(
+    host=os.environ["${prefix}_HOST"],
+    database=os.environ["${prefix}_DATABASE"],
+    user=os.environ["${prefix}_USER"],
+    password=os.environ["${prefix}_PASSWORD"],
+    port=int(os.environ.get("${prefix}_PORT", "5439"))
+)
+
+try:
+    query = "SELECT * FROM your_table LIMIT 100"
+    df = pd.read_sql(query, conn)
+    print(f"Successfully loaded {len(df)} rows from ${connection.name}")
+    print(df.head())
+finally:
+    conn.close()
+`;
+        }
+        return `# Language ${lang} not supported for Redshift connector yet.`;
+    }
+}
+exports.RedshiftConnector = RedshiftConnector;
+// Databricks Connector - uses databricks-sql-connector
+class DatabricksConnector {
+    constructor() {
+        this.type = 'databricks';
+    }
+    async test(connection) {
+        console.log(`[Databricks] Testing connection for ${connection.name}`);
+        if (!connection.host?.trim()) {
+            throw new Error('Databricks host (workspace URL) is required');
+        }
+        console.log(`[Databricks] Connection parameters validated for ${connection.name}`);
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        throw new Error('Use the snippet to query Databricks directly.');
+    }
+    async getSchema(connection, tableName) {
+        return [];
+    }
+    getSnippet(connection, lang) {
+        const prefix = connection.name.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        if (lang === 'python') {
+            return `import os
+from databricks import sql
+import pandas as pd
+
+# Connection: ${connection.name}
+# Type: databricks
+# Credentials loaded from environment variables (set in .env file)
+connection = sql.connect(
+    server_hostname=os.environ["${prefix}_HOST"],
+    http_path=os.environ["${prefix}_HTTP_PATH"],
+    access_token=os.environ["${prefix}_TOKEN"]
+)
+
+try:
+    cursor = connection.cursor()
+    cursor.execute("SELECT * FROM your_table LIMIT 100")
+    df = pd.DataFrame(cursor.fetchall(), columns=[desc[0] for desc in cursor.description])
+    print(f"Successfully loaded {len(df)} rows from ${connection.name}")
+    print(df.head())
+finally:
+    connection.close()
+`;
+        }
+        return `# Language ${lang} not supported for Databricks connector yet.`;
+    }
+}
+exports.DatabricksConnector = DatabricksConnector;
+// ClickHouse Connector - uses clickhouse-connect
+class ClickHouseConnector {
+    constructor() {
+        this.type = 'clickhouse';
+    }
+    async test(connection) {
+        console.log(`[ClickHouse] Testing connection for ${connection.name}`);
+        if (!connection.host?.trim()) {
+            throw new Error('ClickHouse host is required');
+        }
+        console.log(`[ClickHouse] Connection parameters validated for ${connection.name}`);
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        throw new Error('Use the snippet to query ClickHouse directly.');
+    }
+    async getSchema(connection, tableName) {
+        return [];
+    }
+    getSnippet(connection, lang) {
+        const prefix = connection.name.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        if (lang === 'python') {
+            return `import os
+import clickhouse_connect
+import pandas as pd
+
+# Connection: ${connection.name}
+# Type: clickhouse
+# Credentials loaded from environment variables (set in .env file)
+client = clickhouse_connect.get_client(
+    host=os.environ["${prefix}_HOST"],
+    port=int(os.environ.get("${prefix}_PORT", "8123")),
+    username=os.environ.get("${prefix}_USER", "default"),
+    password=os.environ.get("${prefix}_PASSWORD", "")
+)
+
+query = "SELECT * FROM your_table LIMIT 100"
+df = client.query_df(query)
+print(f"Successfully loaded {len(df)} rows from ${connection.name}")
+print(df.head())
+`;
+        }
+        return `# Language ${lang} not supported for ClickHouse connector yet.`;
+    }
+}
+exports.ClickHouseConnector = ClickHouseConnector;
+// MongoDB Connector - uses pymongo
+class MongoDBConnector {
+    constructor() {
+        this.type = 'mongodb';
+    }
+    async test(connection) {
+        console.log(`[MongoDB] Testing connection for ${connection.name}`);
+        if (!connection.host?.trim()) {
+            throw new Error('MongoDB connection string or host is required');
+        }
+        console.log(`[MongoDB] Connection parameters validated for ${connection.name}`);
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        throw new Error('Use the snippet to query MongoDB directly.');
+    }
+    async getSchema(connection, tableName) {
+        return [];
+    }
+    getSnippet(connection, lang) {
+        const prefix = connection.name.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+        if (lang === 'python') {
+            return `import os
+from pymongo import MongoClient
+import pandas as pd
+
+# Connection: ${connection.name}
+# Type: mongodb
+# Credentials loaded from environment variables (set in .env file)
+# Use either a full connection string or host/user/password
+connection_string = os.environ.get("${prefix}_CONNECTION_STRING", 
+    f"mongodb://{os.environ.get('${prefix}_USER', '')}:{os.environ.get('${prefix}_PASSWORD', '')}@{os.environ['${prefix}_HOST']}")
+
+client = MongoClient(connection_string)
+db = client[os.environ.get("${prefix}_DATABASE", "test")]
+
+# Example: Fetch documents from a collection
+collection = db["your_collection"]
+docs = list(collection.find().limit(100))
+df = pd.DataFrame(docs)
+print(f"Successfully loaded {len(df)} documents from ${connection.name}")
+print(df.head())
+
+client.close()
+`;
+        }
+        return `# Language ${lang} not supported for MongoDB connector yet.`;
+    }
+}
+exports.MongoDBConnector = MongoDBConnector;