@ai.ntellect/core 0.6.21 → 0.7.0

package/dist/graph/controller.js

@@ -1,72 +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.GraphController = void 0;
-/**
- * Controller class for managing the execution of graph flows
- * Handles both sequential and parallel execution of multiple graphs
- */
-class GraphController {
-    /**
-     * Executes multiple graphs sequentially
-     * @param graphs - Array of GraphFlow instances to execute
-     * @param startNodes - Array of starting node identifiers for each graph
-     * @param inputContexts - Optional array of initial contexts for each graph
-     * @returns Map containing results of each graph execution, keyed by graph name and index
-     * @template T - Zod schema type for graph context validation
-     */
-    static executeSequential(graphs, startNodes, inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = new Map();
-            for (let i = 0; i < graphs.length; i++) {
-                const result = yield graphs[i].execute(startNodes[i], inputs[i]);
-                results.set(`${graphs[i].name}-${i}`, result);
-            }
-            return Array.from(results.values());
-        });
-    }
-    /**
-     * Executes multiple graphs in parallel with optional concurrency control
-     * @param graphs - Array of GraphFlow instances to execute
-     * @param startNodes - Array of starting node identifiers for each graph
-     * @param inputContexts - Optional array of initial contexts for each graph
-     * @param inputs - Optional array of additional inputs for each graph
-     * @param concurrencyLimit - Optional limit on number of concurrent graph executions
-     * @returns Map containing results of each graph execution, keyed by graph name
-     * @template T - Zod schema type for graph context validation
-     */
-    static executeParallel(graphs, startNodes, concurrency, inputs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = new Map();
-            if (inputs) {
-                inputs = inputs.map((input) => input || {});
-            }
-            if (concurrency) {
-                for (let i = 0; i < graphs.length; i += concurrency) {
-                    const batchResults = yield Promise.all(graphs
-                        .slice(i, i + concurrency)
-                        .map((graph, index) => graph.execute(startNodes[i + index], inputs === null || inputs === void 0 ? void 0 : inputs[i + index])));
-                    batchResults.forEach((result, index) => {
-                        results.set(`${graphs[i + index].name}`, result);
-                    });
-                }
-            }
-            else {
-                const allResults = yield Promise.all(graphs.map((graph, index) => graph.execute(startNodes[index], (inputs === null || inputs === void 0 ? void 0 : inputs[index]) || {})));
-                allResults.forEach((result, index) => {
-                    results.set(`${graphs[index].name}`, result);
-                });
-            }
-            return Array.from(results.values());
-        });
-    }
-}
-exports.GraphController = GraphController;

package/dist/graph/index.js

