@devflow-tools/database 0.18.4 → 0.18.5

package/dist/database.d.ts

@@ -198,6 +198,15 @@ export declare class DevFlowDatabase {
     getRunSteps(runId: string): any[];
     insertEvent(event: any): void;
     getEvents(runId: string): any[];
+    appendDashboardRunEvent(event: {
+        runId: string;
+        projectRoot: string;
+        sequence: number;
+        kind: string;
+        payload?: unknown;
+        timestamp?: number;
+    }): void;
+    listDashboardRunEvents(runId: string, projectRoot: string, after?: number): any[];
     getProjectStats(projectRoot: string): any | null;
     upsertProjectStats(stats: any): void;
     getRuns(): any[];
@@ -256,7 +265,7 @@ export declare class DevFlowDatabase {
         metadata?: Record<string, unknown>;
     }): void;
     mergeSkillExecutionMetadata(executionId: string, incoming: Record<string, unknown>): Record<string, unknown> | null;
-    listSkillExecutions(limit: number, skillName?: string): any[];
+    listSkillExecutions(limit: number, skillName?: string, projectRoot?: string): any[];
     insertToolCallEvent(params: {
         eventId: string;
         executionId: string;
@@ -299,7 +308,7 @@ export declare class DevFlowDatabase {
         missedTools: string[];
         mcpCallShare: number;
     };
-    getMcpCompliance(): {
+    getMcpCompliance(projectRoot?: string): {
         overall: number;
         bySkill: Record<string, number>;
         missedTools: string[];
@@ -323,8 +332,8 @@ export declare class DevFlowDatabase {
         metadata?: string;
         createdAt: number;
     }): void;
-    getToolMetrics(sessionId?: string, toolName?: string, limit?: number, offset?: number): any[];
-    getToolMetricsSummary(days?: number): any[];
+    getToolMetrics(sessionId?: string, toolName?: string, limit?: number, offset?: number, projectRoot?: string): any[];
+    getToolMetricsSummary(days?: number, projectRoot?: string): any[];
     aggregatePendingToolMetrics(limit?: number): number;
     insertFeedback(feedback: FeedbackRecord): void;
     listFeedback(projectRoot?: string, limit?: number): FeedbackRecord[];
@@ -357,12 +366,13 @@ export declare class DevFlowDatabase {
         status?: string;
         limit?: number;
         offset?: number;
+        projectRoot?: string;
     }): any[];
     updateAccuracyFeedback(id: string, feedback: {
         relevance: 'hit' | 'partial' | 'miss';
         note?: string;
     }): void;
-    getAccuracyStats(engine?: string, since?: number): any;
+    getAccuracyStats(engine?: string, since?: number, projectRoot?: string): any;
     insertBenchmarkReport<T extends BenchmarkReportRecord>(report: T): void;
     getBenchmarkReport<T extends BenchmarkReportRecord = BenchmarkReportRecord>(runId: string): T | null;
     getLatestBenchmarkReport<T extends BenchmarkReportRecord = BenchmarkReportRecord>(suiteId?: string): T | null;

package/dist/database.js

@@ -159,6 +159,19 @@ class DevFlowDatabase {
         FOREIGN KEY (run_id) REFERENCES runs(id)
       );
 
+      CREATE TABLE IF NOT EXISTS dashboard_run_events (
+        run_id TEXT NOT NULL,
+        project_root TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        payload TEXT,
+        timestamp INTEGER NOT NULL,
+        PRIMARY KEY (project_root, run_id, sequence)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_dashboard_run_events_project
+        ON dashboard_run_events(project_root, run_id, sequence);
+
       CREATE TABLE IF NOT EXISTS project_stats (
         project_root TEXT PRIMARY KEY,
         total_runs INTEGER DEFAULT 0,
@@ -1077,6 +1090,34 @@ class DevFlowDatabase {
       CREATE INDEX IF NOT EXISTS idx_merge_queue_project
         ON devflow_merge_queue(project_root, state, created_at, merge_id);
     `);
+        // Migration: dashboard run event cursors originally keyed only by run/sequence.
+        // Rebuild the small append-only table so project isolation is part of the key.
+        try {
+            const columns = this.db.prepare('PRAGMA table_info(dashboard_run_events)').all();
+            if (columns.length > 0 && columns.some((column) => column.name === 'project_root')) {
+                const primaryKey = this.db.prepare('PRAGMA table_info(dashboard_run_events)').all();
+                if (primaryKey.filter((column) => column.pk > 0).map((column) => column.name).join(',') === 'run_id,sequence') {
+                    this.db.exec('ALTER TABLE dashboard_run_events RENAME TO dashboard_run_events_legacy');
+                    this.db.exec(`
+            CREATE TABLE dashboard_run_events (
+              run_id TEXT NOT NULL,
+              project_root TEXT NOT NULL,
+              sequence INTEGER NOT NULL,
+              kind TEXT NOT NULL,
+              payload TEXT,
+              timestamp INTEGER NOT NULL,
+              PRIMARY KEY (project_root, run_id, sequence)
+            );
+            INSERT OR IGNORE INTO dashboard_run_events (run_id, project_root, sequence, kind, payload, timestamp)
+              SELECT run_id, project_root, sequence, kind, payload, timestamp FROM dashboard_run_events_legacy;
+            DROP TABLE dashboard_run_events_legacy;
+            CREATE INDEX IF NOT EXISTS idx_dashboard_run_events_project
+              ON dashboard_run_events(project_root, run_id, sequence);
+          `);
+                }
+            }
+        }
+        catch { }
         // Migration: add session_id to skill_executions (SQLite compat — ignore if exists)
         try {
             this.db.exec('ALTER TABLE skill_executions ADD COLUMN session_id TEXT REFERENCES sessions(id)');
@@ -1414,6 +1455,28 @@ class DevFlowDatabase {
             metadata: row.metadata ? JSON.parse(row.metadata) : null
         }));
     }
+    appendDashboardRunEvent(event) {
+        this.db.prepare(`
+      INSERT OR IGNORE INTO dashboard_run_events (run_id, project_root, sequence, kind, payload, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(event.runId, event.projectRoot, event.sequence, event.kind, event.payload === undefined ? null : JSON.stringify(event.payload), event.timestamp ?? Date.now());
+    }
+    listDashboardRunEvents(runId, projectRoot, after = 0) {
+        const rows = this.db.prepare(`
+      SELECT run_id, project_root, sequence, kind, payload, timestamp
+      FROM dashboard_run_events
+      WHERE run_id = ? AND project_root = ? AND sequence > ?
+      ORDER BY sequence ASC
+    `).all(runId, projectRoot, after);
+        return rows.map((row) => ({
+            runId: row.run_id,
+            projectRoot: row.project_root,
+            sequence: row.sequence,
+            kind: row.kind,
+            payload: row.payload ? JSON.parse(row.payload) : null,
+            timestamp: row.timestamp,
+        }));
+    }
     getProjectStats(projectRoot) {
         const row = this.db.prepare('SELECT * FROM project_stats WHERE project_root = ?').get(projectRoot);
         if (!row)
@@ -1759,14 +1822,21 @@ class DevFlowDatabase {
         this.updateSkillExecution(executionId, { metadata: merged });
         return merged;
     }
-    listSkillExecutions(limit, skillName) {
-        let query = 'SELECT * FROM skill_executions';
+    listSkillExecutions(limit, skillName, projectRoot) {
+        let query = 'SELECT e.* FROM skill_executions e LEFT JOIN sessions s ON s.id = e.session_id';
         const params = [];
+        const conditions = [];
         if (skillName) {
-            query += ' WHERE skill_name = ?';
+            conditions.push('e.skill_name = ?');
             params.push(skillName);
         }
-        query += ' ORDER BY started_at DESC LIMIT ?';
+        if (projectRoot) {
+            conditions.push('s.project_root = ?');
+            params.push(projectRoot);
+        }
+        if (conditions.length)
+            query += ` WHERE ${conditions.join(' AND ')}`;
+        query += ' ORDER BY e.started_at DESC LIMIT ?';
         params.push(Number(limit));
         const rows = this.db.prepare(query).all(...params);
         return rows.map(row => ({
@@ -2038,8 +2108,10 @@ class DevFlowDatabase {
         };
     }
     // ---- MCP Compliance ----
-    getMcpCompliance() {
-        const executions = this.db.prepare('SELECT execution_id, skill_name FROM skill_executions').all();
+    getMcpCompliance(projectRoot) {
+        const executions = this.db.prepare(projectRoot
+            ? 'SELECT e.execution_id, e.skill_name FROM skill_executions e JOIN sessions s ON s.id = e.session_id WHERE s.project_root = ?'
+            : 'SELECT execution_id, skill_name FROM skill_executions').all(...(projectRoot ? [projectRoot] : []));
         const bySkill = {};
         const bySkillCounts = new Map();
         let applicableObligations = 0;
@@ -2093,34 +2165,41 @@ class DevFlowDatabase {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(metric.id, metric.toolCallEventId, metric.sessionId, metric.toolName, metric.query ?? null, metric.status ?? 'success', metric.resultCount ?? 0, metric.resultSizeBytes ?? 0, metric.latencyMs ?? 0, metric.engine ?? null, metric.accuracyQueryId ?? null, metric.metadata ?? null, metric.createdAt);
     }
-    getToolMetrics(sessionId, toolName, limit = 100, offset = 0) {
-        let sql = 'SELECT * FROM tool_metrics WHERE 1=1';
+    getToolMetrics(sessionId, toolName, limit = 100, offset = 0, projectRoot) {
+        let sql = 'SELECT tm.* FROM tool_metrics tm LEFT JOIN sessions s ON s.id = tm.session_id WHERE 1=1';
         const params = [];
         if (sessionId) {
-            sql += ' AND session_id = ?';
+            sql += ' AND tm.session_id = ?';
             params.push(sessionId);
         }
         if (toolName) {
-            sql += ' AND tool_name = ?';
+            sql += ' AND tm.tool_name = ?';
             params.push(toolName);
         }
-        sql += ' ORDER BY created_at DESC LIMIT ? OFFSET ?';
+        if (projectRoot) {
+            sql += ' AND s.project_root = ?';
+            params.push(projectRoot);
+        }
+        sql += ' ORDER BY tm.created_at DESC LIMIT ? OFFSET ?';
         params.push(limit, offset);
         return this.db.prepare(sql).all(...params);
     }
-    getToolMetricsSummary(days = 7) {
+    getToolMetricsSummary(days = 7, projectRoot) {
         const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        const projectClause = projectRoot ? ' AND s.project_root = ?' : '';
+        const params = projectRoot ? [cutoff, projectRoot] : [cutoff];
         const rows = this.db.prepare(`
-      SELECT tool_name, COUNT(*) as call_count,
-        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success_count,
-        SUM(CASE WHEN result_count = 0 THEN 1 ELSE 0 END) as empty_count,
-        AVG(result_count) as avg_results,
-        AVG(latency_ms) as avg_latency
-      FROM tool_metrics
-      WHERE created_at >= ?
-      GROUP BY tool_name
+      SELECT tm.tool_name, COUNT(*) as call_count,
+        SUM(CASE WHEN tm.status = 'success' THEN 1 ELSE 0 END) as success_count,
+        SUM(CASE WHEN tm.result_count = 0 THEN 1 ELSE 0 END) as empty_count,
+        AVG(tm.result_count) as avg_results,
+        AVG(tm.latency_ms) as avg_latency
+      FROM tool_metrics tm
+      LEFT JOIN sessions s ON s.id = tm.session_id
+      WHERE tm.created_at >= ?${projectClause}
+      GROUP BY tm.tool_name
       ORDER BY call_count DESC
-    `).all(cutoff);
+    `).all(...params);
         return rows.map((r) => ({
             toolName: r.tool_name,
             callCount: r.call_count,
@@ -2247,17 +2326,21 @@ class DevFlowDatabase {
     `).run(q.id, q.sessionId, q.engine, q.query, q.topKResults, q.selectedIds ?? null, q.createdAt);
     }
     getAccuracyQueries(options) {
-        let sql = 'SELECT * FROM accuracy_queries WHERE 1=1';
+        let sql = 'SELECT aq.* FROM accuracy_queries aq LEFT JOIN sessions s ON s.id = aq.session_id WHERE 1=1';
         const params = [];
         if (options.engine) {
-            sql += ' AND engine = ?';
+            sql += ' AND aq.engine = ?';
             params.push(options.engine);
         }
         if (options.status === 'annotated')
-            sql += ' AND relevance_feedback IS NOT NULL';
+            sql += ' AND aq.relevance_feedback IS NOT NULL';
         if (options.status === 'unannotated')
-            sql += ' AND relevance_feedback IS NULL';
-        sql += ' ORDER BY created_at DESC LIMIT ? OFFSET ?';
+            sql += ' AND aq.relevance_feedback IS NULL';
+        if (options.projectRoot) {
+            sql += ' AND s.project_root = ?';
+            params.push(options.projectRoot);
+        }
+        sql += ' ORDER BY aq.created_at DESC LIMIT ? OFFSET ?';
         params.push(options.limit ?? 50, options.offset ?? 0);
         const rows = this.db.prepare(sql).all(...params);
         return rows.map((r) => ({
@@ -2273,24 +2356,29 @@ class DevFlowDatabase {
     updateAccuracyFeedback(id, feedback) {
         this.db.prepare('UPDATE accuracy_queries SET relevance_feedback = ?, annotator_note = ?, annotated_at = ? WHERE id = ?').run(feedback.relevance, feedback.note ?? null, Date.now(), id);
     }
-    getAccuracyStats(engine, since) {
+    getAccuracyStats(engine, since, projectRoot) {
         let where = 'WHERE 1=1';
         const params = [];
         if (engine) {
-            where += ' AND engine = ?';
+            where += ' AND aq.engine = ?';
             params.push(engine);
         }
         if (since) {
-            where += ' AND created_at >= ?';
+            where += ' AND aq.created_at >= ?';
             params.push(since);
         }
+        if (projectRoot) {
+            where += ' AND s.project_root = ?';
+            params.push(projectRoot);
+        }
         const rows = this.db.prepare(`
       SELECT
         engine,
         COUNT(*) as totalQueries,
         SUM(CASE WHEN relevance_feedback IS NOT NULL THEN 1 ELSE 0 END) as annotatedQueries,
         SUM(CASE WHEN relevance_feedback = 'hit' THEN 1 ELSE 0 END) as hitCount
-      FROM accuracy_queries ${where}
+      FROM accuracy_queries aq
+      LEFT JOIN sessions s ON s.id = aq.session_id ${where}
       GROUP BY engine
     `).all(...params);
         const statsByEngine = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devflow-tools/database",
-  "version": "0.18.4",
+  "version": "0.18.5",
   "description": "SQLite persistence primitives shared by DevFlow runtime packages.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@devflow-tools/sdk": "0.18.4"
+    "@devflow-tools/sdk": "0.18.5"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",