crushdataai 1.2.13 → 1.2.15

package/assets/.agent/workflows/data-analyst.md

@@ -114,6 +114,29 @@ print(f"Missing values:\n{df.isnull().sum()}")
 
 ---
 
+## Step 5: Generate Dashboard Output
+
+After analysis, save for visualization:
+```python
+from pathlib import Path
+import json
+from datetime import datetime
+
+Path("reports/dashboards").mkdir(parents=True, exist_ok=True)
+
+dashboard = {
+    "metadata": {"title": "Analysis Dashboard", "generatedAt": datetime.now().isoformat()},
+    "kpis": [{"id": "kpi-1", "label": "Total", "value": "$50K", "trend": "+12%", "trendDirection": "up"}],
+    "charts": [{"id": "chart-1", "type": "line", "title": "Trend", "data": {"labels": ["Jan","Feb"], "datasets": [{"label": "Revenue", "values": [10000,20000]}]}}]
+}
+
+with open("reports/dashboards/dashboard.json", "w") as f:
+    json.dump(dashboard, f, indent=2)
+```
+Tell user: "Run `npx crushdataai dashboard` to view."
+
+---
+
 ## Pre-Delivery Checklist
 
 - [ ] Business question answered

package/assets/.claude/skills/data-analyst/SKILL.md

@@ -170,6 +170,54 @@ FROM table;
 
 ---
 
+## Step 5: Generate Dashboard Output
+
+**After analysis, save results for dashboard visualization:**
+
+1. **Search for best chart type:**
+   ```bash
+   python3 .claude/skills/data-analyst/scripts/search.py "<metric description>" --domain chart
+   ```
+
+2. **Create dashboard JSON:**
+   ```python
+   from pathlib import Path
+   import json
+   from datetime import datetime
+   
+   Path("reports/dashboards").mkdir(parents=True, exist_ok=True)
+   
+   dashboard = {
+       "metadata": {
+           "title": "Analysis Dashboard",
+           "generatedAt": datetime.now().isoformat(),
+           "dataRange": f"{start_date} to {end_date}"
+       },
+       "kpis": [
+           {"id": "kpi-1", "label": "Total Revenue", "value": "$50,000", "trend": "+12%", "trendDirection": "up"}
+       ],
+       "charts": [
+           {
+               "id": "chart-1",
+               "type": "line",  # line, bar, pie, area, scatter, donut, table
+               "title": "Monthly Trend",
+               "data": {
+                   "labels": ["Jan", "Feb", "Mar"],
+                   "datasets": [{"label": "Revenue", "values": [10000, 15000, 25000]}]
+               }
+           }
+       ]
+   }
+   
+   with open("reports/dashboards/dashboard.json", "w") as f:
+       json.dump(dashboard, f, indent=2)
+   ```
+
+3. **Tell user:**
+   > "Dashboard ready! Run `npx crushdataai dashboard` to view."
+
+---
+
 ## Pre-Delivery Checklist
 
 Before presenting final results:

package/assets/.cursor/commands/data-analyst.md

@@ -60,6 +60,26 @@ Report findings and ask user for confirmation.
 - Compare to benchmarks
 - Present for user validation
 
+### 5. Generate Dashboard Output
+After analysis, save for visualization:
+```python
+from pathlib import Path
+import json
+from datetime import datetime
+
+Path("reports/dashboards").mkdir(parents=True, exist_ok=True)
+
+dashboard = {
+    "metadata": {"title": "Analysis", "generatedAt": datetime.now().isoformat()},
+    "kpis": [{"id": "kpi-1", "label": "Total", "value": "$50K", "trend": "+12%"}],
+    "charts": [{"id": "chart-1", "type": "line", "title": "Trend", "data": {"labels": ["Jan","Feb"], "datasets": [{"label": "Revenue", "values": [10000,20000]}]}}]
+}
+
+with open("reports/dashboards/dashboard.json", "w") as f:
+    json.dump(dashboard, f, indent=2)
+```
+Tell user: "Run `npx crushdataai dashboard` to view."
+
 ---
 
 ## Quick Reference

