@kangthink/q-engine/dist/engine/QEngine.js

A question-answer generation engine that stimulates thinking

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.QEngine = void 0;
const types_1 = require("../types");
const PromptManager_1 = require("../prompts/PromptManager");
const transforms_1 = require("../transforms");
class QEngine {
    constructor(config) {
        this.transforms = new Map();
        this.nodes = new Map();
        this.edges = new Map();
        this.llmProvider = config.llmProvider;
        this.promptManager = new PromptManager_1.PromptManager(config.promptsDirectory);
        // Initialize transforms
        this.initializeTransforms();
    }
    initializeTransforms() {
        this.transforms.set(types_1.TransformMode.FIVE_W_ONE_H, new transforms_1.FiveWOneHTransform(this.llmProvider, this.promptManager));
        this.transforms.set(types_1.TransformMode.SOCRATIC, new transforms_1.SocraticTransform(this.llmProvider, this.promptManager));
        this.transforms.set(types_1.TransformMode.MATRIX, new transforms_1.MatrixTransform(this.llmProvider, this.promptManager));
        this.transforms.set(types_1.TransformMode.SCIENTIFIC, new transforms_1.ScientificTransform(this.llmProvider, this.promptManager));
        this.transforms.set(types_1.TransformMode.ANSWER, new transforms_1.AnswerTransform(this.llmProvider, this.promptManager));
    }
    async initialize() {
        // Load prompts from directory if available
        await this.promptManager.loadFromDirectory();
    }
    async transform(sourceNode, mode, options) {
        const transform = this.transforms.get(mode);
        if (!transform) {
            throw new Error(`Transform mode not supported: ${mode}`);
        }
        const context = {
            sourceNode,
            mode,
            options,
        };
        const result = await transform.transform(context);
        // Store nodes and edges
        this.nodes.set(sourceNode.id, sourceNode);
        this.nodes.set(result.targetNode.id, result.targetNode);
        this.edges.set(result.edge.id, result.edge);
        return result;
    }
    async transformMultiple(sourceNode, mode, options) {
        const transform = this.transforms.get(mode);
        if (!transform) {
            throw new Error(`Transform mode not supported: ${mode}`);
        }
        if (!transform.transformMultiple) {
            throw new Error(`Multiple transform not supported for mode: ${mode}`);
        }
        const context = {
            sourceNode,
            mode,
            options,
        };
        const result = await transform.transformMultiple(context);
        // Store nodes and edges
        this.nodes.set(sourceNode.id, sourceNode);
        result.targetNodes.forEach(node => {
            this.nodes.set(node.id, node);
        });
        result.edges.forEach(edge => {
            this.edges.set(edge.id, edge);
        });
        return result;
    }
    async transformChain(sourceNode, modes, options) {
        const results = [];
        let currentNode = sourceNode;
        for (let i = 0; i < modes.length; i++) {
            const mode = modes[i];
            const modeOptions = options?.[i] || {};
            const result = await this.transform(currentNode, mode, modeOptions);
            results.push(result);
            currentNode = result.targetNode;
        }
        return results;
    }
    getNode(id) {
        return this.nodes.get(id);
    }
    getEdge(id) {
        return this.edges.get(id);
    }
    getAllNodes() {
        return Array.from(this.nodes.values());
    }
    getAllEdges() {
        return Array.from(this.edges.values());
    }
    getNodesByType(type) {
        return this.getAllNodes().filter(node => node.type === type);
    }
    getEdgesByTransform(transform) {
        return this.getAllEdges().filter(edge => edge.transform === transform);
    }
    getConnectedNodes(nodeId) {
        const incoming = [];
        const outgoing = [];
        for (const edge of this.edges.values()) {
            if (edge.to === nodeId) {
                const fromNode = this.nodes.get(edge.from);
                if (fromNode)
                    incoming.push(fromNode);
            }
            if (edge.from === nodeId) {
                const toNode = this.nodes.get(edge.to);
                if (toNode)
                    outgoing.push(toNode);
            }
        }
        return { incoming, outgoing };
    }
    exportGraph() {
        return {
            nodes: this.getAllNodes(),
            edges: this.getAllEdges(),
        };
    }
    importGraph(data) {
        // Clear existing data
        this.nodes.clear();
        this.edges.clear();
        // Import nodes
        for (const node of data.nodes) {
            this.nodes.set(node.id, node);
        }
        // Import edges
        for (const edge of data.edges) {
            this.edges.set(edge.id, edge);
        }
    }
}
exports.QEngine = QEngine;
//# sourceMappingURL=QEngine.js.map