@ai.ntellect/core 0.5.0 → 0.6.1

package/dist/memory/adapters/meilisearch/index.js

@@ -0,0 +1,249 @@
+"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.MeilisearchAdapter = void 0;
+const memory_1 = require("@/memory");
+class MeilisearchAdapter extends memory_1.BaseMemory {
+    constructor(config, baseMemoryService) {
+        super(baseMemoryService);
+        this.config = config;
+    }
+    makeRequest(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = `${this.config.host}${path}`;
+                const response = yield fetch(url, Object.assign(Object.assign({}, options), { headers: Object.assign({ "Content-Type": "application/json", Authorization: `Bearer ${this.config.apiKey}` }, options === null || options === void 0 ? void 0 : options.headers) }));
+                if (!response.ok) {
+                    const errorBody = yield response.text();
+                    throw new Error(`HTTP ${response.status}: ${errorBody || response.statusText}`);
+                }
+                return response.json();
+            }
+            catch (error) {
+                if (error instanceof TypeError && error.message === "Failed to fetch") {
+                    throw new Error(`Network error: Unable to connect to Meilisearch at ${this.config.host}`);
+                }
+                throw error;
+            }
+        });
+    }
+    initializeStorage(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let indexExists = false;
+                try {
+                    // Check if index exists
+                    yield this.makeRequest(`/indexes/${roomId}`);
+                    indexExists = true;
+                }
+                catch (error) {
+                    // Only continue if the error is "Not found"
+                    if (!(error instanceof Error && error.message.includes("Not found"))) {
+                        throw error;
+                    }
+                }
+                if (!indexExists) {
+                    // Create new index
+                    yield this.makeRequest("/indexes", {
+                        method: "POST",
+                        body: JSON.stringify({
+                            uid: roomId,
+                            primaryKey: "id",
+                        }),
+                    });
+                    // Wait for index creation
+                    yield new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                // Update settings
+                yield this.makeRequest(`/indexes/${roomId}/settings`, {
+                    method: "PATCH",
+                    body: JSON.stringify({
+                        searchableAttributes: this.config.searchableAttributes || [
+                            "data",
+                            "query",
+                        ],
+                        sortableAttributes: this.config.sortableAttributes || ["createdAt"],
+                    }),
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                console.error(`Error initializing storage for index ${roomId}:`, errorMessage);
+                throw new Error(`Failed to initialize storage for index ${roomId}: ${errorMessage}`);
+            }
+        });
+    }
+    addDocuments(documents, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.makeRequest(`/indexes/${roomId}/documents`, {
+                method: "POST",
+                body: JSON.stringify(documents),
+            });
+        });
+    }
+    search(query, roomId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchResults = yield this.makeRequest(`/indexes/${roomId}/search`, {
+                method: "POST",
+                body: JSON.stringify({
+                    q: query,
+                    limit: (options === null || options === void 0 ? void 0 : options.limit) || 10,
+                }),
+            });
+            return searchResults.hits.map((hit) => ({
+                document: {
+                    id: hit.id,
+                    data: hit.data,
+                    query: hit.query,
+                    embedding: hit.embedding,
+                    roomId: hit.roomId,
+                    createdAt: hit.createdAt,
+                },
+                score: hit._score || 0,
+            }));
+        });
+    }
+    deleteStorage(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.makeRequest(`/indexes/${roomId}`, {
+                method: "DELETE",
+            });
+        });
+    }
+    // Required BaseMemory implementations
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Initialize the default "memories" index
+                yield this.initializeStorage("memories");
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                console.error("Failed to initialize default index:", errorMessage);
+                throw new Error(`Failed to initialize default index: ${errorMessage}`);
+            }
+        });
+    }
+    createMemory(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize storage for this roomId if needed
+            yield this.initializeStorage(input.roomId);
+            // Search for existing memory with same data and query
+            const searchResults = yield this.search(input.data, input.roomId, {
+                limit: 1,
+            });
+            const existingMemory = searchResults.find((result) => result.document.data === input.data &&
+                result.document.query === input.query &&
+                result.document.roomId === input.roomId);
+            // If found, return existing memory
+            if (existingMemory) {
+                return existingMemory.document;
+            }
+            // If not found, create new memory
+            const memory = {
+                id: crypto.randomUUID(),
+                data: input.data,
+                query: input.query,
+                embedding: input.embedding || null,
+                roomId: input.roomId,
+                createdAt: new Date(),
+            };
+            yield this.addDocuments([memory], input.roomId);
+            return memory;
+        });
+    }
+    getMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.makeRequest(`/indexes/${roomId}/documents/${id}`);
+                return result
+                    ? {
+                        id: result.id,
+                        data: result.data,
+                        query: result.query,
+                        embedding: result.embedding,
+                        roomId: result.roomId,
+                        createdAt: result.createdAt,
+                    }
+                    : null;
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
+    getMemoryByIndex(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.search(query, options.roomId, {
+                limit: options.limit,
+            });
+            return results
+                .filter((result) => result.document.roomId === options.roomId)
+                .map((result) => ({
+                id: result.document.id,
+                data: result.document.data,
+                query: result.document.query,
+                embedding: result.document.embedding,
+                roomId: result.document.roomId,
+                createdAt: result.document.createdAt,
+            }));
+        });
+    }
+    getAllMemories(roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield this.makeRequest(`/indexes/${roomId}/documents`);
+            return results.map((doc) => ({
+                id: doc.id,
+                data: doc.data,
+                query: doc.query,
+                embedding: doc.embedding,
+                roomId: doc.roomId,
+                createdAt: doc.createdAt,
+            }));
+        });
+    }
+    clearMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Ensure the index exists before attempting to delete
+                yield this.initializeStorage(roomId);
+                yield this.makeRequest(`/indexes/${roomId}/documents/${id}`, {
+                    method: "DELETE",
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                console.error(`Error clearing memory ${id} from index ${roomId}:`, errorMessage);
+                throw new Error(`Failed to clear memory ${id} from index ${roomId}: ${errorMessage}`);
+            }
+        });
+    }
+    clearAllMemories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Get all indexes
+                const response = yield this.makeRequest("/indexes");
+                const indexes = response.results || [];
+                // Delete each index
+                for (const index of indexes) {
+                    yield this.deleteStorage(index.uid);
+                }
+                // Reinitialize the default index
+                yield this.init();
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                throw new Error(`Failed to clear all memories: ${errorMessage}`);
+            }
+        });
+    }
+}
+exports.MeilisearchAdapter = MeilisearchAdapter;

