@ai.ntellect/core 0.6.17 → 0.6.20

package/dist/utils/sanitize-results.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResultSanitizer = void 0;
-/**
- * Utility class to sanitize JSON results for evaluation
- */
-class ResultSanitizer {
-    /**
-     * Sanitizes JSON results by removing special characters and formatting
-     * @param results - The results to sanitize
-     * @returns Sanitized string
-     */
-    static sanitize(results) {
-        if (!results)
-            return "";
-        try {
-            const jsonString = JSON.stringify(results);
-            return (jsonString
-                // Basic cleanup
-                .replace(/\\n/g, " ") // Remove newlines
-                .replace(/\s+/g, " ") // Remove extra spaces
-                .replace(/\\"/g, '"') // Fix escaped quotes
-                .replace(/\\+/g, "") // Remove extra backslashes
-                // Remove unnecessary quotes around objects and arrays
-                .replace(/"\[/g, "[") // Remove quotes around arrays start
-                .replace(/\]"/g, "]") // Remove quotes around arrays end
-                .replace(/"{/g, "{") // Remove quotes around objects start
-                .replace(/}"/g, "}") // Remove quotes around objects end
-                // Clean up numbers and values
-                .replace(/"(\d+\.?\d*)"/g, "$1") // Remove quotes around numbers
-                .replace(/:\s*"(true|false|null)"/g, ": $1") // Remove quotes around booleans and null
-                // Clean up URLs and content
-                .replace(/(?<=content":")([^"]+)(?=")/g, (match) => match.trim().replace(/\s+/g, " ") // Clean content spacing
-            )
-                .replace(/(?<=link":")([^"]+)(?=")/g, (match) => match.replace(/&amp;/g, "&") // Fix URL encodings
-            )
-                // Final cleanup
-                .replace(/,\s*([}\]])/g, "$1") // Remove trailing commas
-                .replace(/:\s+/g, ":") // Remove spaces after colons
-                .replace(/,\s+/g, ",") // Remove spaces after commas
-                .trim()); // Remove leading/trailing whitespace
-        }
-        catch (error) {
-            console.error("Error sanitizing results:", error);
-            return String(results);
-        }
-    }
-    /**
-     * Formats numbers to a consistent format
-     * @param value - The number to format
-     * @returns Formatted number string
-     */
-    static formatNumber(value) {
-        return value.toLocaleString("en-US", {
-            maximumFractionDigits: 2,
-            useGrouping: false,
-        });
-    }
-}
-exports.ResultSanitizer = ResultSanitizer;

package/memory/adapters/redis/index.ts

@@ -1,103 +0,0 @@
-import { createClient } from "redis";
-import { BaseMemoryService } from "../../../interfaces";
-import { BaseMemoryType } from "../../../types";
-
-export class RedisAdapter implements BaseMemoryService {
-  private redis;
-  private readonly cachePrefix: string;
-  private readonly cacheTTL: number;
-
-  constructor(
-    private readonly redisUrl: string,
-    options: {
-      cachePrefix?: string;
-      cacheTTL?: number;
-    }
-  ) {
-    this.cachePrefix = options.cachePrefix || "memory:";
-    this.cacheTTL = options.cacheTTL || 3600;
-    this.redis = createClient({
-      url: redisUrl,
-      socket: {
-        tls: true,
-        rejectUnauthorized: true,
-      },
-    });
-  }
-
-  async initializeConnection(): Promise<void> {
-    this.redis.on("error", (err) => console.error("Redis Client Error:", err));
-    await this.redis.connect();
-  }
-
-  async createMemory(memory: BaseMemoryType, ttl?: number): Promise<void> {
-    const key = memory.roomId
-      ? `${this.cachePrefix}${memory.roomId}:${memory.id}`
-      : `${this.cachePrefix}${memory.id}`;
-
-    await this.redis.set(key, JSON.stringify(memory), {
-      EX: ttl || this.cacheTTL,
-    });
-  }
-
-  async getMemoryById(
-    id: string,
-    roomId?: string
-  ): Promise<BaseMemoryType | null> {
-    const key = roomId
-      ? `${this.cachePrefix}${roomId}:${id}`
-      : `${this.cachePrefix}${id}`;
-
-    const data = await this.redis.get(key);
-    return data ? JSON.parse(data) : null;
-  }
-
-  async getMemoryByIndex(
-    query: string,
-    options: {
-      roomId?: string;
-      limit?: number;
-    } = {}
-  ): Promise<BaseMemoryType[]> {
-    const pattern = options.roomId
-      ? `${this.cachePrefix}${options.roomId}:*`
-      : `${this.cachePrefix}*`;
-
-    const keys = await this.redis.keys(pattern);
-    const memories = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-    return memories.filter(Boolean).slice(0, options.limit || 10);
-  }
-
-  async getAllMemories(): Promise<BaseMemoryType[]> {
-    const keys = await this.redis.keys(`${this.cachePrefix}*`);
-    const memories = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data ? JSON.parse(data) : null;
-      })
-    );
-    return memories.filter(Boolean);
-  }
-
-  async clearMemoryById(id: string): Promise<void> {
-    await this.redis.del(`${this.cachePrefix}${id}`);
-  }
-
-  async clearAllMemories(): Promise<void> {
-    const keys = await this.redis.keys(`${this.cachePrefix}*`);
-    if (keys.length > 0) {
-      await this.redis.del(keys);
-    }
-  }
-
-  async quit(): Promise<void> {
-    if (this.redis) {
-      await this.redis.quit();
-    }
-  }
-}