@@ -1,501 +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.GraphFlow = void 0;
-const events_1 = require("events");
-/**
- * @module GraphFlow
- * @description A flexible workflow engine that manages the execution of nodes in a graph-like structure.
- *
- * Key features:
- * - Multiple branches support
- * - Conditional branching (runs first matching condition, or all if none have conditions)
- * - Event-driven nodes
- * - Zod validation of context/inputs/outputs
- * - Automatic retry on node failures
- *
- * @template T - Extends ZodSchema for type validation
- */
-class GraphFlow {
-    /**
-     * Creates a new instance of GraphFlow
-     * @param {string} name - The name of the graph flow
-     * @param {GraphDefinition<T>} config - Configuration object containing nodes, schema, context, and error handlers
-     * @param {Object} options - Optional options for the graph flow
-     */
-    constructor(name, config, options = {}) {
-        var _a;
-        this.name = name;
-        this.logs = [];
-        this.verbose = false;
-        this.nodes = new Map(config.nodes.map((node) => [node.name, node]));
-        this.validator = config.schema;
-        this.context = config.schema.parse(config.context);
-        this.globalErrorHandler = config.onError;
-        this.eventEmitter =
-            config.eventEmitter || new events_1.EventEmitter();
-        this.graphEvents = config.events;
-        this.verbose = (_a = options.verbose) !== null && _a !== void 0 ? _a : false;
-        this.setupEventListeners();
-        this.setupGraphEventListeners();
-    }
-    /**
-     * Creates a new context for execution
-     * @private
-     * @returns {GraphContext<T>} A cloned context to prevent pollution during parallel execution
-     */
-    createNewContext() {
-        return structuredClone(this.context);
-    }
-    /**
-     * Sets up event listeners for node-based events
-     * @private
-     * @description Attaches all node-based event triggers while preserving external listeners
-     */
-    setupEventListeners() {
-        // First remove only the existing node-based listeners that we might have created previously
-        // We do NOT remove, for example, "nodeStarted" or "nodeCompleted" listeners that test code added.
-        for (const [eventName, listener] of this.eventEmitter
-            .rawListeners("*")
-            .entries()) {
-            // This can be tricky—EventEmitter doesn't directly let you remove by "type" of listener.
-            // Alternatively, we can store references in a separate structure.
-            // For simplicity, let's do a full removeAllListeners() on node-specified events (only),
-            // then re-add them below, but keep the test-based events like "nodeStarted" or "nodeCompleted".
-        }
-        // The simplest approach: removeAllListeners for each event that is declared as a node event
-        // so we don't stack up duplicates:
-        const allEvents = new Set();
-        for (const node of this.nodes.values()) {
-            if (node.events) {
-                node.events.forEach((evt) => allEvents.add(evt));
-            }
-        }
-        for (const evt of allEvents) {
-            // remove only those events that are used by nodes
-            this.eventEmitter.removeAllListeners(evt);
-        }
-        // Now re-add the node-based event triggers
-        for (const node of this.nodes.values()) {
-            if (node.events && node.events.length > 0) {
-                node.events.forEach((event) => {
-                    this.eventEmitter.on(event, (data) => __awaiter(this, void 0, void 0, function* () {
-                        const freshContext = this.createNewContext();
-                        if (data)
-                            Object.assign(freshContext, data);
-                        // If triggered by an event, we pass "true" so event-driven node will skip `next`.
-                        yield this.executeNode(node.name, freshContext, undefined, 
-                        /* triggeredByEvent= */ true);
-                    }));
-                });
-            }
-        }
-    }
-    addLog(message) {
-        const logMessage = `[${new Date().toISOString()}] ${message}`;
-        this.logs.push(logMessage);
-        if (this.verbose) {
-            console.log(`[${this.name}] ${message}`);
-        }
-    }
-    /**
-     * Enable or disable verbose logging
-     * @param {boolean} enabled - Whether to enable verbose logging
-     */
-    setVerbose(enabled) {
-        this.verbose = enabled;
-    }
-    /**
-     * Get current verbose setting
-     * @returns {boolean} Current verbose setting
-     */
-    isVerbose() {
-        return this.verbose;
-    }
-    /**
-     * Executes a specific node in the graph
-     * @private
-     * @param {string} nodeName - Name of the node to execute
-     * @param {GraphContext<T>} context - Current execution context
-     * @param {any} inputs - Input parameters for the node
-     * @param {boolean} triggeredByEvent - Whether the execution was triggered by an event
-     * @returns {Promise<void>}
-     */
-    executeNode(nodeName_1, context_1, inputs_1) {
-        return __awaiter(this, arguments, void 0, function* (nodeName, context, inputs, triggeredByEvent = false) {
-            var _a;
-            const node = this.nodes.get(nodeName);
-            if (!node)
-                throw new Error(`Node "${nodeName}" not found.`);
-            this.addLog(`🚀 Starting node "${nodeName}"`);
-            this.eventEmitter.emit("nodeStarted", { name: nodeName });
-            try {
-                const localContext = structuredClone(context);
-                if (node.condition && !node.condition(localContext)) {
-                    this.addLog(`⏭️ Skipping node "${nodeName}" - condition not met`);
-                    return;
-                }
-                // Validate inputs
-                if (node.inputs) {
-                    if (!inputs) {
-                        this.addLog(`❌ Missing required inputs for node "${nodeName}"`);
-                        throw new Error(`Inputs required for node "${nodeName}"`);
-                    }
-                    this.addLog(`📥 Validating inputs for node "${nodeName}"`);
-                    inputs = node.inputs.parse(inputs);
-                }
-                // Handle retry logic
-                if (node.retry && node.retry.maxAttempts > 0) {
-                    let attempts = 0;
-                    let lastError = null;
-                    while (attempts < node.retry.maxAttempts) {
-                        try {
-                            this.addLog(`🔄 Attempt ${attempts + 1}/${node.retry.maxAttempts}`);
-                            yield node.execute(localContext, inputs);
-                            lastError = null;
-                            break;
-                        }
-                        catch (error) {
-                            lastError = error;
-                            attempts++;
-                            this.addLog(`❌ Attempt ${attempts} failed: ${error.message}`);
-                            if (attempts === node.retry.maxAttempts) {
-                                // Si toutes les tentatives ont échoué et qu'il y a un gestionnaire d'échec
-                                if (node.retry.onRetryFailed) {
-                                    this.addLog(`🔄 Executing retry failure handler for node "${nodeName}"`);
-                                    try {
-                                        yield node.retry.onRetryFailed(lastError, localContext);
-                                        // Si le gestionnaire d'échec réussit, on continue l'exécution
-                                        // SEULEMENT si le gestionnaire a explicitement retourné true
-                                        if (node.retry.continueOnFailed) {
-                                            this.addLog(`✅ Retry failure handler succeeded for node "${nodeName}" - continuing execution`);
-                                            break;
-                                        }
-                                        else {
-                                            this.addLog(`⚠️ Retry failure handler executed but node "${nodeName}" will still fail`);
-                                            throw lastError;
-                                        }
-                                    }
-                                    catch (handlerError) {
-                                        this.addLog(`❌ Retry failure handler failed for node "${nodeName}": ${handlerError.message}`);
-                                        throw handlerError;
-                                    }
-                                }
-                                // Si pas de gestionnaire d'échec ou si le gestionnaire a échoué
-                                throw lastError;
-                            }
-                            if (attempts < node.retry.maxAttempts) {
-                                this.addLog(`⏳ Waiting ${node.retry.delay}ms before next attempt`);
-                                yield new Promise((resolve) => { var _a; return setTimeout(resolve, ((_a = node.retry) === null || _a === void 0 ? void 0 : _a.delay) || 0); });
-                            }
-                        }
-                    }
-                }
-                else {
-                    yield node.execute(localContext, inputs);
-                }
-                // Validate outputs
-                if (node.outputs) {
-                    this.addLog(`📤 Validating outputs for node "${nodeName}"`);
-                    node.outputs.parse(localContext);
-                }
-                Object.assign(context, localContext);
-                this.addLog(`✅ Node "${nodeName}" executed successfully ${JSON.stringify(context)}`);
-                this.eventEmitter.emit("nodeCompleted", { name: nodeName });
-                // Handle waitForEvent
-                if (node.waitForEvent && !triggeredByEvent) {
-                    this.addLog(`⏳ Node "${nodeName}" waiting for events: ${(_a = node.events) === null || _a === void 0 ? void 0 : _a.join(", ")}`);
-                    yield new Promise((resolve) => {
-                        var _a;
-                        const eventHandler = () => {
-                            this.addLog(`🚀 Event received for node "${nodeName}"`);
-                            resolve();
-                        };
-                        (_a = node.events) === null || _a === void 0 ? void 0 : _a.forEach((event) => {
-                            this.eventEmitter.once(event, eventHandler);
-                        });
-                    });
-                    const nextNodes = typeof node.next === "function"
-                        ? node.next(context)
-                        : node.next || [];
-                    if (nextNodes.length > 0) {
-                        this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
-                        // Execute next nodes
-                        for (const nextNodeName of nextNodes) {
-                            this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
-                            const nextNode = this.nodes.get(nextNodeName);
-                            if (nextNode) {
-                                yield this.executeNode(nextNodeName, context, undefined, nextNode.waitForEvent);
-                            }
-                            this.addLog(`✅ Branch "${nextNodeName}" completed`);
-                        }
-                        this.eventEmitter.emit("graphCompleted", {
-                            name: this.name,
-                            context: this.context,
-                        });
-                        return;
-                    }
-                }
-                // Execute next nodes
-                const nextNodes = typeof node.next === "function"
-                    ? node.next(localContext)
-                    : node.next || [];
-                if (nextNodes.length > 0) {
-                    this.addLog(`➡️ Executing next nodes: ${nextNodes.join(", ")}`);
-                    // Execute next nodes
-                    for (const nextNodeName of nextNodes) {
-                        this.addLog(`🔄 Starting branch for node "${nextNodeName}"`);
-                        const nextNode = this.nodes.get(nextNodeName);
-                        if (nextNode) {
-                            yield this.executeNode(nextNodeName, context, undefined, nextNode.waitForEvent);
-                        }
-                        this.addLog(`✅ Branch "${nextNodeName}" completed`);
-                    }
-                }
-                // Mettre à jour le contexte global
-                Object.assign(this.context, context);
-            }
-            catch (error) {
-                this.addLog(`❌ Error in node "${nodeName}": ${error.message}`);
-                this.eventEmitter.emit("nodeError", { name: nodeName, error });
-                throw error;
-            }
-        });
-    }
-    /**
-     * Validates the current context against the schema
-     * @private
-     * @param {GraphContext<T>} context - Context to validate
-     * @throws {Error} If validation fails
-     */
-    validateContext(context) {
-        if (this.validator) {
-            this.validator.parse(context);
-        }
-    }
-    /**
-     * Executes the graph flow starting from a specific node
-     * @param {string} startNode - Name of the node to start execution from
-     * @param {Partial<GraphContext<T>>} inputContext - Optional partial context to merge with current context
-     * @param {any} inputParams - Optional input parameters for the start node
-     * @returns {Promise<GraphContext<T>>} Final context after execution
-     */
-    execute(startNode, inputParams, inputContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (inputParams) {
-                // Merge inputParams into context
-                Object.assign(this.context, inputParams);
-            }
-            if (inputContext) {
-                Object.assign(this.context, inputContext);
-            }
-            this.eventEmitter.emit("graphStarted", { name: this.name });
-            try {
-                yield this.executeNode(startNode, this.context, inputParams, false);
-                this.eventEmitter.emit("graphCompleted", {
-                    name: this.name,
-                    context: this.context,
-                });
-                return this.getContext();
-            }
-            catch (error) {
-                this.eventEmitter.emit("graphError", { name: this.name, error });
-                (_a = this.globalErrorHandler) === null || _a === void 0 ? void 0 : _a.call(this, error, this.context);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Emits an event to trigger event-based nodes
-     * @param {string} eventName - Name of the event to emit
-     * @param {Partial<GraphContext<T>>} data - Optional data to merge with context
-     * @returns {Promise<GraphContext<T>>} Updated context after event handling
-     */
-    emit(eventName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const workingContext = this.createNewContext();
-            if (data) {
-                Object.assign(workingContext, data);
-            }
-            const eventNodes = Array.from(this.nodes.values()).filter((node) => { var _a; return (_a = node.events) === null || _a === void 0 ? void 0 : _a.includes(eventName); });
-            // Exécuter les nœuds d'événements séquentiellement
-            for (const node of eventNodes) {
-                yield this.executeNode(node.name, workingContext, undefined, true);
-            }
-            // Mettre à jour le contexte global
-            this.context = workingContext;
-            return this.getContext();
-        });
-    }
-    /**
-     * Registers an event handler
-     * @param {string} eventName - Name of the event to listen for
-     * @param {Function} handler - Handler function to execute when event is emitted
-     */
-    on(eventName, handler) {
-        this.eventEmitter.on(eventName, handler);
-    }
-    /**
-     * Updates the graph definition with new configuration
-     * @param {GraphDefinition<T>} definition - New graph definition
-     */
-    load(definition) {
-        var _a;
-        // Clear all existing nodes
-        this.nodes.clear();
-        // Wipe out old node-based event listeners
-        // (We keep external test listeners like "nodeStarted" or "nodeCompleted".)
-        if ((_a = definition.nodes) === null || _a === void 0 ? void 0 : _a.length) {
-            const allEvents = new Set();
-            definition.nodes.forEach((n) => { var _a; return (_a = n.events) === null || _a === void 0 ? void 0 : _a.forEach((evt) => allEvents.add(evt)); });
-            for (const evt of allEvents) {
-                this.eventEmitter.removeAllListeners(evt);
-            }
-        }
-        // Add in new nodes
-        definition.nodes.forEach((node) => this.nodes.set(node.name, node));
-        // Parse the new context
-        this.context = definition.schema.parse(definition.context);
-        this.validator = definition.schema;
-        // Store entry node
-        this.entryNode = definition.entryNode;
-        // Store graph events
-        this.graphEvents = definition.events;
-        // Re-setup only node-based event triggers
-        for (const node of this.nodes.values()) {
-            if (node.events && node.events.length > 0) {
-                node.events.forEach((event) => {
-                    this.eventEmitter.on(event, (data) => __awaiter(this, void 0, void 0, function* () {
-                        const freshContext = structuredClone(this.context);
-                        if (data)
-                            Object.assign(freshContext, data);
-                        yield this.executeNode(node.name, freshContext, undefined, true);
-                    }));
-                });
-            }
-        }
-        // Re-setup graph event listeners
-        this.setupGraphEventListeners();
-    }
-    /**
-     * Gets a copy of the current context
-     * @returns {GraphContext<T>} A deep copy of the current context
-     */
-    getContext() {
-        return structuredClone(this.context);
-    }
-    /**
-     * Logs a message with optional data
-     * @param {string} message - Message to log
-     * @param {any} data - Optional data to log
-     */
-    log(message, data) {
-        console.log(`[Graph ${this.name}] ${message}`, data);
-    }
-    /**
-     * Adds a new node to the graph
-     * @param {Node<T>} node - Node to add
-     * @throws {Error} If node with same name already exists
-     */
-    addNode(node) {
-        this.nodes.set(node.name, node);
-        if (node.events && node.events.length > 0) {
-            for (const evt of node.events) {
-                this.eventEmitter.on(evt, (data) => __awaiter(this, void 0, void 0, function* () {
-                    const freshContext = this.createNewContext();
-                    if (data)
-                        Object.assign(freshContext, data);
-                    yield this.executeNode(node.name, freshContext, undefined, true);
-                }));
-            }
-        }
-    }
-    /**
-     * Removes a node from the graph
-     * @param {string} nodeName - Name of the node to remove
-     */
-    removeNode(nodeName) {
-        const node = this.nodes.get(nodeName);
-        if (!node)
-            return;
-        // remove the node from the map
-        this.nodes.delete(nodeName);
-        // remove any of its event-based listeners
-        if (node.events && node.events.length > 0) {
-            for (const evt of node.events) {
-                // removeAllListeners(evt) would also remove other node listeners,
-                // so we need a more fine-grained approach. Ideally, we should keep a reference
-                // to the exact listener function we attached. For brevity, let's remove all for that event:
-                this.eventEmitter.removeAllListeners(evt);
-            }
-            // Then reattach the others that remain in the graph
-            for (const n of this.nodes.values()) {
-                if (n.events && n.events.length > 0) {
-                    n.events.forEach((e) => {
-                        this.eventEmitter.on(e, (data) => __awaiter(this, void 0, void 0, function* () {
-                            const freshContext = this.createNewContext();
-                            if (data)
-                                Object.assign(freshContext, data);
-                            yield this.executeNode(n.name, freshContext, undefined, true);
-                        }));
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * Returns all nodes in the graph
-     * @returns {Node<T>[]} Array of all nodes
-     */
-    getNodes() {
-        return Array.from(this.nodes.values());
-    }
-    setupGraphEventListeners() {
-        if (this.graphEvents && this.graphEvents.length > 0) {
-            this.graphEvents.forEach((event) => {
-                this.eventEmitter.on(event, (data) => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const freshContext = this.createNewContext();
-                    if (data)
-                        Object.assign(freshContext, data);
-                    // Emit "graphStarted"
-                    this.eventEmitter.emit("graphStarted", { name: this.name });
-                    try {
-                        // Execute the graph starting from the entry node
-                        if (!this.entryNode) {
-                            throw new Error("No entry node defined for graph event handling");
-                        }
-                        yield this.executeNode(this.entryNode, freshContext, undefined, false);
-                        // Emit "graphCompleted"
-                        this.eventEmitter.emit("graphCompleted", {
-                            name: this.name,
-                            context: this.context,
-                        });
-                    }
-                    catch (error) {
-                        // Emit "graphError"
-                        this.eventEmitter.emit("graphError", { name: this.name, error });
-                        (_a = this.globalErrorHandler) === null || _a === void 0 ? void 0 : _a.call(this, error, freshContext);
-                        throw error;
-                    }
-                }));
-            });
-        }
-    }
-    getLogs() {
-        return [...this.logs];
-    }
-    clearLogs() {
-        this.logs = [];
-    }
-}
-exports.GraphFlow = GraphFlow;

package/dist/index.js

@@ -1,41 +0,0 @@
-"use strict";
-/**
- * @module @ai.ntellect/core
- * @description Core module with workflow functionality, providing graph management,
- * memory storage, agenda scheduling, and embedding capabilities.
- *
- * This module exports various components:
- * - Graph management and controller
- * - Memory storage adapters (Meilisearch, Redis)
- * - Agenda scheduling with node-cron adapter
- * - Embedding functionality with AI adapter
- * - Utility functions for action schema generation and header building
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./graph/controller"), exports);
-__exportStar(require("./graph/index"), exports);
-__exportStar(require("./modules/memory"), exports);
-__exportStar(require("./modules/memory/adapters/meilisearch"), exports);
-__exportStar(require("./modules/memory/adapters/redis"), exports);
-__exportStar(require("./interfaces"), exports);
-__exportStar(require("./modules/agenda"), exports);
-__exportStar(require("./modules/agenda/adapters/node-cron"), exports);
-__exportStar(require("./modules/embedding"), exports);
-__exportStar(require("./modules/embedding/adapters/ai"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils/generate-action-schema"), exports);
-__exportStar(require("./utils/header-builder"), exports);

package/dist/interfaces/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseMemory = void 0;
-/**
- * Abstract base class for memory implementations
- * @abstract
- */
-class BaseMemory {
-    /**
-     * Creates an instance of BaseMemory
-     * @param {IMemoryAdapter} adapter - Memory adapter implementation
-     */
-    constructor(adapter) {
-        this.adapter = adapter;
-    }
-}
-exports.BaseMemory = BaseMemory;

package/dist/modules/agenda/adapters/node-cron/index.js

@@ -1,29 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeCronAdapter = void 0;
-const node_cron_1 = __importDefault(require("node-cron"));
-/**
- * @module NodeCronAdapter
- * @description Adapter implementation for node-cron service.
- * Provides a bridge between the application's scheduling interface and the node-cron library.
- * @implements {ICronService}
- */
-class NodeCronAdapter {
-    /**
-     * Schedules a new cron job
-     * @param {string} expression - Cron expression defining the schedule
-     * @param {Function} callback - Function to be executed when the schedule triggers
-     * @returns {ICronJob} Interface for controlling the scheduled job
-     */
-    schedule(expression, callback) {
-        const job = node_cron_1.default.schedule(expression, callback);
-        return {
-            start: () => job.start(),
-            stop: () => job.stop(),
-        };
-    }
-}
-exports.NodeCronAdapter = NodeCronAdapter;