@affectively/dash 5.0.0 → 5.1.0

package/dist/src/engine/sqlite.d.ts

@@ -30,5 +30,140 @@ export declare class DashEngine {
         maxZ: number;
     }): Promise<any[]>;
     close(): void;
+    /**
+     * Get information about all tables in the database
+     */
+    getAllTables(): TableInfo[];
+    /**
+     * Get detailed schema information for a specific table
+     */
+    getTableSchema(tableName: string): TableSchema | null;
+    /**
+     * Get the row count for a specific table
+     */
+    getTableRowCount(tableName: string): number;
+    /**
+     * Get statistics about the vector index
+     */
+    getVectorIndexStats(): VectorIndexStats;
+    /**
+     * Get all embeddings from the vector index
+     */
+    getAllEmbeddings(limit?: number, offset?: number): EmbeddingEntry[];
+    /**
+     * Search for similar vectors given a raw vector
+     */
+    searchSimilarByVector(vector: number[], k?: number): SimilarityResult[];
+    /**
+     * Get statistics about the spatial R-Tree index
+     */
+    getSpatialIndexStats(): SpatialIndexStats;
+    /**
+     * Get all spatial bounds from the R-Tree index
+     */
+    getAllSpatialBounds(limit?: number, offset?: number): SpatialBound[];
+    /**
+     * Get information about active table subscriptions
+     */
+    getActiveSubscriptions(): SubscriptionInfo[];
+    /**
+     * Get table listener counts as a map
+     */
+    getTableListenerCounts(): Record<string, number>;
+    /**
+     * Check if the database is ready
+     */
+    isReady(): boolean;
+    /**
+     * Get database metadata
+     */
+    getDatabaseInfo(): DatabaseInfo;
+}
+export interface TableInfo {
+    name: string;
+    type: 'table' | 'virtual';
+    rowCount: number;
+    isVirtual: boolean;
+}
+export interface TableSchema {
+    name: string;
+    columns: ColumnInfo[];
+    indexes: IndexInfo[];
+    foreignKeys: ForeignKeyInfo[];
+    rowCount: number;
+}
+export interface ColumnInfo {
+    cid: number;
+    name: string;
+    type: string;
+    notNull: boolean;
+    defaultValue: string | null;
+    isPrimaryKey: boolean;
+}
+export interface IndexInfo {
+    name: string;
+    unique: boolean;
+    origin: string;
+}
+export interface ForeignKeyInfo {
+    id: number;
+    table: string;
+    from: string;
+    to: string;
+}
+export interface VectorIndexStats {
+    totalEmbeddings: number;
+    dimensions: number;
+    indexExists: boolean;
+    tableName?: string;
+    error?: string;
+}
+export interface EmbeddingEntry {
+    id: string;
+    content: string | null;
+    embedding: number[] | null;
+}
+export interface SimilarityResult {
+    id: string;
+    content: string | null;
+    distance: number;
+    score: number;
+}
+export interface SpatialIndexStats {
+    totalEntries: number;
+    indexExists: boolean;
+    tableName?: string;
+    globalBounds?: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+        minZ: number;
+        maxZ: number;
+    };
+    error?: string;
+}
+export interface SpatialBound {
+    id: string;
+    rowid: number;
+    bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+        minZ: number;
+        maxZ: number;
+    };
+    content: string | null;
+}
+export interface SubscriptionInfo {
+    table: string;
+    listenerCount: number;
+}
+export interface DatabaseInfo {
+    ready: boolean;
+    schemaVersion: number;
+    tableCount: number;
+    tables?: string[];
 }
 export declare const dash: DashEngine;

package/dist/src/engine/sqlite.js

