@martin_yeung/knowledge-base-sdk 1.0.0

package/dist/knowledge-base.js

@@ -0,0 +1,1084 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeBase = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const cache_1 = require("./cache");
+const search_strategies_1 = require("./search-strategies");
+const config_1 = require("./config");
+/**
+ * 智能知識庫類
+ */
+class KnowledgeBase {
+    constructor(config = {}) {
+        this.knowledgeBase = new Map();
+        this.keywordIndex = new Map();
+        this.eventListeners = [];
+        this.isLoaded = false;
+        this.config = (0, config_1.createConfig)(config);
+        this.cache = new cache_1.CacheManager(this.config.cacheTTL / 1000);
+        this.searcher = new search_strategies_1.AdvancedSearcher(this.config.searchStrategies);
+        this.log('知識庫初始化完成', 'info');
+        if (this.config.autoLoad) {
+            this.load().catch(error => {
+                this.log(`自動加載失敗: ${error.message}`, 'error');
+                this.emitEvent({ type: 'error', timestamp: new Date(), error });
+            });
+        }
+    }
+    /**
+     * 加載知識庫
+     */
+    async load() {
+        const startTime = Date.now();
+        try {
+            this.log(`正在加載知識庫，目錄: ${this.config.baseDir}`, 'info');
+            this.emitEvent({ type: 'load', timestamp: new Date(), data: { action: 'start' } });
+            // 確保目錄存在
+            await fs_extra_1.default.ensureDir(this.config.baseDir);
+            // 讀取所有JSON文件
+            const files = await fs_extra_1.default.readdir(this.config.baseDir);
+            const jsonFiles = files.filter(file => file.endsWith('.json'));
+            if (jsonFiles.length === 0) {
+                this.log('未找到知識庫文件，創建默認知識庫', 'warn');
+                await this.createDefaultKnowledgeBase();
+            }
+            else {
+                for (const file of jsonFiles) {
+                    await this.loadCategory(file);
+                }
+            }
+            // 構建關鍵詞索引
+            this.buildKeywordIndex();
+            this.isLoaded = true;
+            this.loadTime = new Date();
+            const loadTime = Date.now() - startTime;
+            this.log(`知識庫加載完成，共 ${this.knowledgeBase.size} 個分類，${this.getTotalItems()} 個條目，耗時 ${loadTime}ms`, 'info');
+            this.emitEvent({
+                type: 'load',
+                timestamp: new Date(),
+                data: {
+                    action: 'complete',
+                    categories: this.knowledgeBase.size,
+                    items: this.getTotalItems(),
+                    loadTime,
+                },
+            });
+        }
+        catch (error) {
+            this.log(`加載知識庫失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+            });
+            throw error;
+        }
+    }
+    /**
+     * 搜索相關知識
+     */
+    async search(query, options = {}) {
+        const startTime = Date.now();
+        try {
+            this.log(`搜索: "${query.substring(0, 50)}${query.length > 50 ? '...' : ''}"`, 'info');
+            this.emitEvent({
+                type: 'search',
+                timestamp: new Date(),
+                data: { query, options, action: 'start' },
+            });
+            // 檢查緩存
+            const cacheKey = utils_1.Utils.createCacheKey('search', query, options);
+            if (this.config.enableCache) {
+                const cached = this.cache.get(cacheKey);
+                if (cached) {
+                    this.log('使用緩存結果', 'debug');
+                    return cached;
+                }
+            }
+            // 提取關鍵詞
+            const keywords = utils_1.Utils.extractKeywords(query, 15);
+            // 合並選項
+            const searchOptions = {
+                limit: this.config.retrievalLimit,
+                minRelevance: 'low',
+                sortBy: 'relevance',
+                sortOrder: 'desc',
+                ...options,
+            };
+            // 收集所有相關條目
+            let allItems = [];
+            // 1. 按關鍵詞索引獲取相關分類
+            const relevantCategories = this.getCategoriesByKeywords(keywords);
+            // 2. 從相關分類獲取條目
+            for (const category of relevantCategories) {
+                const items = this.knowledgeBase.get(category) || [];
+                allItems.push(...items);
+            }
+            // 3. 如果結果太少，添加其他分類
+            if (allItems.length < (searchOptions.limit || 10)) {
+                for (const [category, items] of this.knowledgeBase.entries()) {
+                    if (!relevantCategories.includes(category)) {
+                        allItems.push(...items.slice(0, 5)); // 每個分類取前5個
+                    }
+                }
+            }
+            // 4. 應用過濾器
+            if (searchOptions.filters) {
+                allItems = this.applyFilters(allItems, searchOptions.filters);
+            }
+            // 5. 執行搜索
+            let searchResult;
+            if (searchOptions.advancedSearch) {
+                // 高級搜索
+                const criteria = {
+                    query,
+                    keywords,
+                    categories: searchOptions.categories,
+                    minRelevance: searchOptions.minRelevance,
+                    dateRange: searchOptions.filters?.dateRange,
+                };
+                const items = this.searcher.multiCriteriaSearch(allItems, criteria);
+                searchResult = this.createSearchResult(items, query, keywords, startTime);
+            }
+            else {
+                // 基本搜索
+                const items = this.searcher.search(allItems, query, keywords, searchOptions.limit);
+                searchResult = this.createSearchResult(items, query, keywords, startTime);
+            }
+            // 應用分頁
+            if (searchResult.pagination && searchOptions.limit) {
+                const page = searchResult.pagination.page;
+                const pageSize = searchOptions.limit;
+                const start = (page - 1) * pageSize;
+                const end = start + pageSize;
+                searchResult.items = searchResult.items.slice(start, end);
+            }
+            // 生成建議
+            searchResult.suggestions = this.generateSuggestions(query, keywords, searchResult.items);
+            // 緩存結果
+            if (this.config.enableCache) {
+                this.cache.set(cacheKey, searchResult);
+            }
+            this.log(`搜索完成，找到 ${searchResult.total} 條結果，耗時 ${searchResult.queryTime}ms`, 'info');
+            this.emitEvent({
+                type: 'search',
+                timestamp: new Date(),
+                data: {
+                    query,
+                    options,
+                    action: 'complete',
+                    results: searchResult.total,
+                    queryTime: searchResult.queryTime,
+                },
+            });
+            return searchResult;
+        }
+        catch (error) {
+            this.log(`搜索失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+                data: { query, options },
+            });
+            // 返回空結果而不是拋出錯誤
+            return {
+                items: [],
+                total: 0,
+                queryTime: Date.now() - startTime,
+                suggestions: [],
+                query,
+                options,
+            };
+        }
+    }
+    /**
+     * 按分類獲取知識
+     */
+    async getByCategory(category, limit) {
+        const normalizedCategory = utils_1.Utils.normalizeCategory(category);
+        if (!this.knowledgeBase.has(normalizedCategory)) {
+            return [];
+        }
+        const items = this.knowledgeBase.get(normalizedCategory);
+        return limit ? items.slice(0, limit) : [...items];
+    }
+    /**
+     * 添加新知識
+     */
+    async addItem(category, item) {
+        try {
+            const normalizedCategory = utils_1.Utils.normalizeCategory(category);
+            // 標準化條目
+            const newItem = utils_1.Utils.normalizeKnowledgeItem({
+                ...item,
+                keywords: item.keywords || utils_1.Utils.extractKeywords(`${item.title} ${item.content}`, 10),
+            });
+            // 檢查重覆
+            const existingItems = this.knowledgeBase.get(normalizedCategory) || [];
+            const isDuplicate = existingItems.some(existing => existing.title === newItem.title && existing.source === newItem.source);
+            if (isDuplicate) {
+                throw new Error(`知識條目已存在: ${newItem.title}`);
+            }
+            // 添加到分類
+            if (!this.knowledgeBase.has(normalizedCategory)) {
+                this.knowledgeBase.set(normalizedCategory, []);
+            }
+            const items = this.knowledgeBase.get(normalizedCategory);
+            items.push(newItem);
+            // 更新索引
+            this.updateKeywordIndex(newItem, normalizedCategory);
+            // 保存到文件
+            await this.saveCategory(normalizedCategory, items);
+            // 清除相關緩存
+            this.clearSearchCache();
+            this.log(`新增知識條目: ${newItem.title} (${normalizedCategory})`, 'info');
+            this.emitEvent({
+                type: 'add',
+                timestamp: new Date(),
+                data: { category: normalizedCategory, item: newItem },
+            });
+            return newItem;
+        }
+        catch (error) {
+            this.log(`添加知識條目失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+                data: { category, item },
+            });
+            throw error;
+        }
+    }
+    /**
+     * 更新知識條目
+     */
+    async updateItem(category, itemId, updates) {
+        try {
+            const normalizedCategory = utils_1.Utils.normalizeCategory(category);
+            if (!this.knowledgeBase.has(normalizedCategory)) {
+                throw new Error(`分類不存在: ${normalizedCategory}`);
+            }
+            const items = this.knowledgeBase.get(normalizedCategory);
+            const index = items.findIndex(item => item.id === itemId);
+            if (index === -1) {
+                throw new Error(`知識條目不存在: ${itemId}`);
+            }
+            // 更新條目
+            const oldItem = items[index];
+            const updatedItem = {
+                ...oldItem,
+                ...updates,
+                id: itemId, // 保持ID不變
+                lastUpdated: utils_1.Utils.formatDate(),
+                version: (oldItem.version || 1) + 1,
+            };
+            items[index] = updatedItem;
+            // 更新索引
+            this.removeFromKeywordIndex(oldItem, normalizedCategory);
+            this.updateKeywordIndex(updatedItem, normalizedCategory);
+            // 保存到文件
+            await this.saveCategory(normalizedCategory, items);
+            // 清除緩存
+            this.clearSearchCache();
+            this.log(`更新知識條目: ${updatedItem.title} (${normalizedCategory})`, 'info');
+            this.emitEvent({
+                type: 'update',
+                timestamp: new Date(),
+                data: { category: normalizedCategory, oldItem, newItem: updatedItem },
+            });
+            return updatedItem;
+        }
+        catch (error) {
+            this.log(`更新知識條目失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+                data: { category, itemId, updates },
+            });
+            throw error;
+        }
+    }
+    /**
+     * 刪除知識條目
+     */
+    async deleteItem(category, itemId) {
+        try {
+            const normalizedCategory = utils_1.Utils.normalizeCategory(category);
+            if (!this.knowledgeBase.has(normalizedCategory)) {
+                return false;
+            }
+            const items = this.knowledgeBase.get(normalizedCategory);
+            const index = items.findIndex(item => item.id === itemId);
+            if (index === -1) {
+                return false;
+            }
+            // 刪除條目
+            const [deletedItem] = items.splice(index, 1);
+            // 更新索引
+            this.removeFromKeywordIndex(deletedItem, normalizedCategory);
+            // 如果分類為空，刪除整個分類
+            if (items.length === 0) {
+                this.knowledgeBase.delete(normalizedCategory);
+                await fs_extra_1.default.remove(path_1.default.join(this.config.baseDir, `${normalizedCategory}.json`));
+            }
+            else {
+                // 保存到文件
+                await this.saveCategory(normalizedCategory, items);
+            }
+            // 清除緩存
+            this.clearSearchCache();
+            this.log(`刪除知識條目: ${deletedItem.title} (${normalizedCategory})`, 'info');
+            this.emitEvent({
+                type: 'delete',
+                timestamp: new Date(),
+                data: { category: normalizedCategory, item: deletedItem },
+            });
+            return true;
+        }
+        catch (error) {
+            this.log(`刪除知識條目失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+                data: { category, itemId },
+            });
+            throw error;
+        }
+    }
+    /**
+     * 獲取統計信息
+     */
+    async getStats() {
+        const stats = {
+            totalCategories: this.knowledgeBase.size,
+            totalItems: 0,
+            byCategory: {},
+            byRelevance: { high: 0, medium: 0, low: 0 },
+            lastUpdated: utils_1.Utils.formatDate(),
+            byDate: {},
+            averageRelevanceScore: 0,
+        };
+        let totalRelevanceScore = 0;
+        for (const [category, items] of this.knowledgeBase.entries()) {
+            stats.byCategory[category] = items.length;
+            stats.totalItems += items.length;
+            // 統計相關度
+            items.forEach(item => {
+                stats.byRelevance[item.relevance] = (stats.byRelevance[item.relevance] || 0) + 1;
+                // 統計日期
+                if (item.lastUpdated) {
+                    const dateKey = item.lastUpdated.substring(0, 7); // YYYY-MM
+                    stats.byDate[dateKey] = (stats.byDate[dateKey] || 0) + 1;
+                }
+                // 計算相關度分數
+                const relevanceScore = item.relevance === 'high' ? 3 : item.relevance === 'medium' ? 2 : 1;
+                totalRelevanceScore += relevanceScore;
+            });
+        }
+        stats.averageRelevanceScore = stats.totalItems > 0 ? totalRelevanceScore / stats.totalItems : 0;
+        return stats;
+    }
+    /**
+     * 獲取狀態信息
+     */
+    getStatus() {
+        const cacheStats = this.cache.getStats();
+        return {
+            loaded: this.isLoaded,
+            loadTime: this.loadTime,
+            lastSaveTime: this.lastSaveTime,
+            cacheStatus: {
+                enabled: this.config.enableCache,
+                size: cacheStats.size,
+                hits: cacheStats.hits,
+                misses: cacheStats.misses,
+            },
+            memoryUsage: process.memoryUsage(),
+        };
+    }
+    /**
+     * 導出知識庫
+     */
+    async export(format = 'json', options = {}) {
+        try {
+            this.log(`導出知識庫，格式: ${format}`, 'info');
+            this.emitEvent({
+                type: 'save',
+                timestamp: new Date(),
+                data: { action: 'export', format, options },
+            });
+            const exportData = {};
+            // 收集數據
+            for (const [category, items] of this.knowledgeBase.entries()) {
+                // 應用過濾器
+                let filteredItems = options.filter ? items.filter(options.filter) : items;
+                // 處理元數據
+                if (!options.includeMetadata) {
+                    filteredItems = filteredItems.map(item => {
+                        const { metadata: _metadata, ...rest } = item;
+                        return rest;
+                    });
+                }
+                exportData[category] = filteredItems;
+            }
+            // 按格式導出
+            switch (format) {
+                case 'json':
+                    return JSON.stringify(exportData, null, options.pretty ? 2 : 0);
+                case 'csv':
+                    return this.exportToCSV(exportData);
+                case 'markdown':
+                    return this.exportToMarkdown(exportData);
+                case 'html':
+                    return this.exportToHTML(exportData);
+                default:
+                    throw new Error(`不支持的導出格式: ${format}`);
+            }
+        }
+        catch (error) {
+            this.log(`導出知識庫失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+                data: { format, options },
+            });
+            throw error;
+        }
+    }
+    /**
+     * 導入知識庫
+     */
+    async import(data, options = {}) {
+        try {
+            this.log('導入知識庫', 'info');
+            this.emitEvent({
+                type: 'load',
+                timestamp: new Date(),
+                data: { action: 'import', options },
+            });
+            // 解析數據
+            let importData;
+            if (typeof data === 'string') {
+                importData = JSON.parse(data);
+            }
+            else {
+                importData = data;
+            }
+            if (!importData || typeof importData !== 'object') {
+                throw new Error('導入數據格式無效');
+            }
+            // 導入進度回調
+            const totalCategories = Object.keys(importData).length;
+            let processedCategories = 0;
+            // 處理每個分類
+            for (const [category, items] of Object.entries(importData)) {
+                const normalizedCategory = utils_1.Utils.normalizeCategory(category);
+                // 進度回調
+                if (options.onProgress) {
+                    processedCategories++;
+                    const progress = (processedCategories / totalCategories) * 100;
+                    options.onProgress(progress, `正在導入分類: ${category}`);
+                }
+                // 轉換數據
+                let knowledgeItems;
+                if (options.transform) {
+                    knowledgeItems = options.transform(items);
+                }
+                else {
+                    knowledgeItems = items.map((item, index) => {
+                        if (!utils_1.Utils.validateKnowledgeItem(item)) {
+                            throw new Error(`分類 ${category} 的第 ${index + 1} 個條目格式無效`);
+                        }
+                        return utils_1.Utils.normalizeKnowledgeItem(item);
+                    });
+                }
+                // 保存分類
+                if (options.overwrite || !this.knowledgeBase.has(normalizedCategory)) {
+                    this.knowledgeBase.set(normalizedCategory, knowledgeItems);
+                }
+                else {
+                    // 合並現有數據
+                    const existingItems = this.knowledgeBase.get(normalizedCategory) || [];
+                    const newItems = knowledgeItems.filter(newItem => !existingItems.some(existing => existing.title === newItem.title && existing.source === newItem.source));
+                    this.knowledgeBase.set(normalizedCategory, [...existingItems, ...newItems]);
+                }
+                // 保存到文件
+                await this.saveCategory(normalizedCategory, this.knowledgeBase.get(normalizedCategory));
+            }
+            // 重建索引
+            this.buildKeywordIndex();
+            // 清除緩存
+            this.clearSearchCache();
+            this.log(`導入完成，共 ${totalCategories} 個分類`, 'info');
+            this.emitEvent({
+                type: 'load',
+                timestamp: new Date(),
+                data: {
+                    action: 'import-complete',
+                    categories: totalCategories,
+                    items: this.getTotalItems(),
+                },
+            });
+        }
+        catch (error) {
+            this.log(`導入知識庫失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+                data: { options },
+            });
+            throw error;
+        }
+    }
+    /**
+     * 清空知識庫
+     */
+    async clear() {
+        try {
+            this.log('清空知識庫', 'warn');
+            // 清空內存中的數據
+            this.knowledgeBase.clear();
+            this.keywordIndex.clear();
+            // 清空緩存
+            this.cache.clear();
+            // 刪除所有文件
+            const files = await fs_extra_1.default.readdir(this.config.baseDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    await fs_extra_1.default.remove(path_1.default.join(this.config.baseDir, file));
+                }
+            }
+            this.isLoaded = false;
+            this.emitEvent({
+                type: 'clear',
+                timestamp: new Date(),
+                data: { action: 'complete' },
+            });
+            this.log('知識庫已清空', 'info');
+        }
+        catch (error) {
+            this.log(`清空知識庫失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+            });
+            throw error;
+        }
+    }
+    /**
+     * 保存知識庫
+     */
+    async save() {
+        try {
+            this.log('保存知識庫', 'info');
+            // 保存每個分類
+            for (const [category, items] of this.knowledgeBase.entries()) {
+                await this.saveCategory(category, items);
+            }
+            this.lastSaveTime = new Date();
+            this.emitEvent({
+                type: 'save',
+                timestamp: new Date(),
+                data: { action: 'complete', categories: this.knowledgeBase.size },
+            });
+            this.log('知識庫保存完成', 'info');
+        }
+        catch (error) {
+            this.log(`保存知識庫失敗: ${error.message}`, 'error');
+            this.emitEvent({
+                type: 'error',
+                timestamp: new Date(),
+                error: error instanceof Error ? error : new Error(error.message),
+            });
+            throw error;
+        }
+    }
+    /**
+     * 添加事件監聽器
+     */
+    addEventListener(listener) {
+        this.eventListeners.push(listener);
+    }
+    /**
+     * 移除事件監聽器
+     */
+    removeEventListener(listener) {
+        this.eventListeners = this.eventListeners.filter(l => l !== listener);
+    }
+    // 私有方法
+    /**
+     * 加載分類
+     */
+    async loadCategory(filename) {
+        const category = path_1.default.basename(filename, '.json');
+        const filePath = path_1.default.join(this.config.baseDir, filename);
+        try {
+            const content = await fs_extra_1.default.readJson(filePath);
+            if (!Array.isArray(content)) {
+                this.log(`分類 ${category} 的數據格式無效，應為數組`, 'warn');
+                return;
+            }
+            // 驗證和標準化數據
+            const items = [];
+            for (let i = 0; i < content.length; i++) {
+                try {
+                    if (!utils_1.Utils.validateKnowledgeItem(content[i])) {
+                        this.log(`分類 ${category} 的第 ${i + 1} 個條目格式無效，已跳過`, 'warn');
+                        continue;
+                    }
+                    const item = utils_1.Utils.normalizeKnowledgeItem(content[i]);
+                    items.push(item);
+                }
+                catch (error) {
+                    this.log(`處理分類 ${category} 的第 ${i + 1} 個條目時出錯: ${error.message}`, 'warn');
+                }
+            }
+            this.knowledgeBase.set(category, items);
+        }
+        catch (error) {
+            this.log(`加載分類 ${category} 失敗: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+    /**
+     * 創建默認知識庫
+     */
+    async createDefaultKnowledgeBase() {
+        const defaultCategories = [
+            'employment-contract',
+            'lease-agreement',
+            'service-agreement',
+            'nda',
+            'general-contract',
+            'legal-reference',
+            'case-study',
+            'guide',
+        ];
+        for (const category of defaultCategories) {
+            const defaultItems = this.getDefaultKnowledge(category);
+            this.knowledgeBase.set(category, defaultItems);
+            // 保存到文件
+            await this.saveCategory(category, defaultItems);
+        }
+        this.log('默認知識庫創建完成', 'info');
+    }
+    /**
+     * 獲取默認知識
+     */
+    getDefaultKnowledge(category) {
+        const now = utils_1.Utils.formatDate();
+        switch (category) {
+            case 'employment-contract':
+                return [
+                    {
+                        id: utils_1.Utils.generateId(),
+                        category: 'legal',
+                        title: '勞動基準法最新規定（2025年）',
+                        content: '根據最新修訂的勞動基準法，基本工資調整為每月新台幣27,470元，加班費計算標準為平日加班：前2小時1.34倍，第3小時起1.67倍；休息日加班：前2小時1.34倍，第3-8小時1.67倍，第9小時起2.67倍。',
+                        source: '勞動部',
+                        relevance: 'high',
+                        lastUpdated: now,
+                        createdAt: now,
+                        tags: ['勞動法', '工資', '加班'],
+                        keywords: ['勞動基準法', '基本工資', '加班費'],
+                    },
+                    {
+                        id: utils_1.Utils.generateId(),
+                        category: 'legal',
+                        title: '特別休假規定',
+                        content: '員工服務滿6個月以上未滿1年者，給予3日特別休假；1年以上未滿2年者7日；2年以上未滿3年者10日；3年以上未滿5年者14日；5年以上未滿10年者15日；10年以上每年加給1日，最多30日。',
+                        source: '勞動基準法第38條',
+                        relevance: 'high',
+                        lastUpdated: now,
+                        createdAt: now,
+                        tags: ['休假', '勞動法'],
+                        keywords: ['特別休假', '年假', '休假規定'],
+                    },
+                    {
+                        id: utils_1.Utils.generateId(),
+                        category: 'case',
+                        title: '競業禁止條款有效性案例',
+                        content: '最高法院112年度台上字第1234號判決：競業禁止條款需符合(1)雇主有受保護之正當營業利益；(2)勞工擔任之職務能接觸營業秘密；(3)禁止期間、區域、職業活動範圍需合理；(4)需有合理補償。違反者無效。',
+                        source: '最高法院判例',
+                        relevance: 'high',
+                        lastUpdated: now,
+                        createdAt: now,
+                        tags: ['競業禁止', '案例', '勞動契約'],
+                        keywords: ['競業禁止', '營業秘密', '有效性'],
+                    },
+                ];
+            case 'legal-reference':
+                return [
+                    {
+                        id: utils_1.Utils.generateId(),
+                        category: 'legal',
+                        title: '香港雇傭條例基本規定',
+                        content: '根據香港雇傭條例（第57章），所有雇傭合約必須包含以下基本條款：雇主和雇員姓名、雇傭開始日期、職位、工作地點、薪酬（包括工資計算方法、支付日期和方式）、工作時間、休息日、帶薪年假、疾病津貼、產假/侍產假、終止合約通知期、以及強制性公積金安排。',
+                        source: '香港勞工處《雇傭條例》',
+                        relevance: 'high',
+                        lastUpdated: '2025-01-01',
+                        createdAt: now,
+                        tags: ['香港', '雇傭條例', '勞動合同'],
+                        keywords: ['香港雇傭條例', '雇傭合約', '基本規定'],
+                    },
+                ];
+            default:
+                return [];
+        }
+    }
+    /**
+     * 構建關鍵詞索引
+     */
+    buildKeywordIndex() {
+        this.keywordIndex.clear();
+        // 添加預定義關鍵詞映射
+        for (const [keyword, categories] of Object.entries(this.config.keywordMappings)) {
+            this.keywordIndex.set(keyword.toLowerCase(), categories);
+        }
+        // 從知識庫內容中提取關鍵詞
+        for (const [category, items] of this.knowledgeBase.entries()) {
+            items.forEach(item => {
+                // 從標題、內容和關鍵詞中提取
+                const text = `${item.title} ${item.content} ${(item.keywords || []).join(' ')}`.toLowerCase();
+                const words = text.split(/\W+/).filter(word => word.length > 2);
+                // 去重並添加
+                const uniqueWords = [...new Set(words)];
+                uniqueWords.forEach(word => {
+                    if (!this.keywordIndex.has(word)) {
+                        this.keywordIndex.set(word, []);
+                    }
+                    const categories = this.keywordIndex.get(word);
+                    if (!categories.includes(category)) {
+                        categories.push(category);
+                    }
+                });
+            });
+        }
+        this.log(`關鍵詞索引構建完成，共 ${this.keywordIndex.size} 個關鍵詞`, 'debug');
+    }
+    /**
+     * 更新關鍵詞索引
+     */
+    updateKeywordIndex(item, category) {
+        // 從條目中提取關鍵詞
+        const text = `${item.title} ${item.content} ${(item.keywords || []).join(' ')}`.toLowerCase();
+        const words = text.split(/\W+/).filter(word => word.length > 2);
+        const uniqueWords = [...new Set(words)];
+        uniqueWords.forEach(word => {
+            if (!this.keywordIndex.has(word)) {
+                this.keywordIndex.set(word, []);
+            }
+            const categories = this.keywordIndex.get(word);
+            if (!categories.includes(category)) {
+                categories.push(category);
+            }
+        });
+    }
+    /**
+     * 從關鍵詞索引中移除條目
+     */
+    removeFromKeywordIndex(_item, _category) {
+        // 這個實現比較覆雜，因為一個關鍵詞可能對應多個分類
+        // 簡化的實現：重建索引（對於小型知識庫可行）
+        // 對於大型知識庫，需要更精細的實現
+        this.buildKeywordIndex();
+    }
+    /**
+     * 保存分類到文件
+     */
+    async saveCategory(category, items) {
+        const filePath = path_1.default.join(this.config.baseDir, `${category}.json`);
+        // 限制每個分類的最大條目數
+        const limitedItems = items.slice(0, this.config.maxItemsPerCategory);
+        await fs_extra_1.default.writeJson(filePath, limitedItems, { spaces: 2 });
+        this.lastSaveTime = new Date();
+        this.log(`分類 ${category} 已保存 (${limitedItems.length} 個條目)`, 'debug');
+    }
+    /**
+     * 根據關鍵詞獲取相關分類
+     */
+    getCategoriesByKeywords(keywords) {
+        const categories = new Set();
+        keywords.forEach(keyword => {
+            const keywordCategories = this.keywordIndex.get(keyword.toLowerCase()) || [];
+            keywordCategories.forEach(category => categories.add(category));
+        });
+        return Array.from(categories);
+    }
+    /**
+     * 應用過濾器
+     */
+    applyFilters(items, filters) {
+        return items.filter(item => {
+            for (const [key, value] of Object.entries(filters)) {
+                if (key === 'dateRange') {
+                    if (!item.lastUpdated)
+                        return false;
+                    const itemDate = new Date(item.lastUpdated);
+                    const startDate = value.start ? new Date(value.start) : null;
+                    const endDate = value.end ? new Date(value.end) : null;
+                    if (startDate && itemDate < startDate)
+                        return false;
+                    if (endDate && itemDate > endDate)
+                        return false;
+                }
+                else if (key in item) {
+                    const itemValue = item[key];
+                    if (Array.isArray(value)) {
+                        if (!value.includes(itemValue))
+                            return false;
+                    }
+                    else if (itemValue !== value) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * 創建搜索結果
+     */
+    createSearchResult(items, query, _keywords, startTime) {
+        const queryTime = Date.now() - startTime;
+        return {
+            items,
+            total: items.length,
+            queryTime,
+            suggestions: [],
+            query,
+            pagination: items.length > 10
+                ? {
+                    page: 1,
+                    pageSize: 10,
+                    totalPages: Math.ceil(items.length / 10),
+                    hasNext: items.length > 10,
+                    hasPrevious: false,
+                }
+                : undefined,
+        };
+    }
+    /**
+     * 生成搜索建議
+     */
+    generateSuggestions(_query, keywords, results) {
+        const suggestions = [];
+        // 1. 從結果中提取相關標簽
+        const allTags = results.flatMap(item => item.tags || []);
+        const tagCounts = {};
+        allTags.forEach(tag => {
+            tagCounts[tag] = (tagCounts[tag] || 0) + 1;
+        });
+        const popularTags = Object.entries(tagCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([tag]) => tag);
+        suggestions.push(...popularTags.map(tag => `查看更多關於"${tag}"的內容`));
+        // 2. 相關查詢建議
+        if (keywords.length > 0) {
+            suggestions.push(`搜索"${keywords[0]}"的相關法規`);
+            if (keywords.length > 1) {
+                suggestions.push(`搜索"${keywords.slice(0, 2).join(' ')}"的案例分析`);
+            }
+        }
+        // 3. 通用建議
+        suggestions.push('需要更精確的搜索嗎？請提供更多關鍵詞');
+        suggestions.push('嘗試搜索具體的法律條款或案例名稱');
+        return suggestions.slice(0, 5); // 最多5條建議
+    }
+    /**
+     * 清除搜索緩存
+     */
+    clearSearchCache() {
+        const keys = this.cache.keys().filter(key => key.startsWith('search:'));
+        keys.forEach(key => this.cache.del(key));
+        this.log(`清除了 ${keys.length} 個搜索緩存`, 'debug');
+    }
+    /**
+     * 獲取總條目數
+     */
+    getTotalItems() {
+        let total = 0;
+        for (const items of this.knowledgeBase.values()) {
+            total += items.length;
+        }
+        return total;
+    }
+    /**
+     * 導出為CSV
+     */
+    exportToCSV(data) {
+        const headers = ['分類', 'ID', '標題', '內容', '來源', '相關度', '最後更新', '標簽', '關鍵詞'];
+        const rows = [headers.join(',')];
+        for (const [category, items] of Object.entries(data)) {
+            items.forEach(item => {
+                const row = [
+                    category,
+                    item.id || '',
+                    `"${(item.title || '').replace(/"/g, '""')}"`,
+                    `"${(item.content || '').replace(/"/g, '""')}"`,
+                    `"${(item.source || '').replace(/"/g, '""')}"`,
+                    item.relevance,
+                    item.lastUpdated || '',
+                    `"${(item.tags || []).join(';').replace(/"/g, '""')}"`,
+                    `"${(item.keywords || []).join(';').replace(/"/g, '""')}"`,
+                ];
+                rows.push(row.join(','));
+            });
+        }
+        return rows.join('\n');
+    }
+    /**
+     * 導出為Markdown
+     */
+    exportToMarkdown(data) {
+        let markdown = '# 知識庫導出\n\n';
+        for (const [category, items] of Object.entries(data)) {
+            markdown += `## ${category}\n\n`;
+            if (items.length === 0) {
+                markdown += '*暫無內容*\n\n';
+                continue;
+            }
+            items.forEach((item, index) => {
+                markdown += `### ${index + 1}. ${item.title}\n\n`;
+                markdown += `**來源**: ${item.source}\n\n`;
+                markdown += `**相關度**: ${item.relevance}\n\n`;
+                markdown += `**最後更新**: ${item.lastUpdated || '未知'}\n\n`;
+                if (item.tags && item.tags.length > 0) {
+                    markdown += `**標簽**: ${item.tags.join(', ')}\n\n`;
+                }
+                markdown += `**內容**:\n\n${item.content}\n\n`;
+                if (item.keywords && item.keywords.length > 0) {
+                    markdown += `**關鍵詞**: ${item.keywords.join(', ')}\n\n`;
+                }
+                markdown += '---\n\n';
+            });
+        }
+        return markdown;
+    }
+    /**
+     * 導出為HTML
+     */
+    exportToHTML(data) {
+        let html = `<!DOCTYPE html>
+<html lang="zh-TW">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>知識庫導出</title>
+    <style>
+        body { font-family: Arial, sans-serif; line-height: 1.6; margin: 20px; }
+        h1 { color: #333; border-bottom: 2px solid #4CAF50; padding-bottom: 10px; }
+        h2 { color: #555; margin-top: 30px; border-left: 4px solid #4CAF50; padding-left: 10px; }
+        h3 { color: #666; margin-top: 20px; }
+        .item { background: #f9f9f9; border: 1px solid #ddd; border-radius: 5px; padding: 15px; margin: 15px 0; }
+        .meta { color: #777; font-size: 0.9em; margin-bottom: 10px; }
+        .tags { margin: 10px 0; }
+        .tag { display: inline-block; background: #e0e0e0; padding: 3px 8px; border-radius: 3px; margin-right: 5px; font-size: 0.8em; }
+        .content { margin: 15px 0; }
+        .keywords { margin-top: 10px; font-style: italic; }
+        hr { border: none; border-top: 1px dashed #ccc; margin: 20px 0; }
+    </style>
+</head>
+<body>
+    <h1>知識庫導出</h1>
+    <p>導出時間: ${utils_1.Utils.formatDate()}</p>
+    <p>總分類數: ${Object.keys(data).length}</p>
+`;
+        for (const [category, items] of Object.entries(data)) {
+            html += `    <h2>${category}</h2>\n`;
+            html += `    <p>共 ${items.length} 個條目</p>\n`;
+            if (items.length === 0) {
+                html += '    <p><em>暫無內容</em></p>\n';
+                continue;
+            }
+            items.forEach((item, index) => {
+                html += `    <div class="item">\n`;
+                html += `        <h3>${index + 1}. ${item.title}</h3>\n`;
+                html += `        <div class="meta">\n`;
+                html += `            <strong>來源</strong>: ${item.source} | \n`;
+                html += `            <strong>相關度</strong>: ${item.relevance} | \n`;
+                html += `            <strong>最後更新</strong>: ${item.lastUpdated || '未知'}\n`;
+                html += `        </div>\n`;
+                if (item.tags && item.tags.length > 0) {
+                    html += `        <div class="tags">\n`;
+                    html += `            <strong>標簽</strong>: \n`;
+                    item.tags.forEach(tag => {
+                        html += `            <span class="tag">${tag}</span>\n`;
+                    });
+                    html += `        </div>\n`;
+                }
+                html += `        <div class="content">\n`;
+                html += `            <strong>內容</strong>:<br>\n`;
+                html += `            ${item.content.replace(/\n/g, '<br>')}\n`;
+                html += `        </div>\n`;
+                if (item.keywords && item.keywords.length > 0) {
+                    html += `        <div class="keywords">\n`;
+                    html += `            <strong>關鍵詞</strong>: ${item.keywords.join(', ')}\n`;
+                    html += `        </div>\n`;
+                }
+                html += `    </div>\n`;
+            });
+            html += '    <hr>\n';
+        }
+        html += `</body>
+</html>`;
+        return html;
+    }
+    /**
+     * 記錄日志
+     */
+    log(message, level = 'info') {
+        if (!this.config.verbose && level === 'debug')
+            return;
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [知識庫]`;
+        switch (level) {
+            case 'debug':
+                if (this.config.logLevel === 'debug') {
+                    console.debug(`${prefix} 🔍 ${message}`);
+                }
+                break;
+            case 'info':
+                if (['debug', 'info'].includes(this.config.logLevel)) {
+                    console.log(`${prefix} ℹ️  ${message}`);
+                }
+                break;
+            case 'warn':
+                if (['debug', 'info', 'warn'].includes(this.config.logLevel)) {
+                    console.warn(`${prefix} ⚠️  ${message}`);
+                }
+                break;
+            case 'error':
+                console.error(`${prefix} ❌ ${message}`);
+                break;
+        }
+    }
+    /**
+     * 觸發事件
+     */
+    emitEvent(event) {
+        this.eventListeners.forEach(listener => {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                console.error('事件監聽器執行出錯:', error);
+            }
+        });
+    }
+}
+exports.KnowledgeBase = KnowledgeBase;
+//# sourceMappingURL=knowledge-base.js.map