crushdataai 1.0.0 → 1.2.0

package/assets/antigravity/data-analyst.md

@@ -25,6 +25,11 @@ Before writing any code, ask the user:
 2. **Data Context**: Which tables contain the data? What time range?
 3. **Metric Definitions**: How does YOUR company define the key metrics? Any filters?
 
+## Step 1b: Secure Access
+- Check connections: `npx crushdataai connections`
+- Get connection code: `npx crushdataai snippet <name>`
+- **DO NOT** ask for API credentials.
+
 ---
 
 ## Step 2: Search Knowledge Base

package/assets/claude/SKILL.md

@@ -29,7 +29,23 @@ When user requests data analysis work (analyze, query, dashboard, metrics, EDA,
    - How does YOUR company define the key metrics?
    - Any filters to apply? (exclude test users, internal accounts?)
    - What timezone should I use for dates?
-```
+   - What timezone should I use for dates?
+
+### Step 1b: Access Data (SECURE)
+
+**To access data, DO NOT ask for API keys/credentials.**
+
+1. Check available connections:
+   ```bash
+   npx crushdataai connections
+   ```
+
+2. Get the connection code snippet:
+   ```bash
+   npx crushdataai snippet <connection_name> --lang python
+   ```
+
+3. Paste the snippet into your analysis script to load the data.
 
 ### Step 2: Search Relevant Domains
 

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

@@ -19,6 +19,11 @@ Before coding, ask:
 - Which tables contain the data?
 - How does YOUR company define key metrics?
 
+### 1b. Secure Access
+- Check connections: `npx crushdataai connections`
+- Get connection code: `npx crushdataai snippet <name>`
+- **DO NOT** ask for API credentials.
+
 ### 2. Search Knowledge Base
 ```bash
 python3 .github/prompts/../.shared/data-analyst/scripts/search.py "<query>" --domain <domain>

package/assets/cursor/data-analyst.md

@@ -16,6 +16,11 @@ Before coding, ask:
 - Which tables contain the data?
 - How does YOUR company define the key metrics?
 
+3. **Secure Access**:
+   - Check connections: `npx crushdataai connections`
+   - Get connection code: `npx crushdataai snippet <name>`
+   - **DO NOT** ask for API credentials.
+
 ### 2. Search Knowledge Base
 ```bash
 python3 .cursor/commands/../.shared/data-analyst/scripts/search.py "<query>" --domain <domain>

package/assets/kiro/data-analyst.md

@@ -15,6 +15,11 @@ Before writing code, gather:
 - Company-specific metric definitions
 - Time range and filters
 
+### 1b. Secure Access
+- Check connections: `npx crushdataai connections`
+- Get connection code: `npx crushdataai snippet <name>`
+- **DO NOT** ask for API credentials.
+
 ### 2. Search Before Implementing
 ```bash
 python3 .kiro/steering/../.shared/data-analyst/scripts/search.py "<query>" --domain <domain>

package/assets/windsurf/data-analyst.md

@@ -13,6 +13,11 @@ Ask before coding:
 - Which tables/databases contain the data
 - Company-specific metric definitions
 
+### 1b. Secure Access
+- Check connections: `npx crushdataai connections`
+- Get connection code: `npx crushdataai snippet <name>`
+- **DO NOT** ask for API credentials.
+
 ### 2. Search Knowledge
 ```bash
 python3 .windsurf/workflows/../.shared/data-analyst/scripts/search.py "<query>" --domain <domain>

package/dist/commands/snippet.d.ts

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

package/dist/commands/snippet.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snippet = snippet;
+const connections_1 = require("../connections");
+const connectors_1 = require("../connectors");
+async function snippet(connectionName, lang = 'python') {
+    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);
+        }
+        const code = connector.getSnippet(connection, lang);
+        console.log(code);
+    }
+    catch (error) {
+        console.error(`❌ Error generating snippet: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/connections.d.ts

@@ -0,0 +1,37 @@
+export type ConnectionType = 'mysql' | 'postgresql' | 'bigquery' | 'snowflake' | 'shopify' | 'csv';
+export interface Connection {
+    name: string;
+    type: ConnectionType;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    projectId?: string;
+    keyFile?: string;
+    account?: string;
+    warehouse?: string;
+    store?: string;
+    apiKey?: string;
+    apiSecret?: string;
+    filePath?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConnectionsConfig {
+    version: string;
+    connections: Connection[];
+}
+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 saveConnection(connection: Connection): void;
+export declare function getConnection(name: string): Connection | null;
+export declare function deleteConnection(name: string): boolean;
+export declare function listConnections(): Array<{
+    name: string;
+    type: ConnectionType;
+    host?: string;
+    createdAt: string;
+}>;

package/dist/connections.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+exports.loadConnections = loadConnections;
+exports.saveConnections = saveConnections;
+exports.saveConnection = saveConnection;
+exports.getConnection = getConnection;
+exports.deleteConnection = deleteConnection;
+exports.listConnections = listConnections;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs-extra"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// Get config directory
+function getConfigDir() {
+    return path.join(os.homedir(), '.crushdataai');
+}
+function getConfigPath() {
+    return path.join(getConfigDir(), 'connections.json');
+}
+// Get machine-specific encryption key
+function getEncryptionKey() {
+    const machineId = os.hostname() + os.userInfo().username;
+    return crypto.scryptSync(machineId, 'crushdataai-salt', 32);
+}
+// Encrypt sensitive data
+function encrypt(text) {
+    if (!text)
+        return '';
+    const key = getEncryptionKey();
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+}
+// Decrypt sensitive data
+function decrypt(encryptedText) {
+    if (!encryptedText || !encryptedText.includes(':'))
+        return encryptedText;
+    try {
+        const key = getEncryptionKey();
+        const [ivHex, encrypted] = encryptedText.split(':');
+        const iv = Buffer.from(ivHex, 'hex');
+        const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    catch {
+        return '';
+    }
+}
+// Load connections from config file
+function loadConnections() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return { version: '2.0.0', connections: [] };
+    }
+    try {
+        const data = fs.readJsonSync(configPath);
+        return data;
+    }
+    catch {
+        return { version: '2.0.0', connections: [] };
+    }
+}
+// Save connections to config file
+function saveConnections(config) {
+    const configDir = getConfigDir();
+    const configPath = getConfigPath();
+    fs.ensureDirSync(configDir);
+    fs.writeJsonSync(configPath, config, { spaces: 2 });
+    // Set file permissions (user-only on Unix)
+    if (process.platform !== 'win32') {
+        fs.chmodSync(configPath, 0o600);
+    }
+}
+// Add or update a connection
+function saveConnection(connection) {
+    const config = loadConnections();
+    // Encrypt sensitive fields
+    const secureConnection = { ...connection };
+    if (secureConnection.password) {
+        secureConnection.password = encrypt(secureConnection.password);
+    }
+    if (secureConnection.apiKey) {
+        secureConnection.apiKey = encrypt(secureConnection.apiKey);
+    }
+    if (secureConnection.apiSecret) {
+        secureConnection.apiSecret = encrypt(secureConnection.apiSecret);
+    }
+    // Update or add
+    const existingIndex = config.connections.findIndex(c => c.name === connection.name);
+    if (existingIndex >= 0) {
+        config.connections[existingIndex] = secureConnection;
+    }
+    else {
+        config.connections.push(secureConnection);
+    }
+    saveConnections(config);
+}
+// Get a connection (with decrypted credentials)
+function getConnection(name) {
+    const config = loadConnections();
+    const connection = config.connections.find(c => c.name === name);
+    if (!connection)
+        return null;
+    // Decrypt sensitive fields
+    const decrypted = { ...connection };
+    if (decrypted.password) {
+        decrypted.password = decrypt(decrypted.password);
+    }
+    if (decrypted.apiKey) {
+        decrypted.apiKey = decrypt(decrypted.apiKey);
+    }
+    if (decrypted.apiSecret) {
+        decrypted.apiSecret = decrypt(decrypted.apiSecret);
+    }
+    return decrypted;
+}
+// Delete a connection
+function deleteConnection(name) {
+    const config = loadConnections();
+    const initialLength = config.connections.length;
+    config.connections = config.connections.filter(c => c.name !== name);
+    if (config.connections.length < initialLength) {
+        saveConnections(config);
+        return true;
+    }
+    return false;
+}
+// List all connections (without sensitive data)
+function listConnections() {
+    const config = loadConnections();
+    return config.connections.map(c => ({
+        name: c.name,
+        type: c.type,
+        host: c.host || c.store || c.account || c.filePath,
+        createdAt: c.createdAt
+    }));
+}

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

@@ -0,0 +1,16 @@
+import { Connector, Table, TableData } from '../index';
+import { Connection } from '../../connections';
+export declare class BigQueryConnector implements Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, table: string, page: number, limit: number): Promise<TableData>;
+    getSnippet(connection: Connection, lang: string): string;
+}
+export declare class SnowflakeConnector implements Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, table: string, page: number, limit: number): Promise<TableData>;
+    getSnippet(connection: Connection, lang: string): string;
+}

