ai-knowledge/src/index.js

ai-knowledge

const KnowledgeBase = require('./knowledgeBase');
const loaderQueue = require('./loaders/queueManager');

class Knowledge {
    /**
     * 添加AI知识
     * @param {object} params 参数对象
     * @param {string} params.name 知识库名称
     * @param {object} [params.files] 文件相关配置
     * @param {string[]} [params.files.paths] 文件路径列表
     * @param {string[]} [params.files.directories] 文件夹路径列表
     * @param {string[]} [params.urls] URL列表
     * @param {string} [params.text] 文本内容
     * @param {boolean} [params.forceReload=false] 是否强制重新加载
     * @returns {Promise<object>} 返回添加结果
     */
    static async add(params) {
        const {
            name,
            files = { paths: [], directories: [] },
            urls = [],
            text,
            forceReload = false
        } = params;

        try {
            // 获取或创建知识库实例
            const kb = await KnowledgeBase.getInstance(name);
            const tasks = [];
            // 处理文件
            if (files.paths && files.paths.length > 0) {
                for (const filePath of files.paths) {
                    const result = await kb.addFile(filePath, forceReload);
                    tasks.push({ type: 'file', source: filePath, taskId: result.taskId });
                }
            }

            // 处理目录
            if (files.directories && files.directories.length > 0) {
                for (const dirPath of files.directories) {
                    const result = await kb.addDirectory(dirPath, { forceReload });
                    tasks.push({ type: 'directory', source: dirPath, taskId: result.taskId });
                }
            }

            // 处理URL
            if (urls.length > 0) {
                for (const url of urls) {
                    const result = await kb.addUrl(url, forceReload);
                    tasks.push({ type: 'url', source: url, taskId: result.taskId });
                }
            }

            // 处理文本
            if (text) {
                const result = await kb.addText(text, forceReload);
                tasks.push({
                    type: 'text',
                    source: '直接输入文本',
                    taskId: result.taskId
                });
            }

            return {
                success: true,
                name,
                tasks
            };
        } catch (error) {
            console.error('Error adding AI knowledge:', error);
            return {
                success: false,
                name,
                error: error.message
            };
        }
    }

    /**
     * 查询知识库
     * @param {object} params 查询参数
     * @param {string} params.name 知识库名称
     * @param {string} params.query 查询内容
     * @returns {Promise<object>} 查询结果
     */
    static async query(params) {
        const { name, query } = params;
        try {
            // 先检查知识库是否存在
            if (!KnowledgeBase.exists(name)) {
                return {
                    success: false,
                    name,
                    error: `Knowledge base '${name}' does not exist`
                };
            }
            const kb = await KnowledgeBase.getInstance(name);
            const searchResult = await kb.search(query);
            return {
                success: true,
                name,
                results: searchResult.results
            };
        } catch (error) {
            console.error('Error querying knowledge base:', error);
            return {
                success: false,
                name,
                error: error.message
            };
        }
    }

    /**
     * 获取任务状态
     * @param {string} taskId 任务ID
     */
    static async getTaskStatus(taskId) {
        return await loaderQueue.getTaskStatus(taskId);
    }
}

module.exports = Knowledge;