@ai.ntellect/core 0.6.17 → 0.6.19

package/dist/modules/agenda/index.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agenda = void 0;
+/**
+ * @module Agenda
+ * @description A module for scheduling and managing cron-based tasks.
+ * Provides functionality for scheduling requests, managing their lifecycle,
+ * and handling recurring and one-time tasks.
+ */
+class Agenda {
+    /**
+     * Creates an instance of Agenda
+     * @param {ICronService} cronService - The cron service implementation
+     * @param {IMemoryAdapter} storage - The storage service for jobs and requests
+     */
+    constructor(cronService, storage) {
+        this.cronService = cronService;
+        this.storage = storage;
+    }
+    /**
+     * Schedule a new request to be processed later
+     * @param {Object} request - The request configuration
+     * @param {string} request.originalRequest - The original request to be executed
+     * @param {string} request.cronExpression - The cron expression for scheduling
+     * @param {Object} [callbacks] - Optional callback functions
+     * @param {Function} [callbacks.onScheduled] - Called when request is scheduled
+     * @param {Function} [callbacks.onExecuted] - Called when request is executed
+     * @returns {Promise<string>} The ID of the scheduled request
+     */
+    scheduleRequest(request, callbacks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = crypto.randomUUID();
+            const scheduledRequest = {
+                id,
+                originalRequest: request.originalRequest,
+                cronExpression: request.cronExpression,
+                isRecurring: false,
+                createdAt: new Date(),
+            };
+            // Create cron job using the injected service
+            const cronJob = this.cronService.schedule(request.cronExpression, () => __awaiter(this, void 0, void 0, function* () {
+                console.log(`🔄 Executing scheduled request: ${id}`);
+                if (callbacks === null || callbacks === void 0 ? void 0 : callbacks.onExecuted) {
+                    callbacks.onExecuted(id, scheduledRequest.originalRequest);
+                }
+                console.log(`✅ Scheduled request executed successfully: ${id}`);
+                // Auto-stop for non-recurring tasks
+                if (!scheduledRequest.isRecurring) {
+                    yield this.cancelScheduledRequest(id);
+                }
+            }));
+            // Start job in non-running mode
+            cronJob.stop();
+            // Store request and job using storage service
+            yield this.storage.saveRequest(id, scheduledRequest);
+            yield this.storage.saveJob(id, cronJob);
+            if (callbacks === null || callbacks === void 0 ? void 0 : callbacks.onScheduled)
+                callbacks.onScheduled(id);
+            // Start the job after storing
+            cronJob.start();
+            return id;
+        });
+    }
+    /**
+     * Cancels a scheduled request by its ID
+     * @param {string} requestId - The ID of the request to cancel
+     * @returns {Promise<boolean>} True if the request was found and cancelled, false otherwise
+     */
+    cancelScheduledRequest(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cronJob = yield this.storage.getJob(requestId);
+            if (cronJob) {
+                try {
+                    cronJob.stop();
+                    yield this.storage.deleteJob(requestId);
+                    yield this.storage.deleteRequest(requestId);
+                    return true;
+                }
+                catch (error) {
+                    console.error(`Failed to stop cron job ${requestId}:`, error);
+                    return false;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Retrieves all scheduled requests
+     * @returns {Promise<ScheduledRequest[]>} Array of all scheduled requests
+     */
+    getScheduledRequests() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.getAllRequests();
+        });
+    }
+    /**
+     * Stops all scheduled jobs
+     * @returns {Promise<void>}
+     */
+    stopAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requests = yield this.getScheduledRequests();
+            for (const request of requests) {
+                yield this.cancelScheduledRequest(request.id);
+            }
+            yield this.storage.clear();
+        });
+    }
+    /**
+     * Stops the agenda service
+     * @returns {Promise<void>}
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stopAll();
+            yield new Promise((resolve) => setTimeout(resolve, 100));
+        });
+    }
+    /**
+     * Cancels requests matching the query
+     * @param {Object} query - Query to match requests against
+     * @returns {Promise<void>}
+     */
+    cancel(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stopAll();
+            yield new Promise((resolve) => setTimeout(resolve, 100));
+        });
+    }
+}
+exports.Agenda = Agenda;

package/dist/{services/embedding.js → modules/embedding/adapters/ai/index.js}

@@ -9,13 +9,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIEmbeddingService = void 0;
+exports.AIEmbeddingAdapter = void 0;
 const ai_1 = require("ai");