package/dist/connectors/cloud/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnowflakeConnector = exports.BigQueryConnector = void 0;
+class BigQueryConnector {
+    constructor() {
+        this.type = 'bigquery';
+    }
+    async test(connection) {
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, table, page, limit) {
+        return { columns: [], rows: [], pagination: { page, limit, totalRows: 0, totalPages: 0, startIdx: 0, endIdx: 0 } };
+    }
+    getSnippet(connection, lang) {
+        return `# BigQuery snippet generation not implemented yet`;
+    }
+}
+exports.BigQueryConnector = BigQueryConnector;
+class SnowflakeConnector {
+    constructor() {
+        this.type = 'snowflake';
+    }
+    async test(connection) {
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, table, page, limit) {
+        return { columns: [], rows: [], pagination: { page, limit, totalRows: 0, totalPages: 0, startIdx: 0, endIdx: 0 } };
+    }
+    getSnippet(connection, lang) {
+        return `# Snowflake snippet generation not implemented yet`;
+    }
+}
+exports.SnowflakeConnector = SnowflakeConnector;

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

@@ -0,0 +1,9 @@
+import { Connector, Table, TableData } from '../index';
+import { Connection } from '../../connections';
+export declare class CSVConnector 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>;
+    getSnippet(connection: Connection, lang: string): string;
+}