package/assets/.github/prompts/data-analyst.prompt.md

@@ -58,3 +58,21 @@ Report and confirm before proceeding.
 - Check totals
 - Compare benchmarks
 - User validation
+
+### 5. Generate Dashboard Output
+After analysis, save for visualization:
+```python
+from pathlib import Path
+import json
+from datetime import datetime
+
+Path("reports/dashboards").mkdir(parents=True, exist_ok=True)
+dashboard = {
+    "metadata": {"title": "Analysis", "generatedAt": datetime.now().isoformat()},
+    "kpis": [{"id": "kpi-1", "label": "Total", "value": "$50K", "trend": "+12%"}],
+    "charts": [{"id": "chart-1", "type": "line", "title": "Trend", "data": {"labels": ["Jan","Feb"], "datasets": [{"label": "Revenue", "values": [10000,20000]}]}}]
+}
+with open("reports/dashboards/dashboard.json", "w") as f:
+    json.dump(dashboard, f, indent=2)
+```
+Tell user: "Run `npx crushdataai dashboard` to view."

package/assets/.kiro/steering/data-analyst.md

@@ -60,3 +60,21 @@ Ask: "Does this match your expectation?"
 - Compare to benchmarks
 - Document assumptions
 - Present for user confirmation
+
+### 5. Generate Dashboard Output
+After analysis, save for visualization:
+```python
+from pathlib import Path
+import json
+from datetime import datetime
+
+Path("reports/dashboards").mkdir(parents=True, exist_ok=True)
+dashboard = {
+    "metadata": {"title": "Analysis", "generatedAt": datetime.now().isoformat()},
+    "kpis": [{"id": "kpi-1", "label": "Total", "value": "$50K", "trend": "+12%"}],
+    "charts": [{"id": "chart-1", "type": "line", "title": "Trend", "data": {"labels": ["Jan","Feb"], "datasets": [{"label": "Revenue", "values": [10000,20000]}]}}]
+}
+with open("reports/dashboards/dashboard.json", "w") as f:
+    json.dump(dashboard, f, indent=2)
+```
+Tell user: "Run `npx crushdataai dashboard` to view."

package/assets/.windsurf/workflows/data-analyst.md

@@ -58,3 +58,21 @@ print(f"Shape: {df.shape}, Dates: {df['date'].min()} to {df['date'].max()}")
 - Check totals are reasonable
 - Compare to benchmarks
 - Present for user validation
+
+### 5. Generate Dashboard Output
+After analysis, save for visualization:
+```python
+from pathlib import Path
+import json
+from datetime import datetime
+
+Path("reports/dashboards").mkdir(parents=True, exist_ok=True)
+dashboard = {
+    "metadata": {"title": "Analysis", "generatedAt": datetime.now().isoformat()},
+    "kpis": [{"id": "kpi-1", "label": "Total", "value": "$50K", "trend": "+12%"}],
+    "charts": [{"id": "chart-1", "type": "line", "title": "Trend", "data": {"labels": ["Jan","Feb"], "datasets": [{"label": "Revenue", "values": [10000,20000]}]}}]
+}
+with open("reports/dashboards/dashboard.json", "w") as f:
+    json.dump(dashboard, f, indent=2)
+```
+Tell user: "Run `npx crushdataai dashboard` to view."

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/dashboard-server.d.ts

@@ -0,0 +1 @@
+export declare function startDashboardServer(port: number): Promise<void>;

package/dist/dashboard-server.js

