aura-glass 2.0.39 → 2.1.0

package/dist/esm/services/ai/semantic-search-service.js

@@ -0,0 +1,283 @@
+import { Pinecone } from '@pinecone-database/pinecone';
+import OpenAI from 'openai';
+import { CacheService } from './cache-service.js';
+import { ErrorHandler } from './error-handler.js';
+
+// @ts-nocheck - Optional Pinecone and OpenAI dependencies
+class SemanticSearchService {
+  constructor(config) {
+    this.config = config;
+    this.pinecone = new Pinecone({
+      apiKey: config.pinecone.apiKey
+    });
+    this.openai = new OpenAI({
+      apiKey: config.openai.apiKey
+    });
+    this.cache = new CacheService(config.redis);
+    this.errorHandler = new ErrorHandler();
+  }
+  async initialize() {
+    try {
+      await this.cache.connect();
+      const indexes = await this.pinecone.listIndexes();
+      const indexExists = indexes.indexes?.some(idx => idx.name === this.config.pinecone.indexName);
+      if (!indexExists) {
+        await this.createIndex();
+      }
+      this.index = this.pinecone.index(this.config.pinecone.indexName);
+    } catch (error) {
+      this.errorHandler.handleError(error, {
+        service: 'SemanticSearch',
+        operation: 'initialize'
+      });
+      throw error;
+    }
+  }
+  async createIndex() {
+    await this.pinecone.createIndex({
+      name: this.config.pinecone.indexName,
+      dimension: 1536,
+      metric: 'cosine',
+      spec: {
+        serverless: {
+          cloud: 'aws',
+          region: 'us-east-1'
+        }
+      }
+    });
+    await this.waitForIndexReady();
+  }
+  async waitForIndexReady(maxAttempts = 30) {
+    for (let i = 0; i < maxAttempts; i++) {
+      const indexes = await this.pinecone.listIndexes();
+      const index = indexes.indexes?.find(idx => idx.name === this.config.pinecone.indexName);
+      if (index?.status?.ready) {
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    throw new Error('Index creation timeout');
+  }
+  async indexDocuments(documents) {
+    if (!this.index) {
+      await this.initialize();
+    }
+    try {
+      const batchSize = 100;
+      const batches = this.chunkArray(documents, batchSize);
+      for (const batch of batches) {
+        const vectors = await Promise.all(batch.map(async doc => {
+          const embedding = await this.generateEmbedding(doc.content);
+          return {
+            id: doc.id,
+            values: embedding,
+            metadata: {
+              content: doc.content.substring(0, 1000),
+              title: doc.title || '',
+              ...doc.metadata,
+              tags: doc.tags?.join(',') || ''
+            }
+          };
+        }));
+        await this.index.upsert(vectors);
+      }
+      await this.cache.delete('search:*');
+    } catch (error) {
+      this.errorHandler.handleError(error, {
+        service: 'SemanticSearch',
+        operation: 'indexDocuments',
+        metadata: {
+          documentCount: documents.length
+        }
+      });
+      throw error;
+    }
+  }
+  async search(query, options = {}) {
+    if (!this.index) {
+      await this.initialize();
+    }
+    const {
+      topK = 10,
+      filter,
+      includeMetadata = true,
+      namespace
+    } = options;
+    const cacheKey = `search:${query}:${JSON.stringify(options)}`;
+    if (this.config.costOptimization.enableCaching) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached) return cached;
+    }
+    try {
+      const queryEmbedding = await this.generateEmbedding(query);
+      const queryResponse = await this.index.namespace(namespace || '').query({
+        vector: queryEmbedding,
+        topK,
+        includeMetadata,
+        filter
+      });
+      const results = queryResponse.matches.map(match => ({
+        id: match.id,
+        content: match.metadata?.content || '',
+        metadata: match.metadata || {},
+        score: match.score || 0,
+        highlights: this.generateHighlights(query, match.metadata?.content || '')
+      }));
+      if (this.config.costOptimization.enableCaching) {
+        await this.cache.set(cacheKey, results, 300);
+      }
+      return results;
+    } catch (error) {
+      return this.errorHandler.handleWithFallback(error, () => this.fallbackSearch(query, options), {
+        service: 'SemanticSearch',
+        operation: 'search',
+        metadata: {
+          query
+        }
+      });
+    }
+  }
+  async hybridSearch(query, options = {}) {
+    const {
+      semanticWeight = 0.7,
+      keywordWeight = 0.3,
+      topK = 10,
+      filter
+    } = options;
+    const [semanticResults, keywordResults] = await Promise.all([this.search(query, {
+      topK: topK * 2,
+      filter
+    }), this.keywordSearch(query, {
+      topK: topK * 2,
+      filter
+    })]);
+    const scoreMap = new Map();
+    const resultMap = new Map();
+    semanticResults.forEach(result => {
+      const score = result.score * semanticWeight;
+      scoreMap.set(result.id, score);
+      resultMap.set(result.id, result);
+    });
+    keywordResults.forEach(result => {
+      const existingScore = scoreMap.get(result.id) || 0;
+      const newScore = existingScore + result.score * keywordWeight;
+      scoreMap.set(result.id, newScore);
+      if (!resultMap.has(result.id)) {
+        resultMap.set(result.id, result);
+      }
+    });
+    const combinedResults = Array.from(resultMap.values()).map(result => ({
+      ...result,
+      score: scoreMap.get(result.id) || 0
+    })).sort((a, b) => b.score - a.score).slice(0, topK);
+    return combinedResults;
+  }
+  async keywordSearch(query, options = {}) {
+    const keywords = query.toLowerCase().split(/\s+/).filter(k => k.length > 2);
+    if (!this.index) {
+      return [];
+    }
+    try {
+      const results = await this.index.namespace('').query({
+        vector: new Array(1536).fill(0),
+        topK: options.topK || 10,
+        includeMetadata: true,
+        filter: {
+          ...options.filter,
+          $or: keywords.map(keyword => ({
+            content: {
+              $contains: keyword
+            }
+          }))
+        }
+      });
+      return results.matches.map(match => {
+        const content = match.metadata?.content || '';
+        const keywordScore = this.calculateKeywordScore(keywords, content);
+        return {
+          id: match.id,
+          content,
+          metadata: match.metadata || {},
+          score: keywordScore,
+          highlights: this.generateHighlights(query, content)
+        };
+      });
+    } catch (error) {
+      console.error('Keyword search error:', error);
+      return [];
+    }
+  }
+  calculateKeywordScore(keywords, content) {
+    const lowerContent = content.toLowerCase();
+    let score = 0;
+    keywords.forEach(keyword => {
+      const occurrences = (lowerContent.match(new RegExp(keyword, 'g')) || []).length;
+      score += occurrences * (1 / keywords.length);
+    });
+    return Math.min(score / 10, 1);
+  }
+  async generateEmbedding(text) {
+    try {
+      const response = await this.openai.embeddings.create({
+        model: 'text-embedding-ada-002',
+        input: text.substring(0, 8000)
+      });
+      return response.data[0].embedding;
+    } catch (error) {
+      this.errorHandler.handleError(error, {
+        service: 'SemanticSearch',
+        operation: 'generateEmbedding'
+      });
+      throw error;
+    }
+  }
+  generateHighlights(query, content) {
+    const words = query.toLowerCase().split(/\s+/);
+    const sentences = content.split(/[.!?]+/);
+    const highlights = [];
+    sentences.forEach(sentence => {
+      const lowerSentence = sentence.toLowerCase();
+      const hasMatch = words.some(word => lowerSentence.includes(word));
+      if (hasMatch && sentence.trim().length > 20) {
+        highlights.push(sentence.trim());
+      }
+    });
+    return highlights.slice(0, 3);
+  }
+  fallbackSearch(query, options) {
+    console.warn('Falling back to basic search implementation');
+    return [{
+      id: 'fallback-1',
+      content: 'Search service is temporarily unavailable. Please try again later.',
+      metadata: {
+        fallback: true
+      },
+      score: 0.5,
+      highlights: []
+    }];
+  }
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+  async deleteDocument(id) {
+    if (!this.index) {
+      await this.initialize();
+    }
+    await this.index.deleteOne(id);
+    await this.cache.delete('search:*');
+  }
+  async deleteAllDocuments(namespace) {
+    if (!this.index) {
+      await this.initialize();
+    }
+    await this.index.namespace(namespace || '').deleteAll();
+    await this.cache.delete('search:*');
+  }
+}
+
+export { SemanticSearchService };
+//# sourceMappingURL=semantic-search-service.js.map