package/dist/memory/adapters/redis/index.js

@@ -0,0 +1,96 @@
+"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.RedisAdapter = void 0;
+const redis_1 = require("redis");
+class RedisAdapter {
+    constructor(redisUrl, options) {
+        this.redisUrl = redisUrl;
+        this.cachePrefix = options.cachePrefix || "memory:";
+        this.cacheTTL = options.cacheTTL || 3600;
+        this.redis = (0, redis_1.createClient)({
+            url: redisUrl,
+            socket: {
+                tls: true,
+                rejectUnauthorized: true,
+            },
+        });
+    }
+    initializeConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.redis.on("error", (err) => console.error("Redis Client Error:", err));
+            yield this.redis.connect();
+        });
+    }
+    createMemory(memory, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = memory.roomId
+                ? `${this.cachePrefix}${memory.roomId}:${memory.id}`
+                : `${this.cachePrefix}${memory.id}`;
+            yield this.redis.set(key, JSON.stringify(memory), {
+                EX: ttl || this.cacheTTL,
+            });
+        });
+    }
+    getMemoryById(id, roomId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = roomId
+                ? `${this.cachePrefix}${roomId}:${id}`
+                : `${this.cachePrefix}${id}`;
+            const data = yield this.redis.get(key);
+            return data ? JSON.parse(data) : null;
+        });
+    }
+    getMemoryByIndex(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, options = {}) {
+            const pattern = options.roomId
+                ? `${this.cachePrefix}${options.roomId}:*`
+                : `${this.cachePrefix}*`;
+            const keys = yield this.redis.keys(pattern);
+            const memories = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
+                const data = yield this.redis.get(key);
+                return data ? JSON.parse(data) : null;
+            })));
+            return memories.filter(Boolean).slice(0, options.limit || 10);
+        });
+    }
+    getAllMemories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = yield this.redis.keys(`${this.cachePrefix}*`);
+            const memories = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
+                const data = yield this.redis.get(key);
+                return data ? JSON.parse(data) : null;
+            })));
+            return memories.filter(Boolean);
+        });
+    }
+    clearMemoryById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.del(`${this.cachePrefix}${id}`);
+        });
+    }
+    clearAllMemories() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = yield this.redis.keys(`${this.cachePrefix}*`);
+            if (keys.length > 0) {
+                yield this.redis.del(keys);
+            }
+        });
+    }
+    quit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.redis) {
+                yield this.redis.quit();
+            }
+        });
+    }
+}
+exports.RedisAdapter = RedisAdapter;

package/dist/memory/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMemory = void 0;
+class BaseMemory {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+    }
+}
+exports.BaseMemory = BaseMemory;

package/dist/services/agenda.js

@@ -0,0 +1,115 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agenda = void 0;
+const node_cron_1 = __importDefault(require("node-cron"));
+class Agenda {
+    constructor() {
+        this.scheduledRequests = new Map();
+        this.cronJobs = new Map();
+    }
+    /**
+     * Schedule a new request to be processed later
+     */
+    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
+            const cronJob = node_cron_1.default.schedule(request.cronExpression, () => {
+                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 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 === null || callbacks === void 0 ? void 0 : callbacks.onScheduled)
+                callbacks.onScheduled(id);
+            // Démarrer le job après l'avoir stocké
+            cronJob.start();
+            return id;
+        });
+    }
+    /**
+     * Cancel a scheduled request
+     */
+    cancelScheduledRequest(requestId) {
+        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() {
+        return Array.from(this.scheduledRequests.values());
+    }
+    /**
+     * Stop all cron jobs
+     */
+    stopAll() {
+        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();
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopAll();
+            yield new Promise((resolve) => setTimeout(resolve, 100));
+        });
+    }
+    cancel(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopAll();
+            yield new Promise((resolve) => setTimeout(resolve, 100));
+        });
+    }
+}
+exports.Agenda = Agenda;

package/dist/services/embedding.js

@@ -0,0 +1,40 @@
+"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.AIEmbeddingService = void 0;
+const ai_1 = require("ai");
+class AIEmbeddingService {
+    constructor(model) {
+        this.model = model;
+    }
+    embedText(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { embedding } = yield (0, ai_1.embed)({
+                model: this.model,
+                value: text,
+            });
+            return embedding;
+        });
+    }
+    embedMany(texts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { embeddings } = yield (0, ai_1.embedMany)({
+                model: this.model,
+                values: texts,
+            });
+            return embeddings;
+        });
+    }
+    calculateSimilarity(embedding1, embedding2) {
+        return ((0, ai_1.cosineSimilarity)(embedding1, embedding2) + 1) * 50;
+    }
+}
+exports.AIEmbeddingService = AIEmbeddingService;