apexify.js 4.6.2 → 4.7.0

package/lib/ai/ApexModules.ts

@@ -8,6 +8,7 @@ import { electronImagine } from './modals-chat/electronHub/imageModels';
 import { electronChat } from './modals-chat/electronHub/chatmodels';
 import { electronSpeech } from './modals-chat/electronHub/speechModels';
 import { electronVideo } from './modals-chat/electronHub/videoModels';
+import { GoogleGenerativeAI } from"@google/generative-ai";
 
 
 const dbConfig = {
@@ -591,22 +592,26 @@ async function ApexImagine(model: string, prompt: string, options?: ApexImagineO
   return response;
 }
 
-async function ApexChat(model: string, prompt: string, { userId, memory, limit, instruction, Api_key }: { userId?: string, memory?: boolean, limit?: number, instruction?: string, Api_key?: string }): Promise<string> {
+async function ApexChat(
+  model: string,
+  prompt: string,
+  { userId, memory, limit, instruction, Api_key }: { userId?: string; memory?: boolean; limit?: number; instruction?: string; Api_key?: string }
+): Promise<string> {
   try {
-
     let enhancedPrompt: string = prompt;
     let historyChat: string = `- This is Previous chat history between you (System) and the user (User). Don't use the history or reply back anything related to it unless being mentioned in user's new prompt\n`;
-    let commandString: string = ''
-    if (instruction) {
-      commandString = `- Given Constant instruction for the System (AI) to abide and to always follow:\n${instruction}\n\n`
-    }
+    
+    let commandString = instruction ? `- Given Constant instruction for the System (AI) to abide and to always follow:\n${instruction}\n\n` : '';
+
     if (memory && userId) {
-      
       const userHistoryResult = (await db.find(`${userId}`, { userId })).results?.history || [];
-      const historyItems = Array.isArray(userHistoryResult) ? userHistoryResult.slice(-(limit ?? 12)) : [];
+      const historyItems = Array.isArray(userHistoryResult) ? userHistoryResult : [];
+
+      const relevantMessages = await getRelevantHistoryAI(prompt, historyItems, limit ?? 12);
+
 
       let formattedHistory = '';
-      historyItems.forEach((item) => {
+      relevantMessages.forEach((item) => {
         formattedHistory += `User: ${item.user}\nSystem: ${item.model}\n\n`;
       });
 
@@ -628,7 +633,7 @@ async function ApexChat(model: string, prompt: string, { userId, memory, limit,
 
       response = responses.join('');
     } else {
-      response = await processChunk(model, enhancedPrompt, {});
+      response = await processChunk(model, enhancedPrompt, { ApiKey: Api_key, personality: instruction });
     }
 
     if (memory && userId && model !== 'gemini-pro' && model !== 'gemini-flash') {
@@ -637,11 +642,78 @@ async function ApexChat(model: string, prompt: string, { userId, memory, limit,
 
     return response;
   } catch (error: any) {
-    console.error(error.message); 
+    console.error(error.message);
     return '';
   }
 }
 
+const genAI = new GoogleGenerativeAI('AIzaSyAdlBVg12yjqqGfBqxT5DLGMhP2jysG7Hk');
+
+const model = genAI.getGenerativeModel({ model: "text-embedding-004" });
+
+async function getRelevantHistoryAI(prompt: string, history: any[], maxResults: number): Promise<any[]> {
+
+  const trimmedPrompt = prompt.length > 20000 ? prompt.slice(0, 20000) : prompt;
+  const promptEmbedding = await generateEmbedding(trimmedPrompt);
+
+  const threshold = 0.7;
+
+  const scores = await Promise.all(
+    history.map(async (item) => {
+      const trimmedUser = item.user.length > 20000 ? item.user.slice(0, 20000) : item.user;
+
+      const messageEmbedding = await generateEmbedding(trimmedUser);
+      const score = cosineSimilarity(promptEmbedding, messageEmbedding);
+      return { item, score };
+    })
+  );
+
+  const filteredResults = scores.filter(entry => entry.score >= threshold);
+  filteredResults.sort((a, b) => b.score - a.score);
+
+  return filteredResults.slice(0, maxResults).map(entry => entry.item);
+}
+
+async function generateEmbedding(text: string): Promise<number[]> {
+  let maxRetries = 5;
+  let delay = 5000;
+  let attempt = 0;
+
+  while (attempt < maxRetries) {
+    try {
+
+      const response = await model.embedContent(text);
+
+
+      return response.embedding.values;
+    } catch (error: any) {
+      if (error.response) {
+        console.warn(`❌ API Error - Status: ${error.response.status}, Message: ${error.response.statusText}`);
+      } else {
+        console.error("❌ Network or unknown error:", error.message);
+      }
+
+      if (error.response && error.response.status === 429) {
+        console.warn(`⚠️ Rate limited (429). Retrying in ${delay / 1000} seconds...`);
+        await new Promise(res => setTimeout(res, delay));
+      } else {
+        throw error;
+      }
+    }
+
+    attempt++;
+  }
+
+  throw new Error("Max retries reached. Failed to get embedding.");
+}
+
+function cosineSimilarity(a: number[], b: number[]): number {
+  const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
+  const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
+  const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
+  return dotProduct / (magnitudeA * magnitudeB);
+}
+
 async function resetHistory({ id, last }: { id: string; last: number | string }): Promise<boolean> {
   if (!id) return false;
 

package/lib/ai/functions/readFiles.ts

@@ -15,7 +15,7 @@ export async function readFile(pathOrUrl: string, type?: string): Promise<string
         case "pdf":
             return readPdf(buffer);
         default:
-            return buffer.toString();
+            return buffer.toString("utf-8");
     }
 }
 

package/lib/ai/modals-chat/electronHub/chatmodels.ts

@@ -32,14 +32,16 @@ export async function electronChat({
       if (!modelExists) {
         throw new Error('Invalid model name please check out Electron hub models for more info.')
       }
-  
+      console.log(prompt);
+
       const completion = await openai.chat.completions.create({
-        model: 'mistral-large-latest',
+        model: modelName,
         messages: [
           {"role": "system", "content": `${instruction}`},
           {"role": "user", "content": `${prompt}`}
       ]
       });
+
   
       return completion.choices[0]?.message?.content;
     } catch (e: any) {

package/lib/ai/modals-chat/electronHub/speechModels.ts

@@ -17,9 +17,10 @@ export async function electronSpeech({
     
     const validPersonalities = [
       'will', 'maltida', 'liam', 'jessica', 'george', 'lily', 'sana', 
-      'Wahab', 'martin', 'darine', 'guillaume', 'leoni', 'kurt', 'leo', 
+      'wahab', 'martin', 'darine', 'guillaume', 'leonie', 'kurt', 'leo', 
       'shakuntala', 'maciej', 'aneta', 'gabriela', 'juan'
     ];
+    
     if (personality && !validPersonalities.includes(personality)) {
       throw new Error(`Invalid personality. Please choose from the following: ${validPersonalities.join(', ')}`);
     }

package/lib/canvas/ApexPainter.ts

@@ -6,13 +6,10 @@ import axios from 'axios';
 import fs from "fs";
 import path from "path";
 import { OutputFormat, CanvasConfig, TextObject, ImageProperties, GIFOptions, GIFResults, CustomOptions, cropOptions,
-     drawBackgroundGradient, drawBackgroundColor, customBackground, circularBorder, radiusBorder, customLines, applyRotation, applyStroke,
+     drawBackgroundGradient, drawBackgroundColor, customBackground, customLines, applyRotation, applyStroke,
      applyShadow, imageRadius, drawShape, drawText, converter, resizingImg, applyColorFilters, imgEffects,verticalBarChart, pieChart,
      lineChart, cropInner, cropOuter, bgRemoval, detectColors, removeColor, dataURL, base64, arrayBuffer, blob, url, GradientConfig, Frame,
-     PatternOptions, ExtractFramesOptions,
-     applyZoom,
-     ResizeOptions,
-     applyPerspective
+     PatternOptions, ExtractFramesOptions, backgroundRadius, applyZoom, ResizeOptions, applyPerspective
     } from "./utils/utils";
 
   interface CanvasResults {
@@ -49,7 +46,8 @@ export class ApexPainter {
       shadow,
       borderPosition = 'all',
       opacity = 1,
-      zoom
+      zoom,
+      blur
     } = canvas;
   
     const canvasInstance = createCanvas(width, height);
@@ -64,23 +62,20 @@ export class ApexPainter {
     applyShadow(ctx, shadow, x, y, width, height);
   
     ctx.save();
-    if (typeof borderRadius === 'string') {
-      circularBorder(ctx, width, height);
-    } else if (typeof borderRadius === 'number') {
-      radiusBorder(ctx, x, y, width, height, borderRadius, borderPosition);
+    if (borderRadius) {
+      backgroundRadius(ctx, x, y, width, height, borderRadius, borderPosition);
     }
 
-    // ctx.translate(x, y);
-
-    // applyZoom(ctx, zoom);
+    ctx.translate(x, y);
 
     if (customBg) {
-      await customBackground(ctx, canvas);
+      await customBackground(ctx, canvas, zoom, blur);
     } else if (gradientBg) {
-      await drawBackgroundGradient(ctx, canvas);
+      await drawBackgroundGradient(ctx, canvas, zoom, blur);
     } else {
-      await drawBackgroundColor(ctx, canvas);
+      await drawBackgroundColor(ctx, canvas, zoom, blur);
     }
+
     ctx.restore();
 
     applyStroke(ctx, stroke, x, y, width, height);
@@ -165,12 +160,12 @@ export class ApexPainter {
                
                 GlobalFonts.registerFromPath(
                   path.join(process.cwd(), mergedTextOptions.fontPath),
-                    mergedTextOptions.fontName,
+                    (mergedTextOptions.fontName || 'customFont'),
                 );
             }
 
             const size = { width: existingImage.width, height: existingImage.height };
-            drawText(ctx, mergedTextOptions, size);
+            drawText(ctx, mergedTextOptions);
         }
 
         return canvas.toBuffer("image/png");
@@ -469,87 +464,83 @@ async createGIF(gifFrames: { background: string; duration: number }[], options:
     }
   }
 
-  private async drawImage(
-    ctx: SKRSContext2D,
-    image: ImageProperties
-  ): Promise<void> {
+  private async drawImage(ctx: SKRSContext2D, image: ImageProperties): Promise<void> {
     const {
       source,
-      x,
-      y,
-      width,
-      height,
+      x, y, width, height,
       rotation = 0,
       borderRadius = 0,
-      stroke,
-      shadow,
-      isFilled,
-      color,
-      gradient,
+      stroke, shadow,
+      isFilled, color, gradient,
       borderPosition = 'all',
       opacity,
-      perspective
+      perspective,
+      blur = 0,
+      zoom,
+      filling
     } = image;
     
-    if (
-      !source ||
-      typeof x !== 'number' ||
-      typeof y !== 'number' ||
-      typeof width !== 'number' ||
-      typeof height !== 'number'
-    ) {
+    if (perspective) throw new Error("`perspective` Feature is under construction. Please refrain from using it.");
+    
+    if (!source || typeof x !== 'number' || typeof y !== 'number' || typeof width !== 'number' || typeof height !== 'number') {
       throw new Error('Invalid image properties: source, x, y, width, and height are required.');
     }
-    
-    const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite'];
+  
+    const shapeNames = ['circle', 'square', 'triangle', 'pentagon', 'hexagon', 'heptagon', 'octagon', 'star', 'kite', 'arrow', 'star', 'oval', 'heart', 'diamond', 'trapezoid', 'cloud'];
     const isShape = shapeNames.includes(source.toLowerCase());
-    
+  
     if (opacity !== undefined) {
       ctx.globalAlpha = opacity;
     }
-    
+  
     if (isShape) {
-      drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient, borderPosition });
+      drawShape(ctx, { source, x, y, width, height, rotation, borderRadius, stroke, shadow, isFilled, color, gradient, borderPosition, filling });
       ctx.globalAlpha = 1.0;
       return;
     }
-    
+  
     let loadedImage: Image | undefined;
     try {
       if (source.startsWith('http')) {
         loadedImage = await loadImage(source);
       } else {
-        const imagePath = path.join(process.cwd(), source);
+        const imagePath = path.resolve(process.cwd(), source);
         loadedImage = await loadImage(imagePath);
       }
     } catch (e: any) {
       throw new Error(`Error loading image: ${e.message}`);
     }
-    
+  
     if (!loadedImage) {
       throw new Error('Invalid image source or failed to load image');
     }
-    
+  
     ctx.save();
+  
+    const scale = zoom?.scale ?? 1;
+    const focusX = zoom?.x ?? 0.5;
+    const focusY = zoom?.y ?? 0.5;
+  
+    if (scale !== 1) {
+      ctx.translate(focusX, focusY);
+      ctx.scale(scale, scale);
+    }
+  
+    if (blur > 0) {
+      ctx.filter = `blur(${blur}px)`;
+    }
+  
     applyRotation(ctx, rotation, x, y, width, height);
     applyShadow(ctx, shadow, x, y, width, height);
     
     if (perspective) {
-      throw new Error('Under construction')
-        // const offscreen = createCanvas(width, height);
-        // const offCtx = offscreen.getContext('2d') as SKRSContext2D;
-        // offCtx.clearRect(0, 0, width, height);
-        
-        // await applyPerspective(offCtx, loadedImage, 0, 0, width, height, perspective, 10, 10);
-        
-        // imageRadius(ctx, offscreen, x, y, width, height, borderRadius, borderPosition);
+      throw new Error('Under construction');
     }
-
+  
     imageRadius(ctx, loadedImage, x, y, width, height, borderRadius, borderPosition);
-
-    applyStroke(ctx, stroke, x, y, width, height);
+    applyStroke(ctx, stroke, x, y, width, height, undefined, true);
+  
     ctx.restore();
-    
     ctx.globalAlpha = 1.0;
   }
   
@@ -997,7 +988,7 @@ async animate(
       }
 
       if (frame.onDrawCustom) {
-          frame.onDrawCustom(ctx as unknown as CanvasRenderingContext2D, canvas);
+          frame.onDrawCustom(ctx as unknown as SKRSContext2D, canvas);
       }
 
       if (frame.transformations) {

package/lib/canvas/Themes/Level-Up/levelup.ts

@@ -0,0 +1,183 @@
+import { ApexPainter, CanvasConfig, ImageProperties, TextObject } from "../../../index";
+
+const Image = new ApexPainter();
+
+/**
+ * Generates a level-up card.
+ * @param {string} userPfp - User profile picture URL.
+ * @param {string} username - Username.
+ * @param {string} [levelUpmsg="Well done user. You had leveled up 🔥🔥"] - Custom level-up message.
+ * @param {string} prevLevel - Previous level before leveling up.
+ * @param {string} nextLevel - Next level after leveling up.
+ * @returns {Promise<Buffer>} - The generated level-up image.
+ */
+export async function level_up_1(
+    userPfp: string,
+    username: string,
+    levelUpmsg: string = "Well done user. You had leveled up 🔥🔥",
+    prevLevel: string,
+    nextLevel: string
+): Promise<Buffer> {
+
+    /** Helper function to detect Arabic text */
+    const isArabic = (text: string) => /[\u0600-\u06FF]/.test(text);
+
+    /** Helper function to shuffle an array */
+    function shuffleArray<T>(array: T[]): T[] {
+        return array.sort(() => Math.random() - 0.5);
+    }
+
+    /** Extracts and returns random colors from the dominant colors */
+    function getRandomColors(colors: { color: string }[]): string[] {
+        if (colors.length === 0) return ["rgb(0, 255, 247)", "rgb(157, 0, 255)", "rgb(255, 94, 0)"];
+        return shuffleArray(colors).slice(0, 5).map(c => `rgb(${c.color})`);
+    }
+
+    // 1. **Canvas Configuration**
+    const canvasConfig: CanvasConfig = {
+        customBg: './bg.png',
+        width: 1599, height: 876,
+        zoom: {}
+    };
+
+    const bg = await Image.createCanvas(canvasConfig);
+
+    // 2. **Extract Dominant Colors for Gradients**
+    const dominantColors = await Image.colorAnalysis(userPfp);
+    const gradientColors = getRandomColors(dominantColors).map((color, index) => ({
+        stop: index / 4, color
+    }));
+    const shadowGradient = [...gradientColors];
+
+    // 3. **User Profile Picture Configuration**
+    const imgs: ImageProperties[] = [{
+        source: userPfp,
+        width: 240, height: 240,
+        x: 235, y: 235,
+        blur: 0.4,
+        borderRadius: 'circular',
+        stroke: {
+            width: 8, position: 5, blur: 0.5,
+            borderRadius: 'circular',
+            gradient: {
+                type: 'linear',
+                startX: 200, startY: 200,
+                endX: 290, endY: 290,
+                colors: gradientColors
+            }
+        },
+        shadow: {
+            gradient: {
+                type: 'linear',
+                startX: 220, startY: 220,
+                endX: 270, endY: 270,
+                colors: shadowGradient
+            },
+            opacity: 0.7,
+            blur: 25,
+            borderRadius: 90,
+            offsetX: 0, offsetY: 0,
+        }
+    }];
+
+    const img = await Image.createImage(imgs, bg);
+
+    // 4. **Username Text Handling**
+    const maxLength = isArabic(username) ? 12 : 10;
+    let displayName = username.length > maxLength
+        ? isArabic(username)
+            ? '...' + username.slice(-maxLength)
+            : username.slice(0, maxLength - 3) + '...'
+        : username;
+
+    let xPos = isArabic(username) ? Math.max(480 - (displayName.length - 4) * 3, 190) - 30 : 300 - Math.min((displayName.length - 3) * 10, 110);
+
+    // 5. **Message Text Alignment**
+    const container = { width: 590, height: 235, x: 810, y: 520 };
+    const fontName = isArabic(levelUpmsg) ? 'Segoe UI' : 'Segoe UI Emoji';
+    const textX = isArabic(levelUpmsg) ? container.x + 290 : container.x + 285;
+
+    // 6. **Dynamic Level Positioning Function**
+    function getLevelPosition(level: string, isNext: boolean) {
+        let x = isNext ? 1320 : 885;
+        let y = 455;
+        let fontSize = 72;
+
+        if (level.length === 3) {
+            x = isNext ? 1323 : 888;
+            y = 455;
+            fontSize = 63;
+        }
+
+        return { x, y, fontSize };
+    }
+
+    const prevLevelConfig = getLevelPosition(prevLevel, false);
+    const nextLevelConfig = getLevelPosition(nextLevel, true);
+
+    // 7. **Text Elements Configuration**
+    const txts: TextObject[] = [
+        {
+            text: displayName,
+            x: xPos, y: 600,
+            fontSize: 54,
+            fontName: 'Segoe UI',
+            textAlign: isArabic(username) ? 'right' : 'left',
+            gradient: {
+                type: 'linear',
+                startX: 0, startY: 0,
+                endX: 0, endY: 50,
+                colors: [
+                    { stop: 0, color: '#ffffff' },
+                    { stop: 1, color: '#66e6ff' }
+                ]
+            },
+            stroke: { width: 3, color: '#9d00ff' },
+            shadow: { color: '#66e6ff', opacity: 0.4, blur: 8, offsetX: 0, offsetY: 0 }
+        },
+        {
+            text: levelUpmsg,
+            x: textX, y: container.y + 60,
+            fontSize: 34,
+            fontName: fontName,
+            textAlign: 'center',
+            maxWidth: container.width - 30,
+            lineHeight: 42,
+            maxHeight: container.height - 30,
+            gradient: {
+                type: 'linear',
+                startX: 0, startY: 0,
+                endX: 0, endY: 50,
+                colors: [
+                    { stop: 0, color: '#f9ff00' },
+                    { stop: 1, color: '#ff6a00' }
+                ]
+            },
+            stroke: { width: 2, color: '#ff9d00' },
+            shadow: { color: '#ffcc00', opacity: 0.5, blur: 10, offsetX: 0, offsetY: 0 }
+        },
+        {
+            text: prevLevel,
+            x: prevLevelConfig.x, y: prevLevelConfig.y,
+            fontSize: prevLevelConfig.fontSize,
+            fontName: "Bahnschrift",
+            textAlign: "center",
+            gradient: { type: "linear", startX: 0, startY: 0, endX: 0, endY: 80, colors: [{ stop: 0, color: "#00FFFF" }, { stop: 1, color: "#007BFF" }] },
+            stroke: { width: 6, color: "#0033FF" },
+            shadow: { color: "#00BFFF", opacity: 0.6, blur: 15, offsetX: 0, offsetY: 0 }
+        },
+        {
+            text: nextLevel,
+            x: nextLevelConfig.x, y: nextLevelConfig.y,
+            fontSize: nextLevelConfig.fontSize,
+            fontName: "Bahnschrift",
+            textAlign: "center",
+            gradient: { type: "linear", startX: 0, startY: 0, endX: 0, endY: 80, colors: [{ stop: 0, color: "#00FFFF" }, { stop: 1, color: "#007BFF" }] },
+            stroke: { width: 6, color: "#0033FF" },
+            shadow: { color: "#00BFFF", opacity: 0.6, blur: 15, offsetX: 0, offsetY: 0 }
+        }
+    ];
+
+    // 8. **Render Final Image**
+    return await Image.createText(txts, img);
+}