@teachinglab/omd 0.1.0

package/omd/utils/omdStepVisualizerNodeUtils.js

@@ -0,0 +1,268 @@
+/**
+ * Utility functions for node operations in step visualizations
+ */
+export class omdStepVisualizerNodeUtils {
+    /**
+     * Checks if a node is a leaf node (constant, variable, etc.)
+     * @param {omdNode} node - Node to check
+     * @returns {boolean} True if it's a leaf node
+     */
+    static isLeafNode(node) {
+        if (!node) return false;
+        
+        const leafTypes = [
+            'omdConstantNode',
+            'omdVariableNode',
+            'omdOperatorNode'
+        ];
+        
+        if (node.constructor && leafTypes.includes(node.type)) {
+            return true;
+        }
+        
+        if (node.type === 'constant' || node.type === 'variable' || node.type === 'operator') {
+            return true;
+        }
+        
+        if (!node.left && !node.right && !node.argument && !node.expression) {
+            return true;
+        }
+        
+        return false;
+    }
+
+    /**
+     * Checks if a node is a binary operation node
+     * @param {omdNode} node - Node to check
+     * @returns {boolean} True if it's a binary node
+     */
+    static isBinaryNode(node) {
+        if (!node) return false;
+        return node.type === 'omdBinaryExpressionNode' && node.left && node.right;
+    }
+
+    /**
+     * Checks if a node is a unary operation node
+     * @param {omdNode} node - Node to check
+     * @returns {boolean} True if it's a unary node
+     */
+    static isUnaryNode(node) {
+        if (!node) return false;
+        return node.type === 'omdUnaryExpressionNode' && node.argument;
+    }
+
+    /**
+     * Checks if a node has an expression property
+     * @param {omdNode} node - Node to check
+     * @returns {boolean} True if it has an expression
+     */
+    static hasExpression(node) {
+        if (!node) return false;
+        return node.expression !== undefined;
+    }
+
+    /**
+     * Gets the value of a leaf node for comparison
+     * @param {omdNode} node - Node to get value from
+     * @returns {string} String representation of the node's value
+     */
+    static getNodeValue(node) {
+        if (!node) return 'undefined';
+        
+        try {
+            if (node.constructor && node.type === 'omdVariableNode' && node.name !== undefined) {
+                return String(node.name);
+            }
+            
+            if (node.constructor && node.type === 'omdConstantNode' && typeof node.number === 'number') {
+                return String(node.number);
+            }
+            
+            if (node.isConstant && node.isConstant() && node.getValue && typeof node.getValue === 'function') {
+                return String(node.getValue());
+            }
+            
+            if (node.toString && typeof node.toString === 'function') {
+                return node.toString();
+            }
+            
+            if (node.value !== undefined) {
+                return String(node.value);
+            }
+            
+            if (node.number !== undefined) {
+                return String(node.number);
+            }
+            
+            return node.constructor ? node.type : 'unknown';
+        } catch (err) {
+            console.error('Error getting node value:', err);
+            return 'error';
+        }
+    }
+
+    /**
+     * Finds all leaf nodes in a tree
+     * @param {omdNode} node - Root node to search from
+     * @returns {Array} Array of leaf nodes
+     */
+    static findLeafNodes(node) {
+        if (!node) return [];
+
+        if (this.isLeafNode(node)) {
+            return [node];
+        }
+
+        const leafNodes = [];
+        
+        try {
+            if (this.isBinaryNode(node)) {
+                leafNodes.push(...this.findLeafNodes(node.left));
+                leafNodes.push(...this.findLeafNodes(node.right));
+            } else if (this.isUnaryNode(node)) {
+                leafNodes.push(...this.findLeafNodes(node.argument));
+            } else if (this.hasExpression(node)) {
+                leafNodes.push(...this.findLeafNodes(node.expression));
+            }
+        } catch (err) {
+            console.error('Error finding leaf nodes:', err, node);
+        }
+
+        return leafNodes;
+    }
+
+    /**
+     * Finds all variable nodes in a tree
+     * @param {omdNode} node - Root node to search from
+     * @returns {Array} Array of variable nodes
+     */
+    static findVariableNodes(node) {
+        const leaves = this.findLeafNodes(node);
+        return leaves.filter(leaf => leaf.constructor && leaf.type === 'omdVariableNode');
+    }
+
+    /**
+     * Finds all constant nodes in a tree
+     * @param {omdNode} node - Root node to search from
+     * @returns {Array} Array of constant nodes
+     */
+    static findConstantNodes(node) {
+        const leaves = this.findLeafNodes(node);
+        return leaves.filter(leaf => leaf.constructor && leaf.type === 'omdConstantNode');
+    }
+
+    /**
+     * Finds leaf nodes with a specific value
+     * @param {omdNode} node - Root node to search from
+     * @param {string} value - Value to search for
+     * @returns {Array} Array of matching leaf nodes
+     */
+    static findLeafNodesWithValue(node, value) {
+        const leaves = this.findLeafNodes(node);
+        
+        const exactMatches = leaves.filter(leaf => leaf.toString() === value);
+        if (exactMatches.length > 0) {
+            return exactMatches;
+        }
+        
+        const numValue = parseFloat(value);
+        if (!isNaN(numValue)) {
+            const numericMatches = leaves.filter(leaf => {
+                if (leaf.constructor && leaf.type === 'omdConstantNode') {
+                    if (leaf.number !== undefined) {
+                        return Math.abs(leaf.number - numValue) < 0.0001;
+                    }
+                }
+                return false;
+            });
+            
+            if (numericMatches.length > 0) {
+                return numericMatches;
+            }
+        }
+        
+        return leaves.filter(leaf => {
+            const leafStr = leaf.toString();
+            return leafStr.includes(value) || value.includes(leafStr);
+        });
+    }
+
+    /**
+     * Finds all nodes in a tree (not just leaf nodes)
+     * @param {omdNode} node - Root node to search from
+     * @returns {Array} Array of all nodes in the tree
+     */
+    static findAllNodes(node) {
+        if (!node) return [];
+        
+        const allNodes = [node];
+        
+        try {
+            if (node.childList && Array.isArray(node.childList)) {
+                node.childList.forEach(child => {
+                    if (child && child !== node.backRect) {
+                        allNodes.push(...this.findAllNodes(child));
+                    }
+                });
+            }
+            
+            if (node.argumentNodeList) {
+                Object.values(node.argumentNodeList).forEach(child => {
+                    if (child && child !== node) {
+                        if (Array.isArray(child)) {
+                            child.forEach(item => {
+                                if (item && item !== node) {
+                                    allNodes.push(...this.findAllNodes(item));
+                                }
+                            });
+                        } else {
+                            allNodes.push(...this.findAllNodes(child));
+                        }
+                    }
+                });
+            }
+        } catch (err) {
+            console.error('Error finding all nodes:', err, node);
+        }
+        
+        return allNodes;
+    }
+
+    /**
+     * Finds the rightmost leaf node with a specific value in a tree
+     * @param {omdNode} node - Root node to search from
+     * @param {string} value - Value to search for
+     * @returns {omdNode|null} The rightmost matching leaf node, or null if not found
+     */
+    static findRightmostNodeWithValue(node, value) {
+        const leaves = this.findLeafNodes(node);
+        
+        const matchingNodes = leaves.filter(leaf => {
+            const leafStr = leaf.toString();
+            return leafStr === value || 
+                   (leaf.constructor && 
+                    leaf.type === 'omdConstantNode' && 
+                    leaf.number !== undefined && 
+                    Math.abs(leaf.number - parseFloat(value)) < 0.0001);
+        });
+        
+        if (matchingNodes.length === 0) {
+            return null;
+        }
+        
+        const subtractedNodes = matchingNodes.filter(leaf => {
+            const parent = leaf.parent;
+            return parent && 
+                   parent.constructor && 
+                   parent.type === 'omdBinaryExpressionNode' &&
+                   parent.operation === 'subtract' &&
+                   parent.right === leaf;
+        });
+        
+        if (subtractedNodes.length > 0) {
+            return subtractedNodes[subtractedNodes.length - 1];
+        }
+        
+        return matchingNodes[matchingNodes.length - 1];
+    }
+} 