@@ -252,5 +252,303 @@ export class DashEngine {
     close() {
         this.db?.close();
     }
+    // ============================================
+    // INTROSPECTION METHODS FOR DASH-STUDIO
+    // ============================================
+    /**
+     * Get information about all tables in the database
+     */
+    getAllTables() {
+        if (!this.db)
+            return [];
+        const tables = this.execute(`
+      SELECT name, type
+      FROM sqlite_master
+      WHERE type IN ('table', 'virtual table')
+      AND name NOT LIKE 'sqlite_%'
+      ORDER BY name
+    `);
+        return tables.map((t) => {
+            const rowCount = this.getTableRowCount(t.name);
+            return {
+                name: t.name,
+                type: t.type === 'table' ? 'table' : 'virtual',
+                rowCount,
+                isVirtual: t.type !== 'table'
+            };
+        });
+    }
+    /**
+     * Get detailed schema information for a specific table
+     */
+    getTableSchema(tableName) {
+        if (!this.db)
+            return null;
+        try {
+            const columns = this.execute(`PRAGMA table_info('${tableName.replace(/'/g, "''")}')`);
+            // Get indexes for this table
+            const indexes = this.execute(`PRAGMA index_list('${tableName.replace(/'/g, "''")}')`);
+            // Get foreign keys
+            const foreignKeys = this.execute(`PRAGMA foreign_key_list('${tableName.replace(/'/g, "''")}')`);
+            return {
+                name: tableName,
+                columns: columns.map((col) => ({
+                    cid: col.cid,
+                    name: col.name,
+                    type: col.type || 'ANY',
+                    notNull: col.notnull === 1,
+                    defaultValue: col.dflt_value,
+                    isPrimaryKey: col.pk === 1
+                })),
+                indexes: indexes.map((idx) => ({
+                    name: idx.name,
+                    unique: idx.unique === 1,
+                    origin: idx.origin
+                })),
+                foreignKeys: foreignKeys.map((fk) => ({
+                    id: fk.id,
+                    table: fk.table,
+                    from: fk.from,
+                    to: fk.to
+                })),
+                rowCount: this.getTableRowCount(tableName)
+            };
+        }
+        catch (e) {
+            console.warn(`Failed to get schema for table ${tableName}:`, e);
+            return null;
+        }
+    }
+    /**
+     * Get the row count for a specific table
+     */
+    getTableRowCount(tableName) {
+        if (!this.db)
+            return 0;
+        try {
+            const result = this.execute(`SELECT COUNT(*) as count FROM "${tableName.replace(/"/g, '""')}"`);
+            return result[0]?.count ?? 0;
+        }
+        catch (e) {
+            // Virtual tables may not support COUNT
+            return -1;
+        }
+    }
+    /**
+     * Get statistics about the vector index
+     */
+    getVectorIndexStats() {
+        if (!this.db) {
+            return { totalEmbeddings: 0, dimensions: 384, indexExists: false };
+        }
+        try {
+            const countResult = this.execute('SELECT COUNT(*) as count FROM dash_vec_idx');
+            const totalEmbeddings = countResult[0]?.count ?? 0;
+            return {
+                totalEmbeddings,
+                dimensions: 384, // Fixed dimension from schema
+                indexExists: true,
+                tableName: 'dash_vec_idx'
+            };
+        }
+        catch (e) {
+            return {
+                totalEmbeddings: 0,
+                dimensions: 384,
+                indexExists: false,
+                error: e instanceof Error ? e.message : 'Vector index not available'
+            };
+        }
+    }
+    /**
+     * Get all embeddings from the vector index
+     */
+    getAllEmbeddings(limit = 100, offset = 0) {
+        if (!this.db)
+            return [];
+        try {
+            const rows = this.execute(`
+        SELECT v.id, i.content, v.embedding
+        FROM dash_vec_idx v
+        LEFT JOIN dash_items i ON v.id = i.id
+        LIMIT ? OFFSET ?
+      `, [limit, offset]);
+            return rows.map((row) => ({
+                id: row.id,
+                content: row.content,
+                embedding: row.embedding ? Array.from(row.embedding) : null
+            }));
+        }
+        catch (e) {
+            console.warn('Failed to get embeddings:', e);
+            return [];
+        }
+    }
+    /**
+     * Search for similar vectors given a raw vector
+     */
+    searchSimilarByVector(vector, k = 5) {
+        if (!this.db)
+            return [];
+        try {
+            const rows = this.execute(`
+        SELECT
+          item.id,
+          item.content,
+          distance
+        FROM dash_vec_idx
+        JOIN dash_items AS item ON item.id = dash_vec_idx.id
+        WHERE embedding MATCH ?
+        ORDER BY distance
+        LIMIT ?
+      `, [new Float32Array(vector), k]);
+            return rows.map((row) => ({
+                id: row.id,
+                content: row.content,
+                distance: row.distance,
+                score: row.distance !== undefined ? 1 - row.distance : 0
+            }));
+        }
+        catch (e) {
+            console.warn('Vector search failed:', e);
+            return [];
+        }
+    }
+    /**
+     * Get statistics about the spatial R-Tree index
+     */
+    getSpatialIndexStats() {
+        if (!this.db) {
+            return { totalEntries: 0, indexExists: false };
+        }
+        try {
+            const countResult = this.execute('SELECT COUNT(*) as count FROM dash_spatial_idx');
+            const totalEntries = countResult[0]?.count ?? 0;
+            // Get bounding box of all entries
+            const boundsResult = this.execute(`
+        SELECT
+          MIN(minX) as minX, MAX(maxX) as maxX,
+          MIN(minY) as minY, MAX(maxY) as maxY,
+          MIN(minZ) as minZ, MAX(maxZ) as maxZ
+        FROM dash_spatial_idx
+      `);
+            const bounds = boundsResult[0] || {};
+            return {
+                totalEntries,
+                indexExists: true,
+                tableName: 'dash_spatial_idx',
+                globalBounds: totalEntries > 0 ? {
+                    minX: bounds.minX,
+                    maxX: bounds.maxX,
+                    minY: bounds.minY,
+                    maxY: bounds.maxY,
+                    minZ: bounds.minZ,
+                    maxZ: bounds.maxZ
+                } : undefined
+            };
+        }
+        catch (e) {
+            return {
+                totalEntries: 0,
+                indexExists: false,
+                error: e instanceof Error ? e.message : 'Spatial index not available'
+            };
+        }
+    }
+    /**
+     * Get all spatial bounds from the R-Tree index
+     */
+    getAllSpatialBounds(limit = 100, offset = 0) {
+        if (!this.db)
+            return [];
+        try {
+            const rows = this.execute(`
+        SELECT
+          idx.id as rowid,
+          map.item_id as id,
+          idx.minX, idx.maxX,
+          idx.minY, idx.maxY,
+          idx.minZ, idx.maxZ,
+          item.content
+        FROM dash_spatial_idx idx
+        JOIN dash_spatial_map map ON map.rowid = idx.id
+        LEFT JOIN dash_items item ON item.id = map.item_id
+        LIMIT ? OFFSET ?
+      `, [limit, offset]);
+            return rows.map((row) => ({
+                id: row.id,
+                rowid: row.rowid,
+                bounds: {
+                    minX: row.minX,
+                    maxX: row.maxX,
+                    minY: row.minY,
+                    maxY: row.maxY,
+                    minZ: row.minZ,
+                    maxZ: row.maxZ
+                },
+                content: row.content
+            }));
+        }
+        catch (e) {
+            console.warn('Failed to get spatial bounds:', e);
+            return [];
+        }
+    }
+    /**
+     * Get information about active table subscriptions
+     */
+    getActiveSubscriptions() {
+        const subscriptions = [];
+        this.tableListeners.forEach((listeners, tableName) => {
+            subscriptions.push({
+                table: tableName,
+                listenerCount: listeners.size
+            });
+        });
+        // Add global listeners
+        if (this.listeners.size > 0) {
+            subscriptions.push({
+                table: '*',
+                listenerCount: this.listeners.size
+            });
+        }
+        return subscriptions;
+    }
+    /**
+     * Get table listener counts as a map
+     */
+    getTableListenerCounts() {
+        const counts = {};
+        this.tableListeners.forEach((listeners, tableName) => {
+            counts[tableName] = listeners.size;
+        });
+        counts['*'] = this.listeners.size;
+        return counts;
+    }
+    /**
+     * Check if the database is ready
+     */
+    isReady() {
+        return this.db !== null;
+    }
+    /**
+     * Get database metadata
+     */
+    getDatabaseInfo() {
+        if (!this.db) {
+            return {
+                ready: false,
+                schemaVersion: this.currentSchemaVersion,
+                tableCount: 0
+            };
+        }
+        const tables = this.getAllTables();
+        return {
+            ready: true,
+            schemaVersion: this.currentSchemaVersion,
+            tableCount: tables.length,
+            tables: tables.map(t => t.name)
+        };
+    }
 }
 export const dash = new DashEngine();

