@ai.ntellect/core 0.6.20 → 0.7.0

package/dist/modules/agenda/index.js

@@ -1,140 +0,0 @@
-"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/modules/embedding/adapters/ai/index.js

@@ -1,57 +0,0 @@
-"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.AIEmbeddingAdapter = void 0;
-const ai_1 = require("ai");
-/**
- * @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;
-    }
-    /**
-     * 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,
-                value: text,
-            });
-            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)({
-                model: this.model,
-                values: texts,
-            });
-            return embeddings;
-        });
-    }
-}
-exports.AIEmbeddingAdapter = AIEmbeddingAdapter;

package/dist/modules/embedding/index.js

@@ -1,59 +0,0 @@
-"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

@@ -1,210 +0,0 @@
-"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;