@measureoneinc/savant 1.0.0

package/dist/services/knowledge.service.js

@@ -0,0 +1,784 @@
+"use strict";
+/**
+ * @fileoverview Knowledge Service - Sequelize Version
+ *
+ * Service for managing Knowledge entities.
+ * Handles all database operations using Sequelize.
+ *
+ * @author MeasureOne, Inc.
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeService = void 0;
+const logger_1 = require("../lib/utils/logger");
+const sequelize_service_1 = require("../lib/sequelize-service");
+const models_1 = require("../models");
+const sequelize_1 = require("sequelize");
+const uuid_1 = require("uuid");
+const stable_stringify_1 = require("../lib/stable-stringify");
+const source_hash_1 = require("../lib/source-hash");
+const config_1 = require("../config");
+const logger = (0, logger_1.create_default_logger)("knowledge-service");
+class KnowledgeService {
+    constructor() {
+        this.sequelize = (0, sequelize_service_1.get_sequelize_service)();
+    }
+    // ============================================================================
+    // KNOWLEDGE OPERATIONS
+    // ============================================================================
+    /**
+     * Get the next revision number for a knowledge
+     *
+     * @param knowledge_id - ID of the knowledge
+     * @returns Promise resolving to the next revision number
+     */
+    async get_next_revision_number(knowledge_id) {
+        const max_revision = await models_1.KnowledgeRevisionModel.max("revision", {
+            where: { knowledge_id },
+        });
+        return (typeof max_revision === "number" ? max_revision : 0) + 1;
+    }
+    /**
+     * Create a new revision for existing knowledge
+     * Shared method used by both SEED and LEARNING embedding creation
+     *
+     * @param knowledge_id - ID of the knowledge
+     * @param source_data - Source data object (will be stringified)
+     * @param source_hash - Hash of the source data
+     * @param metadata - Optional metadata object (will be stringified)
+     * @param transaction - Optional transaction (if not provided, creates a new one)
+     * @returns Promise resolving to the new revision ID
+     */
+    async create_revision_for_knowledge(knowledge_id, source_data, source_hash, metadata, transaction) {
+        const should_commit = !transaction;
+        const txn = transaction || await this.sequelize.transaction();
+        try {
+            // Get the knowledge to verify it exists
+            const knowledge = await models_1.KnowledgeModel.findByPk(knowledge_id, { transaction: txn });
+            if (!knowledge) {
+                throw new Error(`Knowledge ${knowledge_id} not found`);
+            }
+            // Get the next revision number
+            const next_revision = await this.get_next_revision_number(knowledge_id);
+            // Create new revision
+            const new_revision_id = `kn_rev_${(0, uuid_1.v4)()}`;
+            const revision_data = {
+                id: new_revision_id,
+                knowledge_id: knowledge_id,
+                revision: next_revision,
+                source_data: typeof source_data === 'string' ? source_data : (0, stable_stringify_1.stable_stringify)(source_data),
+                source_hash: source_hash,
+                metadata: metadata ? (typeof metadata === 'string' ? metadata : JSON.stringify(metadata)) : undefined,
+            };
+            await models_1.KnowledgeRevisionModel.create(revision_data, { transaction: txn });
+            // Update knowledge's current_revision_id
+            knowledge.current_revision_id = new_revision_id;
+            await knowledge.save({ transaction: txn });
+            if (should_commit) {
+                await txn.commit();
+            }
+            logger.info("Created new revision for knowledge", {
+                knowledge_id,
+                revision_id: new_revision_id,
+                revision_number: next_revision
+            });
+            return new_revision_id;
+        }
+        catch (error) {
+            if (should_commit) {
+                await txn.rollback();
+            }
+            logger.error("Failed to create revision for knowledge", {
+                knowledge_id,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create new knowledge with LEARNING metadata
+     * Shared method used by both embedding.service and execution-learner
+     *
+     * @param learning_text - The learning text content
+     * @returns Promise resolving to knowledge ID and revision ID
+     */
+    async create_learning_knowledge(learning_text) {
+        const app_id = config_1.config_utils.get("APPLICATION_ID") || "savant-orchestration";
+        const requester_id = config_1.config_utils.get("REQUESTER_ID") || "execution-learner";
+        // Create new knowledge with 1st revision
+        const knowledge_result = await this.create_knowledge({
+            application_id: app_id,
+            requester_id: requester_id,
+            source_data: {
+                source_type: 'VALUE',
+                mime_type: 'text/markdown',
+                content: learning_text
+            },
+            status: 'COMPLETED',
+            delivery_details: {},
+            metadata: {
+                purpose: 'learned-patterns',
+                auto_generated: 'true',
+                created_by: 'execution-learner',
+                type: 'LEARNING'
+            }
+        });
+        // Get the created knowledge with revision
+        const knowledge_model = await models_1.KnowledgeModel.findByPk(knowledge_result.id);
+        if (!knowledge_model?.current_revision_id) {
+            throw new Error(`No revision found for newly created knowledge ${knowledge_result.id}`);
+        }
+        logger.info("Created new knowledge with first revision for learning", {
+            knowledge_id: knowledge_result.id,
+            revision_id: knowledge_model.current_revision_id
+        });
+        return {
+            knowledge_id: knowledge_result.id,
+            revision_id: knowledge_model.current_revision_id
+        };
+    }
+    /**
+     * Get the current revision for a knowledge
+     *
+     * @param knowledge_id - ID of the knowledge
+     * @returns Promise resolving to the current revision or null if not found
+     */
+    async get_current_revision(knowledge_id) {
+        const knowledge = await models_1.KnowledgeModel.findByPk(knowledge_id);
+        if (!knowledge || !knowledge.current_revision_id) {
+            return null;
+        }
+        const revision = await models_1.KnowledgeRevisionModel.findByPk(knowledge.current_revision_id);
+        return revision ? revision.to_shared_type() : null;
+    }
+    /**
+     * Create a new knowledge with initial revision
+     */
+    async create_knowledge(data) {
+        const transaction = await this.sequelize.transaction();
+        try {
+            const knowledge_id = `kn_${(0, uuid_1.v4)()}`;
+            // Validate that source_data is either VALUE or REFERENCE type
+            if (!data.source_data || typeof data.source_data !== 'object') {
+                throw new Error("source_data must be an object.");
+            }
+            if (data.source_data.source_type === 'VALUE') {
+                if (typeof data.source_data.content !== 'string') {
+                    throw new Error("source_data with VALUE type must have a content string.");
+                }
+            }
+            else if (data.source_data.source_type === 'REFERENCE') {
+                if (typeof data.source_data.uri !== 'string') {
+                    throw new Error("source_data with REFERENCE type must have a uri string.");
+                }
+            }
+            else {
+                throw new Error("source_data.source_type must be either 'VALUE' or 'REFERENCE'.");
+            }
+            // Create stable hash for the source data
+            const stable_json = (0, stable_stringify_1.stable_stringify)(data.source_data);
+            const source_hash = (0, source_hash_1.compute_source_hash)(stable_json);
+            const current_revision_id = `kn_rev_${(0, uuid_1.v4)()}`;
+            // Create a proper Knowledge object for from_shared_type
+            // from_shared_type expects a Knowledge with all required schema fields
+            const knowledge_for_model = {
+                id: knowledge_id,
+                application_id: data.application_id,
+                requester_id: data.requester_id,
+                source_data: data.source_data,
+                status: data.status,
+                delivery_details: data.delivery_details,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                ...(data.response && { response: data.response }),
+                ...(data.metadata && { metadata: data.metadata }),
+                ...(data.deleted_at && { deleted_at: data.deleted_at }),
+            };
+            // Convert to model attributes using from_shared_type
+            // from_shared_type always returns required fields, so we can safely use it
+            const knowledge_data = models_1.KnowledgeModel.from_shared_type(knowledge_for_model);
+            // Create Knowledge WITHOUT current_revision_id first (to avoid foreign key constraint violation)
+            // We'll set it after creating the revision
+            const knowledge = await models_1.KnowledgeModel.create(knowledge_data, { transaction });
+            // Create the first revision (revision 1)
+            const revision_data = {
+                id: current_revision_id,
+                knowledge_id: knowledge_id,
+                revision: 1,
+                source_data: stable_json,
+                source_hash: source_hash,
+                metadata: data.metadata ? JSON.stringify(data.metadata) : undefined,
+            };
+            await models_1.KnowledgeRevisionModel.create(revision_data, { transaction });
+            // Now update Knowledge to set current_revision_id (revision exists now)
+            knowledge.current_revision_id = current_revision_id;
+            await knowledge.save({ transaction });
+            await transaction.commit();
+            logger.info("Knowledge created with initial revision", {
+                id: knowledge.id,
+                revision: 1,
+                source_hash: source_hash,
+            });
+            return { id: knowledge.id };
+        }
+        catch (error) {
+            await transaction.rollback();
+            logger.error("Failed to create knowledge", error);
+            throw error;
+        }
+    }
+    /**
+     * Get knowledge by ID
+     */
+    async get_knowledge_by_id(id) {
+        try {
+            const knowledge = await models_1.KnowledgeModel.findByPk(id, {
+                paranoid: true, // Exclude soft-deleted records
+            });
+            if (!knowledge) {
+                throw new Error(`Knowledge not found: ${id}`);
+            }
+            logger.info("Knowledge retrieved", { id });
+            return knowledge.to_shared_type();
+        }
+        catch (error) {
+            logger.error("Failed to get knowledge", error);
+            throw error;
+        }
+    }
+    /**
+     * Update knowledge
+     *
+     * Updates a knowledge and creates a new revision if the source_data
+     * has changed (indicated by a different source_hash). If the source_hash
+     * remains the same, the existing revision is kept.
+     */
+    async update_knowledge(data) {
+        const transaction = await this.sequelize.transaction();
+        try {
+            const knowledge = await models_1.KnowledgeModel.findByPk(data.id);
+            if (!knowledge) {
+                throw new Error(`Knowledge not found: ${data.id}`);
+            }
+            let new_revision_id = null;
+            // Handle source_data changes
+            if (data.source_data) {
+                new_revision_id = await this.handle_source_data_update(data, knowledge, transaction);
+            }
+            // Update other fields
+            this.update_knowledge_fields(knowledge, data);
+            // Update current_revision_id if a new revision was created
+            if (new_revision_id) {
+                knowledge.current_revision_id = new_revision_id;
+            }
+            await knowledge.save({ transaction });
+            await transaction.commit();
+            logger.info("Knowledge updated", {
+                id: data.id,
+                new_revision_created: !!new_revision_id,
+                revision_id: new_revision_id || knowledge.current_revision_id,
+            });
+            return { id: knowledge.id };
+        }
+        catch (error) {
+            await transaction.rollback();
+            logger.error("Failed to update knowledge", error);
+            throw error;
+        }
+    }
+    /**
+     * Handle source data update and revision creation
+     */
+    async handle_source_data_update(data, knowledge, transaction) {
+        // Validate source_data type inline
+        if (!data.source_data || typeof data.source_data !== 'object' ||
+            (data.source_data.source_type !== 'VALUE' && data.source_data.source_type !== 'REFERENCE')) {
+            throw new Error("source_data must be either VALUE or REFERENCE type.");
+        }
+        // Create stable hash for the new source data
+        const stable_json = (0, stable_stringify_1.stable_stringify)(data.source_data);
+        const new_source_hash = (0, source_hash_1.compute_source_hash)(stable_json);
+        // Check if source_hash has changed
+        const current_revision = await models_1.KnowledgeRevisionModel.findOne({
+            where: { id: knowledge.current_revision_id },
+        });
+        if (!current_revision) {
+            throw new Error(`Current revision not found: ${knowledge.current_revision_id}`);
+        }
+        // If source hash hasn't changed, no new revision needed
+        if (current_revision.source_hash === new_source_hash) {
+            knowledge.source_data = stable_json;
+            return null;
+        }
+        // Source data has changed, create new revision
+        const next_revision_number = await this.get_next_revision_number(data.id);
+        const new_revision_id = `kn_rev_${(0, uuid_1.v4)()}`;
+        const revision_data = {
+            id: new_revision_id,
+            knowledge_id: data.id,
+            revision: next_revision_number,
+            source_data: stable_json,
+            source_hash: new_source_hash,
+            metadata: data.metadata ? JSON.stringify(data.metadata) : undefined,
+        };
+        await models_1.KnowledgeRevisionModel.create(revision_data, { transaction });
+        logger.info("New revision created due to source_data change", {
+            knowledge_id: data.id, revision: next_revision_number,
+            old_source_hash: current_revision.source_hash, new_source_hash: new_source_hash,
+        });
+        // Update the source_data field
+        knowledge.source_data = stable_json;
+        return new_revision_id;
+    }
+    /**
+     * Update knowledge fields (excluding source_data)
+     */
+    update_knowledge_fields(knowledge, data) {
+        if (data.application_id)
+            knowledge.application_id = data.application_id;
+        if (data.requester_id)
+            knowledge.requester_id = data.requester_id;
+        if (data.status)
+            knowledge.status = data.status;
+        if (data.response !== undefined)
+            knowledge.response = data.response;
+        if (data.delivery_details)
+            knowledge.delivery_details = JSON.stringify(data.delivery_details);
+        if (data.metadata !== undefined) {
+            knowledge.metadata = data.metadata ? JSON.stringify(data.metadata) : undefined;
+        }
+    }
+    /**
+     * Delete knowledge (soft delete)
+     */
+    async delete_knowledge(id) {
+        try {
+            const knowledge = await models_1.KnowledgeModel.findByPk(id);
+            if (!knowledge) {
+                throw new Error(`Knowledge not found: ${id}`);
+            }
+            await knowledge.destroy(); // Sequelize handles soft delete with paranoid: true
+            logger.info("Knowledge soft deleted", { id });
+            return { id };
+        }
+        catch (error) {
+            logger.error("Failed to delete knowledge", error);
+            throw error;
+        }
+    }
+    /**
+     * List knowledge with pagination and filtering
+     */
+    async list_knowledge(filters) {
+        try {
+            const { page = 1, limit = 20, application_id, requester_id, status } = filters;
+            const offset = (page - 1) * limit;
+            const where = {};
+            if (application_id)
+                where.application_id = application_id;
+            if (requester_id)
+                where.requester_id = requester_id;
+            if (status)
+                where.status = status;
+            const { count: total, rows: knowledge_list } = await models_1.KnowledgeModel.findAndCountAll({
+                where,
+                offset,
+                limit,
+                order: [["created_at", "DESC"]],
+                paranoid: true, // Exclude soft-deleted records
+            });
+            const converted_list = knowledge_list.map((kn) => kn.to_shared_type());
+            const pagination = {
+                page,
+                limit,
+                offset,
+                total,
+                total_pages: Math.ceil(total / limit),
+                has_next: page < Math.ceil(total / limit),
+                has_prev: page > 1,
+            };
+            logger.info("Knowledge listed", {
+                count: knowledge_list.length,
+                total,
+            });
+            return { data: converted_list, pagination };
+        }
+        catch (error) {
+            logger.error("Failed to list knowledge", error);
+            throw error;
+        }
+    }
+    /**
+     * Get knowledge by application ID
+     */
+    async get_knowledge_by_application(application_id, filters) {
+        try {
+            const { page = 1, limit = 20, status } = filters;
+            const offset = (page - 1) * limit;
+            const where = { application_id };
+            if (status)
+                where.status = status;
+            const { count: total, rows: knowledge_list } = await models_1.KnowledgeModel.findAndCountAll({
+                where,
+                offset,
+                limit,
+                order: [["created_at", "DESC"]],
+                paranoid: true,
+            });
+            const converted_list = knowledge_list.map((kn) => kn.to_shared_type());
+            const pagination = {
+                page,
+                limit,
+                offset,
+                total,
+                total_pages: Math.ceil(total / limit),
+                has_next: page < Math.ceil(total / limit),
+                has_prev: page > 1,
+            };
+            logger.info("Knowledge listed by application", {
+                application_id,
+                count: knowledge_list.length,
+                total,
+            });
+            return { data: converted_list, pagination };
+        }
+        catch (error) {
+            logger.error("Failed to get knowledge by application", error);
+            throw error;
+        }
+    }
+    /**
+     * Get knowledge by requester ID
+     */
+    async get_knowledge_by_requester(requester_id, filters) {
+        try {
+            const { page = 1, limit = 20, status } = filters;
+            const offset = (page - 1) * limit;
+            const where = { requester_id };
+            if (status)
+                where.status = status;
+            const { count: total, rows: knowledge_list } = await models_1.KnowledgeModel.findAndCountAll({
+                where,
+                offset,
+                limit,
+                order: [["created_at", "DESC"]],
+                paranoid: true,
+            });
+            const converted_list = knowledge_list.map((kn) => kn.to_shared_type());
+            const pagination = {
+                page,
+                limit,
+                offset,
+                total,
+                total_pages: Math.ceil(total / limit),
+                has_next: page < Math.ceil(total / limit),
+                has_prev: page > 1,
+            };
+            logger.info("Knowledge listed by requester", {
+                requester_id,
+                count: knowledge_list.length,
+                total,
+            });
+            return { data: converted_list, pagination };
+        }
+        catch (error) {
+            logger.error("Failed to get knowledge by requester", error);
+            throw error;
+        }
+    }
+    /**
+     * Update knowledge status
+     */
+    async update_knowledge_status(id, status, response) {
+        try {
+            const knowledge = await models_1.KnowledgeModel.findByPk(id);
+            if (!knowledge) {
+                throw new Error(`Knowledge not found: ${id}`);
+            }
+            knowledge.status = status;
+            if (response !== undefined) {
+                knowledge.response = response;
+            }
+            await knowledge.save();
+            logger.info("Knowledge status updated", { id, status });
+            return { id };
+        }
+        catch (error) {
+            logger.error("Failed to update knowledge status", error);
+            throw error;
+        }
+    }
+    /**
+     * Get knowledge statistics
+     */
+    async get_knowledge_stats(filters) {
+        try {
+            const where = {};
+            if (filters.application_id)
+                where.application_id = filters.application_id;
+            if (filters.requester_id)
+                where.requester_id = filters.requester_id;
+            if (filters.start_date || filters.end_date) {
+                where.created_at = {};
+                if (filters.start_date)
+                    where.created_at[sequelize_1.Op.gte] = new Date(filters.start_date);
+                if (filters.end_date)
+                    where.created_at[sequelize_1.Op.lte] = new Date(filters.end_date);
+            }
+            const { count: total } = await models_1.KnowledgeModel.findAndCountAll({
+                where,
+                paranoid: true,
+            });
+            const sequelize = this.sequelize;
+            const statusCounts = await models_1.KnowledgeModel.findAll({
+                where,
+                attributes: ["status", [sequelize.fn("COUNT", sequelize.col("id")), "count"]],
+                group: ["status"],
+                paranoid: true,
+                raw: true,
+            });
+            const by_status = statusCounts.reduce((acc, item) => {
+                acc[item.status] = parseInt(item.count);
+                return acc;
+            }, {});
+            const stats = {
+                total,
+                pending: by_status.PENDING || 0,
+                completed: by_status.COMPLETED || 0,
+                failed: by_status.FAILED || 0,
+                by_status,
+            };
+            logger.info("Knowledge stats retrieved", { total, by_status });
+            return stats;
+        }
+        catch (error) {
+            logger.error("Failed to get knowledge stats", error);
+            throw error;
+        }
+    }
+    /**
+     * Set content for knowledge (placeholder method)
+     */
+    async set_content(data) {
+        try {
+            // This is a placeholder method - implement based on your requirements
+            logger.info("Set content called", { data });
+            return {
+                success: true,
+                message: "Content set successfully",
+            };
+        }
+        catch (error) {
+            logger.error("Failed to set content", error);
+            throw error;
+        }
+    }
+    // ============================================================================
+    // KNOWLEDGE REVISION OPERATIONS
+    // ============================================================================
+    /**
+     * Update knowledge with revision tracking
+     */
+    async update_knowledge_with_revision(payload) {
+        const transaction = await this.sequelize.transaction();
+        try {
+            logger.info("Updating knowledge with revision", { knowledge_id: payload.id });
+            const knowledge = await this.load_knowledge_for_update(payload.id, transaction);
+            const revision_info = await this.handle_revision_update(payload, transaction);
+            await transaction.commit();
+            const response = this.build_update_response(payload.id, knowledge, revision_info);
+            logger.info("Knowledge updated successfully", { knowledge_id: payload.id, revision: revision_info.revision_number, reused: revision_info.reused, revision_id: revision_info.revision_id });
+            return response;
+        }
+        catch (error) {
+            await transaction.rollback();
+            logger.error("Failed to update knowledge with revision", { knowledge_id: payload.id, error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    /**
+     * Load knowledge for update
+     */
+    async load_knowledge_for_update(id, transaction) {
+        const knowledge = await models_1.KnowledgeModel.findByPk(id, { paranoid: true, transaction });
+        if (!knowledge) {
+            throw new Error(`Knowledge not found: ${id}`);
+        }
+        return knowledge;
+    }
+    /**
+     * Handle revision update logic
+     */
+    async handle_revision_update(payload, transaction) {
+        let revision_number = 1;
+        let reused = false;
+        let source_hash = "";
+        let revision_id = "";
+        if (!payload.source_data) {
+            return { revision_number, reused, source_hash, revision_id };
+        }
+        // Validate and compute hash - only VALUE sources are supported
+        if (!payload.source_data || typeof payload.source_data !== 'object' || payload.source_data.source_type !== 'VALUE') {
+            throw new Error("Only VALUE sources are supported at this time.");
+        }
+        if (typeof payload.source_data.content !== 'string') {
+            throw new Error("source_data with VALUE type must have a content string.");
+        }
+        const stable_json = (0, stable_stringify_1.stable_stringify)(payload.source_data);
+        source_hash = (0, source_hash_1.compute_source_hash)(stable_json);
+        // Check for existing revision
+        const existing_revision = await models_1.KnowledgeRevisionModel.findOne({
+            where: { knowledge_id: payload.id, source_hash },
+            transaction,
+        });
+        if (existing_revision) {
+            revision_number = existing_revision.to_shared_type().revision;
+            revision_id = existing_revision.id;
+            reused = true;
+            logger.info("Reusing existing revision", {
+                knowledge_id: payload.id,
+                revision: revision_number,
+                revision_id,
+                source_hash,
+            });
+        }
+        if (!existing_revision) {
+            // Create new revision using shared method
+            revision_id = await this.create_revision_for_knowledge(payload.id, stable_json, source_hash, undefined, transaction);
+            // Get the created revision to get revision number
+            const created_revision = await models_1.KnowledgeRevisionModel.findByPk(revision_id, { transaction });
+            revision_number = created_revision ? created_revision.revision : 1;
+            logger.info("Created new revision", {
+                knowledge_id: payload.id,
+                revision: revision_number,
+                revision_id,
+                source_hash,
+            });
+        }
+        const knowledge = await models_1.KnowledgeModel.findByPk(payload.id, { transaction });
+        // Update knowledge source_data (current_revision_id already updated by create_revision_for_knowledge)
+        knowledge.source_data = stable_json;
+        await knowledge.save({ transaction });
+        return { revision_number, reused, source_hash, revision_id };
+    }
+    /**
+     * Build update response
+     */
+    build_update_response(id, knowledge, revision_info) {
+        return {
+            id,
+            revision_number: revision_info.revision_number,
+            reused: revision_info.reused,
+            source_hash: revision_info.source_hash,
+            revision_id: revision_info.revision_id,
+            status: knowledge.status,
+            updated_at: knowledge.updated_at.toISOString(),
+        };
+    }
+    /**
+     * Validate update knowledge request data
+     * Checks that knowledge_id exists in DB and is not associated with LEARNING embeddings
+     * Returns validation result with error message if validation fails
+     */
+    async validate_update_knowledge_data(data) {
+        logger.info('🔍 Validating update knowledge data', {
+            knowledge_id: data.knowledge_id
+        });
+        // Validate that knowledge_id exists in DB
+        const knowledge = await models_1.KnowledgeModel.findByPk(data.knowledge_id, { paranoid: true });
+        if (!knowledge) {
+            logger.warn('❌ Knowledge not found', { knowledge_id: data.knowledge_id });
+            return {
+                isValid: false,
+                errorMessage: `Knowledge not found: ${data.knowledge_id}`,
+                errorDetails: { knowledge_id: data.knowledge_id, field: 'id' }
+            };
+        }
+        // Check if knowledge has LEARNING embeddings - these cannot be updated
+        const learning_embeddings_count = await models_1.EmbeddingModel.count({
+            where: {
+                knowledge_id: data.knowledge_id,
+                type: models_1.EmbeddingType.LEARNING
+            }
+        });
+        if (learning_embeddings_count > 0) {
+            logger.warn('❌ Cannot update knowledge with LEARNING embeddings', {
+                knowledge_id: data.knowledge_id,
+                learning_embeddings_count
+            });
+            return {
+                isValid: false,
+                errorMessage: `Knowledge cannot be updated: it is associated with ${learning_embeddings_count} LEARNING embedding(s). Learning knowledge is read-only and managed automatically by the execution learner.`,
+                errorDetails: {
+                    knowledge_id: data.knowledge_id,
+                    learning_embeddings_count,
+                    reason: 'LEARNING_EMBEDDINGS_EXIST'
+                }
+            };
+        }
+        return { isValid: true };
+    }
+    /**
+     * Get knowledge revision
+     */
+    async get_knowledge_revision(payload) {
+        try {
+            logger.info("Getting knowledge revision", { knowledge_id: payload.knowledge_id, revision: payload.revision });
+            let where_clause = {
+                knowledge_id: payload.knowledge_id,
+            };
+            if (payload.revision !== undefined) {
+                where_clause.revision = payload.revision;
+            }
+            const revision = await models_1.KnowledgeRevisionModel.findOne({ where: where_clause, order: payload.revision === undefined ? [["revision", "DESC"]] : undefined });
+            if (!revision) {
+                const error_msg = payload.revision !== undefined
+                    ? `Revision ${payload.revision} not found for knowledge ${payload.knowledge_id}`
+                    : `No revisions found for knowledge ${payload.knowledge_id}`;
+                throw new Error(error_msg);
+            }
+            logger.info("Knowledge revision retrieved", { knowledge_id: payload.knowledge_id, revision: revision.revision });
+            return revision.to_shared_type();
+        }
+        catch (error) {
+            logger.error("Failed to get knowledge revision", { knowledge_id: payload.knowledge_id, revision: payload.revision, error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    /**
+     * Get knowledge by ID with latest revision info
+     */
+    async get_knowledge_by_id_with_revision(id) {
+        try {
+            const knowledge = await models_1.KnowledgeModel.findByPk(id, {
+                paranoid: true,
+                include: [
+                    {
+                        model: models_1.KnowledgeRevisionModel,
+                        as: "revisions",
+                        limit: 1,
+                        order: [["revision", "DESC"]],
+                        attributes: ["id", "revision"],
+                    },
+                ],
+            });
+            if (!knowledge) {
+                throw new Error(`Knowledge not found: ${id}`);
+            }
+            const result = knowledge.to_shared_type();
+            // Add latest revision ID if available
+            const revisions = knowledge.revisions;
+            if (revisions && revisions.length > 0) {
+                result.latest_revision_id = revisions[0].id;
+            }
+            logger.info("Knowledge with revision info retrieved", { id });
+            return result;
+        }
+        catch (error) {
+            logger.error("Failed to get knowledge with revision info", error);
+            throw error;
+        }
+    }
+}
+exports.KnowledgeService = KnowledgeService;
+//# sourceMappingURL=knowledge.service.js.map