@sriinnu/harmon-store 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @sriinnu/harmon-store
+
+![logo](./logo.svg)
+
+> SQLite persistence layer for sessions, journal entries, events, and settings.
+
+## Install
+
+```bash
+pnpm add @sriinnu/harmon-store
+```
+
+## Quick Start
+
+```typescript
+import { createStore } from '@sriinnu/harmon-store';
+
+const store = await createStore({ dbPath: '.harmon.db' });
+const sessionId = await store.createSession(JSON.stringify(policy));
+await store.logEvent('track.started', { trackId: '123' }, sessionId);
+await store.endSession(sessionId);
+```
+
+## API
+
+| Export | Description |
+|---|---|
+| `createStore(config?)` | Create store and run migrations |
+| `HarmonStore` | Store class with full CRUD |
+| `store.createSession(policy)` | Start a new session |
+| `store.endSession(id)` | Mark session completed |
+| `store.logEvent(type, payload, sessionId?)` | Append to event log |
+| `store.addJournalEntry(entry)` | Insert a mood journal entry |
+| `store.getJournalEntriesByMood(mood)` | Query entries by mood tag |
+| `store.getSetting(key)` / `setSetting(key, value)` | Key-value settings |
+| `store.getStats()` | Aggregate counts and mood distribution |
+
+## Architecture
+
+harmon-store sits beneath the daemon, providing durable storage via libSQL/SQLite. It manages automatic migrations, journal entries with mood tags, session lifecycle, and a typed event log. The daemon reads and writes through this layer exclusively.
+
+## License
+
+GNU Affero General Public License v3.0 only. See [LICENSE](../../LICENSE).

package/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: harmon-store
+description: SQLite persistence layer with versioned migrations for sessions, journals, and events
+capabilities:
+  - Store and query journal entries with mood tags, energy levels, and embeddings
+  - Manage session lifecycle (create, end, cancel) with status tracking
+  - Log and retrieve events with session correlation and time-based queries
+tags:
+  - database
+  - sqlite
+  - persistence
+  - storage
+provider: harmon
+version: 0.1.0
+---
+
+# Harmon Store
+
+## What this does
+harmon-store provides the persistence layer for the entire harmon system. It manages a SQLite database (via libsql) with automatic versioned migrations, storing journal entries, sessions, event logs, and key-value settings. The store enforces WAL mode for concurrent read performance and validates that encryption is enabled in production environments.
+
+## When to use
+- Persisting session history, event logs, or journal entries to disk
+- Querying past sessions, mood distributions, or recent play statistics
+- Adding a new migration when the schema needs to evolve
+
+## Key exports
+- `HarmonStore` — class with methods for journals, sessions, events, settings, and stats
+- `createStore` — async factory that instantiates HarmonStore and runs pending migrations
+- `JournalEntry` — interface for a parsed journal record (mood, energy, content, embedding)
+- `Session` — interface for a session record (id, policy, status, timestamps)
+
+## Example
+```typescript
+import { createStore } from '@sriinnu/harmon-store';
+
+const store = await createStore({ dbPath: '.harmon.db' });
+const sessionId = await store.createSession(JSON.stringify(policy));
+await store.logEvent('session.started', { sessionId });
+const stats = await store.getStats();
+```

