@devflow-tools/database 0.1.0

package/__tests__/database.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { DevFlowDatabase } from '../src/database';
+import { rmSync, existsSync } from 'fs';
+import { join } from 'path';
+
+describe('DevFlowDatabase', () => {
+  const testDir = join(process.cwd(), '.devflow-test');
+  let db: DevFlowDatabase;
+
+  beforeEach(() => {
+    // 清理测试目录
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+    db = new DevFlowDatabase(testDir);
+  });
+
+  afterEach(() => {
+    db.close();
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  it('should create .devflow directory and database file', () => {
+    expect(existsSync(join(testDir, '.devflow', 'devflow.db'))).toBe(true);
+  });
+
+  it('should initialize schema with runs table', () => {
+    const runs = db.getRuns();
+    expect(runs).toBeDefined();
+    expect(Array.isArray(runs)).toBe(true);
+  });
+
+  it('should insert and retrieve a run', () => {
+    const run = {
+      id: 'run-123',
+      source: 'mcp',
+      tool: 'test_tool',
+      input: { query: 'test' },
+      status: 'completed',
+      startedAt: Date.now(),
+      finishedAt: Date.now(),
+      tokenUsed: 100,
+      metadata: { projectRoot: testDir }
+    };
+
+    db.insertRun(run);
+    const retrieved = db.getRun('run-123');
+
+    expect(retrieved).toBeDefined();
+    expect(retrieved?.id).toBe('run-123');
+    expect(retrieved?.tool).toBe('test_tool');
+  });
+
+  it('should update a run', () => {
+    const run = {
+      id: 'run-456',
+      source: 'cli',
+      tool: 'test',
+      status: 'active',
+      startedAt: Date.now(),
+      tokenUsed: 0
+    };
+
+    db.insertRun(run);
+    db.updateRun('run-456', { status: 'completed', finishedAt: Date.now(), tokenUsed: 50 });
+
+    const retrieved = db.getRun('run-456');
+    expect(retrieved?.status).toBe('completed');
+    expect(retrieved?.token_used).toBe(50);
+  });
+
+  it('should insert and retrieve run steps', () => {
+    const run = {
+      id: 'run-789',
+      source: 'test',
+      tool: 'test',
+      status: 'active',
+      startedAt: Date.now(),
+      tokenUsed: 0
+    };
+    db.insertRun(run);
+
+    const step = {
+      runId: 'run-789',
+      name: 'step-1',
+      startTime: Date.now(),
+      endTime: Date.now(),
+      duration: 100,
+      status: 'completed',
+      metadata: { tokensUsed: 50 }
+    };
+
+    db.insertRunStep(step);
+    const steps = db.getRunSteps('run-789');
+
+    expect(steps).toHaveLength(1);
+    expect(steps[0].name).toBe('step-1');
+  });
+
+  it('should insert and retrieve telemetry events', () => {
+    // Insert a parent run first (FK constraint)
+    db.insertRun({
+      id: 'run-123',
+      source: 'test',
+      tool: 'test',
+      status: 'active',
+      startedAt: Date.now(),
+      tokenUsed: 0
+    });
+
+    const event = {
+      runId: 'run-123',
+      kind: 'tool_use',
+      timestamp: Date.now(),
+      duration: 100,
+      success: 1,
+      toolName: 'test',
+      pluginName: 'react',
+      metadata: { test: true }
+    };
+
+    db.insertEvent(event);
+    const events = db.getEvents('run-123');
+
+    expect(events).toHaveLength(1);
+    expect(events[0].kind).toBe('tool_use');
+  });
+
+  it('should upsert project stats', () => {
+    const stats = {
+      projectRoot: testDir,
+      totalRuns: 10,
+      successfulRuns: 8,
+      totalTokens: 1000,
+      lastActiveAt: Date.now(),
+      topTools: [{ toolName: 'test', count: 5 }]
+    };
+
+    db.upsertProjectStats(stats);
+    const retrieved = db.getProjectStats(testDir);
+
+    expect(retrieved).toBeDefined();
+    expect(retrieved?.totalRuns).toBe(10);
+  });
+});

package/__tests__/node-sqlite.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { NodeSqliteDatabase } from '../src/node-sqlite';
+import { unlinkSync, existsSync } from 'fs';
+
+describe('NodeSqliteDatabase', () => {
+  let db: NodeSqliteDatabase;
+  const testDbPath = '/tmp/test-node-sqlite.db';
+
+  beforeEach(() => {
+    if (existsSync(testDbPath)) {
+      unlinkSync(testDbPath);
+    }
+    db = new NodeSqliteDatabase(testDbPath);
+  });
+
+  afterEach(() => {
+    db.close();
+    if (existsSync(testDbPath)) {
+      unlinkSync(testDbPath);
+    }
+  });
+
+  it('should create database and execute SQL', () => {
+    db.exec(`
+      CREATE TABLE test (
+        id INTEGER PRIMARY KEY,
+        name TEXT
+      )
+    `);
+
+    const stmt = db.prepare('INSERT INTO test (name) VALUES (?)');
+    const result = stmt.run('test');
+
+    expect(result.changes).toBe(1);
+  });
+
+  it('should query data', () => {
+    db.exec('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)');
+    db.prepare('INSERT INTO test (name) VALUES (?)').run('Alice');
+    db.prepare('INSERT INTO test (name) VALUES (?)').run('Bob');
+
+    const row = db.prepare('SELECT * FROM test WHERE name = ?').get('Alice');
+    expect(row.name).toBe('Alice');
+
+    const rows = db.prepare('SELECT * FROM test').all();
+    expect(rows).toHaveLength(2);
+  });
+
+  it('should support transactions', () => {
+    db.exec('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)');
+
+    db.transaction(() => {
+      db.prepare('INSERT INTO test (name) VALUES (?)').run('Alice');
+      db.prepare('INSERT INTO test (name) VALUES (?)').run('Bob');
+    });
+
+    const rows = db.prepare('SELECT * FROM test').all();
+    expect(rows).toHaveLength(2);
+  });
+});

package/dist/database.d.ts

@@ -0,0 +1,16 @@
+export declare class DevFlowDatabase {
+    private db;
+    constructor(projectRoot: string);
+    private initializeSchema;
+    insertRun(run: any): void;
+    getRun(id: string): any | null;
+    updateRun(id: string, updates: any): void;
+    insertRunStep(step: any): void;
+    getRunSteps(runId: string): any[];
+    insertEvent(event: any): void;
+    getEvents(runId: string): any[];
+    getProjectStats(projectRoot: string): any | null;
+    upsertProjectStats(stats: any): void;
+    getRuns(): any[];
+    close(): void;
+}

package/dist/database.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevFlowDatabase = void 0;
+const node_sqlite_1 = require("./node-sqlite");
+const path_1 = require("path");
+const fs_1 = require("fs");
+class DevFlowDatabase {
+    constructor(projectRoot) {
+        const devflowDir = (0, path_1.join)(projectRoot, '.devflow');
+        if (!(0, fs_1.existsSync)(devflowDir)) {
+            (0, fs_1.mkdirSync)(devflowDir, { recursive: true });
+        }
+        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.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        source TEXT NOT NULL,
+        tool TEXT NOT NULL,
+        input TEXT,
+        status TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        finished_at INTEGER,
+        token_used INTEGER DEFAULT 0,
+        metadata TEXT,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS run_steps (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER,
+        duration INTEGER,
+        status TEXT,
+        metadata TEXT,
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS telemetry_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id TEXT,
+        kind TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        duration INTEGER,
+        success INTEGER,
+        tool_name TEXT,
+        plugin_name TEXT,
+        metadata TEXT,
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS project_stats (
+        project_root TEXT PRIMARY KEY,
+        total_runs INTEGER DEFAULT 0,
+        successful_runs INTEGER DEFAULT 0,
+        total_tokens INTEGER DEFAULT 0,
+        last_active_at INTEGER,
+        top_tools TEXT,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_runs_started_at ON runs(started_at);
+      CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+      CREATE INDEX IF NOT EXISTS idx_run_steps_run_id ON run_steps(run_id);
+      CREATE INDEX IF NOT EXISTS idx_telemetry_events_run_id ON telemetry_events(run_id);
+    `);
+    }
+    insertRun(run) {
+        this.db.prepare(`
+      INSERT INTO runs (id, source, tool, input, status, started_at, finished_at, token_used, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(run.id, run.source, run.tool, JSON.stringify(run.input) ?? null, run.status, run.startedAt, run.finishedAt ?? null, run.tokenUsed ?? 0, JSON.stringify(run.metadata) ?? null, Date.now());
+    }
+    getRun(id) {
+        const row = this.db.prepare('SELECT * FROM runs WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return {
+            ...row,
+            input: row.input ? JSON.parse(row.input) : null,
+            metadata: row.metadata ? JSON.parse(row.metadata) : null
+        };
+    }
+    updateRun(id, updates) {
+        const sets = [];
+        const values = [];
+        if (updates.status !== undefined) {
+            sets.push('status = ?');
+            values.push(updates.status);
+        }
+        if (updates.finishedAt !== undefined) {
+            sets.push('finished_at = ?');
+            values.push(updates.finishedAt);
+        }
+        if (updates.tokenUsed !== undefined) {
+            sets.push('token_used = ?');
+            values.push(updates.tokenUsed);
+        }
+        if (sets.length > 0) {
+            values.push(id);
+            this.db.prepare(`UPDATE runs SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+        }
+    }
+    insertRunStep(step) {
+        this.db.prepare(`
+      INSERT INTO run_steps (run_id, name, start_time, end_time, duration, status, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(step.runId, step.name, step.startTime, step.endTime, step.duration, step.status, JSON.stringify(step.metadata) ?? null);
+    }
+    getRunSteps(runId) {
+        const rows = this.db.prepare('SELECT * FROM run_steps WHERE run_id = ?').all(runId);
+        return rows.map(row => ({
+            ...row,
+            metadata: row.metadata ? JSON.parse(row.metadata) : null
+        }));
+    }
+    insertEvent(event) {
+        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);
+    }
+    getEvents(runId) {
+        const rows = this.db.prepare('SELECT * FROM telemetry_events WHERE run_id = ?').all(runId);
+        return rows.map(row => ({
+            ...row,
+            metadata: row.metadata ? JSON.parse(row.metadata) : null
+        }));
+    }
+    getProjectStats(projectRoot) {
+        const row = this.db.prepare('SELECT * FROM project_stats WHERE project_root = ?').get(projectRoot);
+        if (!row)
+            return null;
+        return {
+            projectRoot: row.project_root,
+            totalRuns: row.total_runs,
+            successfulRuns: row.successful_runs,
+            totalTokens: row.total_tokens,
+            lastActiveAt: row.last_active_at,
+            topTools: row.top_tools ? JSON.parse(row.top_tools) : null,
+            updatedAt: row.updated_at
+        };
+    }
+    upsertProjectStats(stats) {
+        this.db.prepare(`
+      INSERT INTO project_stats (project_root, total_runs, successful_runs, total_tokens, last_active_at, top_tools, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_root) DO UPDATE SET
+        total_runs = excluded.total_runs,
+        successful_runs = excluded.successful_runs,
+        total_tokens = excluded.total_tokens,
+        last_active_at = excluded.last_active_at,
+        top_tools = excluded.top_tools,
+        updated_at = excluded.updated_at
+    `).run(stats.projectRoot, stats.totalRuns, stats.successfulRuns, stats.totalTokens, stats.lastActiveAt, JSON.stringify(stats.topTools) ?? null, Date.now());
+    }
+    getRuns() {
+        return this.db.prepare('SELECT * FROM runs').all();
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.DevFlowDatabase = DevFlowDatabase;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { DevFlowDatabase } from './database';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevFlowDatabase = void 0;
+var database_1 = require("./database");
+Object.defineProperty(exports, "DevFlowDatabase", { enumerable: true, get: function () { return database_1.DevFlowDatabase; } });

package/dist/node-sqlite.d.ts

@@ -0,0 +1,9 @@
+import type { Database, Statement } from './types';
+export declare class NodeSqliteDatabase implements Database {
+    private db;
+    constructor(path: string);
+    exec(sql: string): void;
+    prepare(sql: string): Statement;
+    transaction<T>(fn: () => T): T;
+    close(): void;
+}

package/dist/node-sqlite.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSqliteDatabase = void 0;
+// node:sqlite is a Node.js 22+ experimental built-in. TypeScript does not
+// resolve `node:` prefixed modules unless @types/node includes them (which
+// requires @types/node >= 22.5). We suppress the TS error here and rely on
+// the ambient types defined below until the project upgrades @types/node.
+// @ts-expect-error - node:sqlite types not available in @types/node@20
+const node_sqlite_1 = require("node:sqlite");
+class NodeSqliteDatabase {
+    constructor(path) {
+        this.db = new node_sqlite_1.DatabaseSync(path);
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    prepare(sql) {
+        const stmt = this.db.prepare(sql);
+        return {
+            run: (...params) => {
+                const result = stmt.run(...params);
+                return {
+                    changes: result.changes,
+                    lastInsertRowid: result.lastInsertRowid,
+                };
+            },
+            get: (...params) => {
+                return stmt.get(...params);
+            },
+            all: (...params) => {
+                return stmt.all(...params);
+            },
+        };
+    }
+    transaction(fn) {
+        this.db.exec('BEGIN');
+        try {
+            const result = fn();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (err) {
+            this.db.exec('ROLLBACK');
+            throw err;
+        }
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.NodeSqliteDatabase = NodeSqliteDatabase;

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+export interface Database {
+    exec(sql: string): void;
+    prepare(sql: string): Statement;
+    transaction<T>(fn: () => T): T;
+    close(): void;
+}
+export interface Statement {
+    run(...params: any[]): RunResult;
+    get(...params: any[]): any;
+    all(...params: any[]): any[];
+}
+export interface RunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@devflow-tools/database",
+  "version": "0.1.0",
+  "description": "DevFlow SQLite database package",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}

package/src/database.ts

@@ -0,0 +1,224 @@
+import { NodeSqliteDatabase } from './node-sqlite';
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+
+export class DevFlowDatabase {
+  private db: NodeSqliteDatabase;
+
+  constructor(projectRoot: string) {
+    const devflowDir = join(projectRoot, '.devflow');
+    if (!existsSync(devflowDir)) {
+      mkdirSync(devflowDir, { recursive: true });
+    }
+
+    const dbPath = join(devflowDir, 'devflow.db');
+    this.db = new NodeSqliteDatabase(dbPath);
+
+    // 启用 WAL 模式
+    this.db.exec('PRAGMA journal_mode = WAL');
+    this.db.exec('PRAGMA busy_timeout = 5000');
+
+    this.initializeSchema();
+  }
+
+  private initializeSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        source TEXT NOT NULL,
+        tool TEXT NOT NULL,
+        input TEXT,
+        status TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        finished_at INTEGER,
+        token_used INTEGER DEFAULT 0,
+        metadata TEXT,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS run_steps (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER,
+        duration INTEGER,
+        status TEXT,
+        metadata TEXT,
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS telemetry_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id TEXT,
+        kind TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        duration INTEGER,
+        success INTEGER,
+        tool_name TEXT,
+        plugin_name TEXT,
+        metadata TEXT,
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS project_stats (
+        project_root TEXT PRIMARY KEY,
+        total_runs INTEGER DEFAULT 0,
+        successful_runs INTEGER DEFAULT 0,
+        total_tokens INTEGER DEFAULT 0,
+        last_active_at INTEGER,
+        top_tools TEXT,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_runs_started_at ON runs(started_at);
+      CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+      CREATE INDEX IF NOT EXISTS idx_run_steps_run_id ON run_steps(run_id);
+      CREATE INDEX IF NOT EXISTS idx_telemetry_events_run_id ON telemetry_events(run_id);
+    `);
+  }
+
+  insertRun(run: any): void {
+    this.db.prepare(`
+      INSERT INTO runs (id, source, tool, input, status, started_at, finished_at, token_used, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      run.id,
+      run.source,
+      run.tool,
+      JSON.stringify(run.input) ?? null,
+      run.status,
+      run.startedAt,
+      run.finishedAt ?? null,
+      run.tokenUsed ?? 0,
+      JSON.stringify(run.metadata) ?? null,
+      Date.now()
+    );
+  }
+
+  getRun(id: string): any | null {
+    const row = this.db.prepare('SELECT * FROM runs WHERE id = ?').get(id) as any;
+    if (!row) return null;
+
+    return {
+      ...row,
+      input: row.input ? JSON.parse(row.input) : null,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null
+    };
+  }
+
+  updateRun(id: string, updates: any): void {
+    const sets: string[] = [];
+    const values: any[] = [];
+
+    if (updates.status !== undefined) {
+      sets.push('status = ?');
+      values.push(updates.status);
+    }
+    if (updates.finishedAt !== undefined) {
+      sets.push('finished_at = ?');
+      values.push(updates.finishedAt);
+    }
+    if (updates.tokenUsed !== undefined) {
+      sets.push('token_used = ?');
+      values.push(updates.tokenUsed);
+    }
+
+    if (sets.length > 0) {
+      values.push(id);
+      this.db.prepare(`UPDATE runs SET ${sets.join(', ')} WHERE id = ?`).run(...values);
+    }
+  }
+
+  insertRunStep(step: any): void {
+    this.db.prepare(`
+      INSERT INTO run_steps (run_id, name, start_time, end_time, duration, status, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      step.runId,
+      step.name,
+      step.startTime,
+      step.endTime,
+      step.duration,
+      step.status,
+      JSON.stringify(step.metadata) ?? null
+    );
+  }
+
+  getRunSteps(runId: string): any[] {
+    const rows = this.db.prepare('SELECT * FROM run_steps WHERE run_id = ?').all(runId) as any[];
+    return rows.map(row => ({
+      ...row,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null
+    }));
+  }
+
+  insertEvent(event: any): void {
+    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
+    );
+  }
+
+  getEvents(runId: string): any[] {
+    const rows = this.db.prepare('SELECT * FROM telemetry_events WHERE run_id = ?').all(runId) as any[];
+    return rows.map(row => ({
+      ...row,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null
+    }));
+  }
+
+  getProjectStats(projectRoot: string): any | null {
+    const row = this.db.prepare('SELECT * FROM project_stats WHERE project_root = ?').get(projectRoot) as any;
+    if (!row) return null;
+
+    return {
+      projectRoot: row.project_root,
+      totalRuns: row.total_runs,
+      successfulRuns: row.successful_runs,
+      totalTokens: row.total_tokens,
+      lastActiveAt: row.last_active_at,
+      topTools: row.top_tools ? JSON.parse(row.top_tools) : null,
+      updatedAt: row.updated_at
+    };
+  }
+
+  upsertProjectStats(stats: any): void {
+    this.db.prepare(`
+      INSERT INTO project_stats (project_root, total_runs, successful_runs, total_tokens, last_active_at, top_tools, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_root) DO UPDATE SET
+        total_runs = excluded.total_runs,
+        successful_runs = excluded.successful_runs,
+        total_tokens = excluded.total_tokens,
+        last_active_at = excluded.last_active_at,
+        top_tools = excluded.top_tools,
+        updated_at = excluded.updated_at
+    `).run(
+      stats.projectRoot,
+      stats.totalRuns,
+      stats.successfulRuns,
+      stats.totalTokens,
+      stats.lastActiveAt,
+      JSON.stringify(stats.topTools) ?? null,
+      Date.now()
+    );
+  }
+
+  getRuns(): any[] {
+    return this.db.prepare('SELECT * FROM runs').all();
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { DevFlowDatabase } from './database';

package/src/node-sqlite.ts

@@ -0,0 +1,54 @@
+// node:sqlite is a Node.js 22+ experimental built-in. TypeScript does not
+// resolve `node:` prefixed modules unless @types/node includes them (which
+// requires @types/node >= 22.5). We suppress the TS error here and rely on
+// the ambient types defined below until the project upgrades @types/node.
+// @ts-expect-error - node:sqlite types not available in @types/node@20
+import { DatabaseSync } from 'node:sqlite';
+import type { Database, Statement, RunResult } from './types';
+
+export class NodeSqliteDatabase implements Database {
+  private db: DatabaseSync;
+
+  constructor(path: string) {
+    this.db = new DatabaseSync(path);
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  prepare(sql: string): Statement {
+    const stmt = this.db.prepare(sql);
+    return {
+      run: (...params: any[]): RunResult => {
+        const result = stmt.run(...params);
+        return {
+          changes: result.changes,
+          lastInsertRowid: result.lastInsertRowid,
+        };
+      },
+      get: (...params: any[]): any => {
+        return stmt.get(...params);
+      },
+      all: (...params: any[]): any[] => {
+        return stmt.all(...params);
+      },
+    };
+  }
+
+  transaction<T>(fn: () => T): T {
+    this.db.exec('BEGIN');
+    try {
+      const result = fn();
+      this.db.exec('COMMIT');
+      return result;
+    } catch (err) {
+      this.db.exec('ROLLBACK');
+      throw err;
+    }
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/types.ts

@@ -0,0 +1,17 @@
+export interface Database {
+  exec(sql: string): void;
+  prepare(sql: string): Statement;
+  transaction<T>(fn: () => T): T;
+  close(): void;
+}
+
+export interface Statement {
+  run(...params: any[]): RunResult;
+  get(...params: any[]): any;
+  all(...params: any[]): any[];
+}
+
+export interface RunResult {
+  changes: number;
+  lastInsertRowid: number | bigint;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "composite": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "__tests__"]
+}

package/vitest.config.ts

@@ -0,0 +1,41 @@
+import { defineConfig, type Plugin } from 'vitest/config';
+
+// Vite 5 doesn't recognize node:sqlite and strips the `node:` prefix,
+// trying to resolve `sqlite` as a regular module. This plugin prevents that
+// by providing the module directly as a re-export.
+const nodeSqlitePlugin: Plugin = {
+  name: 'node-sqlite-resolver',
+  enforce: 'pre',
+  resolveId(source) {
+    if (source === 'node:sqlite') {
+      // Return a virtual module id that won't be further processed
+      return '\0node:sqlite';
+    }
+    return null;
+  },
+  load(id) {
+    if (id === '\0node:sqlite') {
+      // Use createRequire to load node:sqlite without triggering vite resolution
+      return `
+        import { createRequire } from 'module';
+        const require = createRequire(import.meta.url);
+        const mod = require('node:sqlite');
+        export const DatabaseSync = mod.DatabaseSync;
+      `;
+    }
+    return null;
+  },
+};
+
+export default defineConfig({
+  plugins: [nodeSqlitePlugin],
+  test: {
+    globals: false,
+    pool: 'forks',
+    poolOptions: {
+      forks: {
+        execArgv: ['--experimental-sqlite'],
+      },
+    },
+  },
+});