-class AIEmbeddingService {
+/**
+ * @module AIEmbeddingAdapter
+ * @description Adapter implementation for AI-based embedding service.
+ * Provides integration with AI models for text embedding generation.
+ * @implements {IEmbeddingModel}
+ */
+class AIEmbeddingAdapter {
+    /**
+     * Creates an instance of AIEmbeddingAdapter
+     * @param {EmbeddingModel<string>} model - The AI embedding model to use
+     */
     constructor(model) {
         this.model = model;
     }
-    embedText(text) {
+    /**
+     * Generates an embedding vector for a single text using the AI model
+     * @param {string} text - The text to embed
+     * @returns {Promise<number[]>} The generated embedding vector
+     */
+    embed(text) {
         return __awaiter(this, void 0, void 0, function* () {
             const { embedding } = yield (0, ai_1.embed)({
                 model: this.model,
@@ -24,6 +39,11 @@ class AIEmbeddingService {
             return embedding;
         });
     }
+    /**
+     * Generates embedding vectors for multiple texts using the AI model
+     * @param {string[]} texts - Array of texts to embed
+     * @returns {Promise<number[][]>} Array of generated embedding vectors
+     */
     embedMany(texts) {
         return __awaiter(this, void 0, void 0, function* () {
             const { embeddings } = yield (0, ai_1.embedMany)({
@@ -33,8 +53,5 @@ class AIEmbeddingService {
             return embeddings;
         });
     }
-    calculateSimilarity(embedding1, embedding2) {
-        return ((0, ai_1.cosineSimilarity)(embedding1, embedding2) + 1) * 50;
-    }
 }
-exports.AIEmbeddingService = AIEmbeddingService;
+exports.AIEmbeddingAdapter = AIEmbeddingAdapter;

package/dist/modules/embedding/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Embedding = void 0;
+const ai_1 = require("ai");
+/**
+ * @module Embedding
+ * @description A module for generating and managing text embeddings.
+ * Provides functionality for converting text into vector representations
+ * and calculating similarities between embeddings.
+ * @implements {IEmbeddingModule}
+ */
+class Embedding {
+    /**
+     * Creates an instance of Embedding
+     * @param {IEmbeddingModel} embeddingModel - The embedding model implementation to use
+     */
+    constructor(embeddingModel) {
+        this.embeddingModel = embeddingModel;
+    }
+    /**
+     * Generates an embedding vector for a single text
+     * @param {string} text - The text to embed
+     * @returns {Promise<number[]>} The embedding vector
+     */
+    embedText(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.embeddingModel.embed(text);
+        });
+    }
+    /**
+     * Generates embedding vectors for multiple texts
+     * @param {string[]} texts - Array of texts to embed
+     * @returns {Promise<number[][]>} Array of embedding vectors
+     */
+    embedMany(texts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.embeddingModel.embedMany(texts);
+        });
+    }
+    /**
+     * Calculates the similarity score between two embeddings
+     * @param {number[]} embedding1 - First embedding vector
+     * @param {number[]} embedding2 - Second embedding vector
+     * @returns {number} Similarity score between 0 and 100
+     */
+    calculateSimilarity(embedding1, embedding2) {
+        return ((0, ai_1.cosineSimilarity)(embedding1, embedding2) + 1) * 50;
+    }
+}
+exports.Embedding = Embedding;

package/dist/modules/memory/adapters/in-memory/index.js

@@ -0,0 +1,210 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryAdapter = void 0;
+/**
+ * @module InMemoryAdapter
+ * @description In-memory implementation of the memory storage adapter.
+ * Provides a simple Map-based storage solution
+ * @implements {IMemoryAdapter}
+ */
+class InMemoryAdapter {
+    /**
+     * Creates an instance of InMemoryAdapter
+     */
+    constructor() {
+        this.storage = new Map();
+        this.jobs = new Map();
+        this.requests = new Map();
+    }
+    /**
+     * Initializes storage for a room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    init(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.storage.has(roomId)) {
+                this.storage.set(roomId, []);
+            }
+        });
+    }
+    /**
+     * Creates a new memory entry
+     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
+     * @returns {Promise<BaseMemoryType | undefined>} Created memory or existing memory if duplicate
+     */
+    createMemory(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.init(input.roomId);
+            // Check if memory already exists
+            const memories = this.storage.get(input.roomId) || [];
+            const existingMemory = memories.find((m) => m.data === input.data);
+            if (existingMemory) {
+                return existingMemory;
+            }
+            // Create new memory
+            const memory = {
+                id: input.id || crypto.randomUUID(),
+                data: input.data,
+                embedding: input.embedding,
+                roomId: input.roomId,
+                createdAt: new Date(),
+            };
+            memories.push(memory);
+            this.storage.set(input.roomId, memories);
+            return memory;
+        });
+    }
+    /**
+     * Retrieves a memory by ID and room ID
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
+     */
+    getMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memories = this.storage.get(roomId) || [];
+            return memories.find((m) => m.id === id) || null;
+        });
+    }
+    /**
+     * Searches for memories based on query and options
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {string} options.roomId - Room identifier
+     * @param {number} [options.limit] - Maximum number of results
+     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
+     */
+    getMemoryByIndex(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memories = this.storage.get(options.roomId) || [];
+            const filtered = memories.filter((m) => m.data.includes(query));
+            return filtered.slice(0, options.limit || filtered.length);
+        });
+    }
+    /**
+     * Retrieves all memories for a room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType[]>} Array of all memories
+     */
+    getAllMemories(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storage.get(roomId) || [];
+        });
+    }
+    /**
+     * Deletes a specific memory
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
+    clearMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const memories = this.storage.get(roomId) || [];
+            const filtered = memories.filter((m) => m.id !== id);
+            this.storage.set(roomId, filtered);
+        });
+    }
+    /**
+     * Clears all memories across all rooms
+     * @returns {Promise<void>}
+     */
+    clearAllMemories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.storage.clear();
+            this.jobs.clear();
+            this.requests.clear();
+        });
+    }
+    /**
+     * Saves a job to the internal storage
+     * @param {string} id - Job identifier
+     * @param {ICronJob} job - Job data
+     * @returns {Promise<void>}
+     */
+    saveJob(id, job) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.jobs.set(id, job);
+        });
+    }
+    /**
+     * Saves a request to the internal storage
+     * @param {string} id - Request identifier
+     * @param {ScheduledRequest} request - Request data
+     * @returns {Promise<void>}
+     */
+    saveRequest(id, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.requests.set(id, request);
+        });
+    }
+    /**
+     * Retrieves a job by ID
+     * @param {string} id - Job identifier
+     * @returns {Promise<ICronJob | undefined>} Job data or undefined if not found
+     */
+    getJob(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.jobs.get(id);
+        });
+    }
+    /**
+     * Retrieves a request by ID
+     * @param {string} id - Request identifier
+     * @returns {Promise<ScheduledRequest | undefined>} Request data or undefined if not found
+     */
+    getRequest(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requests.get(id);
+        });
+    }
+    /**
+     * Deletes a job by ID
+     * @param {string} id - Job identifier
+     * @returns {Promise<void>}
+     */
+    deleteJob(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.jobs.delete(id);
+        });
+    }
+    /**
+     * Deletes a request by ID
+     * @param {string} id - Request identifier
+     * @returns {Promise<void>}
+     */
+    deleteRequest(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.requests.delete(id);
+        });
+    }
+    /**
+     * Retrieves all requests
+     * @returns {Promise<ScheduledRequest[]>} Array of all requests
+     */
+    getAllRequests() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Array.from(this.requests.values());
+        });
+    }
+    /**
+     * Clears all jobs and requests
+     * @returns {Promise<void>}
+     */
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.jobs.clear();
+            this.requests.clear();
+        });
+    }
+}
+exports.InMemoryAdapter = InMemoryAdapter;

