crushdataai 1.2.14 → 1.2.17

package/README.md

@@ -0,0 +1,261 @@
+# CrushData AI
+
+**Data Analyst Intelligence for AI IDEs**
+
+An AI skill that provides structured, professional data analysis workflows with built-in validation - helping AI coding assistants perform data analysis like a careful human analyst.
+
+![CrushData AI Landing Page](assets/images/crushdataai-landing-page.png)
+
+## 🎯 What It Does
+
+CrushData AI provides:
+- **10 Analysis Workflows** - EDA, Dashboard, A/B Test, Cohort, Funnel, Time Series, Segmentation, Data Cleaning, Ad-hoc, KPI Reporting
+- **400+ Searchable Patterns** - Metrics, SQL, Python, Charts, Database Tips, Common Mistakes
+- **Context-Building Protocol** - Forces AI to ask questions and validate before delivering results
+- **4 Industry Modules** - SaaS, E-commerce, Finance, Marketing specific metrics
+
+## 🚀 Quick Start
+
+### Install via CLI
+
+```bash
+npm install -g crushdataai
+```
+
+### What `npm install -g crushdataai` Does
+
+The `-g` flag means **Global Install**:
+
+| | Local Install (`npm install`) | Global Install (`npm install -g`) |
+|--|-------------------------------|-----------------------------------|
+| **Location** | `./node_modules/` in current folder | System-wide (e.g., `%APPDATA%\npm\`) |
+| **Scope** | Only available in that project | Available everywhere on your computer |
+| **Use Case** | Libraries for your project | CLI tools you want to run anywhere |
+
+Then in any project:
+```bash
+cd your-project
+crushdataai init --ai all    # All AI IDEs
+crushdataai init --ai claude # Claude Code only
+```
+
+### What `crushdataai init` Does
+
+When you run `crushdataai init --ai all`, the CLI:
+
+1. **Creates `.shared/data-analyst/`** - Contains the BM25 search engine and 13 CSV knowledge databases (~400 rows of data analyst patterns)
+
+2. **Creates AI IDE config files** based on `--ai` flag:
+   | Flag | Creates |
+   |------|---------|
+   | `--ai claude` | `.claude/skills/data-analyst/SKILL.md` |
+   | `--ai cursor` | `.cursor/commands/data-analyst.md` |
+   | `--ai windsurf` | `.windsurf/workflows/data-analyst.md` |
+   | `--ai antigravity` | `.agent/workflows/data-analyst.md` |
+   | `--ai copilot` | `.github/prompts/data-analyst.prompt.md` |
+   | `--ai kiro` | `.kiro/steering/data-analyst.md` |
+   | `--ai all` | All of the above |
+
+3. **Your AI IDE automatically detects** the config files and enables the `/data-analyst` command
+
+### Updating
+To update the CLI and refresh your project's AI skill files:
+```bash
+npm install -g crushdataai@latest
+# Update specific IDE (recommended):
+crushdataai init --ai cursor --force
+
+# Or update everything:
+crushdataai init --force
+```
+
+## 🔌 Data Connections (New in v1.2)
+
+CrushData AI now features a **Connection Manager** to securely handle your data credentials.
+
+### 1. Add Data Sources
+Run the connect command to open the management UI:
+
+```bash
+crushdataai connect
+```
+
+- **Supported Types**: CSV, MySQL, PostgreSQL, Shopify, BigQuery, Snowflake
+- **Private & Secure**: Credentials are stored **locally** on your machine (`~/.crushdataai/connections.json`). They are **never** uploaded to any server or included in the npm package.
+
+![CrushData AI Connection Manager](assets/images/crushdataai-data-connection-ui.png)
+
+> [!NOTE]
+> **Persistence**: Once you add a connection, you can **close the UI** (Ctrl+C). The AI IDE reads the saved connection details directly from your local config file, so the server does NOT need to keep running.
+
+### 2. View Saved Connections
+```bash
+crushdataai connections
+```
+
+## 📈 Data Visualization (New in v1.3)
+
+CrushData AI generates interactive dashboards to visualize your analysis results.
+
+### 1. View Dashboard
+Run the dashboard command to open the local React-based viewer:
+
+```bash
+# Using installed package (generally faster)
+crushdataai dashboard
+
+# OR using npx (if not in PATH)
+npx crushdataai dashboard
+```
+
+![Advanced Dashboard](assets/images/crushdataai-dashboard.png)
+*Advanced charts visualization (Funnel, Gauge, Radar, etc.)*
+
+![Simple Dashboard](assets/images/crushdataai-dashboard-simple-charts.png)
+*Standard charts visualization (Line, Bar, Pie, etc.)*
+
+### 2. Features
+- **Tier 1 Charts**: Line, Bar, Pie, Area, Scatter, Radar (via Recharts)
+- **Tier 2 Charts**: Funnel, Gauge, Heatmap, Sankey, Treemap, Waterfall (via Plotly)
+- **Auto-Refresh**: The dashboard automatically updates when your AI agent writes new data to `reports/dashboards/`.
+- **Data Refresh**: Use the "Refresh" button 🔄 on any chart to re-run the saved SQL/Python query against your data source.
+
+### 3. AI Workflow Example
+
+When you ask an AI agent (like Claude or Cursor) to "create a dashboard", it follows this process:
+
+1. **Analyzes Data**: The AI runs SQL/Python to calculate metrics and aggregates.
+2. **Generates JSON**: It creates a file at `reports/dashboards/your-topic.json` using the CrushData schema.
+3. **Visualizes**: You run the dashboard command to see the rendered charts instantly.
+
+*The AI automatically selects the best chart type (e.g., Line for trends, Bar for comparisons) based on your data.*
+
+## 💻 Usage
+
+### Step 1: Initialize
+```bash
+crushdataai init --ai all
+```
+
+### Step 2: Use in AI IDE
+The skill activates automatically (Claude) or via slash command (others).
+
+**Example Workflow:**
+
+1. **User Request**: "Analyze the sales trends in `my-shop-data`"
+2. **AI Action**: The AI checks your saved connections.
+3. **AI Action**: The AI runs:
+   ```bash
+   npx crushdataai snippet my-shop-data --lang python
+   ```
+4. **Result**: The AI receives the secure code to connect to your data (read-only) and proceeds with analysis.
+
+### Claude Code
+
+
+### Claude Code
+
+The skill activates automatically when you request data analysis work. Just chat naturally:
+
+```
+Analyze customer churn for my SaaS product
+```
+
+### Cursor / Windsurf / Antigravity
+
+Use the slash command to invoke the skill:
+
+```
+/data-analyst Analyze customer churn for my SaaS product
+```
+
+### Kiro
+
+Type `/` in chat to see available commands, then select `data-analyst`:
+
+```
+/data-analyst Analyze customer churn for my SaaS product
+```
+
+### GitHub Copilot
+
+In VS Code with Copilot, type `/` in chat to see available prompts, then select `data-analyst`:
+
+```
+/data-analyst Analyze customer churn for my SaaS product
+```
+
+### Example Prompts
+
+```
+Analyze customer churn for my SaaS product
+Create a dashboard for e-commerce analytics
+Calculate MRR and ARR from subscription data
+Build a cohort retention analysis
+Perform A/B test analysis on conversion rates
+```
+
+### Search Directly
+```bash
+# Search workflows
+python3 .shared/data-analyst/scripts/search.py "EDA" --domain workflow
+
+# Search metrics
+python3 .shared/data-analyst/scripts/search.py "churn" --domain metric
+
+# Search SQL patterns
+python3 .shared/data-analyst/scripts/search.py "cohort" --domain sql
+
+# Industry-specific
+python3 .shared/data-analyst/scripts/search.py "MRR" --industry saas
+```
+
+## 📊 Search Domains
+
+| Domain | Content |
+|--------|---------|
+| `workflow` | Step-by-step analysis processes |
+| `metric` | Metric definitions with formulas |
+| `chart` | Visualization recommendations |
+| `cleaning` | Data quality patterns |
+| `sql` | SQL patterns (window functions, cohorts) |
+| `python` | pandas/polars code snippets |
+| `database` | PostgreSQL, BigQuery, Snowflake tips |
+| `report` | Dashboard UX guidelines |
+| `validation` | Common mistakes to avoid |
+
+## 🏭 Industry Modules
+
+| Industry | Key Metrics |
+|----------|-------------|
+| `saas` | MRR, ARR, Churn, CAC, LTV, NRR |
+| `ecommerce` | Conversion, AOV, Cart Abandonment |
+| `finance` | Margins, ROI, Cash Flow, Ratios |
+| `marketing` | CTR, CPA, ROAS, Lead Conversion |
+
+## 🔒 How It Works
+
+### Context-Building Protocol
+
+1. **Discovery** - AI asks about business context before coding
+2. **Data Profiling** - Mandatory checks before analysis
+3. **Data Cleaning (ETL)** - Handle missing values/duplicates in `etl/` folder
+4. **Validation** - Verify JOINs, aggregations, and totals
+5. **Sanity Checks** - Compare to benchmarks before delivery
+
+### Python Environment
+To prevent global conflicts, the AI is instructed to:
+1. **Check**: Look for existing `venv` or `.venv`.
+2. **Create**: If missing, run `python3 -m venv venv`.
+4. **Reports**: Save all validation/profiling outputs to `reports/` folder. Create if missing.
+
+This prevents the common AI mistakes:
+- ❌ Wrong metric definitions
+- ❌ Duplicate row inflation
+- ❌ Incorrect JOIN types
+- ❌ Unreasonable totals
+- ❌ Cluttered workspaces (scripts are organized in `analysis/` and `etl/`)
+
+## 📝 License
+
+Apache 2.0

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

@@ -8,11 +8,13 @@ export declare class BigQueryConnector implements Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
 }
 export declare class SnowflakeConnector implements Connector {
     type: string;
     private createConnection;
-    private executeQuery;
+    private executeInternal;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
     test(connection: Connection): Promise<boolean>;
     getTables(connection: Connection): Promise<Table[]>;
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;

package/dist/connectors/cloud/index.js

@@ -168,6 +168,18 @@ print(df.head())
         }
         return `# Language ${lang} not supported for BigQuery connector yet.`;
     }