package/dist/src/sync/aeon/config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Aeon Integration Configuration
+ *
+ * Configuration for Aeon sync features in Dash.
+ * All features enabled by default.
+ */
+export interface AeonConfig {
+    /** Enable delta sync optimization (70-80% bandwidth reduction) */
+    enableDeltaSync: boolean;
+    /** Enable rich presence tracking (cursors, sections, activity) */
+    enableRichPresence: boolean;
+    /** Enable offline operation queuing */
+    enableOfflineQueue: boolean;
+    /** Bytes threshold before falling back to full sync instead of delta */
+    deltaThreshold: number;
+    /** Maximum operations to hold in offline queue */
+    maxOfflineQueueSize: number;
+    /** Maximum retries for failed offline operations */
+    maxOfflineRetries: number;
+}
+export declare const defaultAeonConfig: AeonConfig;

package/dist/src/sync/aeon/config.js

@@ -0,0 +1,14 @@
+/**
+ * Aeon Integration Configuration
+ *
+ * Configuration for Aeon sync features in Dash.
+ * All features enabled by default.
+ */
+export const defaultAeonConfig = {
+    enableDeltaSync: true,
+    enableRichPresence: true,
+    enableOfflineQueue: true,
+    deltaThreshold: 1000,
+    maxOfflineQueueSize: 1000,
+    maxOfflineRetries: 3,
+};

