@devflow-tools/database 0.8.10 → 0.9.0

package/dist/database.js

@@ -12,9 +12,9 @@ class DevFlowDatabase {
         }
         const dbPath = (0, path_1.join)(devflowDir, 'devflow.db');
         this.db = new node_sqlite_1.NodeSqliteDatabase(dbPath);
-        // 启用 WAL 模式
         this.db.exec('PRAGMA journal_mode = WAL');
         this.db.exec('PRAGMA busy_timeout = 5000');
+        this.db.exec('PRAGMA foreign_keys = OFF');
         this.initializeSchema();
     }
     initializeSchema() {
@@ -115,8 +115,7 @@ class DevFlowDatabase {
         subagent_id TEXT,
         error TEXT,
         blocked INTEGER DEFAULT 0 CHECK (blocked IN (0, 1)),
-        block_reason TEXT,
-        FOREIGN KEY (execution_id) REFERENCES skill_executions(execution_id) ON DELETE CASCADE
+        block_reason TEXT
       );
 
       CREATE INDEX IF NOT EXISTS idx_executions_skill ON skill_executions(skill_name);
@@ -126,7 +125,93 @@ class DevFlowDatabase {
       CREATE INDEX IF NOT EXISTS idx_events_timestamp ON tool_call_events(timestamp);
       CREATE INDEX IF NOT EXISTS idx_events_tool_type ON tool_call_events(tool_type);
       CREATE INDEX IF NOT EXISTS idx_events_mcp ON tool_call_events(is_mcp_tool);
+      CREATE INDEX IF NOT EXISTS idx_events_session ON tool_call_events(session_id);
+
+      -- Sessions table: top-level container per Claude Code session
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        project_root TEXT NOT NULL,
+        label TEXT,
+        started_at INTEGER NOT NULL,
+        finished_at INTEGER,
+        duration_ms INTEGER DEFAULT 0,
+        total_tool_calls INTEGER DEFAULT 0,
+        mcp_tool_calls INTEGER DEFAULT 0,
+        direct_tool_calls INTEGER DEFAULT 0,
+        subagent_count INTEGER DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'running' CHECK (status IN ('running', 'completed', 'failed'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_root);
+      CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at DESC);
     `);
+        // 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)');
+        }
+        catch { }
+        // Migration: add session_id to tool_call_events
+        try {
+            this.db.exec('ALTER TABLE tool_call_events ADD COLUMN session_id TEXT REFERENCES sessions(id)');
+        }
+        catch { }
+        // Migration: kind column for event type classification
+        try {
+            this.db.exec("ALTER TABLE tool_call_events ADD COLUMN kind TEXT DEFAULT 'tool_use'");
+        }
+        catch { }
+        // Migration: workflow run persistence
+        try {
+            this.db.exec('ALTER TABLE tool_call_events ADD COLUMN workflow_run_id TEXT');
+        }
+        catch { }
+        // Migration: tool_metrics table for per-tool metrics collection
+        try {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS tool_metrics (
+          id TEXT PRIMARY KEY,
+          tool_call_event_id TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          tool_name TEXT NOT NULL,
+          query TEXT,
+          status TEXT NOT NULL DEFAULT 'success',
+          result_count INTEGER DEFAULT 0,
+          result_size_bytes INTEGER DEFAULT 0,
+          latency_ms INTEGER DEFAULT 0,
+          engine TEXT,
+          accuracy_query_id TEXT,
+          metadata TEXT,
+          created_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_tool_metrics_session ON tool_metrics(session_id);
+        CREATE INDEX IF NOT EXISTS idx_tool_metrics_tool ON tool_metrics(tool_name);
+        CREATE INDEX IF NOT EXISTS idx_tool_metrics_created ON tool_metrics(created_at);
+      `);
+        }
+        catch { }
+        // Migration: accuracy queries table for search quality tracking
+        try {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS accuracy_queries (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          engine TEXT NOT NULL CHECK(engine IN ('codegraph','knowledge','memory')),
+          query TEXT NOT NULL,
+          top_k_results TEXT NOT NULL,
+          selected_ids TEXT,
+          relevance_feedback TEXT CHECK(relevance_feedback IN ('hit','partial','miss')),
+          annotator_note TEXT,
+          annotated_at INTEGER,
+          created_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_accuracy_queries_engine ON accuracy_queries(engine);
+        CREATE INDEX IF NOT EXISTS idx_accuracy_queries_session ON accuracy_queries(session_id);
+        CREATE INDEX IF NOT EXISTS idx_accuracy_queries_feedback ON accuracy_queries(relevance_feedback);
+      `);
+        }
+        catch { }
     }
     insertRun(run) {
         this.db.prepare(`
@@ -181,7 +266,7 @@ class DevFlowDatabase {
         this.db.prepare(`
       INSERT INTO telemetry_events (run_id, kind, timestamp, duration, success, tool_name, plugin_name, metadata)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(event.runId, event.kind, event.timestamp, event.duration, event.success, event.toolName, event.pluginName, JSON.stringify(event.metadata) ?? null);
+    `).run(event.runId ?? null, event.kind ?? null, event.timestamp ?? null, event.duration ?? null, event.success ?? null, event.toolName ?? null, event.pluginName ?? null, event.metadata ? JSON.stringify(event.metadata) : null);
     }
     getEvents(runId) {
         const rows = this.db.prepare('SELECT * FROM telemetry_events WHERE run_id = ?').all(runId);
@@ -234,13 +319,146 @@ class DevFlowDatabase {
     deleteSetting(key) {
         this.db.prepare('DELETE FROM settings WHERE key = ?').run(key);
     }
+    // ---- Sessions ----
+    insertSession(params) {
+        this.db.prepare(`
+      INSERT OR IGNORE INTO sessions (id, project_root, label, started_at, status)
+      VALUES (?, ?, ?, ?, 'running')
+    `).run(params.id, params.projectRoot, params.label ?? null, params.startedAt);
+    }
+    getSession(id) {
+        const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            projectRoot: row.project_root,
+            label: row.label,
+            startedAt: row.started_at,
+            finishedAt: row.finished_at,
+            durationMs: row.duration_ms,
+            totalToolCalls: row.total_tool_calls,
+            mcpToolCalls: row.mcp_tool_calls,
+            directToolCalls: row.direct_tool_calls,
+            subagentCount: row.subagent_count,
+            status: row.status,
+        };
+    }
+    listSessions(limit, offset, projectRoot) {
+        let query = 'SELECT * FROM sessions';
+        const params = [];
+        if (projectRoot) {
+            query += ' WHERE project_root = ?';
+            params.push(projectRoot);
+        }
+        query += ' ORDER BY started_at DESC LIMIT ? OFFSET ?';
+        params.push(Number(limit), Number(offset));
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((row) => ({
+            id: row.id,
+            projectRoot: row.project_root,
+            label: row.label,
+            startedAt: row.started_at,
+            finishedAt: row.finished_at,
+            durationMs: row.duration_ms,
+            totalToolCalls: row.total_tool_calls,
+            mcpToolCalls: row.mcp_tool_calls,
+            directToolCalls: row.direct_tool_calls,
+            subagentCount: row.subagent_count,
+            status: row.status,
+        }));
+    }
+    closeSession(id, finishedAt) {
+        const events = this.db.prepare('SELECT * FROM tool_call_events WHERE session_id = ? OR execution_id = ?').all(id, id);
+        // deduplicate by event_id
+        const seen = new Set();
+        const unique = events.filter((e) => {
+            if (seen.has(e.event_id))
+                return false;
+            seen.add(e.event_id);
+            return true;
+        });
+        const totalToolCalls = unique.length;
+        const mcpToolCalls = unique.filter((e) => e.is_mcp_tool === 1).length;
+        const directToolCalls = totalToolCalls - mcpToolCalls;
+        const subagentCount = unique.filter((e) => e.tool_type === 'subagent').length;
+        const timestamps = unique.map((e) => e.timestamp).filter(Boolean);
+        const durationMs = timestamps.length >= 2
+            ? Math.max(...timestamps) - Math.min(...timestamps)
+            : 0;
+        this.db.prepare(`
+      UPDATE sessions
+      SET finished_at = ?, duration_ms = ?, total_tool_calls = ?,
+          mcp_tool_calls = ?, direct_tool_calls = ?, subagent_count = ?,
+          status = 'completed'
+      WHERE id = ?
+    `).run(finishedAt ?? Date.now(), durationMs, totalToolCalls, mcpToolCalls, directToolCalls, subagentCount, id);
+    }
+    listToolCallEventsBySession(sessionId) {
+        const rows = this.db.prepare('SELECT * FROM tool_call_events WHERE session_id = ? ORDER BY timestamp ASC').all(sessionId);
+        return rows.map(row => ({
+            eventId: row.event_id,
+            executionId: row.execution_id,
+            sessionId: row.session_id,
+            timestamp: row.timestamp,
+            toolName: row.tool_name,
+            toolType: row.tool_type,
+            isMcpTool: row.is_mcp_tool === 1,
+            mcpToolName: row.mcp_tool_name,
+            mcpEnforced: row.mcp_enforced === 1,
+            mcpFallback: row.mcp_fallback === 1,
+            kind: row.kind,
+            input: row.input ? JSON.parse(row.input) : null,
+            output: row.output ? JSON.parse(row.output) : null,
+            duration: row.duration,
+            parentToolCallId: row.parent_tool_call_id,
+            subagentId: row.subagent_id,
+            error: row.error,
+            blocked: row.blocked === 1,
+            blockReason: row.block_reason,
+        }));
+    }
+    listToolCallEventsBySessions(sessionIds) {
+        if (sessionIds.length === 0)
+            return {};
+        const placeholders = sessionIds.map(() => '?').join(',');
+        const rows = this.db.prepare(`SELECT * FROM tool_call_events WHERE session_id IN (${placeholders}) ORDER BY timestamp ASC`).all(...sessionIds);
+        const grouped = {};
+        for (const row of rows) {
+            const sid = row.session_id;
+            if (!grouped[sid])
+                grouped[sid] = [];
+            grouped[sid].push({
+                eventId: row.event_id,
+                executionId: row.execution_id,
+                sessionId: row.session_id,
+                timestamp: row.timestamp,
+                toolName: row.tool_name,
+                toolType: row.tool_type,
+                isMcpTool: row.is_mcp_tool === 1,
+                mcpToolName: row.mcp_tool_name,
+                mcpEnforced: row.mcp_enforced === 1,
+                mcpFallback: row.mcp_fallback === 1,
+                kind: row.kind,
+                input: row.input ? JSON.parse(row.input) : null,
+                output: row.output ? JSON.parse(row.output) : null,
+                duration: row.duration,
+                parentToolCallId: row.parent_tool_call_id,
+                subagentId: row.subagent_id,
+                error: row.error,
+                blocked: row.blocked === 1,
+                blockReason: row.block_reason,
+            });
+        }
+        return grouped;
+    }
     // ---- Skill Executions ----
     insertSkillExecution(params) {
         this.db.prepare(`
       INSERT INTO skill_executions
-      (execution_id, skill_name, started_at, status, required_mcp_tools, available_mcp_tools)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(params.executionId, params.skillName, params.startedAt, params.status, params.requiredMcpTools ? JSON.stringify(params.requiredMcpTools) : null, params.availableMcpTools ? JSON.stringify(params.availableMcpTools) : null);
+      (execution_id, session_id, skill_name, started_at, status, required_mcp_tools, available_mcp_tools)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(params.executionId, params.sessionId ?? null, params.skillName, params.startedAt, params.status, params.requiredMcpTools ? JSON.stringify(params.requiredMcpTools) : null, params.availableMcpTools ? JSON.stringify(params.availableMcpTools) : null);
     }
     getSkillExecution(executionId) {
         const row = this.db.prepare('SELECT * FROM skill_executions WHERE execution_id = ?').get(executionId);
@@ -248,6 +466,7 @@ class DevFlowDatabase {
             return null;
         return {
             executionId: row.execution_id,
+            sessionId: row.session_id,
             skillName: row.skill_name,
             startedAt: row.started_at,
             finishedAt: row.finished_at,
@@ -258,7 +477,6 @@ class DevFlowDatabase {
             mcpToolCalls: row.mcp_tool_calls,
             directToolCalls: row.direct_tool_calls,
             subagentCount: row.subagent_count,
-            totalTokens: row.total_tokens,
             totalDuration: row.total_duration,
             mcpComplianceRate: row.mcp_compliance_rate,
             missedMcpTools: row.missed_mcp_tools ? JSON.parse(row.missed_mcp_tools) : null,
@@ -280,10 +498,6 @@ class DevFlowDatabase {
             sets.push('total_duration = ?');
             values.push(updates.totalDuration);
         }
-        if (updates.totalTokens !== undefined) {
-            sets.push('total_tokens = ?');
-            values.push(updates.totalTokens);
-        }
         if (updates.mcpComplianceRate !== undefined) {
             sets.push('mcp_compliance_rate = ?');
             values.push(updates.mcpComplianceRate);
@@ -314,13 +528,6 @@ class DevFlowDatabase {
         }
     }
     listSkillExecutions(limit, skillName) {
-        // Auto-timeout stale running executions (> 30 minutes)
-        const timeoutThreshold = Date.now() - 30 * 60 * 1000;
-        this.db.prepare(`
-      UPDATE skill_executions
-      SET status = 'failed', finished_at = ?
-      WHERE status = 'running' AND started_at < ?
-    `).run(Date.now(), timeoutThreshold);
         let query = 'SELECT * FROM skill_executions';
         const params = [];
         if (skillName) {
@@ -332,6 +539,7 @@ class DevFlowDatabase {
         const rows = this.db.prepare(query).all(...params);
         return rows.map(row => ({
             executionId: row.execution_id,
+            sessionId: row.session_id,
             skillName: row.skill_name,
             startedAt: row.started_at,
             finishedAt: row.finished_at,
@@ -340,7 +548,6 @@ class DevFlowDatabase {
             mcpToolCalls: row.mcp_tool_calls,
             directToolCalls: row.direct_tool_calls,
             subagentCount: row.subagent_count,
-            totalTokens: row.total_tokens,
             totalDuration: row.total_duration,
             mcpComplianceRate: row.mcp_compliance_rate,
         }));
@@ -349,11 +556,11 @@ class DevFlowDatabase {
     insertToolCallEvent(params) {
         this.db.prepare(`
       INSERT INTO tool_call_events
-      (event_id, execution_id, timestamp, tool_name, tool_type, is_mcp_tool,
-       mcp_tool_name, mcp_enforced, mcp_fallback, input, output, tokens_used, duration,
-       parent_tool_call_id, subagent_id, error, blocked, block_reason)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(params.eventId, params.executionId, params.timestamp, params.toolName, params.toolType, params.isMcpTool ? 1 : 0, params.mcpToolName || null, params.mcpEnforced ? 1 : 0, params.mcpFallback ? 1 : 0, JSON.stringify(params.input) ?? null, params.output ? JSON.stringify(params.output) : null, params.tokensUsed, params.duration, params.parentToolCallId || null, params.subagentId || null, params.error || null, params.blocked ? 1 : 0, params.blockReason || null);
+      (event_id, execution_id, session_id, timestamp, tool_name, tool_type, is_mcp_tool,
+       mcp_tool_name, mcp_enforced, mcp_fallback, kind, input, output, duration,
+       parent_tool_call_id, subagent_id, error, blocked, block_reason, workflow_run_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(params.eventId, params.executionId || null, params.sessionId ?? null, params.timestamp, params.toolName, params.toolType, params.isMcpTool ? 1 : 0, params.mcpToolName || null, params.mcpEnforced ? 1 : 0, params.mcpFallback ? 1 : 0, params.kind ?? 'tool_use', JSON.stringify(params.input) ?? null, params.output ? JSON.stringify(params.output) : null, params.duration, params.parentToolCallId || null, params.subagentId || null, params.error || null, params.blocked ? 1 : 0, params.blockReason || null, params.workflowRunId || null);
         // Update execution summary counters
         this.db.prepare(`
       UPDATE skill_executions
@@ -369,6 +576,7 @@ class DevFlowDatabase {
         return rows.map(row => ({
             eventId: row.event_id,
             executionId: row.execution_id,
+            sessionId: row.session_id,
             timestamp: row.timestamp,
             toolName: row.tool_name,
             toolType: row.tool_type,
@@ -376,9 +584,9 @@ class DevFlowDatabase {
             mcpToolName: row.mcp_tool_name,
             mcpEnforced: row.mcp_enforced === 1,
             mcpFallback: row.mcp_fallback === 1,
+            kind: row.kind,
             input: row.input ? JSON.parse(row.input) : null,
             output: row.output ? JSON.parse(row.output) : null,
-            tokensUsed: row.tokens_used,
             duration: row.duration,
             parentToolCallId: row.parent_tool_call_id,
             subagentId: row.subagent_id,
@@ -398,6 +606,10 @@ class DevFlowDatabase {
             sets.push('error = ?');
             values.push(updates.error);
         }
+        if (updates.duration !== undefined) {
+            sets.push('duration = ?');
+            values.push(updates.duration);
+        }
         if (sets.length > 0) {
             values.push(eventId);
             this.db.prepare(`UPDATE tool_call_events SET ${sets.join(', ')} WHERE event_id = ?`).run(...values);
@@ -441,6 +653,117 @@ class DevFlowDatabase {
         const missedTools = missedRows.map((row) => row.mcp_tool_name);
         return { overall, bySkill, missedTools };
     }
+    cleanupStaleRecords() {
+        const cutoff = Date.now() - 30 * 60 * 1000;
+        try {
+            this.db.prepare(`UPDATE skill_executions SET status = 'failed', finished_at = ? WHERE status = 'running' AND started_at < ?`).run(Date.now(), cutoff);
+            this.db.prepare(`UPDATE sessions SET status = 'failed', finished_at = ? WHERE status = 'running' AND started_at < ?`).run(Date.now(), cutoff);
+        }
+        catch { /* best-effort */ }
+    }
+    insertToolMetric(metric) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO tool_metrics (id, tool_call_event_id, session_id, tool_name, query, status, result_count, result_size_bytes, latency_ms, engine, accuracy_query_id, metadata, created_at)
+      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';
+        const params = [];
+        if (sessionId) {
+            sql += ' AND session_id = ?';
+            params.push(sessionId);
+        }
+        if (toolName) {
+            sql += ' AND tool_name = ?';
+            params.push(toolName);
+        }
+        sql += ' ORDER BY created_at DESC LIMIT ? OFFSET ?';
+        params.push(limit, offset);
+        return this.db.prepare(sql).all(...params);
+    }
+    getToolMetricsSummary(days = 7) {
+        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+        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
+      ORDER BY call_count DESC
+    `).all(cutoff);
+        return rows.map((r) => ({
+            toolName: r.tool_name,
+            callCount: r.call_count,
+            successRate: r.call_count > 0 ? Math.round((r.success_count / r.call_count) * 10000) / 100 : 0,
+            emptyRate: r.call_count > 0 ? Math.round((r.empty_count / r.call_count) * 10000) / 100 : 0,
+            avgResults: Math.round(r.avg_results * 10) / 10,
+            avgLatency: Math.round(r.avg_latency),
+        }));
+    }
+    // ---- Accuracy Queries ----
+    insertAccuracyQuery(q) {
+        this.db.prepare(`
+      INSERT INTO accuracy_queries (id, session_id, engine, query, top_k_results, selected_ids, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).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';
+        const params = [];
+        if (options.engine) {
+            sql += ' AND engine = ?';
+            params.push(options.engine);
+        }
+        if (options.status === 'annotated')
+            sql += ' AND relevance_feedback IS NOT NULL';
+        if (options.status === 'unannotated')
+            sql += ' AND relevance_feedback IS NULL';
+        sql += ' ORDER BY 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) => ({
+            id: r.id, sessionId: r.session_id, engine: r.engine, query: r.query,
+            topKResults: r.top_k_results ? JSON.parse(r.top_k_results) : [],
+            selectedIds: r.selected_ids ? JSON.parse(r.selected_ids) : null,
+            relevanceFeedback: r.relevance_feedback,
+            annotatorNote: r.annotator_note,
+            annotatedAt: r.annotated_at,
+            createdAt: r.created_at,
+        }));
+    }
+    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) {
+        let where = 'WHERE 1=1';
+        const params = [];
+        if (engine) {
+            where += ' AND engine = ?';
+            params.push(engine);
+        }
+        if (since) {
+            where += ' AND created_at >= ?';
+            params.push(since);
+        }
+        const totalQueries = this.db.prepare(`SELECT COUNT(*) as c FROM accuracy_queries ${where}`).get(...params)?.c ?? 0;
+        const annotatedQueries = this.db.prepare(`SELECT COUNT(*) as c FROM accuracy_queries ${where} AND relevance_feedback IS NOT NULL`).get(...params)?.c ?? 0;
+        const hitCount = annotatedQueries > 0
+            ? (this.db.prepare(`SELECT COUNT(*) as c FROM accuracy_queries ${where} AND relevance_feedback = 'hit'`).get(...params)?.c ?? 0)
+            : 0;
+        const hitRate = annotatedQueries > 0 ? hitCount / annotatedQueries : null;
+        return { totalQueries, annotatedQueries, hitRate };
+    }
+    // Convenience methods for raw SQL queries (used by AutoChecker)
+    all(sql, ...params) {
+        return this.db.prepare(sql).all(...params);
+    }
+    get(sql, ...params) {
+        return this.db.prepare(sql).get(...params);
+    }
     close() {
         this.db.close();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devflow-tools/database",
-  "version": "0.8.10",
+  "version": "0.9.0",
   "description": "DevFlow SQLite database package",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,5 +13,5 @@
     "typescript": "^5.5.0",
     "vitest": "^2.0.0"
   },
-  "gitHead": "ac4f93d6a52fa40b4126b514e899eee581f8f46e"
+  "gitHead": "7872bccedbacd09cc92b983f30b3702db6878125"
 }