@@ -0,0 +1,78 @@
+"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.startDashboardServer = startDashboardServer;
+const express_1 = __importDefault(require("express"));
+const path = __importStar(require("path"));
+const open_1 = __importDefault(require("open"));
+const dashboard_1 = __importDefault(require("./routes/dashboard"));
+async function startDashboardServer(port) {
+    const app = (0, express_1.default)();
+    // Serve static files from the built dashboard UI
+    const uiPath = path.join(__dirname, '..', 'ui-dashboard-dist');
+    app.use(express_1.default.static(uiPath));
+    // API routes
+    app.use('/api', dashboard_1.default);
+    // SPA fallback - serve index.html for client-side routing
+    app.get('*', (_req, res) => {
+        res.sendFile(path.join(uiPath, 'index.html'));
+    });
+    return new Promise((resolve, reject) => {
+        const server = app.listen(port, async () => {
+            console.log(`\n📊 Dashboard UI running at http://localhost:${port}\n`);
+            console.log('   Looking for dashboards in: reports/dashboards/');
+            console.log('   Press Ctrl+C to stop\n');
+            // Open browser
+            try {
+                await (0, open_1.default)(`http://localhost:${port}`);
+            }
+            catch (err) {
+                // Ignore open errors
+            }
+            resolve();
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${port} is already in use. Try a different port with --port`));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}

package/dist/index.js

@@ -37,12 +37,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const commands_1 = require("./commands");
 const server_1 = require("./server");
+const dashboard_server_1 = require("./dashboard-server");
 const connections_1 = require("./connections");
 const program = new commander_1.Command();
 program
     .name('crushdataai')
     .description('CLI to install CrushData AI data analyst skill for AI coding assistants')
-    .version('1.2.1');
+    .version('1.2.14');
 program
     .command('init')
     .description('Initialize CrushData AI skill in current project')
@@ -125,4 +126,19 @@ program
     const { schema } = await Promise.resolve().then(() => __importStar(require('./commands/schema')));
     await schema(connection, table);
 });
+program
+    .command('dashboard')
+    .description('Open the dashboard visualization UI')
+    .option('-p, --port <port>', 'Server port', '3002')
+    .action(async (options) => {
+    const port = parseInt(options.port);
+    console.log('\n📊 Starting CrushData AI Dashboard...\n');
+    try {
+        await (0, dashboard_server_1.startDashboardServer)(port);
+    }
+    catch (error) {
+        console.error(`❌ Error: ${error.message}`);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/routes/dashboard.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/dashboard.js

@@ -0,0 +1,166 @@
+"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 });
+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() {
+    return path.join(process.cwd(), 'reports', 'dashboards');
+}
+// List all available dashboards
+router.get('/dashboards', (_req, res) => {
+    try {
+        const dashboardsDir = getDashboardsDir();
+        // Check if directory exists
+        if (!fs.existsSync(dashboardsDir)) {
+            return res.json([]);
+        }
+        // Read all JSON files in the directory
+        const files = fs.readdirSync(dashboardsDir)
+            .filter(file => file.endsWith('.json'));
+        const dashboards = files.map(file => {
+            const filePath = path.join(dashboardsDir, file);
+            const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            // Use filename without extension as ID
+            const id = path.basename(file, '.json');
+            return {
+                id,
+                title: content.metadata?.title || id,
+                generatedAt: content.metadata?.generatedAt || '',
+                chartCount: content.charts?.length || 0,
+                kpiCount: content.kpis?.length || 0
+            };
+        });
+        res.json(dashboards);
+    }
+    catch (error) {
+        console.error('Error listing dashboards:', error);
+        res.status(500).json({ error: 'Failed to list dashboards' });
+    }
+});
+// Get a specific dashboard by ID
+router.get('/dashboards/:id', (req, res) => {
+    try {
+        const { id } = req.params;
+        const dashboardsDir = getDashboardsDir();
+        const filePath = path.join(dashboardsDir, `${id}.json`);
+        if (!fs.existsSync(filePath)) {
+            return res.status(404).json({ error: 'Dashboard not found' });
+        }
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        res.json({ id, ...content });
+    }
+    catch (error) {
+        console.error('Error reading dashboard:', error);
+        res.status(500).json({ error: 'Failed to read dashboard' });
+    }
+});
+// Refresh a chart's data (placeholder for now - would re-run query)
+router.post('/charts/:id/refresh', async (req, res) => {
+    try {
+        const { id } = req.params;
+        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: 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;
+}