package/dist/src/sync/aeon/delta-adapter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Delta Adapter for Dash
+ *
+ * Wraps Aeon's DeltaSyncOptimizer to provide delta compression
+ * for Yjs document updates. Achieves 70-80% bandwidth reduction.
+ */
+import { type DeltaOperation, type DeltaStats } from '@affectively/aeon';
+/**
+ * Adapter that wraps Yjs updates with delta compression
+ */
+export declare class DashDeltaAdapter {
+    private optimizer;
+    private roomId;
+    private updateCounter;
+    constructor(roomId: string, threshold?: number);
+    /**
+     * Wrap a Yjs update with delta compression
+     * Returns a delta payload ready for transmission
+     */
+    wrapUpdate(update: Uint8Array, origin?: string): DeltaPayload;
+    /**
+     * Unwrap a delta payload back to Yjs update
+     */
+    unwrapDelta(payload: DeltaPayload): Uint8Array;
+    /**
+     * Encode delta payload for wire transmission
+     */
+    encodePayload(payload: DeltaPayload): Uint8Array;
+    /**
+     * Decode delta payload from wire
+     */
+    decodePayload(data: Uint8Array): DeltaPayload;
+    /**
+     * Get compression statistics
+     */
+    getStats(): DeltaStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Get memory footprint estimate
+     */
+    getMemoryEstimate(): number;
+    /**
+     * Clear operation history
+     */
+    clearHistory(): void;
+}
+/**
+ * Delta payload structure for wire transmission
+ */
+export interface DeltaPayload {
+    type: 'delta';
+    delta: DeltaOperation;
+    originalSize: number;
+    deltaSize: number;
+}
+/**
+ * Check if a payload is a delta payload
+ */
+export declare function isDeltaPayload(data: unknown): data is DeltaPayload;

package/dist/src/sync/aeon/delta-adapter.js