package/dist/connectors/csv/index.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSVConnector = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const papaparse_1 = __importDefault(require("papaparse"));
+class CSVConnector {
+    constructor() {
+        this.type = 'csv';
+    }
+    async test(connection) {
+        if (!connection.filePath) {
+            throw new Error('File path is required');
+        }
+        // Remove surrounding quotes if present
+        let filePath = connection.filePath;
+        if (filePath.startsWith('"') && filePath.endsWith('"')) {
+            filePath = filePath.slice(1, -1);
+        }
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            throw new Error('File not found');
+        }
+        return true;
+    }
+    async getTables(connection) {
+        if (!connection.filePath) {
+            return [];
+        }
+        let filePath = connection.filePath;
+        if (filePath.startsWith('"') && filePath.endsWith('"')) {
+            filePath = filePath.slice(1, -1);
+        }
+        const fileName = path.basename(filePath, '.csv');
+        // Basic check if file exists, if not it might have been deleted
+        if (fs.existsSync(filePath)) {
+            return [{ name: fileName, type: 'csv', rowCount: null }];
+        }
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        let filePath = connection.filePath;
+        if (filePath && filePath.startsWith('"') && filePath.endsWith('"')) {
+            filePath = filePath.slice(1, -1);
+        }
+        if (!filePath || !fs.existsSync(filePath)) {
+            throw new Error('CSV file not found');
+        }
+        const fileContent = fs.readFileSync(filePath, 'utf8');
+        const result = papaparse_1.default.parse(fileContent, {
+            header: true,
+            skipEmptyLines: true
+        });
+        const data = result.data;
+        const columns = result.meta.fields || [];
+        const totalRows = data.length;
+        const totalPages = Math.ceil(totalRows / limit);
+        const startIdx = (page - 1) * limit;
+        const endIdx = Math.min(startIdx + limit, totalRows);
+        const rows = data.slice(startIdx, endIdx);
+        return {
+            columns,
+            rows,
+            pagination: {
+                page,
+                limit,
+                totalRows,
+                totalPages,
+                startIdx: startIdx + 1,
+                endIdx
+            }
+        };
+    }
+    getSnippet(connection, lang) {
+        let filePath = connection.filePath || '';
+        if (filePath.startsWith('"') && filePath.endsWith('"')) {
+            filePath = filePath.slice(1, -1);
+        }
+        // Escape backslashes for string literals
+        const escapedPath = filePath.replace(/\\/g, '\\\\');
+        if (lang === 'python') {
+            return `import pandas as pd
+
+# Connection: ${connection.name}
+# Type: csv
+file_path = "${escapedPath}"
+
+try:
+    df = pd.read_csv(file_path)
+    print(f"Successfully loaded {len(df)} rows from ${connection.name}")
+    print(df.head())
+except Exception as e:
+    print(f"Error loading CSV: {e}")
+`;
+        }
+        return `# Language ${lang} not supported for CSV connector yet.`;
+    }
+}
+exports.CSVConnector = CSVConnector;