package/dist/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Harmon Store - SQLite persistence layer with migrations
+ */
+import { type Client } from '@libsql/client';
+export interface Database {
+    client: Client;
+}
+export interface JournalEntry {
+    id: string;
+    filename: string;
+    timestamp: string;
+    source: string;
+    device: string;
+    sessionId?: string;
+    moodTags: string;
+    energyLevel?: string;
+    context?: string;
+    content: string;
+    policy?: string;
+    embedding?: number[];
+    createdAt: string;
+}
+export interface Session {
+    id: string;
+    policy: string;
+    startedAt: string;
+    endedAt?: string;
+    status: 'active' | 'completed' | 'cancelled';
+}
+export interface EventLog {
+    id: string;
+    sessionId?: string;
+    type: string;
+    payload: string;
+    createdAt: string;
+}
+export interface HarmonStoreConfig {
+    dbPath?: string;
+    memory?: boolean;
+}
+export declare class HarmonStore {
+    private client;
+    private dbPath;
+    private memory;
+    constructor(config?: HarmonStoreConfig);
+    /**
+     * Run migrations
+     */
+    migrate(): Promise<void>;
+    /**
+     * Close the database
+     */
+    close(): Promise<void>;
+    /**
+     * I create the SQLite files myself so the daemon never relies on process
+     * umask to keep journal data owner-only.
+     */
+    private ensureDatabaseFiles;
+    /**
+     * I keep the main DB and SQLite sidecars private to the current user.
+     */
+    private enforceDatabaseFilePermissions;
+    addJournalEntry(entry: Omit<JournalEntry, 'id' | 'createdAt'>): Promise<string>;
+    getJournalEntry(id: string): Promise<JournalEntry | null>;
+    getJournalEntries(limit?: number, offset?: number): Promise<JournalEntry[]>;
+    getJournalEntriesByMood(mood: string, limit?: number): Promise<JournalEntry[]>;
+    getRecentJournalEntries(days?: number, limit?: number): Promise<JournalEntry[]>;
+    private rowToJournalEntry;
+    createSession(policy: string): Promise<string>;
+    endSession(id: string): Promise<void>;
+    cancelSession(id: string): Promise<void>;
+    getSession(id: string): Promise<Session | null>;
+    getActiveSession(): Promise<Session | null>;
+    getRecentSessions(limit?: number): Promise<Session[]>;
+    private rowToSession;
+    logEvent(type: string, payload: Record<string, unknown>, sessionId?: string): Promise<string>;
+    getEvents(sessionId?: string, limit?: number): Promise<EventLog[]>;
+    getRecentEvents(limit?: number): Promise<EventLog[]>;
+    private rowToEventLog;
+    getSetting(key: string): Promise<string | null>;
+    setSetting(key: string, value: string): Promise<void>;
+    deleteSetting(key: string): Promise<void>;
+    getStats(): Promise<{
+        totalEntries: number;
+        totalSessions: number;
+        activeSessions: number;
+        eventsLogged: number;
+        recentMoodDistribution: Record<string, number>;
+    }>;
+    /**
+     * Get database path
+     */
+    getDbPath(): string;
+    /**
+     * Validate encryption is enabled in production
+     * This should be called after the store is initialized
+     */
+    static validateEncryptionInProduction(encryptionEnabled: boolean): void;
+    /**
+     * Check if encryption should be required based on environment
+     */
+    static isEncryptionRequired(): boolean;
+}
+/**
+ * Create a store with default configuration
+ */
+export declare function createStore(config?: HarmonStoreConfig): Promise<HarmonStore>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,473 @@
+/**
+ * Harmon Store - SQLite persistence layer with migrations
+ */
+import { createClient } from '@libsql/client';
+import { v4 as uuidv4 } from 'uuid';
+import path from 'node:path';
+import fs from 'node:fs';
+const MIGRATIONS = [
+    {
+        version: 1,
+        statements: [
+            `
+      CREATE TABLE IF NOT EXISTS journal_entries (
+        id TEXT PRIMARY KEY,
+        filename TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        source TEXT NOT NULL,
+        device TEXT NOT NULL,
+        sessionId TEXT,
+        moodTags TEXT,
+        energyLevel TEXT,
+        context TEXT,
+        content TEXT NOT NULL,
+        policy TEXT,
+        embedding BLOB,
+        createdAt TEXT DEFAULT (datetime('now'))
+      )
+      `,
+            'CREATE INDEX IF NOT EXISTS idx_journal_timestamp ON journal_entries(timestamp)',
+            'CREATE INDEX IF NOT EXISTS idx_journal_moodTags ON journal_entries(moodTags)',
+            'CREATE INDEX IF NOT EXISTS idx_journal_sessionId ON journal_entries(sessionId)',
+            `
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        policy TEXT NOT NULL,
+        startedAt TEXT NOT NULL,
+        endedAt TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        createdAt TEXT DEFAULT (datetime('now'))
+      )
+      `,
+            'CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)',
+            'CREATE INDEX IF NOT EXISTS idx_sessions_startedAt ON sessions(startedAt)',
+            `
+      CREATE TABLE IF NOT EXISTS event_log (
+        id TEXT PRIMARY KEY,
+        sessionId TEXT,
+        type TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        createdAt TEXT DEFAULT (datetime('now'))
+      )
+      `,
+            'CREATE INDEX IF NOT EXISTS idx_event_log_sessionId ON event_log(sessionId)',
+            'CREATE INDEX IF NOT EXISTS idx_event_log_type ON event_log(type)',
+            'CREATE INDEX IF NOT EXISTS idx_event_log_createdAt ON event_log(createdAt)',
+        ],
+    },
+    {
+        version: 2,
+        statements: [`
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updatedAt TEXT DEFAULT (datetime('now'))
+      )
+    `],
+    },
+    {
+        version: 3,
+        statements: ['PRAGMA journal_mode=WAL'],
+    },
+];
+export class HarmonStore {
+    client;
+    dbPath;
+    memory;
+    constructor(config = {}) {
+        const dbPath = config.dbPath || '.harmon.db';
+        this.dbPath = path.resolve(dbPath);
+        this.memory = config.memory === true;
+        // Ensure directory exists
+        const dir = path.dirname(this.dbPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+        if (!this.memory) {
+            this.ensureDatabaseFiles();
+        }
+        const url = this.memory ? 'file::memory:' : `file:${this.dbPath}`;
+        this.client = createClient({
+            url,
+        });
+    }
+    /**
+     * Run migrations
+     */
+    async migrate() {
+        // Ensure migration tracking table exists
+        await this.client.execute(`
+      CREATE TABLE IF NOT EXISTS _migrations (
+        version INTEGER PRIMARY KEY,
+        appliedAt TEXT DEFAULT (datetime('now'))
+      )
+    `);
+        // Get current version
+        const result = await this.client.execute('SELECT MAX(version) as v FROM _migrations');
+        const currentVersion = result.rows[0]?.v || 0;
+        // Run pending migrations (each wrapped in a transaction for atomicity).
+        // PRAGMA statements cannot execute inside a transaction, so they are
+        // run separately and the version is recorded in its own batch.
+        for (const migration of MIGRATIONS) {
+            if (migration.version > currentVersion) {
+                const pragmas = migration.statements.filter((s) => /^\s*PRAGMA\b/i.test(s));
+                const regular = migration.statements.filter((s) => !/^\s*PRAGMA\b/i.test(s));
+                // Execute PRAGMA statements outside a transaction
+                for (const pragma of pragmas) {
+                    await this.client.execute(pragma.trim());
+                }
+                // Batch the remaining DDL/DML with the version bookmark
+                await this.client.batch([
+                    ...regular.map((s) => s.trim()),
+                    { sql: 'INSERT INTO _migrations (version) VALUES (?)', args: [migration.version] },
+                ], 'write');
+            }
+        }
+        this.enforceDatabaseFilePermissions();
+    }
+    /**
+     * Close the database
+     */
+    async close() {
+        this.client.close();
+    }
+    /**
+     * I create the SQLite files myself so the daemon never relies on process
+     * umask to keep journal data owner-only.
+     */
+    ensureDatabaseFiles() {
+        const handle = fs.openSync(this.dbPath, 'a', 0o600);
+        fs.closeSync(handle);
+        this.enforceDatabaseFilePermissions();
+    }
+    /**
+     * I keep the main DB and SQLite sidecars private to the current user.
+     */
+    enforceDatabaseFilePermissions() {
+        if (this.memory) {
+            return;
+        }
+        for (const filePath of [this.dbPath, `${this.dbPath}-shm`, `${this.dbPath}-wal`]) {
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+            fs.chmodSync(filePath, 0o600);
+        }
+    }
+    // ============================================================================
+    // Journal Entries
+    // ============================================================================
+    async addJournalEntry(entry) {
+        const id = uuidv4();
+        const now = new Date().toISOString();
+        await this.client.execute({
+            sql: `
+        INSERT INTO journal_entries
+        (id, filename, timestamp, source, device, sessionId, moodTags, energyLevel, context, content, policy, embedding, createdAt)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+            args: [
+                id,
+                entry.filename,
+                entry.timestamp,
+                entry.source,
+                entry.device,
+                entry.sessionId || null,
+                entry.moodTags,
+                entry.energyLevel || null,
+                entry.context || null,
+                entry.content,
+                entry.policy || null,
+                entry.embedding ? Buffer.from(JSON.stringify(entry.embedding)) : null,
+                now,
+            ],
+        });
+        return id;
+    }
+    async getJournalEntry(id) {
+        const result = await this.client.execute({
+            sql: 'SELECT * FROM journal_entries WHERE id = ?',
+            args: [id],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToJournalEntry(result.rows[0]);
+    }
+    async getJournalEntries(limit = 100, offset = 0) {
+        const result = await this.client.execute({
+            sql: 'SELECT * FROM journal_entries ORDER BY timestamp DESC LIMIT ? OFFSET ?',
+            args: [limit.toString(), offset.toString()],
+        });
+        return result.rows.map((row) => this.rowToJournalEntry(row));
+    }
+    async getJournalEntriesByMood(mood, limit = 50) {
+        const result = await this.client.execute({
+            sql: `
+        SELECT * FROM journal_entries
+        WHERE moodTags LIKE ?
+        ORDER BY timestamp DESC
+        LIMIT ?
+      `,
+            args: [`%${mood}%`, limit.toString()],
+        });
+        return result.rows.map((row) => this.rowToJournalEntry(row));
+    }
+    async getRecentJournalEntries(days = 7, limit = 100) {
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+        const result = await this.client.execute({
+            sql: `
+        SELECT * FROM journal_entries
+        WHERE timestamp >= ?
+        ORDER BY timestamp DESC
+        LIMIT ?
+      `,
+            args: [cutoff, limit.toString()],
+        });
+        return result.rows.map((row) => this.rowToJournalEntry(row));
+    }
+    rowToJournalEntry(row) {
+        return {
+            id: row.id,
+            filename: row.filename,
+            timestamp: row.timestamp,
+            source: row.source,
+            device: row.device,
+            sessionId: row.sessionId,
+            moodTags: row.moodTags,
+            energyLevel: row.energyLevel,
+            context: row.context,
+            content: row.content,
+            policy: row.policy,
+            embedding: row.embedding ? JSON.parse(row.embedding.toString()) : undefined,
+            createdAt: row.createdAt,
+        };
+    }
+    // ============================================================================
+    // Sessions
+    // ============================================================================
+    async createSession(policy) {
+        const id = `sess_${uuidv4().slice(0, 8)}`;
+        const now = new Date().toISOString();
+        await this.client.execute({
+            sql: `
+        INSERT INTO sessions (id, policy, startedAt, status)
+        VALUES (?, ?, ?, 'active')
+      `,
+            args: [id, policy, now],
+        });
+        return id;
+    }
+    async endSession(id) {
+        const now = new Date().toISOString();
+        const result = await this.client.execute({
+            sql: `
+        UPDATE sessions
+        SET endedAt = ?, status = 'completed'
+        WHERE id = ? AND status = 'active'
+      `,
+            args: [now, id],
+        });
+        if (result.rowsAffected === 0) {
+            throw new Error(`Session ${id} not found or not active`);
+        }
+    }
+    async cancelSession(id) {
+        const now = new Date().toISOString();
+        const result = await this.client.execute({
+            sql: `
+        UPDATE sessions
+        SET endedAt = ?, status = 'cancelled'
+        WHERE id = ? AND status = 'active'
+      `,
+            args: [now, id],
+        });
+        if (result.rowsAffected === 0) {
+            throw new Error(`Session ${id} not found or not active`);
+        }
+    }
+    async getSession(id) {
+        const result = await this.client.execute({
+            sql: 'SELECT * FROM sessions WHERE id = ?',
+            args: [id],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToSession(result.rows[0]);
+    }
+    async getActiveSession() {
+        const result = await this.client.execute({
+            sql: 'SELECT * FROM sessions WHERE status = ? ORDER BY startedAt DESC LIMIT 1',
+            args: ['active'],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.rowToSession(result.rows[0]);
+    }
+    async getRecentSessions(limit = 20) {
+        const result = await this.client.execute({
+            sql: 'SELECT * FROM sessions ORDER BY startedAt DESC LIMIT ?',
+            args: [limit.toString()],
+        });
+        return result.rows.map((row) => this.rowToSession(row));
+    }
+    rowToSession(row) {
+        return {
+            id: row.id,
+            policy: row.policy,
+            startedAt: row.startedAt,
+            endedAt: row.endedAt,
+            status: row.status,
+        };
+    }
+    // ============================================================================
+    // Event Log
+    // ============================================================================
+    async logEvent(type, payload, sessionId) {
+        const id = uuidv4();
+        const now = new Date().toISOString();
+        await this.client.execute({
+            sql: `
+        INSERT INTO event_log (id, sessionId, type, payload, createdAt)
+        VALUES (?, ?, ?, ?, ?)
+      `,
+            args: [id, sessionId || null, type, JSON.stringify(payload), now],
+        });
+        return id;
+    }
+    async getEvents(sessionId, limit = 100) {
+        let sql = 'SELECT * FROM event_log';
+        const args = [];
+        if (sessionId) {
+            sql += ' WHERE sessionId = ?';
+            args.push(sessionId);
+        }
+        sql += ' ORDER BY createdAt DESC LIMIT ?';
+        args.push(limit.toString());
+        const result = await this.client.execute({ sql, args });
+        return result.rows.map((row) => this.rowToEventLog(row));
+    }
+    async getRecentEvents(limit = 50) {
+        const result = await this.client.execute({
+            sql: 'SELECT * FROM event_log ORDER BY createdAt DESC LIMIT ?',
+            args: [limit.toString()],
+        });
+        return result.rows.map((row) => this.rowToEventLog(row));
+    }
+    rowToEventLog(row) {
+        return {
+            id: row.id,
+            sessionId: row.sessionId,
+            type: row.type,
+            payload: row.payload,
+            createdAt: row.createdAt,
+        };
+    }
+    // ============================================================================
+    // Settings
+    // ============================================================================
+    async getSetting(key) {
+        const result = await this.client.execute({
+            sql: 'SELECT value FROM settings WHERE key = ?',
+            args: [key],
+        });
+        if (result.rows.length === 0)
+            return null;
+        return result.rows[0]?.value;
+    }
+    async setSetting(key, value) {
+        await this.client.execute({
+            sql: `
+        INSERT INTO settings (key, value, updatedAt)
+        VALUES (?, ?, datetime('now'))
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          updatedAt = datetime('now')
+      `,
+            args: [key, value],
+        });
+    }
+    async deleteSetting(key) {
+        await this.client.execute({
+            sql: 'DELETE FROM settings WHERE key = ?',
+            args: [key],
+        });
+    }
+    // ============================================================================
+    // Statistics
+    // ============================================================================
+    async getStats() {
+        const entriesResult = await this.client.execute({
+            sql: 'SELECT COUNT(*) as count FROM journal_entries',
+            args: [],
+        });
+        const sessionsResult = await this.client.execute({
+            sql: 'SELECT COUNT(*) as count FROM sessions WHERE status = ?',
+            args: ['active'],
+        });
+        const totalSessionsResult = await this.client.execute({
+            sql: 'SELECT COUNT(*) as count FROM sessions',
+            args: [],
+        });
+        const eventsResult = await this.client.execute({
+            sql: 'SELECT COUNT(*) as count FROM event_log',
+            args: [],
+        });
+        // Get mood distribution from last 7 days
+        const cutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+        const moodResult = await this.client.execute({
+            sql: `
+        SELECT moodTags, COUNT(*) as count FROM journal_entries
+        WHERE timestamp >= ?
+        GROUP BY moodTags
+        ORDER BY count DESC
+      `,
+            args: [cutoff],
+        });
+        const recentMoodDistribution = {};
+        for (const row of moodResult.rows) {
+            const tags = (row.moodTags || '').split(',').map((t) => t.trim());
+            for (const tag of tags) {
+                if (tag) {
+                    recentMoodDistribution[tag] = (recentMoodDistribution[tag] || 0) + row.count;
+                }
+            }
+        }
+        return {
+            totalEntries: entriesResult.rows[0]?.count || 0,
+            totalSessions: totalSessionsResult.rows[0]?.count || 0,
+            activeSessions: sessionsResult.rows[0]?.count || 0,
+            eventsLogged: eventsResult.rows[0]?.count || 0,
+            recentMoodDistribution,
+        };
+    }
+    /**
+     * Get database path
+     */
+    getDbPath() {
+        return this.dbPath;
+    }
+    /**
+     * Validate encryption is enabled in production
+     * This should be called after the store is initialized
+     */
+    static validateEncryptionInProduction(encryptionEnabled) {
+        if (process.env.NODE_ENV === 'production' && !encryptionEnabled) {
+            throw new Error('Encryption is required in production. Set HARMON_ENCRYPTION_SECRET environment variable.');
+        }
+    }
+    /**
+     * Check if encryption should be required based on environment
+     */
+    static isEncryptionRequired() {
+        return process.env.NODE_ENV === 'production';
+    }
+}
+/**
+ * Create a store with default configuration
+ */
+export async function createStore(config) {
+    const store = new HarmonStore(config);
+    await store.migrate();
+    return store;
+}
+//# sourceMappingURL=index.js.map