package/omd/utils/omdTranscriptionService.js

@@ -0,0 +1,125 @@
+/**
+ * omdTranscriptionService - AI-powered transcription service for handwritten content
+ */
+
+/**
+ * Transcription service using server endpoint
+ */
+export class omdTranscriptionService {
+    constructor(options = {}) {
+        this.options = {
+            endpoint: options.endpoint || this._getDefaultEndpoint(),
+            defaultProvider: options.defaultProvider || 'gemini',
+            ...options
+        };
+        
+        console.log('omdTranscriptionService constructor called with options:', {
+            endpoint: this.options.endpoint,
+            defaultProvider: this.options.defaultProvider
+        });
+    }
+    
+    /**
+     * Get the default endpoint based on current environment
+     * @private
+     */
+    _getDefaultEndpoint() {
+        return '/.netlify/functions/transcribe';
+    }
+    
+    /**
+     * Convert blob to base64
+     * @private
+     */
+    async _blobToBase64(blob) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                const base64 = reader.result.split(',')[1];
+                resolve(base64);
+            };
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+        });
+    }
+    
+    /**
+     * Transcribe an image using the server endpoint
+     * @param {Blob} imageBlob - The image blob to transcribe
+     * @param {Object} options - Transcription options
+     * @param {string} options.prompt - Custom prompt for transcription
+     * @returns {Promise<Object>} Transcription result
+     */
+    async transcribe(imageBlob, options = {}) {
+        try {
+            console.log('Starting transcription with endpoint:', this.options.endpoint);
+            
+            // Convert blob to base64
+            const base64Image = await this._blobToBase64(imageBlob);
+            
+            // Call server endpoint
+            const response = await fetch(this.options.endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    imageBase64: base64Image,
+                    prompt: options.prompt || 'Please transcribe the handwritten mathematical expression in this image. Return only the mathematical expression in pure format (no LaTeX, no dollar signs). For powers use ^, for fractions use /, for square roots use sqrt().'
+                })
+            });
+            
+            if (!response.ok) {
+                throw new Error(`Transcription API error: ${response.status} ${response.statusText}`);
+            }
+            
+            const result = await response.json();
+            console.log('Transcription result:', result);
+            
+            return {
+                text: result.text,
+                provider: result.provider || 'gemini',
+                confidence: result.confidence || 1.0
+            };
+            
+        } catch (error) {
+            console.error('Transcription error:', error);
+            throw error;
+        }
+    }
+    
+    /**
+     * Transcribe with fallback (same as transcribe for now)
+     * @param {Blob} imageBlob - The image blob to transcribe
+     * @param {Object} options - Transcription options
+     * @returns {Promise<Object>} Transcription result
+     */
+    async transcribeWithFallback(imageBlob, options = {}) {
+        return this.transcribe(imageBlob, options);
+    }
+    
+    /**
+     * Check if transcription service is available
+     * @returns {boolean} True if service is available
+     */
+    isAvailable() {
+        return true; // Always available since we use server endpoint
+    }
+    
+    /**
+     * Get available providers (simplified)
+     * @returns {Array} List of available providers
+     */
+    getAvailableProviders() {
+        return ['gemini']; // Server handles the provider selection
+    }
+    
+    /**
+     * Check if a specific provider is available
+     * @param {string} provider - Provider name
+     * @returns {boolean} True if provider is available
+     */
+    isProviderAvailable(provider) {
+        return provider === 'gemini'; // Only gemini is supported via server
+    }
+}