+    async executeQuery(connection, query) {
+        console.log(`[BigQuery] executeQuery called for ${connection.name}`);
+        const bigquery = this.createClient(connection);
+        try {
+            const [rows] = await bigquery.query(query);
+            return rows;
+        }
+        catch (error) {
+            console.error(`[BigQuery] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+    }
 }
 exports.BigQueryConnector = BigQueryConnector;
 class SnowflakeConnector {
@@ -193,7 +205,7 @@ class SnowflakeConnector {
             });
         });
     }
-    executeQuery(conn, query) {
+    executeInternal(conn, query) {
         return new Promise((resolve, reject) => {
             conn.execute({
                 sqlText: query,
@@ -208,6 +220,22 @@ class SnowflakeConnector {
             });
         });
     }
+    async executeQuery(connection, query) {
+        console.log(`[Snowflake] executeQuery called for ${connection.name}`);
+        let conn = null;
+        try {
+            conn = await this.createConnection(connection);
+            return await this.executeInternal(conn, query);
+        }
+        catch (error) {
+            console.error(`[Snowflake] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+        finally {
+            if (conn)
+                conn.destroy(() => { });
+        }
+    }
     async test(connection) {
         console.log(`[Snowflake] Testing connection for ${connection.name} (Account: ${connection.account})`);
         // Validate required fields
@@ -226,7 +254,7 @@ class SnowflakeConnector {
         let conn = null;
         try {
             conn = await this.createConnection(connection);
-            await this.executeQuery(conn, 'SELECT CURRENT_VERSION()');
+            await this.executeInternal(conn, 'SELECT CURRENT_VERSION()');
             console.log(`[Snowflake] Connection test successful for ${connection.name}`);
             return true;
         }
@@ -244,7 +272,7 @@ class SnowflakeConnector {
         let conn = null;
         try {
             conn = await this.createConnection(connection);
-            const rows = await this.executeQuery(conn, 'SHOW TABLES');
+            const rows = await this.executeInternal(conn, 'SHOW TABLES');
             return rows.map((row) => ({
                 name: row.name || row.TABLE_NAME,
                 type: 'table',
@@ -266,9 +294,9 @@ class SnowflakeConnector {
         try {
             conn = await this.createConnection(connection);
             const offset = (page - 1) * limit;
-            const countRows = await this.executeQuery(conn, `SELECT COUNT(*) as TOTAL FROM "${tableName}"`);
+            const countRows = await this.executeInternal(conn, `SELECT COUNT(*) as TOTAL FROM "${tableName}"`);
             const totalRows = countRows[0]?.TOTAL || 0;
-            const rows = await this.executeQuery(conn, `SELECT * FROM "${tableName}" LIMIT ${limit} OFFSET ${offset}`);
+            const rows = await this.executeInternal(conn, `SELECT * FROM "${tableName}" LIMIT ${limit} OFFSET ${offset}`);
             const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
             const totalPages = Math.ceil(totalRows / limit) || 1;
             return {
@@ -298,7 +326,7 @@ class SnowflakeConnector {
         let conn = null;
         try {
             conn = await this.createConnection(connection);
-            const rows = await this.executeQuery(conn, `DESCRIBE TABLE "${tableName}"`);
+            const rows = await this.executeInternal(conn, `DESCRIBE TABLE "${tableName}"`);
             return rows.map((row) => ({
                 name: row.name || row.COLUMN_NAME,
                 type: row.type || row.DATA_TYPE,

package/dist/connectors/index.d.ts

@@ -28,6 +28,7 @@ export interface Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery?(connection: Connection, query: string): Promise<any[]>;
 }
 export declare class ConnectorRegistry {
     private static connectors;

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

@@ -7,4 +7,5 @@ export declare class MySQLConnector implements Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<import('../index').ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
 }

package/dist/connectors/mysql/index.js

@@ -178,5 +178,28 @@ finally:
         }
         return `# Language ${lang} not supported for MySQL connector yet.`;
     }
+    async executeQuery(connection, query) {
+        console.log(`[MySQL] executeQuery called for ${connection.name}`);
+        let conn = null;
+        try {
+            conn = await promise_1.default.createConnection({
+                host: connection.host,
+                port: connection.port || 3306,
+                user: connection.user,
+                password: connection.password || '',
+                database: connection.database
+            });
+            const [rows] = await conn.execute(query);
+            return rows;
+        }
+        catch (error) {
+            console.error(`[MySQL] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+        finally {
+            if (conn)
+                await conn.end();
+        }
+    }
 }
 exports.MySQLConnector = MySQLConnector;

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

@@ -8,4 +8,5 @@ export declare class PostgreSQLConnector implements Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<import('../index').ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
 }

package/dist/connectors/postgresql/index.js

@@ -156,5 +156,21 @@ finally:
         }
         return `# Language ${lang} not supported for PostgreSQL connector yet.`;
     }
+    async executeQuery(connection, query) {
+        console.log(`[PostgreSQL] executeQuery called for ${connection.name}`);
+        const client = this.createClient(connection);
+        try {
+            await client.connect();
+            const result = await client.query(query);
+            return result.rows;
+        }
+        catch (error) {
+            console.error(`[PostgreSQL] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+        finally {
+            await client.end();
+        }
+    }
 }
 exports.PostgreSQLConnector = PostgreSQLConnector;

package/dist/routes/dashboard.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const query_executor_1 = require("../services/query-executor");
 const router = (0, express_1.Router)();
 // Get reports/dashboards directory path relative to current working directory
 function getDashboardsDir() {
@@ -82,7 +83,7 @@ router.get('/dashboards/:id', (req, res) => {
             return res.status(404).json({ error: 'Dashboard not found' });
         }
         const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        res.json(content);
+        res.json({ id, ...content });
     }
     catch (error) {
         console.error('Error reading dashboard:', error);
@@ -90,24 +91,76 @@ router.get('/dashboards/:id', (req, res) => {
     }
 });
 // Refresh a chart's data (placeholder for now - would re-run query)
-router.post('/charts/:id/refresh', (req, res) => {
+router.post('/charts/:id/refresh', async (req, res) => {
     try {
         const { id } = req.params;
-        // For now, just return a success message
-        // In the future, this would:
-        // 1. Find the chart in a dashboard
-        // 2. Re-run its query against the data source
-        // 3. Update the chart data
-        // 4. Save the updated dashboard
-        res.json({
-            message: 'Refresh not yet implemented',
-            chartId: id,
-            lastRefreshed: new Date().toISOString()
-        });
+        const dashboardsDir = getDashboardsDir();
+        // 1. Find the chart in any dashboard
+        // We have to search all dashboards because we don't know which one calls it
+        // In a real DB we'd have a chart table, but here we scan JSONs
+        const files = fs.readdirSync(dashboardsDir).filter(file => file.endsWith('.json'));
+        let targetDashboard = null;
+        let targetDashboardFile = '';
+        let targetChart = null;
+        for (const file of files) {
+            const filePath = path.join(dashboardsDir, file);
+            const dashboard = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            const chart = dashboard.charts.find(c => c.id === id);
+            if (chart) {
+                targetDashboard = dashboard;
+                targetDashboardFile = filePath;
+                targetChart = chart;
+                break;
+            }
+        }
+        if (!targetDashboard || !targetChart || !targetDashboardFile) {
+            return res.status(404).json({ error: 'Chart not found' });
+        }
+        // 2. Execute Query
+        if (!targetChart.query || !targetChart.query.connection) {
+            return res.status(400).json({ error: 'Chart has no query configuration' });
+        }
+        console.log(`Refreshing chart ${id} using connection ${targetChart.query.connection}...`);
+        const newData = await query_executor_1.QueryExecutor.execute(targetChart.query);
+        // 3. Update Dashboard
+        targetChart.data = newData;
+        targetChart.lastRefreshed = new Date().toISOString();
+        // Save back to disk
+        fs.writeFileSync(targetDashboardFile, JSON.stringify(targetDashboard, null, 2));
+        // 4. Return new data
+        res.json(targetChart);
     }
     catch (error) {
         console.error('Error refreshing chart:', error);
-        res.status(500).json({ error: 'Failed to refresh chart' });
+        res.status(500).json({ error: error instanceof Error ? error.message : 'Failed to refresh chart' });
+    }
+});
+// SSE Endpoint for file watching
+router.get('/events', (req, res) => {
+    // Set headers for SSE
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+    const dashboardsDir = getDashboardsDir();
+    if (!fs.existsSync(dashboardsDir)) {
+        return res.end();
     }
+    console.log('Client connected to SSE stream');
+    // Watch for file changes
+    const watcher = fs.watch(dashboardsDir, (eventType, filename) => {
+        if (filename && filename.endsWith('.json')) {
+            console.log(`File changed: ${filename} (${eventType})`);
+            const dashboardId = path.basename(filename, '.json');
+            // Send event
+            res.write(`data: ${JSON.stringify({ type: 'dashboard-update', id: dashboardId })}\n\n`);
+        }
+    });
+    // Cleanup on close
+    req.on('close', () => {
+        watcher.close();
+        console.log('Client disconnected from SSE stream');
+        res.end();
+    });
 });
 exports.default = router;

package/dist/services/query-executor.d.ts

@@ -0,0 +1,5 @@
+import { ChartQuery, ChartData } from '../types/dashboard';
+export declare class QueryExecutor {
+    static execute(query: ChartQuery): Promise<ChartData>;
+    private static transformToChartData;
+}

package/dist/services/query-executor.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryExecutor = void 0;
+const connections_1 = require("../connections");
+const postgresql_1 = require("../connectors/postgresql");
+const mysql_1 = require("../connectors/mysql");
+// import { BigQueryConnector } from '../connectors/bigquery';
+// import { SnowflakeConnector } from '../connectors/snowflake';
+const shopify_1 = require("../connectors/shopify");
+class QueryExecutor {
+    static async execute(query) {
+        if (!query.connection) {
+            throw new Error('No connection specified in query');
+        }
+        const connectionConfig = (0, connections_1.getConnection)(query.connection);
+        if (!connectionConfig) {
+            throw new Error(`Connection "${query.connection}" not found`);
+        }
+        let result;
+        // Execute query based on connection type
+        switch (connectionConfig.type) {
+            case 'postgresql': {
+                const connector = new postgresql_1.PostgreSQLConnector();
+                if (!query.sql)
+                    throw new Error('SQL query required for Postgres');
+                result = await connector.executeQuery(connectionConfig, query.sql);
+                break;
+            }
+            case 'mysql': {
+                const connector = new mysql_1.MySQLConnector();
+                if (!query.sql)
+                    throw new Error('SQL query required for MySQL');
+                result = await connector.executeQuery(connectionConfig, query.sql);
+                break;
+            }
+            // case 'bigquery': {
+            //     const connector = new BigQueryConnector();
+            //     if (!query.sql) throw new Error('SQL query required for BigQuery');
+            //     result = await connector.executeQuery(connectionConfig, query.sql);
+            //     break;
+            // }
+            // case 'snowflake': {
+            //     const connector = new SnowflakeConnector();
+            //     if (!query.sql) throw new Error('SQL query required for Snowflake');
+            //     result = await connector.executeQuery(connectionConfig, query.sql);
+            //     break;
+            // }
+            case 'shopify': {
+                const connector = new shopify_1.ShopifyConnector();
+                // For Shopify, query.sql is treated as the table name/endpoint
+                const tableName = query.sql?.trim() || 'orders';
+                // Fetch first page, limit 1000
+                const tableData = await connector.getData(connectionConfig, tableName, 1, 1000);
+                result = tableData.rows;
+                break;
+            }
+            default:
+                throw new Error(`Unsupported connection type: ${connectionConfig.type}`);
+        }
+        // Transform result to ChartData format
+        return this.transformToChartData(result, query);
+    }
+    static transformToChartData(data, query) {
+        if (!data || data.length === 0) {
+            return { labels: [], datasets: [] };
+        }
+        // Auto-detect labels (first string/date column)
+        const keys = Object.keys(data[0]);
+        const labelKey = keys.find(k => typeof data[0][k] === 'string' || data[0][k] instanceof Date) || keys[0];
+        const labels = data.map(row => String(row[labelKey]));
+        // Create datasets for all numeric columns
+        const valueKeys = keys.filter(k => k !== labelKey && typeof data[0][k] === 'number');
+        const datasets = valueKeys.map((key, i) => ({
+            label: key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, ' '),
+            values: data.map(row => Number(row[key]))
+        }));
+        return { labels, datasets };
+    }
+}
+exports.QueryExecutor = QueryExecutor;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crushdataai",
-    "version": "1.2.14",
+    "version": "1.2.17",
     "description": "CLI to install CrushData AI data analyst skill for AI coding assistants",
     "main": "dist/index.js",
     "bin": {
@@ -47,6 +47,7 @@
     "files": [
         "dist",
         "assets",
+        "media",
         "ui",
         "ui-dashboard-dist"
     ],