@myrialabs/clopen 0.0.1

package/backend/lib/database/queries/snapshot-queries.ts

@@ -0,0 +1,326 @@
+/**
+ * Database queries for message snapshots and session relationships
+ * Used for time travel feature
+ */
+
+import type { MessageSnapshot, SessionRelationship } from '$shared/types/database/schema';
+import { getDatabase } from '../index';
+
+import { debug } from '$shared/utils/logger';
+export const snapshotQueries = {
+	/**
+	 * Create a new message snapshot
+	 * Supports both full and delta snapshots
+	 */
+	createSnapshot(data: {
+		id?: string; // Optional: allow caller to provide ID (for blob store tree naming)
+		message_id: string;
+		session_id: string;
+		project_id: string;
+		files_snapshot: Record<string, string> | {}; // Will be JSON.stringified
+		project_metadata?: any;
+		snapshot_type?: 'full' | 'delta';
+		parent_snapshot_id?: string;
+		delta_changes?: any; // DeltaChanges object
+		files_changed?: number;
+		insertions?: number;
+		deletions?: number;
+		branch_id?: string;
+		tree_hash?: string; // Blob store tree hash (new format)
+	}): MessageSnapshot {
+		const db = getDatabase();
+		const id = data.id || `snapshot_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+		const now = new Date().toISOString();
+
+		const snapshot: MessageSnapshot = {
+			id,
+			message_id: data.message_id,
+			session_id: data.session_id,
+			project_id: data.project_id,
+			files_snapshot: JSON.stringify(data.files_snapshot),
+			project_metadata: data.project_metadata ? JSON.stringify(data.project_metadata) : undefined,
+			created_at: now,
+			snapshot_type: data.snapshot_type || 'full',
+			parent_snapshot_id: data.parent_snapshot_id,
+			delta_changes: data.delta_changes ? JSON.stringify(data.delta_changes) : undefined,
+			files_changed: data.files_changed || 0,
+			insertions: data.insertions || 0,
+			deletions: data.deletions || 0,
+			is_deleted: 0,
+			branch_id: data.branch_id || null,
+			tree_hash: data.tree_hash || null
+		};
+
+		db.prepare(`
+			INSERT INTO message_snapshots (
+				id, message_id, session_id, project_id,
+				files_snapshot, project_metadata, created_at,
+				snapshot_type, parent_snapshot_id, delta_changes,
+				files_changed, insertions, deletions,
+				is_deleted, branch_id, tree_hash
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+		`).run(
+			snapshot.id,
+			snapshot.message_id,
+			snapshot.session_id,
+			snapshot.project_id,
+			snapshot.files_snapshot,
+			snapshot.project_metadata || null,
+			snapshot.created_at,
+			snapshot.snapshot_type,
+			snapshot.parent_snapshot_id || null,
+			snapshot.delta_changes || null,
+			snapshot.files_changed,
+			snapshot.insertions,
+			snapshot.deletions,
+			snapshot.branch_id || null,
+			snapshot.tree_hash || null
+		);
+
+		return snapshot;
+	},
+
+	/**
+	 * Get snapshot by ID
+	 */
+	getById(snapshotId: string): MessageSnapshot | null {
+		const db = getDatabase();
+		const snapshot = db.prepare(`
+			SELECT * FROM message_snapshots WHERE id = ?
+		`).get(snapshotId) as MessageSnapshot | null;
+
+		return snapshot;
+	},
+
+	/**
+	 * Get snapshot by message ID
+	 */
+	getByMessageId(messageId: string): MessageSnapshot | null {
+		const db = getDatabase();
+		const snapshot = db.prepare(`
+			SELECT * FROM message_snapshots WHERE message_id = ?
+		`).get(messageId) as MessageSnapshot | null;
+
+		return snapshot;
+	},
+
+	/**
+	 * Get all snapshots for a session
+	 */
+	getBySessionId(sessionId: string): MessageSnapshot[] {
+		const db = getDatabase();
+		const snapshots = db.prepare(`
+			SELECT * FROM message_snapshots
+			WHERE session_id = ?
+			ORDER BY created_at ASC
+		`).all(sessionId) as MessageSnapshot[];
+
+		return snapshots;
+	},
+
+	/**
+	 * Get latest snapshot for a project
+	 */
+	getLatestByProjectId(projectId: string): MessageSnapshot | null {
+		const db = getDatabase();
+		const snapshot = db.prepare(`
+			SELECT * FROM message_snapshots
+			WHERE project_id = ?
+			ORDER BY created_at DESC
+			LIMIT 1
+		`).get(projectId) as MessageSnapshot | null;
+
+		return snapshot;
+	},
+
+	/**
+	 * Delete snapshots after a certain message in a session
+	 * Used when restoring to a previous state (hard delete - deprecated)
+	 */
+	deleteAfterMessage(sessionId: string, messageId: string, messageTimestamp: string): void {
+		const db = getDatabase();
+
+		// Delete snapshots created at and after this message
+		db.prepare(`
+			DELETE FROM message_snapshots
+			WHERE session_id = ?
+			AND created_at >= ?
+		`).run(sessionId, messageTimestamp);
+	},
+
+	/**
+	 * Soft delete snapshots after a certain checkpoint message (for undo with branch support)
+	 * Deletes snapshots from next user message onward, preserving checkpoint conversation snapshots
+	 */
+	softDeleteAfterMessage(sessionId: string, checkpointTimestamp: string, branchId: string): void {
+		const db = getDatabase();
+
+		// Get snapshots with their associated messages to determine type
+		const allSnapshots = db.prepare(`
+			SELECT ms.id, ms.created_at, ms.message_id, m.sdk_message
+			FROM message_snapshots ms
+			JOIN messages m ON ms.message_id = m.id
+			WHERE ms.session_id = ?
+			ORDER BY ms.created_at ASC
+		`).all(sessionId) as { id: string; created_at: string; message_id: string; sdk_message: string }[];
+
+		// Find the checkpoint snapshot index
+		const checkpointIndex = allSnapshots.findIndex(snap => snap.created_at === checkpointTimestamp);
+
+		if (checkpointIndex === -1) {
+			debug.warn('database', `Checkpoint snapshot with timestamp ${checkpointTimestamp} not found`);
+			return;
+		}
+
+		// Find next USER message snapshot after checkpoint
+		let deleteFromIndex = -1;
+		for (let i = checkpointIndex + 1; i < allSnapshots.length; i++) {
+			const sdkMessage = JSON.parse(allSnapshots[i].sdk_message);
+			if (sdkMessage.type === 'user') {
+				deleteFromIndex = i;
+				break;
+			}
+		}
+
+		// If no user message snapshot found after checkpoint, nothing to delete
+		if (deleteFromIndex === -1) {
+			debug.log('database', 'No user message snapshots to soft delete after checkpoint');
+			return;
+		}
+
+		// Get IDs of snapshots from next user message onward
+		const snapshotsToDelete = allSnapshots
+			.slice(deleteFromIndex)
+			.map(snap => snap.id);
+
+		if (snapshotsToDelete.length === 0) {
+			debug.log('database', 'No snapshots to soft delete after checkpoint');
+			return;
+		}
+
+		// Soft delete snapshots
+		const placeholders = snapshotsToDelete.map(() => '?').join(',');
+		db.prepare(`
+			UPDATE message_snapshots
+			SET is_deleted = 1, branch_id = ?
+			WHERE id IN (${placeholders}) AND (is_deleted IS NULL OR is_deleted = 0)
+		`).run(branchId, ...snapshotsToDelete);
+
+		debug.log('database', `Soft deleted ${snapshotsToDelete.length} snapshots from next user message after checkpoint`);
+	},
+
+	/**
+	 * Restore snapshots from a specific branch
+	 */
+	restoreBranchSnapshots(sessionId: string, branchId: string): void {
+		const db = getDatabase();
+
+		// Mark all current active snapshots as deleted
+		db.prepare(`
+			UPDATE message_snapshots
+			SET is_deleted = 1
+			WHERE session_id = ? AND (is_deleted IS NULL OR is_deleted = 0)
+		`).run(sessionId);
+
+		// Restore snapshots from target branch
+		db.prepare(`
+			UPDATE message_snapshots
+			SET is_deleted = 0
+			WHERE session_id = ? AND branch_id = ?
+		`).run(sessionId, branchId);
+
+		// Restore snapshots on main branch up to branching point
+		const firstBranchSnapshot = db.prepare(`
+			SELECT MIN(created_at) as min_timestamp
+			FROM message_snapshots
+			WHERE session_id = ? AND branch_id = ?
+		`).get(sessionId, branchId) as { min_timestamp: string } | undefined;
+
+		if (firstBranchSnapshot?.min_timestamp) {
+			db.prepare(`
+				UPDATE message_snapshots
+				SET is_deleted = 0
+				WHERE session_id = ? AND (branch_id IS NULL OR branch_id = '') AND created_at < ?
+			`).run(sessionId, firstBranchSnapshot.min_timestamp);
+		}
+	},
+
+	/**
+	 * Create session relationship
+	 */
+	createRelationship(data: {
+		parent_session_id: string;
+		child_session_id: string;
+		branched_from_message_id?: string;
+	}): SessionRelationship {
+		const db = getDatabase();
+		const id = `rel_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+		const now = new Date().toISOString();
+
+		const relationship: SessionRelationship = {
+			id,
+			parent_session_id: data.parent_session_id,
+			child_session_id: data.child_session_id,
+			branched_from_message_id: data.branched_from_message_id,
+			created_at: now
+		};
+
+		db.prepare(`
+			INSERT INTO session_relationships (
+				id, parent_session_id, child_session_id,
+				branched_from_message_id, created_at
+			) VALUES (?, ?, ?, ?, ?)
+		`).run(
+			relationship.id,
+			relationship.parent_session_id,
+			relationship.child_session_id,
+			relationship.branched_from_message_id || null,
+			relationship.created_at
+		);
+
+		return relationship;
+	},
+
+	/**
+	 * Get relationship by child session ID
+	 */
+	getRelationshipByChildId(childSessionId: string): SessionRelationship | null {
+		const db = getDatabase();
+		const relationship = db.prepare(`
+			SELECT * FROM session_relationships WHERE child_session_id = ?
+		`).get(childSessionId) as SessionRelationship | null;
+
+		return relationship;
+	},
+
+	/**
+	 * Get all child sessions of a parent
+	 */
+	getChildSessions(parentSessionId: string): SessionRelationship[] {
+		const db = getDatabase();
+		const relationships = db.prepare(`
+			SELECT * FROM session_relationships
+			WHERE parent_session_id = ?
+			ORDER BY created_at ASC
+		`).all(parentSessionId) as SessionRelationship[];
+
+		return relationships;
+	},
+
+	/**
+	 * Get complete session tree for a project
+	 * Returns all relationships for building a timeline
+	 */
+	getSessionTree(projectId: string): SessionRelationship[] {
+		const db = getDatabase();
+		const relationships = db.prepare(`
+			SELECT sr.*
+			FROM session_relationships sr
+			INNER JOIN chat_sessions cs ON sr.parent_session_id = cs.id
+			WHERE cs.project_id = ?
+			ORDER BY sr.created_at ASC
+		`).all(projectId) as SessionRelationship[];
+
+		return relationships;
+	}
+};

package/backend/lib/database/queries/utils-queries.ts

@@ -0,0 +1,59 @@
+import { getDatabase } from '../index';
+import type { DatabaseMessage } from '$shared/types/database/schema';
+
+import { debug } from '$shared/utils/logger';
+export const dbUtils = {
+	// Get dashboard statistics
+	getStats(): {
+		totalProjects: number;
+		totalSessions: number;
+		totalMessages: number;
+	} {
+		const db = getDatabase();
+
+		const totalProjects = (db.prepare('SELECT COUNT(*) as count FROM projects').get() as { count: number }).count;
+		const totalSessions = (db.prepare('SELECT COUNT(*) as count FROM chat_sessions').get() as { count: number }).count;
+		const totalMessages = (db.prepare('SELECT COUNT(*) as count FROM messages').get() as { count: number }).count;
+
+		return {
+			totalProjects,
+			totalSessions,
+			totalMessages
+		};
+	},
+
+	// Search across messages
+	searchMessages(query: string, limit: number = 50): (DatabaseMessage & { project_name: string })[] {
+		const db = getDatabase();
+		return db.prepare(`
+			SELECT m.*, p.name as project_name
+			FROM messages m
+			JOIN chat_sessions cs ON m.session_id = cs.id
+			JOIN projects p ON cs.project_id = p.id
+			WHERE m.content LIKE ?
+			ORDER BY m.timestamp DESC
+			LIMIT ?
+		`).all(`%${query}%`, limit) as (DatabaseMessage & { project_name: string })[];
+	},
+
+	// Clean up old data
+	cleanupOldData(daysOld: number = 30): void {
+		const db = getDatabase();
+		const cutoffDate = new Date();
+		cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+		const cutoff = cutoffDate.toISOString();
+		
+		// Delete old ended sessions and their messages
+		const oldSessions = db.prepare(`
+			SELECT id FROM chat_sessions 
+			WHERE ended_at IS NOT NULL AND ended_at < ?
+		`).all(cutoff) as { id: string }[];
+		
+		for (const session of oldSessions) {
+			db.prepare('DELETE FROM messages WHERE session_id = ?').run(session.id);
+			db.prepare('DELETE FROM chat_sessions WHERE id = ?').run(session.id);
+		}
+		
+		debug.log('database', `✅ Cleaned up ${oldSessions.length} old sessions`);
+	}
+};

package/backend/lib/database/seeders/index.ts

@@ -0,0 +1,13 @@
+// Import all seeders
+import * as settingsSeeder from './settings_seeder';
+
+// Export all seeders
+export const seeders = [
+	{
+		name: 'settings',
+		description: settingsSeeder.description,
+		seed: settingsSeeder.seed
+	}
+];
+
+export default seeders;

package/backend/lib/database/seeders/settings_seeder.ts

@@ -0,0 +1,84 @@
+import type { DatabaseConnection } from '$shared/types/database/connection';
+
+import { debug } from '$shared/utils/logger';
+export const seed = (db: DatabaseConnection): void => {
+	debug.log('seeder', '🌱 Seeding default settings...');
+
+	const now = new Date().toISOString();
+
+	// Insert default settings
+	const insertSetting = db.prepare(`
+		INSERT INTO settings (key, value, updated_at)
+		VALUES (?, ?, ?)
+	`);
+
+	const defaultSettings = [
+		{
+			key: 'claude_model',
+			value: 'sonnet',
+			description: 'Default Claude model for chat'
+		},
+		{ 
+			key: 'max_tokens', 
+			value: '4000',
+			description: 'Maximum tokens per response'
+		},
+		{ 
+			key: 'temperature', 
+			value: '0.3',
+			description: 'AI response creativity (0.0 - 1.0)'
+		},
+		{ 
+			key: 'auto_save_sessions', 
+			value: 'true',
+			description: 'Automatically save chat sessions'
+		},
+		{ 
+			key: 'file_watch_enabled', 
+			value: 'true',
+			description: 'Enable file system watching'
+		},
+		{ 
+			key: 'theme', 
+			value: 'system',
+			description: 'UI theme preference (light/dark/system)'
+		},
+		{ 
+			key: 'session_timeout', 
+			value: '3600000',
+			description: 'Session timeout in milliseconds (1 hour)'
+		},
+		{
+			key: 'enable_notifications',
+			value: 'true',
+			description: 'Enable desktop notifications'
+		},
+		{
+			key: 'auto_cleanup_old_sessions',
+			value: 'false',
+			description: 'Automatically clean up old chat sessions'
+		},
+		{
+			key: 'default_project_template',
+			value: 'svelte',
+			description: 'Default template for new projects'
+		}
+	];
+
+	for (const setting of defaultSettings) {
+		try {
+			insertSetting.run(setting.key, setting.value, now);
+		} catch (error) {
+			// Skip if setting already exists
+			if (error instanceof Error && error.message.includes('UNIQUE constraint failed')) {
+				debug.log('seeder', `ℹ️  Setting ${setting.key} already exists, skipping`);
+			} else {
+				throw error;
+			}
+		}
+	}
+
+	debug.log('seeder', `✅ Seeded ${defaultSettings.length} default settings`);
+};
+
+export const description = 'Seed default application settings and configuration';

package/backend/lib/database/utils/connection.ts

@@ -0,0 +1,174 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { Database } from 'bun:sqlite';
+import type { DatabaseConnection } from '$shared/types/database/connection';
+
+import { debug } from '$shared/utils/logger';
+export class DatabaseManager {
+	private static instance: DatabaseManager | null = null;
+	private db: DatabaseConnection | null = null;
+	private readonly dbPath: string;
+
+	private constructor() {
+		const clopenDir = join(homedir(), '.clopen');
+		this.dbPath = join(clopenDir, 'app.db');
+	}
+
+	static getInstance(): DatabaseManager {
+		if (!DatabaseManager.instance) {
+			DatabaseManager.instance = new DatabaseManager();
+		}
+		return DatabaseManager.instance;
+	}
+
+	async connect(): Promise<DatabaseConnection> {
+		if (this.db) {
+			return this.db;
+		}
+
+		debug.log('database', '🔗 Connecting to database...');
+
+		try {
+			// Create ~/.clopen directory if it doesn't exist
+			const clopenDir = join(homedir(), '.clopen');
+			const dirFile = Bun.file(clopenDir);
+
+			// Check if directory exists, if not create it
+			try {
+				await dirFile.stat();
+			} catch {
+				// Directory doesn't exist, create using Bun.write workaround
+				const tempFile = join(clopenDir, '.init');
+				await Bun.write(tempFile, '');
+				// Remove the temp file
+				try {
+					const tempFileHandle = Bun.file(tempFile);
+					if (await tempFileHandle.exists()) {
+						if (process.platform === 'win32') {
+							await Bun.spawn(['cmd', '/c', 'del', '/f', '/q', tempFile.replace(/\//g, '\\')], {
+								stdout: 'ignore',
+								stderr: 'ignore'
+							}).exited;
+						} else {
+							await Bun.spawn(['rm', '-f', tempFile], {
+								stdout: 'ignore',
+								stderr: 'ignore'
+							}).exited;
+						}
+					}
+				} catch {
+					// Ignore cleanup errors
+				}
+			}
+
+			// Use Bun's native SQLite exclusively
+			this.db = new Database(this.dbPath);
+
+			// Configure database for optimal performance
+			this.configurePragmas();
+
+			debug.log('database', `✅ Connected to database at: ${this.dbPath}`);
+			return this.db;
+
+		} catch (error) {
+			debug.error('database', '❌ Failed to connect to database:', error);
+			throw error;
+		}
+	}
+
+	private configurePragmas(): void {
+		if (!this.db) return;
+
+		debug.log('database', '⚙️  Configuring database pragmas...');
+
+		// Bun SQLite uses exec for pragmas
+		this.db.exec('PRAGMA journal_mode = WAL');
+		this.db.exec('PRAGMA synchronous = NORMAL');
+		this.db.exec('PRAGMA cache_size = 1000000');
+		this.db.exec('PRAGMA temp_store = memory');
+		this.db.exec('PRAGMA foreign_keys = ON');
+
+		debug.log('database', '✅ Database pragmas configured');
+	}
+
+	getConnection(): DatabaseConnection {
+		if (!this.db) {
+			throw new Error('Database not connected. Call connect() first.');
+		}
+		return this.db;
+	}
+
+	isConnected(): boolean {
+		return this.db !== null;
+	}
+
+	close(): void {
+		if (this.db) {
+			debug.log('database', '🔗 Closing database connection...');
+			this.db.close();
+			this.db = null;
+			debug.log('database', '✅ Database connection closed');
+		}
+	}
+
+	getPath(): string {
+		return this.dbPath;
+	}
+
+	async resetDatabase(): Promise<void> {
+		debug.log('database', '⚠️ Resetting database (dropping all tables)...');
+		
+		if (!this.db) {
+			throw new Error('Database not connected');
+		}
+
+		// Drop all tables
+		const tables = this.db.prepare(`
+			SELECT name FROM sqlite_master 
+			WHERE type='table' AND name NOT LIKE 'sqlite_%'
+		`).all() as { name: string }[];
+
+		for (const table of tables) {
+			debug.log('database', `🗑️ Dropping table: ${table.name}`);
+			this.db.exec(`DROP TABLE IF EXISTS ${table.name}`);
+		}
+
+		debug.log('database', '✅ Database reset completed');
+	}
+
+	async vacuum(): Promise<void> {
+		debug.log('database', '🧹 Running database vacuum...');
+		
+		if (!this.db) {
+			throw new Error('Database not connected');
+		}
+
+		this.db.exec('VACUUM');
+		debug.log('database', '✅ Database vacuum completed');
+	}
+
+	getDatabaseInfo(): object {
+		if (!this.db) {
+			throw new Error('Database not connected');
+		}
+
+		// Helper to get pragma values with Bun SQLite
+		const getPragma = (name: string) => {
+			const result = this.db!.query(`PRAGMA ${name}`).get() as any;
+			return result ? Object.values(result)[0] : null;
+		};
+		
+		return {
+			path: this.dbPath,
+			journalMode: getPragma('journal_mode'),
+			synchronous: getPragma('synchronous'),
+			cacheSize: getPragma('cache_size'),
+			tempStore: getPragma('temp_store'),
+			foreignKeys: getPragma('foreign_keys'),
+			userVersion: getPragma('user_version'),
+			pageSize: getPragma('page_size'),
+			pageCount: getPragma('page_count'),
+			freelistCount: getPragma('freelist_count')
+		};
+	}
+}

package/backend/lib/database/utils/index.ts

@@ -0,0 +1,4 @@
+// Export all database utilities
+export { DatabaseManager } from './connection';
+export { MigrationRunner } from './migration-runner';
+export { SeederRunner } from './seeder-runner';