package/dist/{memory → modules/memory}/adapters/meilisearch/index.js

@@ -10,10 +10,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MeilisearchAdapter = void 0;
+/**
+ * @module MeilisearchAdapter
+ * @description Adapter implementation for Meilisearch as a memory storage solution.
+ * Provides integration with Meilisearch for storing and retrieving memory entries.
+ * @implements {IMemoryAdapter}
+ */
 class MeilisearchAdapter {
+    /**
+     * Creates an instance of MeilisearchAdapter
+     * @param {MeilisearchConfig} config - Configuration for Meilisearch connection
+     */
     constructor(config) {
         this.config = config;
     }
+    /**
+     * Makes an HTTP request to the Meilisearch API
+     * @private
+     * @param {string} path - API endpoint path
+     * @param {RequestInit} [options] - Fetch request options
+     * @returns {Promise<any>} Response data
+     * @throws {Error} If the request fails
+     */
     makeRequest(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -33,6 +51,12 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Initializes a storage index for a room
+     * @private
+     * @param {string} roomId - Room identifier to create index for
+     * @returns {Promise<void>}
+     */
     initializeStorage(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -72,6 +96,13 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Adds documents to the Meilisearch index
+     * @private
+     * @param {BaseMemoryType[]} documents - Documents to add
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     addDocuments(documents, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.makeRequest(`/indexes/${roomId}/documents`, {
@@ -80,6 +111,12 @@ class MeilisearchAdapter {
             });
         });
     }
+    /**
+     * Deletes a storage index for a room
+     * @private
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     deleteStorage(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.makeRequest(`/indexes/${roomId}`, {
@@ -87,7 +124,11 @@ class MeilisearchAdapter {
             });
         });
     }
-    // Required BaseMemory implementations
+    /**
+     * Initializes the adapter for a specific room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     init(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -101,6 +142,16 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Performs a search in the Meilisearch index
+     * @private
+     * @param {string} query - Search query
+     * @param {string} roomId - Room identifier
+     * @param {Object} [options] - Search options
+     * @param {number} [options.limit] - Maximum number of results
+     * @param {number} [options.threshold] - Minimum score threshold
+     * @returns {Promise<SearchResult[]>} Search results
+     */
     search(query, roomId, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const searchResults = yield this.makeRequest(`/indexes/${roomId}/search`, {
@@ -110,6 +161,9 @@ class MeilisearchAdapter {
                     limit: (options === null || options === void 0 ? void 0 : options.limit) || 10,
                 }),
             });
+            if (!searchResults.hits) {
+                return [];
+            }
             return searchResults.hits.map((hit) => ({
                 document: {
                     id: hit.id,
@@ -122,15 +176,27 @@ class MeilisearchAdapter {
             }));
         });
     }
+    /**
+     * Creates a new memory entry
+     * @param {CreateMemoryInput & { embedding?: number[] }} input - Memory data with optional embedding
+     * @returns {Promise<BaseMemoryType | undefined>} Created memory or undefined
+     */
     createMemory(input) {
         return __awaiter(this, void 0, void 0, function* () {
             // Initialize storage for this roomId if needed
             yield this.initializeStorage(input.roomId);
+            // Check if the memory already exists
+            const existingMemory = yield this.search(input.data, input.roomId, {
+                limit: 1,
+            });
+            if (existingMemory.length > 0) {
+                return existingMemory[0].document;
+            }
             // If not found, create new memory
             const memory = {
                 id: input.id || crypto.randomUUID(),
                 data: input.data,
-                embedding: input.embedding || null,
+                embedding: input.embedding,
                 roomId: input.roomId,
                 createdAt: new Date(),
             };
@@ -138,6 +204,12 @@ class MeilisearchAdapter {
             return memory;
         });
     }
+    /**
+     * Retrieves a memory by ID and room ID
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType | null>} Memory entry or null if not found
+     */
     getMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -157,6 +229,14 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Searches for memories based on query and options
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {string} options.roomId - Room identifier
+     * @param {number} [options.limit] - Maximum number of results
+     * @returns {Promise<BaseMemoryType[]>} Array of matching memories
+     */
     getMemoryByIndex(query, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const results = yield this.search(query, options.roomId, {
@@ -173,6 +253,11 @@ class MeilisearchAdapter {
             }));
         });
     }
+    /**
+     * Retrieves all memories for a room
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<BaseMemoryType[]>} Array of all memories
+     */
     getAllMemories(roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             const results = yield this.makeRequest(`/indexes/${roomId}/documents`);
@@ -188,6 +273,12 @@ class MeilisearchAdapter {
             }));
         });
     }
+    /**
+     * Deletes a specific memory
+     * @param {string} id - Memory identifier
+     * @param {string} roomId - Room identifier
+     * @returns {Promise<void>}
+     */
     clearMemoryById(id, roomId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -204,6 +295,10 @@ class MeilisearchAdapter {
             }
         });
     }
+    /**
+     * Clears all memories across all rooms
+     * @returns {Promise<void>}
+     */
     clearAllMemories() {
         return __awaiter(this, void 0, void 0, function* () {
             try {