package/dist/esm/services/ai/semantic-search-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-search-service.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/services/ai/vision-service.js

@@ -0,0 +1,357 @@
+import vision from '@google-cloud/vision';
+import { CacheService } from './cache-service.js';
+import { ErrorHandler } from './error-handler.js';
+
+// @ts-nocheck - Optional Google Cloud Vision dependency
+class VisionService {
+  constructor(config) {
+    this.config = config;
+    this.client = null;
+    this.cache = new CacheService(config.redis);
+    this.errorHandler = new ErrorHandler();
+    this.removeBgApiKey = config.removeBg.apiKey;
+    this.initializeClient();
+  }
+  initializeClient() {
+    try {
+      if (this.config.googleCloud.keyFilename) {
+        this.client = new vision.ImageAnnotatorClient({
+          keyFilename: this.config.googleCloud.keyFilename
+        });
+      } else if (this.config.googleCloud.apiKey) {
+        this.client = new vision.ImageAnnotatorClient({
+          apiEndpoint: 'vision.googleapis.com',
+          credentials: {
+            client_email: 'vision-api@project.iam.gserviceaccount.com',
+            private_key: this.config.googleCloud.apiKey
+          }
+        });
+      }
+    } catch (error) {
+      console.warn('Google Vision client initialization failed, using fallback:', error);
+    }
+  }
+  async detectFaces(imageBuffer) {
+    const cacheKey = `vision:faces:${this.hashBuffer(imageBuffer)}`;
+    if (this.config.costOptimization.enableCaching) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached) return cached;
+    }
+    try {
+      if (!this.client) {
+        return this.fallbackFaceDetection();
+      }
+      const [result] = await this.client.faceDetection(imageBuffer);
+      const faces = result.faceAnnotations || [];
+      const detectionResults = faces.map(face => ({
+        boundingBox: this.convertBoundingPoly(face.boundingPoly),
+        confidence: face.detectionConfidence || 0,
+        emotions: {
+          joy: this.likelihoodToScore(face.joyLikelihood),
+          sorrow: this.likelihoodToScore(face.sorrowLikelihood),
+          anger: this.likelihoodToScore(face.angerLikelihood),
+          surprise: this.likelihoodToScore(face.surpriseLikelihood)
+        },
+        landmarks: face.landmarks?.map(landmark => ({
+          type: landmark.type || '',
+          position: landmark.position || {
+            x: 0,
+            y: 0,
+            z: 0
+          }
+        }))
+      }));
+      if (this.config.costOptimization.enableCaching) {
+        await this.cache.set(cacheKey, detectionResults, 3600);
+      }
+      return detectionResults;
+    } catch (error) {
+      return this.errorHandler.handleWithFallback(error, () => this.fallbackFaceDetection(), {
+        service: 'Vision',
+        operation: 'detectFaces'
+      });
+    }
+  }
+  async detectObjects(imageBuffer) {
+    const cacheKey = `vision:objects:${this.hashBuffer(imageBuffer)}`;
+    if (this.config.costOptimization.enableCaching) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached) return cached;
+    }
+    try {
+      if (!this.client) {
+        return this.fallbackObjectDetection();
+      }
+      const [result] = await this.client.objectLocalization(imageBuffer);
+      const objects = result.localizedObjectAnnotations || [];
+      const detectionResults = objects.map(obj => ({
+        name: obj.name || 'unknown',
+        confidence: obj.score || 0,
+        boundingBox: this.convertBoundingPoly(obj.boundingPoly)
+      }));
+      if (this.config.costOptimization.enableCaching) {
+        await this.cache.set(cacheKey, detectionResults, 3600);
+      }
+      return detectionResults;
+    } catch (error) {
+      return this.errorHandler.handleWithFallback(error, () => this.fallbackObjectDetection(), {
+        service: 'Vision',
+        operation: 'detectObjects'
+      });
+    }
+  }
+  async extractText(imageBuffer) {
+    const cacheKey = `vision:text:${this.hashBuffer(imageBuffer)}`;
+    if (this.config.costOptimization.enableCaching) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached) return cached;
+    }
+    try {
+      if (!this.client) {
+        return this.fallbackTextExtraction();
+      }
+      const [result] = await this.client.documentTextDetection(imageBuffer);
+      const fullTextAnnotation = result.fullTextAnnotation;
+      if (!fullTextAnnotation) {
+        return {
+          text: '',
+          confidence: 0,
+          blocks: []
+        };
+      }
+      const extractionResult = {
+        text: fullTextAnnotation.text || '',
+        confidence: this.calculateAverageConfidence(fullTextAnnotation.pages ?? undefined),
+        language: result.textAnnotations?.[0]?.locale || undefined,
+        blocks: fullTextAnnotation.pages?.[0]?.blocks?.map(block => ({
+          text: this.extractBlockText(block),
+          confidence: block.confidence || 0,
+          boundingBox: block.boundingBox
+        })) || []
+      };
+      if (this.config.costOptimization.enableCaching) {
+        await this.cache.set(cacheKey, extractionResult, 3600);
+      }
+      return extractionResult;
+    } catch (error) {
+      return this.errorHandler.handleWithFallback(error, () => this.fallbackTextExtraction(), {
+        service: 'Vision',
+        operation: 'extractText'
+      });
+    }
+  }
+  async analyzeImage(imageBuffer) {
+    const cacheKey = `vision:analysis:${this.hashBuffer(imageBuffer)}`;
+    if (this.config.costOptimization.enableCaching) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached) return cached;
+    }
+    try {
+      if (!this.client) {
+        return this.fallbackImageAnalysis();
+      }
+      const [result] = await this.client.annotateImage({
+        image: {
+          content: imageBuffer.toString('base64')
+        },
+        features: [{
+          type: 'LABEL_DETECTION',
+          maxResults: 10
+        }, {
+          type: 'SAFE_SEARCH_DETECTION'
+        }, {
+          type: 'IMAGE_PROPERTIES'
+        }, {
+          type: 'CROP_HINTS',
+          maxResults: 3
+        }]
+      });
+      const analysisResult = {
+        labels: result.labelAnnotations?.map(label => ({
+          description: label.description || '',
+          score: label.score || 0
+        })) || [],
+        safeSearch: {
+          adult: String(result.safeSearchAnnotation?.adult ?? 'UNKNOWN'),
+          violence: String(result.safeSearchAnnotation?.violence ?? 'UNKNOWN'),
+          medical: String(result.safeSearchAnnotation?.medical ?? 'UNKNOWN')
+        },
+        colors: result.imagePropertiesAnnotation?.dominantColors?.colors?.map(color => ({
+          color: {
+            red: color.color?.red || 0,
+            green: color.color?.green || 0,
+            blue: color.color?.blue || 0
+          },
+          score: color.score || 0,
+          pixelFraction: color.pixelFraction || 0
+        })) || [],
+        cropHints: result.cropHintsAnnotation?.cropHints?.map(hint => ({
+          boundingBox: hint.boundingPoly,
+          confidence: hint.confidence || 0,
+          importanceFraction: hint.importanceFraction || 0
+        }))
+      };
+      if (this.config.costOptimization.enableCaching) {
+        await this.cache.set(cacheKey, analysisResult, 3600);
+      }
+      return analysisResult;
+    } catch (error) {
+      return this.errorHandler.handleWithFallback(error, () => this.fallbackImageAnalysis(), {
+        service: 'Vision',
+        operation: 'analyzeImage'
+      });
+    }
+  }
+  async removeBackground(imageBuffer) {
+    const cacheKey = `vision:removebg:${this.hashBuffer(imageBuffer)}`;
+    if (this.config.costOptimization.enableCaching) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached) return Buffer.from(cached, 'base64');
+    }
+    try {
+      const formData = new FormData();
+      // Convert Node Buffer to Blob-compatible data for fetch
+      formData.append('image_file', new Blob([new Uint8Array(imageBuffer)]), 'image.jpg');
+      formData.append('size', 'auto');
+      const response = await fetch('https://api.remove.bg/v1.0/removebg', {
+        method: 'POST',
+        headers: {
+          'X-Api-Key': this.removeBgApiKey
+        },
+        body: formData
+      });
+      if (!response.ok) {
+        throw new Error(`Remove.bg API error: ${response.status}`);
+      }
+      const resultBuffer = Buffer.from(await response.arrayBuffer());
+      if (this.config.costOptimization.enableCaching) {
+        await this.cache.set(cacheKey, resultBuffer.toString('base64'), 3600);
+      }
+      return resultBuffer;
+    } catch (error) {
+      return this.errorHandler.handleWithFallback(error, () => imageBuffer, {
+        service: 'Vision',
+        operation: 'removeBackground'
+      });
+    }
+  }
+  async generateImageDescription(imageBuffer) {
+    try {
+      const analysis = await this.analyzeImage(imageBuffer);
+      const topLabels = analysis.labels.slice(0, 5);
+      if (topLabels.length === 0) {
+        return 'No description available';
+      }
+      const labelDescriptions = topLabels.map(l => l.description).join(', ');
+      return `This image contains: ${labelDescriptions}`;
+    } catch (error) {
+      return this.errorHandler.handleWithFallback(error, () => 'Unable to generate image description', {
+        service: 'Vision',
+        operation: 'generateImageDescription'
+      });
+    }
+  }
+  convertBoundingPoly(boundingPoly) {
+    if (!boundingPoly?.vertices || boundingPoly.vertices.length < 4) {
+      return {
+        left: 0,
+        top: 0,
+        width: 0,
+        height: 0
+      };
+    }
+    const vertices = boundingPoly.vertices;
+    const left = Math.min(...vertices.map(v => v.x || 0));
+    const top = Math.min(...vertices.map(v => v.y || 0));
+    const right = Math.max(...vertices.map(v => v.x || 0));
+    const bottom = Math.max(...vertices.map(v => v.y || 0));
+    return {
+      left,
+      top,
+      width: right - left,
+      height: bottom - top
+    };
+  }
+  likelihoodToScore(likelihood) {
+    const map = {
+      VERY_UNLIKELY: 0,
+      UNLIKELY: 0.25,
+      POSSIBLE: 0.5,
+      LIKELY: 0.75,
+      VERY_LIKELY: 1
+    };
+    return map[likelihood || ''] || 0;
+  }
+  calculateAverageConfidence(pages) {
+    if (!pages || pages.length === 0) return 0;
+    const confidences = [];
+    pages.forEach(page => {
+      page.blocks?.forEach(block => {
+        if (block.confidence) confidences.push(block.confidence);
+      });
+    });
+    if (confidences.length === 0) return 0;
+    return confidences.reduce((a, b) => a + b, 0) / confidences.length;
+  }
+  extractBlockText(block) {
+    if (!block.paragraphs) return '';
+    return block.paragraphs.map(p => p.words?.map(w => w.symbols?.map(s => s.text || '').join('') || '').join(' ') || '').join('\n');
+  }
+  hashBuffer(buffer) {
+    const crypto = require('crypto');
+    return crypto.createHash('md5').update(buffer).digest('hex');
+  }
+  fallbackFaceDetection() {
+    return [{
+      boundingBox: {
+        left: 100,
+        top: 100,
+        width: 200,
+        height: 200
+      },
+      confidence: 0.5,
+      emotions: {
+        joy: 0.5,
+        sorrow: 0,
+        anger: 0,
+        surprise: 0
+      }
+    }];
+  }
+  fallbackObjectDetection() {
+    return [{
+      name: 'object',
+      confidence: 0.5,
+      boundingBox: {
+        left: 0,
+        top: 0,
+        width: 100,
+        height: 100
+      }
+    }];
+  }
+  fallbackTextExtraction() {
+    return {
+      text: 'Text extraction unavailable',
+      confidence: 0,
+      blocks: []
+    };
+  }
+  fallbackImageAnalysis() {
+    return {
+      labels: [{
+        description: 'image',
+        score: 0.5
+      }],
+      safeSearch: {
+        adult: 'UNKNOWN',
+        violence: 'UNKNOWN',
+        medical: 'UNKNOWN'
+      },
+      colors: []
+    };
+  }
+}
+
+export { VisionService };
+//# sourceMappingURL=vision-service.js.map

package/dist/esm/services/ai/vision-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vision-service.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}