@teamlens/core 0.1.0

package/dist/store/database.js

@@ -0,0 +1,677 @@
+import initSqlJs from 'sql.js';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import fs from 'node:fs';
+import picomatch from 'picomatch';
+export class MemoryDatabase {
+    storageDir;
+    db;
+    dbPath;
+    sqlModule;
+    saveTimer = null;
+    dirty = false;
+    constructor(storageDir) {
+        this.storageDir = storageDir;
+        this.dbPath = path.join(storageDir, 'memory.db');
+    }
+    /** Async factory — sql.js requires async initialization. */
+    static async create(storageDir) {
+        const instance = new MemoryDatabase(storageDir);
+        fs.mkdirSync(storageDir, { recursive: true });
+        const SQL = await initSqlJs();
+        instance.sqlModule = SQL;
+        if (fs.existsSync(instance.dbPath)) {
+            const buffer = fs.readFileSync(instance.dbPath);
+            instance.db = new SQL.Database(buffer);
+        }
+        else {
+            instance.db = new SQL.Database();
+        }
+        instance.migrate();
+        instance.save();
+        return instance;
+    }
+    /** Reload the database from disk. Use when another process may have written changes. */
+    reload() {
+        if (fs.existsSync(this.dbPath)) {
+            const buffer = fs.readFileSync(this.dbPath);
+            this.db.close();
+            this.db = new this.sqlModule.Database(buffer);
+        }
+    }
+    // ── Compatibility Helpers ──
+    queryOne(sql, ...params) {
+        const stmt = this.db.prepare(sql);
+        if (params.length)
+            stmt.bind(params);
+        const row = stmt.step() ? stmt.getAsObject() : undefined;
+        stmt.free();
+        return row;
+    }
+    queryAll(sql, ...params) {
+        const stmt = this.db.prepare(sql);
+        if (params.length)
+            stmt.bind(params);
+        const rows = [];
+        while (stmt.step())
+            rows.push(stmt.getAsObject());
+        stmt.free();
+        return rows;
+    }
+    execute(sql, ...params) {
+        this.db.run(sql, params);
+        this.scheduleSave();
+    }
+    scheduleSave() {
+        this.dirty = true;
+        if (this.saveTimer)
+            return; // already scheduled
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            if (this.dirty) {
+                this.save();
+                this.dirty = false;
+            }
+        }, 100); // 100ms debounce
+    }
+    save() {
+        fs.writeFileSync(this.dbPath, Buffer.from(this.db.export()));
+    }
+    /** Force an immediate save (call before close). */
+    flush() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        if (this.dirty) {
+            this.save();
+            this.dirty = false;
+        }
+    }
+    // ── Schema ──
+    migrate() {
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id            TEXT PRIMARY KEY,
+        content       TEXT NOT NULL,
+        category      TEXT NOT NULL,
+        source        TEXT NOT NULL,
+        tier          TEXT NOT NULL DEFAULT 'personal',
+        author        TEXT NOT NULL DEFAULT 'unknown',
+        tags          TEXT NOT NULL DEFAULT '[]',
+        related_files TEXT NOT NULL DEFAULT '[]',
+        commit_sha    TEXT,
+        staleness     REAL NOT NULL DEFAULT 0.0,
+        confidence    REAL NOT NULL DEFAULT 0.8,
+        embedding     BLOB,
+        created_at    TEXT NOT NULL,
+        updated_at    TEXT NOT NULL,
+        validated_at  TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS tracked_files (
+        path          TEXT PRIMARY KEY,
+        hash          TEXT NOT NULL,
+        last_modified TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS tracked_commits (
+        sha       TEXT PRIMARY KEY,
+        message   TEXT NOT NULL,
+        author    TEXT NOT NULL,
+        date      TEXT NOT NULL,
+        files     TEXT NOT NULL DEFAULT '[]',
+        processed INTEGER NOT NULL DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+      CREATE INDEX IF NOT EXISTS idx_memories_staleness ON memories(staleness);
+      CREATE INDEX IF NOT EXISTS idx_memories_commit ON memories(commit_sha);
+    `);
+        // Migration: add tier/author columns if upgrading from v0.1
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN tier TEXT NOT NULL DEFAULT 'personal'`);
+        }
+        catch { /* column already exists */ }
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN author TEXT NOT NULL DEFAULT 'unknown'`);
+        }
+        catch { /* column already exists */ }
+        // Create indexes for tier/author (after migration ensures columns exist)
+        this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier);
+      CREATE INDEX IF NOT EXISTS idx_memories_author ON memories(author);
+    `);
+        // Migration: add governance columns
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN scope TEXT DEFAULT NULL`);
+        }
+        catch { /* column already exists */ }
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN priority TEXT DEFAULT NULL`);
+        }
+        catch { /* column already exists */ }
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN examples TEXT DEFAULT NULL`);
+        }
+        catch { /* column already exists */ }
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN active INTEGER NOT NULL DEFAULT 1`);
+        }
+        catch { /* column already exists */ }
+        // Indexes for governance queries
+        this.db.run(`
+      CREATE INDEX IF NOT EXISTS idx_memories_source ON memories(source);
+      CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(active);
+      CREATE INDEX IF NOT EXISTS idx_memories_priority ON memories(priority);
+    `);
+        // Migration: add session tracking columns
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN session_id TEXT DEFAULT NULL`);
+        }
+        catch { /* column already exists */ }
+        try {
+            this.db.run(`ALTER TABLE memories ADD COLUMN reuse_count INTEGER NOT NULL DEFAULT 0`);
+        }
+        catch { /* column already exists */ }
+        // Sessions table
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id                   TEXT PRIMARY KEY,
+        developer            TEXT NOT NULL,
+        task                 TEXT DEFAULT '',
+        status               TEXT DEFAULT 'active',
+        tool_name            TEXT DEFAULT 'unknown',
+        started_at           TEXT NOT NULL,
+        ended_at             TEXT,
+        duration_seconds     INTEGER,
+        files_touched        TEXT DEFAULT '[]',
+        summary              TEXT,
+        insight_count        INTEGER DEFAULT 0,
+        activity_count       INTEGER DEFAULT 0,
+        duplicates_prevented INTEGER DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_developer ON sessions(developer);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+      CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+    `);
+        // Activity events table
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS activity_events (
+        id          TEXT PRIMARY KEY,
+        session_id  TEXT NOT NULL,
+        type        TEXT NOT NULL,
+        description TEXT DEFAULT '',
+        files       TEXT DEFAULT '[]',
+        timestamp   TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_activity_session ON activity_events(session_id);
+    `);
+    }
+    // ── Memories ──
+    insertMemory(extracted, author, tier = 'personal', sessionId) {
+        const now = new Date().toISOString();
+        const memory = {
+            id: randomUUID(),
+            content: extracted.content,
+            category: extracted.category,
+            source: extracted.commitSha ? 'git' : 'agent',
+            tier,
+            author,
+            tags: extracted.tags,
+            relatedFiles: extracted.relatedFiles,
+            commitSha: extracted.commitSha,
+            staleness: 0,
+            confidence: extracted.confidence,
+            embedding: null,
+            scope: null,
+            priority: null,
+            examples: null,
+            active: true,
+            sessionId: sessionId ?? null,
+            reuseCount: 0,
+            createdAt: now,
+            updatedAt: now,
+            validatedAt: now,
+        };
+        this.execute(`INSERT INTO memories (id, content, category, source, tier, author, tags, related_files, commit_sha, staleness, confidence, embedding, scope, priority, examples, active, session_id, reuse_count, created_at, updated_at, validated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, memory.id, memory.content, memory.category, memory.source, memory.tier, memory.author, JSON.stringify(memory.tags), JSON.stringify(memory.relatedFiles), memory.commitSha, memory.staleness, memory.confidence, null, null, null, null, 1, memory.sessionId, 0, memory.createdAt, memory.updatedAt, memory.validatedAt);
+        return memory;
+    }
+    /** Insert a team memory with a known id (for import from team.jsonl). */
+    insertTeamMemory(memory) {
+        const now = new Date().toISOString();
+        this.execute(`INSERT OR IGNORE INTO memories (id, content, category, source, tier, author, tags, related_files, commit_sha, staleness, confidence, embedding, scope, priority, examples, active, session_id, reuse_count, created_at, updated_at, validated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, memory.id, memory.content, memory.category, memory.source, 'team', memory.author, JSON.stringify(memory.tags), JSON.stringify(memory.relatedFiles), memory.commitSha, 0, memory.confidence, null, memory.scope ? JSON.stringify(memory.scope) : null, memory.priority ?? null, memory.examples ? JSON.stringify(memory.examples) : null, memory.active ? 1 : 0, null, 0, memory.createdAt, now, now);
+    }
+    getMemory(id) {
+        const row = this.queryOne('SELECT * FROM memories WHERE id = ?', id);
+        return row ? this.rowToMemory(row) : null;
+    }
+    getAllMemories(includeStale = false) {
+        const query = includeStale
+            ? 'SELECT * FROM memories ORDER BY created_at DESC'
+            : 'SELECT * FROM memories WHERE staleness < 1.0 ORDER BY created_at DESC';
+        const rows = this.queryAll(query);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    getMemoriesByTier(tier, includeStale = false) {
+        const query = includeStale
+            ? 'SELECT * FROM memories WHERE tier = ? ORDER BY created_at DESC'
+            : 'SELECT * FROM memories WHERE tier = ? AND staleness < 1.0 ORDER BY created_at DESC';
+        const rows = this.queryAll(query, tier);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    getMemoriesByCategory(category) {
+        const rows = this.queryAll('SELECT * FROM memories WHERE category = ? AND staleness < 1.0 ORDER BY created_at DESC', category);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    getMemoriesByFile(filePath) {
+        const rows = this.queryAll('SELECT * FROM memories WHERE related_files LIKE ? ORDER BY created_at DESC', `%${filePath}%`);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    getMemoriesByAuthor(author) {
+        const rows = this.queryAll('SELECT * FROM memories WHERE author = ? AND staleness < 1.0 ORDER BY created_at DESC', author);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    getTeamAuthors() {
+        const rows = this.queryAll(`SELECT author, COUNT(*) as count FROM memories WHERE tier = 'team' AND staleness < 1.0 GROUP BY author ORDER BY count DESC`);
+        return rows.map((r) => ({ author: r.author, count: r.count }));
+    }
+    getMemoriesBySessionId(sessionId) {
+        const rows = this.queryAll('SELECT * FROM memories WHERE session_id = ? ORDER BY created_at DESC', sessionId);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    updateTier(id, tier) {
+        this.execute('UPDATE memories SET tier = ?, updated_at = ? WHERE id = ?', tier, new Date().toISOString(), id);
+    }
+    updateStaleness(id, staleness) {
+        this.execute('UPDATE memories SET staleness = ?, updated_at = ? WHERE id = ?', Math.min(staleness, 1.0), new Date().toISOString(), id);
+    }
+    updateEmbedding(id, embedding) {
+        const buffer = Buffer.from(new Float32Array(embedding).buffer);
+        this.execute('UPDATE memories SET embedding = ?, updated_at = ? WHERE id = ?', buffer, new Date().toISOString(), id);
+    }
+    validateMemory(id) {
+        const now = new Date().toISOString();
+        this.execute('UPDATE memories SET staleness = 0.0, validated_at = ?, updated_at = ? WHERE id = ?', now, now, id);
+    }
+    deleteMemory(id) {
+        this.execute('DELETE FROM memories WHERE id = ?', id);
+    }
+    hasMemory(id) {
+        const row = this.queryOne('SELECT 1 FROM memories WHERE id = ?', id);
+        return !!row;
+    }
+    incrementReuseCount(id) {
+        this.execute('UPDATE memories SET reuse_count = reuse_count + 1, updated_at = ? WHERE id = ?', new Date().toISOString(), id);
+    }
+    getTotalReuseCount() {
+        const row = this.queryOne('SELECT COALESCE(SUM(reuse_count), 0) as total FROM memories');
+        return row?.total ?? 0;
+    }
+    getMemoryCount() {
+        const total = this.queryOne('SELECT COUNT(*) as count FROM memories').count;
+        const stale = this.queryOne('SELECT COUNT(*) as count FROM memories WHERE staleness >= 0.6').count;
+        const team = this.queryOne("SELECT COUNT(*) as count FROM memories WHERE tier = 'team'").count;
+        return { total, stale, fresh: total - stale, team, personal: total - team };
+    }
+    // ── Rule Methods ──
+    /** Get all rules, ordered by priority. Optionally include inactive. */
+    getRules(includeInactive = false) {
+        const query = includeInactive
+            ? `SELECT * FROM memories WHERE source = 'rule' ORDER BY
+           CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'normal' THEN 2 WHEN 'low' THEN 3 ELSE 2 END,
+           created_at DESC`
+            : `SELECT * FROM memories WHERE source = 'rule' AND active = 1 ORDER BY
+           CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'normal' THEN 2 WHEN 'low' THEN 3 ELSE 2 END,
+           created_at DESC`;
+        const rows = this.queryAll(query);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    /** Get rules that apply to a specific file path (by scope glob matching). */
+    getRulesForFile(filePath) {
+        const allRules = this.getRules(false);
+        return allRules.filter((rule) => {
+            if (!rule.scope || rule.scope.length === 0)
+                return true; // global rule
+            return picomatch.isMatch(filePath, rule.scope);
+        });
+    }
+    /** Toggle a rule active/inactive. */
+    setRuleActive(id, active) {
+        this.execute('UPDATE memories SET active = ?, updated_at = ? WHERE id = ?', active ? 1 : 0, new Date().toISOString(), id);
+    }
+    /** Update governance-specific fields on a memory (scope, priority, examples, source). */
+    updateRuleFields(id, fields) {
+        const updates = [];
+        const params = [];
+        if (fields.source !== undefined) {
+            updates.push('source = ?');
+            params.push(fields.source);
+        }
+        if (fields.scope !== undefined) {
+            updates.push('scope = ?');
+            params.push(fields.scope ? JSON.stringify(fields.scope) : null);
+        }
+        if (fields.priority !== undefined) {
+            updates.push('priority = ?');
+            params.push(fields.priority);
+        }
+        if (fields.examples !== undefined) {
+            updates.push('examples = ?');
+            params.push(fields.examples ? JSON.stringify(fields.examples) : null);
+        }
+        if (updates.length === 0)
+            return;
+        updates.push('updated_at = ?');
+        params.push(new Date().toISOString());
+        params.push(id);
+        this.execute(`UPDATE memories SET ${updates.join(', ')} WHERE id = ?`, ...params);
+    }
+    // ── Sessions ──
+    insertSession(session) {
+        this.execute(`INSERT INTO sessions (id, developer, task, status, tool_name, started_at, ended_at, duration_seconds, files_touched, summary, insight_count, activity_count, duplicates_prevented)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, session.id, session.developer, session.task, session.status, session.toolName, session.startedAt, session.endedAt, session.durationSeconds, JSON.stringify(session.filesTouched), session.summary, session.insightCount, session.activityCount, session.duplicatesPrevented);
+    }
+    updateSession(id, fields) {
+        const updates = [];
+        const params = [];
+        if (fields.status !== undefined) {
+            updates.push('status = ?');
+            params.push(fields.status);
+        }
+        if (fields.task !== undefined) {
+            updates.push('task = ?');
+            params.push(fields.task);
+        }
+        if (fields.endedAt !== undefined) {
+            updates.push('ended_at = ?');
+            params.push(fields.endedAt);
+        }
+        if (fields.durationSeconds !== undefined) {
+            updates.push('duration_seconds = ?');
+            params.push(fields.durationSeconds);
+        }
+        if (fields.filesTouched !== undefined) {
+            updates.push('files_touched = ?');
+            params.push(JSON.stringify(fields.filesTouched));
+        }
+        if (fields.summary !== undefined) {
+            updates.push('summary = ?');
+            params.push(fields.summary);
+        }
+        if (fields.insightCount !== undefined) {
+            updates.push('insight_count = ?');
+            params.push(fields.insightCount);
+        }
+        if (fields.activityCount !== undefined) {
+            updates.push('activity_count = ?');
+            params.push(fields.activityCount);
+        }
+        if (fields.duplicatesPrevented !== undefined) {
+            updates.push('duplicates_prevented = ?');
+            params.push(fields.duplicatesPrevented);
+        }
+        if (updates.length === 0)
+            return;
+        params.push(id);
+        this.execute(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`, ...params);
+    }
+    getSession(id) {
+        const row = this.queryOne('SELECT * FROM sessions WHERE id = ?', id);
+        return row ? this.rowToSession(row) : null;
+    }
+    getActiveSession(developer) {
+        const row = this.queryOne(`SELECT * FROM sessions WHERE developer = ? AND status = 'active' ORDER BY started_at DESC LIMIT 1`, developer);
+        return row ? this.rowToSession(row) : null;
+    }
+    getSessionsInRange(startDate, endDate, limit = 100) {
+        const rows = this.queryAll('SELECT * FROM sessions WHERE started_at >= ? AND started_at <= ? ORDER BY started_at DESC LIMIT ?', startDate, endDate, limit);
+        return rows.map((r) => this.rowToSession(r));
+    }
+    getAllSessions(limit = 100, offset = 0) {
+        const rows = this.queryAll('SELECT * FROM sessions ORDER BY started_at DESC LIMIT ? OFFSET ?', limit, offset);
+        return rows.map((r) => this.rowToSession(r));
+    }
+    closeSession(id, summary) {
+        const session = this.getSession(id);
+        if (!session)
+            return;
+        const endedAt = new Date().toISOString();
+        const durationSeconds = Math.round((new Date(endedAt).getTime() - new Date(session.startedAt).getTime()) / 1000);
+        this.updateSession(id, {
+            status: 'completed',
+            endedAt,
+            durationSeconds,
+            summary: summary ?? session.summary,
+        });
+    }
+    cleanupStaleSessions(timeoutMinutes) {
+        const cutoff = new Date(Date.now() - timeoutMinutes * 60 * 1000).toISOString();
+        const staleSessions = this.queryAll(`SELECT * FROM sessions WHERE status = 'active' AND started_at < ?`, cutoff);
+        for (const row of staleSessions) {
+            const session = this.rowToSession(row);
+            this.updateSession(session.id, {
+                status: 'abandoned',
+                endedAt: new Date().toISOString(),
+                durationSeconds: Math.round((Date.now() - new Date(session.startedAt).getTime()) / 1000),
+            });
+        }
+        return staleSessions.length;
+    }
+    // ── Activity Events ──
+    insertActivityEvent(event) {
+        this.execute(`INSERT INTO activity_events (id, session_id, type, description, files, timestamp)
+       VALUES (?, ?, ?, ?, ?, ?)`, event.id, event.sessionId, event.type, event.description, JSON.stringify(event.files), event.timestamp);
+        // Increment activity count on session
+        this.execute('UPDATE sessions SET activity_count = activity_count + 1 WHERE id = ?', event.sessionId);
+    }
+    getActivitiesBySession(sessionId) {
+        const rows = this.queryAll('SELECT * FROM activity_events WHERE session_id = ? ORDER BY timestamp ASC', sessionId);
+        return rows.map((r) => this.rowToActivity(r));
+    }
+    // ── Analytics Queries ──
+    getInsightCountsByDeveloper() {
+        const rows = this.queryAll(`SELECT author as developer, COUNT(*) as count FROM memories
+       WHERE tier = 'team' AND staleness < 1.0
+       GROUP BY author ORDER BY count DESC`);
+        return rows.map((r) => ({ developer: r.developer, count: r.count }));
+    }
+    getSessionCountsByDate(days) {
+        const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        const rows = this.queryAll(`SELECT DATE(started_at) as date, COUNT(*) as count FROM sessions
+       WHERE DATE(started_at) >= ? GROUP BY DATE(started_at) ORDER BY date ASC`, since);
+        return rows.map((r) => ({ date: r.date, count: r.count }));
+    }
+    getInsightCountsByDate(days) {
+        const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        const rows = this.queryAll(`SELECT DATE(created_at) as date, COUNT(*) as count FROM memories
+       WHERE tier = 'team' AND DATE(created_at) >= ? GROUP BY DATE(created_at) ORDER BY date ASC`, since);
+        return rows.map((r) => ({ date: r.date, count: r.count }));
+    }
+    getActiveDevelopersByDate(days) {
+        const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+        const rows = this.queryAll(`SELECT DATE(started_at) as date, COUNT(DISTINCT developer) as count FROM sessions
+       WHERE DATE(started_at) >= ? GROUP BY DATE(started_at) ORDER BY date ASC`, since);
+        return rows.map((r) => ({ date: r.date, count: r.count }));
+    }
+    getHotFiles(limit = 10) {
+        // Only fetch the two columns we need instead of full Memory objects
+        const memories = this.queryAll(`SELECT related_files, created_at FROM memories
+       WHERE tier = 'team' AND staleness < 1.0 AND related_files != '[]'
+       ORDER BY created_at DESC`);
+        const fileMap = new Map();
+        for (const row of memories) {
+            try {
+                const files = JSON.parse(row.related_files);
+                for (const file of files) {
+                    const existing = fileMap.get(file);
+                    if (!existing) {
+                        fileMap.set(file, { count: 1, lastInsight: row.created_at });
+                    }
+                    else {
+                        existing.count++;
+                        if (row.created_at > existing.lastInsight) {
+                            existing.lastInsight = row.created_at;
+                        }
+                    }
+                }
+            }
+            catch { /* skip malformed */ }
+        }
+        return Array.from(fileMap.entries())
+            .map(([filePath, data]) => ({ filePath, count: data.count, lastInsight: data.lastInsight }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, limit);
+    }
+    getTotalSessionCount() {
+        const row = this.queryOne('SELECT COUNT(*) as count FROM sessions');
+        return row?.count ?? 0;
+    }
+    getTotalSessionDuration() {
+        const row = this.queryOne('SELECT COALESCE(SUM(duration_seconds), 0) as total FROM sessions WHERE duration_seconds IS NOT NULL');
+        return row?.total ?? 0;
+    }
+    getDistinctDevelopers() {
+        const rows = this.queryAll('SELECT DISTINCT developer FROM sessions ORDER BY developer ASC');
+        return rows.map((r) => r.developer);
+    }
+    getDuplicatesPrevented() {
+        const row = this.queryOne('SELECT COALESCE(SUM(duplicates_prevented), 0) as total FROM sessions');
+        return row?.total ?? 0;
+    }
+    getSessionsByDeveloper(developer) {
+        const rows = this.queryAll('SELECT * FROM sessions WHERE developer = ? ORDER BY started_at DESC', developer);
+        return rows.map((r) => this.rowToSession(r));
+    }
+    getInsightsByCategory() {
+        const rows = this.queryAll(`SELECT category, COUNT(*) as count FROM memories
+       WHERE tier = 'team' AND staleness < 1.0
+       GROUP BY category ORDER BY count DESC`);
+        const result = {};
+        for (const r of rows) {
+            result[r.category] = r.count;
+        }
+        return result;
+    }
+    getRecentInsights(limit = 20) {
+        const rows = this.queryAll(`SELECT * FROM memories WHERE tier = 'team' AND staleness < 1.0
+       ORDER BY created_at DESC LIMIT ?`, limit);
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    // ── Optimized SQL Counts (for analytics) ──
+    getTeamInsightCount() {
+        const row = this.queryOne(`SELECT COUNT(*) as count FROM memories WHERE tier = 'team' AND staleness < 1.0`);
+        return row?.count ?? 0;
+    }
+    getTeamInsightCountSince(since) {
+        const row = this.queryOne(`SELECT COUNT(*) as count FROM memories WHERE tier = 'team' AND staleness < 1.0 AND created_at >= ?`, since);
+        return row?.count ?? 0;
+    }
+    getActiveSessionCount() {
+        const row = this.queryOne(`SELECT COUNT(*) as count FROM sessions WHERE status = 'active'`);
+        return row?.count ?? 0;
+    }
+    getTotalActivityCount() {
+        const row = this.queryOne(`SELECT COUNT(*) as count FROM activity_events`);
+        return row?.count ?? 0;
+    }
+    getAvgSessionDuration() {
+        const row = this.queryOne(`SELECT COALESCE(AVG(duration_seconds), 0) as avg FROM sessions WHERE duration_seconds IS NOT NULL`);
+        return Math.round(row?.avg ?? 0);
+    }
+    // ── Tracked Files ──
+    upsertTrackedFile(file) {
+        this.execute(`INSERT INTO tracked_files (path, hash, last_modified) VALUES (?, ?, ?)
+       ON CONFLICT(path) DO UPDATE SET hash = excluded.hash, last_modified = excluded.last_modified`, file.path, file.hash, file.lastModified);
+    }
+    getTrackedFile(filePath) {
+        const row = this.queryOne('SELECT * FROM tracked_files WHERE path = ?', filePath);
+        if (!row)
+            return null;
+        return { path: row.path, hash: row.hash, lastModified: row.last_modified };
+    }
+    removeTrackedFile(filePath) {
+        this.execute('DELETE FROM tracked_files WHERE path = ?', filePath);
+    }
+    // ── Tracked Commits ──
+    upsertCommit(commit) {
+        this.execute(`INSERT INTO tracked_commits (sha, message, author, date, files, processed) VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(sha) DO UPDATE SET processed = excluded.processed`, commit.sha, commit.message, commit.author, commit.date, JSON.stringify(commit.files), commit.processed ? 1 : 0);
+    }
+    getUnprocessedCommits() {
+        const rows = this.queryAll('SELECT * FROM tracked_commits WHERE processed = 0 ORDER BY date ASC');
+        return rows.map((row) => ({
+            sha: row.sha,
+            message: row.message,
+            author: row.author,
+            date: row.date,
+            files: JSON.parse(row.files),
+            processed: Boolean(row.processed),
+        }));
+    }
+    markCommitProcessed(sha) {
+        this.execute('UPDATE tracked_commits SET processed = 1 WHERE sha = ?', sha);
+    }
+    // ── Helpers ──
+    rowToMemory(row) {
+        return {
+            id: row.id,
+            content: row.content,
+            category: row.category,
+            source: row.source,
+            tier: (row.tier ?? 'personal'),
+            author: row.author ?? 'unknown',
+            tags: JSON.parse(row.tags),
+            relatedFiles: JSON.parse(row.related_files),
+            commitSha: row.commit_sha,
+            staleness: row.staleness,
+            confidence: row.confidence,
+            embedding: row.embedding ? Array.from(new Float32Array(row.embedding.buffer)) : null,
+            scope: row.scope ? JSON.parse(row.scope) : null,
+            priority: row.priority ?? null,
+            examples: row.examples ? JSON.parse(row.examples) : null,
+            active: row.active === undefined ? true : Boolean(row.active),
+            sessionId: row.session_id ?? null,
+            reuseCount: row.reuse_count ?? 0,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            validatedAt: row.validated_at,
+        };
+    }
+    rowToSession(row) {
+        return {
+            id: row.id,
+            developer: row.developer,
+            task: row.task ?? '',
+            status: row.status ?? 'active',
+            toolName: row.tool_name ?? 'unknown',
+            startedAt: row.started_at,
+            endedAt: row.ended_at ?? null,
+            durationSeconds: row.duration_seconds ?? null,
+            filesTouched: JSON.parse(row.files_touched ?? '[]'),
+            summary: row.summary ?? null,
+            insightCount: row.insight_count ?? 0,
+            activityCount: row.activity_count ?? 0,
+            duplicatesPrevented: row.duplicates_prevented ?? 0,
+        };
+    }
+    rowToActivity(row) {
+        return {
+            id: row.id,
+            sessionId: row.session_id,
+            type: row.type,
+            description: row.description ?? '',
+            files: JSON.parse(row.files ?? '[]'),
+            timestamp: row.timestamp,
+        };
+    }
+    close() {
+        this.flush();
+        this.db.close();
+    }
+}
+//# sourceMappingURL=database.js.map