@affectively/dash 5.0.0 → 5.0.1

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/hybrid-provider.d.ts

@@ -25,4 +25,83 @@ export declare class HybridProvider extends Observable<string> {
     private onDocUpdate;
     private onAwarenessUpdate;
     destroy(): void;
+    /**
+     * Get comprehensive connection status
+     */
+    getConnectionStatus(): ConnectionStatus;
+    /**
+     * Get all awareness states from connected peers
+     */
+    getAwarenessStates(): AwarenessState[];
+    /**
+     * Get the local client ID
+     */
+    getLocalClientId(): number;
+    /**
+     * Get connected peer count (excluding local)
+     */
+    getPeerCount(): number;
+    /**
+     * Get document state information
+     */
+    getDocumentState(): DocumentState;
+    /**
+     * Get a snapshot of the Yjs document for inspection
+     */
+    getDocumentSnapshot(): DocumentSnapshot;
+    /**
+     * Set local awareness state for introspection (admin view)
+     */
+    setLocalAwareness(state: Record<string, unknown>): void;
+    /**
+     * Get full provider status for debugging
+     */
+    getProviderStatus(): ProviderStatus;
+}
+export interface ConnectionStatus {
+    connected: boolean;
+    roomName: string;
+    url: string;
+    websocket: {
+        state: 'connecting' | 'open' | 'closing' | 'closed';
+        connected: boolean;
+    };
+    webTransport: {
+        connected: boolean;
+        highFrequencyMode: boolean;
+    };
+    transport: 'WebSocket' | 'WebTransport';
+}
+export interface AwarenessState {
+    clientId: number;
+    state: Record<string, unknown>;
+    isLocal: boolean;
+}
+export interface SharedTypeInfo {
+    name: string;
+    type: 'YMap' | 'YArray' | 'YText' | 'YXmlFragment' | 'unknown';
+    size: number;
+}
+export interface DocumentState {
+    clientId: number;
+    guid: string;
+    stateVectorSize: number;
+    updateSize: number;
+    sharedTypes: SharedTypeInfo[];
+    transactionCount: number;
+    gcEnabled: boolean;
+}
+export interface DocumentSnapshot {
+    timestamp: string;
+    roomName: string;
+    content: Record<string, unknown>;
+}
+export interface ProviderStatus {
+    connection: ConnectionStatus;
+    awareness: {
+        localClientId: number;
+        peerCount: number;
+        states: AwarenessState[];
+    };
+    document: DocumentState;
 }

package/dist/src/sync/hybrid-provider.js

@@ -1,3 +1,4 @@
+import * as Y from 'yjs';
 import { Observable } from 'lib0/observable';
 import * as encoding from 'lib0/encoding';
 import * as decoding from 'lib0/decoding';
@@ -191,4 +192,167 @@ export class HybridProvider extends Observable {
         this.connected = false;
         super.destroy();
     }
+    // ============================================
+    // INTROSPECTION METHODS FOR DASH-STUDIO
+    // ============================================
+    /**
+     * Get comprehensive connection status
+     */
+    getConnectionStatus() {
+        let wsState = 'closed';
+        if (this.ws) {
+            switch (this.ws.readyState) {
+                case WebSocket.CONNECTING:
+                    wsState = 'connecting';
+                    break;
+                case WebSocket.OPEN:
+                    wsState = 'open';
+                    break;
+                case WebSocket.CLOSING:
+                    wsState = 'closing';
+                    break;
+                case WebSocket.CLOSED:
+                    wsState = 'closed';
+                    break;
+            }
+        }
+        return {
+            connected: this.connected,
+            roomName: this.roomName,
+            url: this.url,
+            websocket: {
+                state: wsState,
+                connected: this.ws !== null && this.ws.readyState === WebSocket.OPEN
+            },
+            webTransport: {
+                connected: this.wt !== null,
+                highFrequencyMode: this.highFrequencyMode
+            },
+            transport: this.highFrequencyMode ? 'WebTransport' : 'WebSocket'
+        };
+    }
+    /**
+     * Get all awareness states from connected peers
+     */
+    getAwarenessStates() {
+        const states = [];
+        const awarenessStates = this.awareness.getStates();
+        awarenessStates.forEach((state, clientId) => {
+            states.push({
+                clientId,
+                state,
+                isLocal: clientId === this.awareness.clientID
+            });
+        });
+        return states;
+    }
+    /**
+     * Get the local client ID
+     */
+    getLocalClientId() {
+        return this.awareness.clientID;
+    }
+    /**
+     * Get connected peer count (excluding local)
+     */
+    getPeerCount() {
+        const states = this.awareness.getStates();
+        return Math.max(0, states.size - 1); // Exclude self
+    }
+    /**
+     * Get document state information
+     */
+    getDocumentState() {
+        const stateVector = Y.encodeStateVector(this.doc);
+        const update = Y.encodeStateAsUpdate(this.doc);
+        // Get shared types info
+        const sharedTypes = [];
+        this.doc.share.forEach((type, name) => {
+            let typeKind = 'unknown';
+            let size = 0;
+            if (type instanceof Y.Map) {
+                typeKind = 'YMap';
+                size = type.size;
+            }
+            else if (type instanceof Y.Array) {
+                typeKind = 'YArray';
+                size = type.length;
+            }
+            else if (type instanceof Y.Text) {
+                typeKind = 'YText';
+                size = type.length;
+            }
+            else if (type instanceof Y.XmlFragment) {
+                typeKind = 'YXmlFragment';
+                size = type.length;
+            }
+            sharedTypes.push({
+                name,
+                type: typeKind,
+                size
+            });
+        });
+        return {
+            clientId: this.doc.clientID,
+            guid: this.doc.guid,
+            stateVectorSize: stateVector.byteLength,
+            updateSize: update.byteLength,
+            sharedTypes,
+            transactionCount: 0, // Yjs doesn't expose this directly
+            gcEnabled: this.doc.gc
+        };
+    }
+    /**
+     * Get a snapshot of the Yjs document for inspection
+     */
+    getDocumentSnapshot() {
+        const content = {};
+        this.doc.share.forEach((type, name) => {
+            try {
+                if (type instanceof Y.Map) {
+                    content[name] = type.toJSON();
+                }
+                else if (type instanceof Y.Array) {
+                    content[name] = type.toJSON();
+                }
+                else if (type instanceof Y.Text) {
+                    content[name] = type.toString();
+                }
+                else if (type instanceof Y.XmlFragment) {
+                    content[name] = type.toString();
+                }
+                else {
+                    content[name] = '[unsupported type]';
+                }
+            }
+            catch (e) {
+                content[name] = '[error reading content]';
+            }
+        });
+        return {
+            timestamp: new Date().toISOString(),
+            roomName: this.roomName,
+            content
+        };
+    }
+    /**
+     * Set local awareness state for introspection (admin view)
+     */
+    setLocalAwareness(state) {
+        this.awareness.setLocalState(state);
+    }
+    /**
+     * Get full provider status for debugging
+     */
+    getProviderStatus() {
+        return {
+            connection: this.getConnectionStatus(),
+            awareness: {
+                localClientId: this.awareness.clientID,
+                peerCount: this.getPeerCount(),
+                states: this.getAwarenessStates()
+            },
+            document: this.getDocumentState()
+        };
+    }
 }