@@ -0,0 +1,98 @@
+/**
+ * Delta Adapter for Dash
+ *
+ * Wraps Aeon's DeltaSyncOptimizer to provide delta compression
+ * for Yjs document updates. Achieves 70-80% bandwidth reduction.
+ */
+import { DeltaSyncOptimizer, } from '@affectively/aeon';
+/**
+ * Adapter that wraps Yjs updates with delta compression
+ */
+export class DashDeltaAdapter {
+    optimizer;
+    roomId;
+    updateCounter = 0;
+    constructor(roomId, threshold = 1000) {
+        this.roomId = roomId;
+        this.optimizer = new DeltaSyncOptimizer(threshold);
+    }
+    /**
+     * Wrap a Yjs update with delta compression
+     * Returns a delta payload ready for transmission
+     */
+    wrapUpdate(update, origin) {
+        const operationId = `${this.roomId}-${this.updateCounter++}`;
+        // Create an Aeon Operation from the Yjs update
+        const operation = {
+            id: operationId,
+            type: 'update',
+            sessionId: this.roomId,
+            data: {
+                update: Array.from(update),
+                origin: origin ?? 'local',
+            },
+            status: 'pending',
+            createdAt: Date.now(),
+        };
+        const delta = this.optimizer.computeDelta(operation);
+        return {
+            type: 'delta',
+            delta,
+            originalSize: update.byteLength,
+            deltaSize: new TextEncoder().encode(JSON.stringify(delta)).byteLength,
+        };
+    }
+    /**
+     * Unwrap a delta payload back to Yjs update
+     */
+    unwrapDelta(payload) {
+        const operation = this.optimizer.decompressDelta(payload.delta);
+        return new Uint8Array(operation.data.update);
+    }
+    /**
+     * Encode delta payload for wire transmission
+     */
+    encodePayload(payload) {
+        return new TextEncoder().encode(JSON.stringify(payload));
+    }
+    /**
+     * Decode delta payload from wire
+     */
+    decodePayload(data) {
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    /**
+     * Get compression statistics
+     */
+    getStats() {
+        return this.optimizer.getStats();
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.optimizer.resetStats();
+    }
+    /**
+     * Get memory footprint estimate
+     */
+    getMemoryEstimate() {
+        return this.optimizer.getMemoryEstimate();
+    }
+    /**
+     * Clear operation history
+     */
+    clearHistory() {
+        this.optimizer.resetStats();
+    }
+}
+/**
+ * Check if a payload is a delta payload
+ */
+export function isDeltaPayload(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'type' in data &&
+        data.type === 'delta' &&
+        'delta' in data);
+}

package/dist/src/sync/aeon/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Aeon Integration for Dash
+ *
+ * Provides enhanced sync capabilities through Aeon:
+ * - Delta compression (70-80% bandwidth reduction)
+ * - Rich presence tracking (cursors, sections, activity)
+ * - Offline operation queuing with persistence
+ * - Schema versioning and migrations
+ */
+export { defaultAeonConfig, type AeonConfig } from './config.js';
+export { DashDeltaAdapter, isDeltaPayload, type DeltaPayload, } from './delta-adapter.js';
+export { DashPresenceAdapter, type PresenceEvents, } from './presence-adapter.js';
+export { DashOfflineAdapter, type ProcessQueueResult, type OfflineQueueEvents, } from './offline-adapter.js';
+export { DashSchemaAdapter, createSchemaAdapter, } from './schema-adapter.js';
+export type { DeltaOperation, DeltaStats, DeltaBatch, } from '@affectively/aeon';
+export type { AgentPresence, } from '@affectively/aeon';
+export type { OfflineOperation, OfflineQueueStats, OperationPriority, } from '@affectively/aeon';
+export type { SchemaVersion, Migration, MigrationResult, MigrationRecord, } from '@affectively/aeon';

package/dist/src/sync/aeon/index.js

@@ -0,0 +1,19 @@
+/**
+ * Aeon Integration for Dash
+ *
+ * Provides enhanced sync capabilities through Aeon:
+ * - Delta compression (70-80% bandwidth reduction)
+ * - Rich presence tracking (cursors, sections, activity)
+ * - Offline operation queuing with persistence
+ * - Schema versioning and migrations
+ */
+// Configuration
+export { defaultAeonConfig } from './config.js';
+// Delta compression adapter
+export { DashDeltaAdapter, isDeltaPayload, } from './delta-adapter.js';
+// Presence adapter
+export { DashPresenceAdapter, } from './presence-adapter.js';
+// Offline queue adapter
+export { DashOfflineAdapter, } from './offline-adapter.js';
+// Schema versioning adapter
+export { DashSchemaAdapter, createSchemaAdapter, } from './schema-adapter.js';