package/memory/index.ts

@@ -1,22 +0,0 @@
-import { BaseMemoryService } from "../interfaces";
-import { BaseMemoryType, CreateMemoryInput } from "../types";
-
-export abstract class BaseMemory {
-  constructor(protected readonly cacheService: BaseMemoryService) {}
-
-  abstract init(): Promise<void>;
-  abstract createMemory(
-    input: CreateMemoryInput & { embedding?: number[] }
-  ): Promise<BaseMemoryType | undefined>;
-  abstract getMemoryById(
-    id: string,
-    roomId: string
-  ): Promise<BaseMemoryType | null>;
-  abstract getMemoryByIndex(
-    query: string,
-    options: { roomId: string; limit?: number }
-  ): Promise<BaseMemoryType[]>;
-  abstract getAllMemories(roomId: string): Promise<BaseMemoryType[]>;
-  abstract clearMemoryById(id: string, roomId: string): Promise<void>;
-  abstract clearAllMemories(): Promise<void>;
-}

package/services/agenda.ts

@@ -1,118 +0,0 @@
-import { ScheduledRequest } from "../types";
-import cron from "node-cron";
-
-export class Agenda {
-  private scheduledRequests: Map<string, ScheduledRequest> = new Map();
-  private cronJobs: Map<string, cron.ScheduledTask> = new Map();
-
-  /**
-   * Schedule a new request to be processed later
-   */
-  async scheduleRequest(
-    request: {
-      originalRequest: string;
-      cronExpression: string;
-    },
-    callbacks?: {
-      onScheduled?: (id: string) => void;
-      onExecuted?: (id: string, originalRequest: string) => void;
-    }
-  ): Promise<string> {
-    const id = crypto.randomUUID();
-
-    const scheduledRequest: ScheduledRequest = {
-      id,
-      originalRequest: request.originalRequest,
-      cronExpression: request.cronExpression,
-      isRecurring: false,
-      createdAt: new Date(),
-    };
-
-    // Create cron job
-    const cronJob = cron.schedule(request.cronExpression, () => {
-      console.log(`🔄 Executing scheduled request: ${id}`);
-
-      if (callbacks?.onExecuted) {
-        callbacks.onExecuted(id, scheduledRequest.originalRequest);
-      }
-
-      console.log(`✅ Scheduled request executed successfully: ${id}`);
-
-      // Auto-stop pour les tâches non récurrentes
-      if (!scheduledRequest.isRecurring) {
-        this.cancelScheduledRequest(id);
-      }
-    });
-
-    // Démarrer le job en mode non-running
-    cronJob.stop();
-
-    // Store request and job
-    this.scheduledRequests.set(id, scheduledRequest);
-    this.cronJobs.set(id, cronJob);
-
-    if (callbacks?.onScheduled) callbacks.onScheduled(id);
-
-    // Démarrer le job après l'avoir stocké
-    cronJob.start();
-
-    return id;
-  }
-
-  /**
-   * Cancel a scheduled request
-   */
-  cancelScheduledRequest(requestId: string): boolean {
-    const cronJob = this.cronJobs.get(requestId);
-    if (cronJob) {
-      try {
-        cronJob.stop();
-        this.cronJobs.delete(requestId);
-        this.scheduledRequests.delete(requestId);
-        return true;
-      } catch (error) {
-        console.error(`Failed to stop cron job ${requestId}:`, error);
-        return false;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Get all scheduled requests
-   */
-  getScheduledRequests(): ScheduledRequest[] {
-    return Array.from(this.scheduledRequests.values());
-  }
-
-  /**
-   * Stop all cron jobs
-   */
-  stopAll(): void {
-    const ids = Array.from(this.cronJobs.keys());
-
-    // Arrêter tous les jobs de manière synchrone
-    for (const id of ids) {
-      const job = this.cronJobs.get(id);
-      if (job) {
-        job.stop();
-        this.cronJobs.delete(id);
-        this.scheduledRequests.delete(id);
-      }
-    }
-
-    // Double vérification
-    this.cronJobs.clear();
-    this.scheduledRequests.clear();
-  }
-
-  public async stop(): Promise<void> {
-    this.stopAll();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-
-  public async cancel(query: {}): Promise<void> {
-    this.stopAll();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-}

package/services/embedding.ts

@@ -1,26 +0,0 @@
-import { EmbeddingService } from "../interfaces";
-import { cosineSimilarity, embed, EmbeddingModel, embedMany } from "ai";
-
-export class AIEmbeddingService implements EmbeddingService {
-  constructor(private readonly model: EmbeddingModel<string>) {}
-
-  async embedText(text: string): Promise<number[]> {
-    const { embedding } = await embed({
-      model: this.model,
-      value: text,
-    });
-    return embedding;
-  }
-
-  async embedMany(texts: string[]): Promise<number[][]> {
-    const { embeddings } = await embedMany({
-      model: this.model,
-      values: texts,
-    });
-    return embeddings;
-  }
-
-  calculateSimilarity(embedding1: number[], embedding2: number[]): number {
-    return (cosineSimilarity(embedding1, embedding2) + 1) * 50;
-  }
-}

package/services/queue.ts

@@ -1,145 +0,0 @@
-import {
-  ActionSchema,
-  QueueCallbacks,
-  QueueItem,
-  QueueItemParameter,
-  QueueResult,
-} from "../types";
-
-export class Queue {
-  private queue: QueueItem[] = [];
-  private results: QueueResult[] = [];
-  private callbacks: QueueCallbacks;
-  private actions: ActionSchema[];
-  private isProcessing: boolean = false;
-
-  constructor(actions: ActionSchema[], callbacks: QueueCallbacks = {}) {
-    this.actions = actions;
-    this.callbacks = callbacks;
-  }
-
-  add(actions: QueueItem | QueueItem[]) {
-    if (Array.isArray(actions)) {
-      this.queue.push(...actions);
-    } else {
-      this.queue.push(actions);
-    }
-  }
-
-  async execute() {
-    if (this.isProcessing) {
-      return;
-    }
-
-    this.isProcessing = true;
-    const actionPromises: Promise<QueueResult>[] = [];
-
-    for (const action of this.queue) {
-      const actionConfig = this.actions.find((a) => a.name === action.name);
-      if (actionConfig?.confirmation?.requireConfirmation) {
-        const shouldProceed = await this.callbacks.onConfirmationRequired?.(
-          actionConfig.confirmation.message ||
-            `Do you want to proceed with action: ${action.name}?`
-        );
-
-        if (!shouldProceed) {
-          this.results.push({
-            name: action.name,
-            parameters: this.formatArguments(action.parameters),
-            result: null,
-            error: "Action cancelled by user",
-            cancelled: true,
-          });
-          continue;
-        }
-      }
-      const parameters = this.formatArguments(action.parameters);
-
-      actionPromises.push(
-        this.executeAction(action)
-          .then((result) => {
-            this.callbacks.onActionComplete?.(result);
-            return result;
-          })
-          .catch((error) => {
-            const result = {
-              name: action.name,
-              parameters,
-              result: null,
-              error: error.message || "Unknown error occurred",
-            };
-            this.callbacks.onActionComplete?.(result);
-            return result;
-          })
-      );
-    }
-
-    try {
-      const results = await Promise.all(actionPromises);
-      this.results.push(...results);
-      this.queue = [];
-      this.callbacks.onQueueComplete?.(this.results);
-      this.isProcessing = false;
-      return this.results;
-    } catch (error) {
-      this.isProcessing = false;
-      throw error;
-    }
-  }
-
-  private formatArguments(args: QueueItemParameter[]): Record<string, string> {
-    return args.reduce<Record<string, string>>((acc, arg) => {
-      try {
-        // Parse the JSON string if the value is a stringified JSON object
-        const parsedValue = JSON.parse(arg.value);
-        if (
-          parsedValue &&
-          typeof parsedValue === "object" &&
-          "value" in parsedValue
-        ) {
-          acc[parsedValue.name] = parsedValue.value;
-        } else {
-          // Fallback to original value if not in expected format
-          acc[arg.name] = arg.value;
-        }
-      } catch {
-        // If JSON parsing fails, use the original value
-        acc[arg.name] = arg.value;
-      }
-      return acc;
-    }, {});
-  }
-
-  private async executeAction(action: QueueItem): Promise<QueueResult> {
-    this.callbacks.onActionStart?.(action);
-
-    const actionConfig = this.actions.find((a) => a.name === action.name);
-    if (!actionConfig) {
-      return {
-        name: action.name,
-        parameters: {},
-        result: null,
-        error: `Action '${action.name}' not found in actions list`,
-      };
-    }
-
-    const actionArgs = this.formatArguments(action.parameters);
-
-    try {
-      const result = await actionConfig.execute(actionArgs);
-      return {
-        name: action.name,
-        parameters: actionArgs,
-        result,
-        error: null,
-      };
-    } catch (error) {
-      return {
-        name: action.name,
-        parameters: actionArgs,
-        result: null,
-        error: (error as Error).message || "Unknown error occurred",
-      };
-    }
-  }
-}

package/test/memory/adapters/redis.test.ts

@@ -1,159 +0,0 @@
-import { BaseMemoryService } from "../../../interfaces";
-import { RedisAdapter } from "../../../memory/adapters/redis";
-import { BaseMemoryType } from "../../../types";
-import { expect } from "chai";
-import dotenv from "dotenv";
-import Redis from "ioredis";
-
-// Load environment variables
-dotenv.config();
-
-describe("RedisAdapter", () => {
-  before(function () {
-    this.timeout(15000);
-  });
-
-  let redisAdapter: RedisAdapter;
-  let mockBaseMemoryService: BaseMemoryService;
-  let redisClient: Redis | null = null;
-  const fixedDate = new Date("2025-01-30T07:43:50.626Z");
-
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    embedding: [0.1, 0.2, 0.3],
-    roomId: "test-room",
-    createdAt: fixedDate,
-  };
-
-  beforeEach(async () => {
-    mockBaseMemoryService = {
-      initializeConnection: async () => {},
-      createMemory: async () => {},
-      getMemoryById: async () => testMemory,
-      getMemoryByIndex: async () => [testMemory],
-      getAllMemories: async () => [testMemory],
-      clearMemoryById: async () => {},
-      clearAllMemories: async () => {},
-    };
-
-    // Use real Redis if environment variables are set, otherwise mock
-    if (process.env.REDIS_URL) {
-      redisClient = new Redis(process.env.REDIS_URL);
-      redisAdapter = new RedisAdapter(process.env.REDIS_URL, {
-        cachePrefix: "test-prefix",
-        cacheTTL: 3600,
-      });
-    } else {
-      // Mock Redis implementation
-      const mockRedis = {
-        connect: async () => {},
-        disconnect: async () => {},
-        set: async (key: string, value: string) => "OK",
-        get: async (key: string) => {
-          if (key.includes("test-id")) {
-            return JSON.stringify({
-              ...testMemory,
-              createdAt: fixedDate.toISOString(),
-            });
-          }
-          return null;
-        },
-        keys: async (pattern: string) => {
-          return [`${pattern}test-id`];
-        },
-        mget: async (keys: string[]) => {
-          return keys.map(() =>
-            JSON.stringify({
-              ...testMemory,
-              createdAt: fixedDate.toISOString(),
-            })
-          );
-        },
-        del: async () => 1,
-        flushall: async () => "OK",
-        quit: async () => {},
-      };
-
-      redisAdapter = new RedisAdapter(mockRedis as any, {
-        cachePrefix: "test-prefix",
-        cacheTTL: 3600,
-      });
-    }
-
-    await redisAdapter.initializeConnection();
-  });
-
-  afterEach(async () => {
-    if (redisClient) {
-      await redisClient.quit();
-      redisClient = null;
-    }
-    // @ts-ignore pour éviter l'erreur de typage
-    await redisAdapter?.quit?.();
-  });
-
-  describe("Initialization", () => {
-    it("should initialize storage", async () => {
-      await expect(redisAdapter.initializeConnection()).to.not.throw;
-    });
-  });
-
-  describe("Memory Operations", () => {
-    const TEST_ROOM_ID = "test-room";
-
-    it("should create memory", async () => {
-      await expect(
-        redisAdapter.createMemory({
-          data: "test data",
-          query: "test query",
-          roomId: TEST_ROOM_ID,
-          id: "test-id",
-          embedding: [0.1, 0.2, 0.3],
-          createdAt: fixedDate,
-        })
-      ).to.not.throw;
-    });
-
-    it("should get memory by ID", async () => {
-      const result = await redisAdapter.getMemoryById("test-id", TEST_ROOM_ID);
-      if (result) {
-        result.createdAt = new Date(result.createdAt);
-      }
-      expect(result).to.deep.equal({
-        ...testMemory,
-        createdAt: testMemory.createdAt,
-      });
-    });
-
-    it("should get memories by index", async () => {
-      const results = await redisAdapter.getMemoryByIndex("test", {
-        roomId: TEST_ROOM_ID,
-        limit: 10,
-      });
-
-      expect(results).to.be.an("array");
-      if (results[0]) {
-        results[0].createdAt = new Date(results[0].createdAt);
-      }
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should get all memories", async () => {
-      const results = await redisAdapter.getAllMemories();
-      expect(results).to.be.an("array");
-      if (results[0]) {
-        results[0].createdAt = new Date(results[0].createdAt);
-      }
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should clear memory by ID", async () => {
-      await expect(redisAdapter.clearMemoryById("test-id")).to.not.throw;
-    });
-
-    it("should clear all memories", async () => {
-      await expect(redisAdapter.clearAllMemories()).to.not.throw;
-    });
-  });
-});