package/dist/connectors/index.d.ts

@@ -0,0 +1,30 @@
+import { Connection } from '../connections';
+export interface Table {
+    name: string;
+    type?: string;
+    rowCount?: number | null;
+}
+export interface TableData {
+    columns: string[];
+    rows: any[];
+    pagination: {
+        page: number;
+        limit: number;
+        totalRows: number;
+        totalPages: number;
+        startIdx: number;
+        endIdx: number;
+    };
+}
+export interface Connector {
+    type: string;
+    test(connection: Connection): Promise<boolean>;
+    getTables(connection: Connection): Promise<Table[]>;
+    getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
+    getSnippet(connection: Connection, lang: string): string;
+}
+export declare class ConnectorRegistry {
+    private static connectors;
+    static register(connector: Connector): void;
+    static get(type: string): Connector;
+}

package/dist/connectors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorRegistry = void 0;
+class ConnectorRegistry {
+    static register(connector) {
+        this.connectors.set(connector.type, connector);
+    }
+    static get(type) {
+        const connector = this.connectors.get(type);
+        if (!connector) {
+            throw new Error(`No connector found for type: ${type}`);
+        }
+        return connector;
+    }
+}
+exports.ConnectorRegistry = ConnectorRegistry;
+ConnectorRegistry.connectors = new Map();

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

@@ -0,0 +1,9 @@
+import { Connector, Table, TableData } from '../index';
+import { Connection } from '../../connections';
+export declare class MySQLConnector 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>;
+    getSnippet(connection: Connection, lang: string): string;
+}

package/dist/connectors/mysql/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLConnector = void 0;
+class MySQLConnector {
+    constructor() {
+        this.type = 'mysql';
+    }
+    async test(connection) {
+        // Stub implementation
+        if (!connection.host || !connection.user || !connection.database) {
+            throw new Error('Host, user, and database are required');
+        }
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        return {
+            columns: [],
+            rows: [],
+            pagination: { page, limit, totalRows: 0, totalPages: 0, startIdx: 0, endIdx: 0 }
+        };
+    }
+    getSnippet(connection, lang) {
+        return `# MySQL snippet generation not implemented yet`;
+    }
+}
+exports.MySQLConnector = MySQLConnector;

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

@@ -0,0 +1,9 @@
+import { Connector, Table, TableData } from '../index';
+import { Connection } from '../../connections';
+export declare class PostgreSQLConnector 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>;
+    getSnippet(connection: Connection, lang: string): string;
+}

package/dist/connectors/postgresql/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLConnector = void 0;
+class PostgreSQLConnector {
+    constructor() {
+        this.type = 'postgresql';
+    }
+    async test(connection) {
+        if (!connection.host || !connection.user || !connection.database) {
+            throw new Error('Host, user, and database are required');
+        }
+        return true;
+    }
+    async getTables(connection) {
+        return [];
+    }
+    async getData(connection, tableName, page, limit) {
+        return {
+            columns: [],
+            rows: [],
+            pagination: { page, limit, totalRows: 0, totalPages: 0, startIdx: 0, endIdx: 0 }
+        };
+    }
+    getSnippet(connection, lang) {
+        return `# PostgreSQL snippet generation not implemented yet`;
+    }
+}
+exports.PostgreSQLConnector = PostgreSQLConnector;

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

@@ -0,0 +1,9 @@
+import { Connector, Table, TableData } from '../index';
+import { Connection } from '../../connections';
+export declare class ShopifyConnector 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>;
+    getSnippet(connection: Connection, lang: string): string;
+}