From 125d3e5e4a44def1203419e2f54e781796db8ba4 Mon Sep 17 00:00:00 2001 From: wizardchen Date: Mon, 9 Mar 2026 13:14:42 +0800 Subject: [PATCH] feat: implement knowledge move functionality - Added API endpoints for moving knowledge items between knowledge bases, including validation for source and target compatibility. - Implemented asynchronous task handling for knowledge moves, tracking progress and status updates. - Introduced new localization strings for move-related UI elements in English, Korean, Russian, and Chinese. - Enhanced the frontend to support knowledge move operations, including target selection and progress monitoring. These changes significantly improve the application's capabilities for managing knowledge across different bases, providing users with a seamless experience in organizing their knowledge assets. --- frontend/src/api/knowledge-base/index.ts | 20 ++ frontend/src/i18n/locales/en-US.ts | 16 + frontend/src/i18n/locales/ko-KR.ts | 16 + frontend/src/i18n/locales/ru-RU.ts | 16 + frontend/src/i18n/locales/zh-CN.ts | 16 + .../src/views/knowledge/KnowledgeBase.vue | 301 +++++++++++++++- internal/application/repository/chunk.go | 7 + internal/application/service/knowledge.go | 330 +++++++++++++++++- internal/handler/knowledge.go | 190 ++++++++++ internal/handler/knowledgebase.go | 63 ++++ internal/router/router.go | 6 + internal/router/sync_task.go | 1 + internal/router/task.go | 3 + internal/types/extract_graph.go | 27 ++ internal/types/interfaces/chunk.go | 2 + internal/types/interfaces/knowledge.go | 6 + 16 files changed, 1015 insertions(+), 5 deletions(-) diff --git a/frontend/src/api/knowledge-base/index.ts b/frontend/src/api/knowledge-base/index.ts index d270b8a0..b3d26809 100644 --- a/frontend/src/api/knowledge-base/index.ts +++ b/frontend/src/api/knowledge-base/index.ts @@ -45,6 +45,26 @@ export function copyKnowledgeBase(data: { source_id: string; target_id?: string return post(`/api/v1/knowledge-bases/copy`, data); } +// 获取可移动目标知识库列表(同类型、同Embedding模型) +export function listMoveTargets(sourceKbId: string) { + return get(`/api/v1/knowledge-bases/${sourceKbId}/move-targets`); +} + +// 移动知识到其他知识库 +export function moveKnowledge(data: { + knowledge_ids: string[]; + source_kb_id: string; + target_kb_id: string; + mode: 'reuse_vectors' | 'reparse'; +}) { + return post('/api/v1/knowledge/move', data); +} + +// 获取知识移动进度 +export function getKnowledgeMoveProgress(taskId: string) { + return get(`/api/v1/knowledge/move/progress/${taskId}`); +} + export function togglePinKnowledgeBase(id: string) { return put(`/api/v1/knowledge-bases/${id}/pin`); } diff --git a/frontend/src/i18n/locales/en-US.ts b/frontend/src/i18n/locales/en-US.ts index 5af9772f..fdb9b313 100755 --- a/frontend/src/i18n/locales/en-US.ts +++ b/frontend/src/i18n/locales/en-US.ts @@ -200,6 +200,22 @@ export default { draftTip: 'Temporarily saved and not included in retrieval', untitledDocument: 'Untitled Document', deleteDocument: 'Delete Document', + moveDocument: 'Move to...', + moveToKnowledgeBase: 'Move to Knowledge Base', + moveSelectTarget: 'Select target knowledge base', + moveNoTargets: 'No compatible knowledge bases found (same type and embedding model required)', + moveMode: 'Move Mode', + moveModeReuseVectors: 'Reuse Vectors (Fast)', + moveModeReuseVectorsDesc: 'Directly move chunks and vector indices. Use when chunking config is the same.', + moveModeReparse: 'Re-parse', + moveModeReparseDesc: "Re-parse documents using the target knowledge base's chunking config.", + moveConfirm: 'Confirm Move', + moveConfirmTitle: 'Confirm move settings', + moveStarted: 'Move task submitted', + moveFailed: 'Move failed', + moveCompleted: 'Move completed', + moveCompletedWithErrors: 'Move completed: {success} succeeded, {failed} failed', + moveProgress: 'Moving...', parsingFailed: 'Parsing failed', parsingInProgress: 'Parsing...', generatingSummary: 'Generating summary...', diff --git a/frontend/src/i18n/locales/ko-KR.ts b/frontend/src/i18n/locales/ko-KR.ts index f6fb4af0..811605e4 100755 --- a/frontend/src/i18n/locales/ko-KR.ts +++ b/frontend/src/i18n/locales/ko-KR.ts @@ -203,6 +203,22 @@ export default { draftTip: "임시 저장된 내용, 검색에 포함되지 않음", untitledDocument: "제목 없는 문서", deleteDocument: "문서 삭제", + moveDocument: "이동...", + moveToKnowledgeBase: "지식베이스로 이동", + moveSelectTarget: "대상 지식베이스 선택", + moveNoTargets: "호환되는 지식베이스가 없습니다 (동일한 유형과 임베딩 모델 필요)", + moveMode: "이동 모드", + moveModeReuseVectors: "벡터 재사용 (빠름)", + moveModeReuseVectorsDesc: "청크와 벡터 인덱스를 직접 이동합니다. 청킹 설정이 동일할 때 사용합니다.", + moveModeReparse: "재해석", + moveModeReparseDesc: "대상 지식베이스의 청킹 설정으로 문서를 다시 해석합니다.", + moveConfirm: "이동 확인", + moveConfirmTitle: "이동 설정 확인", + moveStarted: "이동 작업이 제출되었습니다", + moveFailed: "이동 실패", + moveCompleted: "이동 완료", + moveCompletedWithErrors: "이동 완료: {success}개 성공, {failed}개 실패", + moveProgress: "이동 중...", parsingFailed: "파싱 실패", parsingInProgress: "파싱 중...", generatingSummary: "요약 생성 중...", diff --git a/frontend/src/i18n/locales/ru-RU.ts b/frontend/src/i18n/locales/ru-RU.ts index f2a9b58d..88123f04 100755 --- a/frontend/src/i18n/locales/ru-RU.ts +++ b/frontend/src/i18n/locales/ru-RU.ts @@ -172,6 +172,22 @@ export default { draftTip: 'Временно сохранён, не участвует в поиске', untitledDocument: 'Документ без названия', deleteDocument: 'Удалить документ', + moveDocument: 'Переместить в...', + moveToKnowledgeBase: 'Переместить в базу знаний', + moveSelectTarget: 'Выберите целевую базу знаний', + moveNoTargets: 'Совместимые базы знаний не найдены (требуется одинаковый тип и модель эмбеддинга)', + moveMode: 'Режим перемещения', + moveModeReuseVectors: 'Повторное использование векторов (быстро)', + moveModeReuseVectorsDesc: 'Прямое перемещение чанков и векторных индексов. Используйте при одинаковой конфигурации разбиения.', + moveModeReparse: 'Повторный парсинг', + moveModeReparseDesc: 'Повторный парсинг документов с конфигурацией разбиения целевой базы знаний.', + moveConfirm: 'Подтвердить перемещение', + moveConfirmTitle: 'Подтвердите настройки перемещения', + moveStarted: 'Задача перемещения отправлена', + moveFailed: 'Перемещение не удалось', + moveCompleted: 'Перемещение завершено', + moveCompletedWithErrors: 'Перемещение завершено: {success} успешно, {failed} не удалось', + moveProgress: 'Перемещение...', parsingFailed: 'Парсинг не удался', parsingInProgress: 'Парсинг...', generatingSummary: 'Генерация резюме...', diff --git a/frontend/src/i18n/locales/zh-CN.ts b/frontend/src/i18n/locales/zh-CN.ts index 7be3a591..846d0c7e 100755 --- a/frontend/src/i18n/locales/zh-CN.ts +++ b/frontend/src/i18n/locales/zh-CN.ts @@ -200,6 +200,22 @@ export default { draftTip: "暂存内容,未参与检索", untitledDocument: "未命名文档", deleteDocument: "删除文档", + moveDocument: "移动到...", + moveToKnowledgeBase: "移动到知识库", + moveSelectTarget: "选择目标知识库", + moveNoTargets: "没有兼容的目标知识库(需要相同类型和 Embedding 模型)", + moveMode: "移动模式", + moveModeReuseVectors: "复用向量(快速)", + moveModeReuseVectorsDesc: "直接移动分块和向量索引,适用于分片配置相同的情况", + moveModeReparse: "重新解析", + moveModeReparseDesc: "使用目标知识库的分片配置重新解析文档", + moveConfirm: "确认移动", + moveConfirmTitle: "确认移动设置", + moveStarted: "移动任务已提交", + moveFailed: "移动失败", + moveCompleted: "移动完成", + moveCompletedWithErrors: "移动完成:{success} 成功,{failed} 失败", + moveProgress: "正在移动...", parsingFailed: "解析失败", parsingInProgress: "解析中...", generatingSummary: "生成摘要中...", diff --git a/frontend/src/views/knowledge/KnowledgeBase.vue b/frontend/src/views/knowledge/KnowledgeBase.vue index 01dbfc7f..494365fc 100644 --- a/frontend/src/views/knowledge/KnowledgeBase.vue +++ b/frontend/src/views/knowledge/KnowledgeBase.vue @@ -30,6 +30,7 @@ import { reparseKnowledge, } from "@/api/knowledge-base/index"; import FAQEntryManager from './components/FAQEntryManager.vue'; +import { listMoveTargets, moveKnowledge, getKnowledgeMoveProgress } from '@/api/knowledge-base'; import { useI18n } from 'vue-i18n'; import { formatStringDate, kbFileTypeVerification } from '@/utils'; import { getParserEngines, type ParserEngineInfo } from '@/api/system'; @@ -151,7 +152,13 @@ const kbLastUpdated = computed(() => { }); const knowledgeList = ref>([]); -let { cardList, total, moreIndex, details, getKnowled, delKnowledge, openMore, onVisibleChange, getCardDetails, getfDetails } = useKnowledgeBase(kbId.value) +let { cardList, total, moreIndex, details, getKnowled, delKnowledge, openMore, onVisibleChange: _onVisibleChange, getCardDetails, getfDetails } = useKnowledgeBase(kbId.value) +const onVisibleChange = (visible: boolean) => { + _onVisibleChange(visible); + if (!visible) { + moveMenuMode.value = 'normal'; + } +}; let isCardDetails = ref(false); let timeout: ReturnType | null = null; let delDialog = ref(false) @@ -161,6 +168,17 @@ let knowledgeScroll = ref() let page = 1; let pageSize = 35; +// Move state — inline in card menu +const moveMenuMode = ref<'normal' | 'targets' | 'confirm'>('normal'); +const moveKnowledgeId = ref(''); +const moveTargetKbs = ref([]); +const moveTargetsLoading = ref(false); +const moveSelectedTargetId = ref(''); +const moveSelectedTargetName = ref(''); +const moveMode = ref<'reuse_vectors' | 'reparse'>('reuse_vectors'); +const moveSubmitting = ref(false); +let movePollTimer: ReturnType | null = null; + const selectedTagId = ref(''); const tagList = ref([]); const tagLoading = ref(false); @@ -659,6 +677,7 @@ onMounted(() => { onUnmounted(() => { window.removeEventListener('knowledgeFileUploaded', handleFileUploaded as EventListener); window.removeEventListener('openURLImportDialog', handleOpenURLImportDialog as EventListener); + stopMovePoll(); }); watch(() => cardList.value, (newValue) => { if (isFAQ.value) return; @@ -783,6 +802,99 @@ const delCard = (index: number, item: KnowledgeCard) => { delDialog.value = true; }; +const handleMoveKnowledge = async (item: KnowledgeCard) => { + moveKnowledgeId.value = item.id; + moveMenuMode.value = 'targets'; + moveTargetsLoading.value = true; + moveTargetKbs.value = []; + try { + const res: any = await listMoveTargets(kbId.value); + moveTargetKbs.value = res.data || []; + } catch { + moveTargetKbs.value = []; + } finally { + moveTargetsLoading.value = false; + } +}; + +const handleMoveSelectTarget = (kb: any) => { + moveSelectedTargetId.value = kb.id; + moveSelectedTargetName.value = kb.name; + moveMode.value = 'reuse_vectors'; + moveMenuMode.value = 'confirm'; +}; + +const handleMoveBack = () => { + if (moveMenuMode.value === 'confirm') { + moveMenuMode.value = 'targets'; + } else { + moveMenuMode.value = 'normal'; + } +}; + +const handleMoveConfirm = async () => { + if (!moveSelectedTargetId.value || moveSubmitting.value) return; + moveSubmitting.value = true; + try { + const res: any = await moveKnowledge({ + knowledge_ids: [moveKnowledgeId.value], + source_kb_id: kbId.value, + target_kb_id: moveSelectedTargetId.value, + mode: moveMode.value, + }); + const taskId = res.data?.task_id; + MessagePlugin.info(t('knowledgeBase.moveStarted')); + // Close the card menu + moveMenuMode.value = 'normal'; + cardList.value.forEach(c => { c.isMore = false; }); + + if (taskId) { + startMovePoll(taskId); + } else { + moveSubmitting.value = false; + loadKnowledgeFiles(kbId.value); + } + } catch (e: any) { + MessagePlugin.error(e?.message || t('knowledgeBase.moveFailed')); + moveSubmitting.value = false; + } +}; + +const startMovePoll = (taskId: string) => { + if (movePollTimer) clearInterval(movePollTimer); + movePollTimer = setInterval(async () => { + try { + const res: any = await getKnowledgeMoveProgress(taskId); + const data = res.data; + if (!data) return; + if (data.status === 'completed') { + stopMovePoll(); + moveSubmitting.value = false; + const failed = data.failed || 0; + if (failed > 0) { + MessagePlugin.warning(t('knowledgeBase.moveCompletedWithErrors', { success: (data.processed || 0) - failed, failed })); + } else { + MessagePlugin.success(t('knowledgeBase.moveCompleted')); + } + loadKnowledgeFiles(kbId.value); + } else if (data.status === 'failed') { + stopMovePoll(); + moveSubmitting.value = false; + MessagePlugin.error(t('knowledgeBase.moveFailed')); + } + } catch { + // ignore poll errors + } + }, 2000); +}; + +const stopMovePoll = () => { + if (movePollTimer) { + clearInterval(movePollTimer); + movePollTimer = null; + } +}; + const manualEditorSuccess = ({ kbId: savedKbId }: { kbId: string; knowledgeId: string; status: 'draft' | 'publish' }) => { if (savedKbId === kbId.value && !isFAQ.value) { loadKnowledgeFiles(savedKbId); @@ -1605,7 +1717,8 @@ async function createNewSession(value: string): Promise { @@ -1750,7 +1933,7 @@ async function createNewSession(value: string): Promise { - + { } .card-more .t-popup__content { - width: 180px; + min-width: 180px; + width: auto; padding: 6px 0; margin-top: 4px !important; color: var(--td-text-color-primary); @@ -2785,6 +2969,115 @@ async function createNewSession(value: string): Promise { } } +.move-menu { + min-width: 220px; + max-width: 280px; + max-height: 360px; + overflow-y: auto; + + .move-menu-header { + display: flex; + align-items: center; + gap: 6px; + padding: 8px 12px; + font-size: 13px; + font-weight: 500; + color: var(--td-text-color-primary); + border-bottom: 1px solid var(--td-component-stroke); + cursor: pointer; + + &:hover { + background: var(--td-bg-color-container-hover); + } + } + + .move-menu-loading { + display: flex; + align-items: center; + justify-content: center; + padding: 20px 0; + } + + .move-menu-empty { + padding: 12px 16px; + font-size: 12px; + color: var(--td-text-color-placeholder); + text-align: center; + line-height: 1.5; + } + + .move-target-name { + flex: 1; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + } + + .move-target-count { + font-size: 12px; + color: var(--td-text-color-placeholder); + } + + .move-confirm-body { + padding: 8px; + + .move-target-info { + display: flex; + align-items: center; + gap: 6px; + padding: 6px 8px; + background: var(--td-bg-color-container-hover); + border-radius: 6px; + font-size: 13px; + color: var(--td-text-color-secondary); + margin-bottom: 8px; + } + + .move-mode-item { + display: flex; + align-items: flex-start; + gap: 6px; + padding: 6px 8px; + border-radius: 6px; + cursor: pointer; + margin-bottom: 4px; + + &:hover { + background: var(--td-bg-color-container-hover); + } + + &.active { + background: var(--td-brand-color-light); + } + + .move-mode-text { + display: flex; + flex-direction: column; + gap: 2px; + + .move-mode-label { + font-size: 13px; + font-weight: 500; + color: var(--td-text-color-primary); + } + + .move-mode-desc { + font-size: 11px; + color: var(--td-text-color-placeholder); + line-height: 1.4; + } + } + } + + .move-confirm-actions { + display: flex; + justify-content: flex-end; + gap: 8px; + margin-top: 8px; + } + } +} + .card-draft { display: flex; align-items: center; diff --git a/internal/application/repository/chunk.go b/internal/application/repository/chunk.go index 5a6a1f9f..7e2a9b51 100644 --- a/internal/application/repository/chunk.go +++ b/internal/application/repository/chunk.go @@ -420,6 +420,13 @@ func (r *chunkRepository) DeleteByKnowledgeList(ctx context.Context, tenantID ui ).Delete(&types.Chunk{}).Error } +// MoveChunksByKnowledgeID updates knowledge_base_id for all chunks of a knowledge item +func (r *chunkRepository) MoveChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string, targetKBID string) error { + return r.db.WithContext(ctx).Model(&types.Chunk{}). + Where("tenant_id = ? AND knowledge_id = ?", tenantID, knowledgeID). + Update("knowledge_base_id", targetKBID).Error +} + // DeleteChunksByTagID deletes all chunks with the specified tag ID // Returns the IDs of deleted chunks for index cleanup func (r *chunkRepository) DeleteChunksByTagID(ctx context.Context, tenantID uint64, kbID string, tagID string, excludeIDs []string) ([]string, error) { diff --git a/internal/application/service/knowledge.go b/internal/application/service/knowledge.go index b2f42d75..36664879 100644 --- a/internal/application/service/knowledge.go +++ b/internal/application/service/knowledge.go @@ -1938,7 +1938,7 @@ func (s *knowledgeService) ProcessSummaryGeneration(ctx context.Context, t *asyn } if kb.SummaryModelID == "" { - logger.Errorf(ctx, "Knowledge base summary model ID is empty") + logger.Warn(ctx, "Knowledge base summary model ID is empty, skipping summary generation") return nil } @@ -8399,6 +8399,334 @@ func (s *knowledgeService) GetKBCloneProgress(ctx context.Context, taskID string return &progress, nil } +// ─── Knowledge Move ───────────────────────────────────────────────────────── + +const ( + knowledgeMoveProgressKeyPrefix = "knowledge_move_progress:" + knowledgeMoveProgressTTL = 24 * time.Hour +) + +func getKnowledgeMoveProgressKey(taskID string) string { + return knowledgeMoveProgressKeyPrefix + taskID +} + +func (s *knowledgeService) saveKnowledgeMoveProgress(ctx context.Context, progress *types.KnowledgeMoveProgress) error { + key := getKnowledgeMoveProgressKey(progress.TaskID) + data, err := json.Marshal(progress) + if err != nil { + return fmt.Errorf("failed to marshal move progress: %w", err) + } + return s.redisClient.Set(ctx, key, data, knowledgeMoveProgressTTL).Err() +} + +// SaveKnowledgeMoveProgress saves the knowledge move progress to Redis (public method for handler use) +func (s *knowledgeService) SaveKnowledgeMoveProgress(ctx context.Context, progress *types.KnowledgeMoveProgress) error { + return s.saveKnowledgeMoveProgress(ctx, progress) +} + +// GetKnowledgeMoveProgress retrieves the progress of a knowledge move task +func (s *knowledgeService) GetKnowledgeMoveProgress(ctx context.Context, taskID string) (*types.KnowledgeMoveProgress, error) { + key := getKnowledgeMoveProgressKey(taskID) + data, err := s.redisClient.Get(ctx, key).Bytes() + if err != nil { + if errors.Is(err, redis.Nil) { + return nil, werrors.NewNotFoundError("Knowledge move task not found") + } + return nil, fmt.Errorf("failed to get move progress from Redis: %w", err) + } + + var progress types.KnowledgeMoveProgress + if err := json.Unmarshal(data, &progress); err != nil { + return nil, fmt.Errorf("failed to unmarshal move progress: %w", err) + } + return &progress, nil +} + +// ProcessKnowledgeMove handles Asynq knowledge move tasks +func (s *knowledgeService) ProcessKnowledgeMove(ctx context.Context, t *asynq.Task) error { + var payload types.KnowledgeMovePayload + if err := json.Unmarshal(t.Payload(), &payload); err != nil { + return fmt.Errorf("failed to unmarshal knowledge move payload: %w", err) + } + + // Add tenant ID to context + ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID) + + // Get tenant info and add to context + tenantInfo, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID) + if err != nil { + logger.Errorf(ctx, "ProcessKnowledgeMove: failed to get tenant info: %v", err) + return fmt.Errorf("failed to get tenant info: %w", err) + } + ctx = context.WithValue(ctx, types.TenantInfoContextKey, tenantInfo) + + // Check if this is the last retry + retryCount, _ := asynq.GetRetryCount(ctx) + maxRetry, _ := asynq.GetMaxRetry(ctx) + isLastRetry := retryCount >= maxRetry + + logger.Infof(ctx, "ProcessKnowledgeMove: task=%s, source=%s, target=%s, mode=%s, count=%d, retry=%d/%d", + payload.TaskID, payload.SourceKBID, payload.TargetKBID, payload.Mode, len(payload.KnowledgeIDs), retryCount, maxRetry) + + // Helper function to handle errors - only mark as failed on last retry + handleError := func(progress *types.KnowledgeMoveProgress, err error, message string) { + if isLastRetry { + progress.Status = types.KBCloneStatusFailed + progress.Error = err.Error() + progress.Message = message + progress.UpdatedAt = time.Now().Unix() + _ = s.saveKnowledgeMoveProgress(ctx, progress) + } + } + + // Update progress to processing + progress := &types.KnowledgeMoveProgress{ + TaskID: payload.TaskID, + SourceKBID: payload.SourceKBID, + TargetKBID: payload.TargetKBID, + Status: types.KBCloneStatusProcessing, + Total: len(payload.KnowledgeIDs), + Progress: 0, + Message: "Starting knowledge move...", + UpdatedAt: time.Now().Unix(), + } + _ = s.saveKnowledgeMoveProgress(ctx, progress) + + // Get source and target knowledge bases + sourceKB, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.SourceKBID) + if err != nil { + handleError(progress, err, "Failed to get source knowledge base") + return err + } + targetKB, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.TargetKBID) + if err != nil { + handleError(progress, err, "Failed to get target knowledge base") + return err + } + + // Validate compatibility + if sourceKB.Type != targetKB.Type { + err := fmt.Errorf("type mismatch: source=%s, target=%s", sourceKB.Type, targetKB.Type) + handleError(progress, err, "Source and target knowledge bases must be the same type") + return err + } + if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID { + err := fmt.Errorf("embedding model mismatch: source=%s, target=%s", sourceKB.EmbeddingModelID, targetKB.EmbeddingModelID) + handleError(progress, err, "Source and target must use the same embedding model") + return err + } + + // Process each knowledge item + for i, knowledgeID := range payload.KnowledgeIDs { + err := s.moveOneKnowledge(ctx, knowledgeID, sourceKB, targetKB, payload.Mode) + if err != nil { + logger.Errorf(ctx, "ProcessKnowledgeMove: failed to move knowledge %s: %v", knowledgeID, err) + progress.Failed++ + } + progress.Processed = i + 1 + if progress.Total > 0 { + progress.Progress = progress.Processed * 100 / progress.Total + } + progress.Message = fmt.Sprintf("Moved %d/%d knowledge items", progress.Processed, progress.Total) + progress.UpdatedAt = time.Now().Unix() + _ = s.saveKnowledgeMoveProgress(ctx, progress) + } + + // Mark as completed + if progress.Failed > 0 && progress.Failed == progress.Total { + progress.Status = types.KBCloneStatusFailed + progress.Message = fmt.Sprintf("Knowledge move failed: all %d items failed", progress.Total) + } else { + progress.Status = types.KBCloneStatusCompleted + progress.Message = fmt.Sprintf("Knowledge move completed: %d/%d succeeded", progress.Processed-progress.Failed, progress.Total) + } + progress.Progress = 100 + progress.UpdatedAt = time.Now().Unix() + _ = s.saveKnowledgeMoveProgress(ctx, progress) + + logger.Infof(ctx, "ProcessKnowledgeMove: task=%s completed, processed=%d, failed=%d", payload.TaskID, progress.Processed, progress.Failed) + return nil +} + +// moveOneKnowledge moves a single knowledge item from source KB to target KB. +func (s *knowledgeService) moveOneKnowledge( + ctx context.Context, + knowledgeID string, + sourceKB, targetKB *types.KnowledgeBase, + mode string, +) error { + tenantID := ctx.Value(types.TenantIDContextKey).(uint64) + + // Get the knowledge item + knowledge, err := s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID) + if err != nil { + return fmt.Errorf("failed to get knowledge %s: %w", knowledgeID, err) + } + + // Only move completed items + if knowledge.ParseStatus != types.ParseStatusCompleted { + return fmt.Errorf("knowledge %s is not in completed status (current: %s)", knowledgeID, knowledge.ParseStatus) + } + + // Mark as processing during move + knowledge.ParseStatus = types.ParseStatusProcessing + if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil { + return fmt.Errorf("failed to mark knowledge as processing: %w", err) + } + + switch mode { + case "reuse_vectors": + return s.moveKnowledgeReuseVectors(ctx, knowledge, sourceKB, targetKB) + case "reparse": + return s.moveKnowledgeReparse(ctx, knowledge, sourceKB, targetKB) + default: + return fmt.Errorf("unknown move mode: %s", mode) + } +} + +// moveKnowledgeReuseVectors moves knowledge by copying vector indices and updating DB references. +func (s *knowledgeService) moveKnowledgeReuseVectors( + ctx context.Context, + knowledge *types.Knowledge, + sourceKB, targetKB *types.KnowledgeBase, +) error { + tenantID := ctx.Value(types.TenantIDContextKey).(uint64) + tenantInfo := ctx.Value(types.TenantInfoContextKey).(*types.Tenant) + + // 1. Get old chunk IDs for vector index copy mapping + oldChunks, err := s.chunkRepo.ListChunksByKnowledgeID(ctx, tenantID, knowledge.ID) + if err != nil { + return fmt.Errorf("failed to list chunks: %w", err) + } + + // Build identity mapping (same chunk IDs, just moving between KBs) + chunkIDMapping := make(map[string]string, len(oldChunks)) + for _, c := range oldChunks { + chunkIDMapping[c.ID] = c.ID + } + + // 2. Copy vector indices from source KB to target KB + if len(chunkIDMapping) > 0 && knowledge.EmbeddingModelID != "" { + retrieveEngine, err := retriever.NewCompositeRetrieveEngine(s.retrieveEngine, tenantInfo.GetEffectiveEngines()) + if err != nil { + return fmt.Errorf("failed to init retrieve engine: %w", err) + } + embeddingModel, err := s.modelService.GetEmbeddingModel(ctx, knowledge.EmbeddingModelID) + if err != nil { + return fmt.Errorf("failed to get embedding model: %w", err) + } + + // Copy indices from source KB to target KB + knowledgeIDMapping := map[string]string{knowledge.ID: knowledge.ID} + if err := retrieveEngine.CopyIndices(ctx, sourceKB.ID, targetKB.ID, + knowledgeIDMapping, chunkIDMapping, + embeddingModel.GetDimensions(), sourceKB.Type, + ); err != nil { + return fmt.Errorf("failed to copy indices: %w", err) + } + + // Delete indices from source KB + if err := retrieveEngine.DeleteByKnowledgeIDList(ctx, []string{knowledge.ID}, + embeddingModel.GetDimensions(), sourceKB.Type, + ); err != nil { + logger.Warnf(ctx, "moveKnowledgeReuseVectors: failed to delete old indices for knowledge %s: %v", knowledge.ID, err) + // Non-fatal: indices will be orphaned but won't affect correctness + } + } + + // 3. Update chunks' knowledge_base_id in DB + if err := s.chunkRepo.MoveChunksByKnowledgeID(ctx, tenantID, knowledge.ID, targetKB.ID); err != nil { + return fmt.Errorf("failed to move chunks: %w", err) + } + + // 4. Update knowledge record + knowledge.KnowledgeBaseID = targetKB.ID + knowledge.TagID = "" // Clear tag since tags are KB-scoped + knowledge.ParseStatus = types.ParseStatusCompleted + knowledge.UpdatedAt = time.Now() + if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil { + return fmt.Errorf("failed to update knowledge: %w", err) + } + + return nil +} + +// moveKnowledgeReparse moves knowledge to target KB and re-parses it with target KB's configuration. +func (s *knowledgeService) moveKnowledgeReparse( + ctx context.Context, + knowledge *types.Knowledge, + _, targetKB *types.KnowledgeBase, +) error { + tenantID := ctx.Value(types.TenantIDContextKey).(uint64) + + // 1. Clean up existing chunks and vector indices + if err := s.cleanupKnowledgeResources(ctx, knowledge); err != nil { + logger.Warnf(ctx, "moveKnowledgeReparse: cleanup partial error for knowledge %s: %v", knowledge.ID, err) + // Continue - partial cleanup is acceptable + } + + // 2. Update knowledge to belong to target KB + knowledge.KnowledgeBaseID = targetKB.ID + knowledge.EmbeddingModelID = targetKB.EmbeddingModelID + knowledge.TagID = "" // Clear tag since tags are KB-scoped + knowledge.ParseStatus = types.ParseStatusPending + knowledge.EnableStatus = "disabled" + knowledge.Description = "" + knowledge.ProcessedAt = nil + knowledge.UpdatedAt = time.Now() + if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil { + return fmt.Errorf("failed to update knowledge: %w", err) + } + + // 3. Enqueue document processing task with target KB's configuration + if knowledge.IsManual() { + meta, err := knowledge.ManualMetadata() + if err != nil || meta == nil { + return fmt.Errorf("failed to get manual metadata for reparse: %w", err) + } + s.triggerManualProcessing(ctx, targetKB, knowledge, meta.Content, false) + return nil + } + + if knowledge.FilePath != "" { + enableMultimodel := targetKB.IsMultimodalEnabled() + enableQuestionGeneration := false + questionCount := 3 + if targetKB.QuestionGenerationConfig != nil && targetKB.QuestionGenerationConfig.Enabled { + enableQuestionGeneration = true + if targetKB.QuestionGenerationConfig.QuestionCount > 0 { + questionCount = targetKB.QuestionGenerationConfig.QuestionCount + } + } + + taskPayload := types.DocumentProcessPayload{ + TenantID: tenantID, + KnowledgeID: knowledge.ID, + KnowledgeBaseID: targetKB.ID, + FilePath: knowledge.FilePath, + FileName: knowledge.FileName, + FileType: getFileType(knowledge.FileName), + EnableMultimodel: enableMultimodel, + EnableQuestionGeneration: enableQuestionGeneration, + QuestionCount: questionCount, + } + + payloadBytes, err := json.Marshal(taskPayload) + if err != nil { + return fmt.Errorf("failed to marshal document process payload: %w", err) + } + + task := asynq.NewTask(types.TypeDocumentProcess, payloadBytes, asynq.Queue("default"), asynq.MaxRetry(3)) + info, err := s.task.Enqueue(task) + if err != nil { + return fmt.Errorf("failed to enqueue document process task: %w", err) + } + logger.Infof(ctx, "moveKnowledgeReparse: enqueued reparse task id=%s for knowledge=%s", info.ID, knowledge.ID) + } + + return nil +} + // getOrCreateTagInTarget finds or creates a tag in the target knowledge base based on the source tag. // It looks up the source tag by ID, then tries to find a tag with the same name in the target KB. // If not found, it creates a new tag with the same properties. diff --git a/internal/handler/knowledge.go b/internal/handler/knowledge.go index c6e582b7..6c10754a 100644 --- a/internal/handler/knowledge.go +++ b/internal/handler/knowledge.go @@ -8,16 +8,20 @@ import ( "net/http" "strconv" "strings" + "time" goerrors "errors" + "github.com/Tencent/WeKnora/internal/application/repository" "github.com/Tencent/WeKnora/internal/application/service" "github.com/Tencent/WeKnora/internal/errors" "github.com/Tencent/WeKnora/internal/logger" "github.com/Tencent/WeKnora/internal/types" "github.com/Tencent/WeKnora/internal/types/interfaces" + "github.com/Tencent/WeKnora/internal/utils" secutils "github.com/Tencent/WeKnora/internal/utils" "github.com/gin-gonic/gin" + "github.com/hibiken/asynq" ) // KnowledgeHandler processes HTTP requests related to knowledge resources @@ -26,6 +30,7 @@ type KnowledgeHandler struct { kbService interfaces.KnowledgeBaseService kbShareService interfaces.KBShareService agentShareService interfaces.AgentShareService + asynqClient interfaces.TaskEnqueuer } // NewKnowledgeHandler creates a new knowledge handler instance @@ -34,12 +39,14 @@ func NewKnowledgeHandler( kbService interfaces.KnowledgeBaseService, kbShareService interfaces.KBShareService, agentShareService interfaces.AgentShareService, + asynqClient interfaces.TaskEnqueuer, ) *KnowledgeHandler { return &KnowledgeHandler{ kgService: kgService, kbService: kbService, kbShareService: kbShareService, agentShareService: agentShareService, + asynqClient: asynqClient, } } @@ -1284,3 +1291,186 @@ func (h *KnowledgeHandler) SearchKnowledge(c *gin.Context) { "has_more": hasMore, }) } + +// MoveKnowledgeRequest defines the request for moving knowledge items +type MoveKnowledgeRequest struct { + KnowledgeIDs []string `json:"knowledge_ids" binding:"required,min=1"` + SourceKBID string `json:"source_kb_id" binding:"required"` + TargetKBID string `json:"target_kb_id" binding:"required"` + Mode string `json:"mode" binding:"required,oneof=reuse_vectors reparse"` +} + +// MoveKnowledgeResponse defines the response for move knowledge +type MoveKnowledgeResponse struct { + TaskID string `json:"task_id"` + SourceKBID string `json:"source_kb_id"` + TargetKBID string `json:"target_kb_id"` + KnowledgeCount int `json:"knowledge_count"` + Message string `json:"message"` +} + +// MoveKnowledge moves knowledge items from one knowledge base to another (async task). +func (h *KnowledgeHandler) MoveKnowledge(c *gin.Context) { + ctx := c.Request.Context() + + var req MoveKnowledgeRequest + if err := c.ShouldBindJSON(&req); err != nil { + logger.Error(ctx, "MoveKnowledge: failed to parse request", err) + c.Error(errors.NewBadRequestError("Invalid request parameters: " + err.Error())) + return + } + + // Validate source != target + if req.SourceKBID == req.TargetKBID { + c.Error(errors.NewBadRequestError("Source and target knowledge base cannot be the same")) + return + } + + tenantID, exists := c.Get(types.TenantIDContextKey.String()) + if !exists { + c.Error(errors.NewUnauthorizedError("Unauthorized")) + return + } + + // Validate source KB + sourceKB, err := h.kbService.GetKnowledgeBaseByID(ctx, req.SourceKBID) + if err != nil { + if goerrors.Is(err, repository.ErrKnowledgeBaseNotFound) { + c.Error(errors.NewNotFoundError("Source knowledge base not found")) + return + } + c.Error(errors.NewInternalServerError(err.Error())) + return + } + if sourceKB.TenantID != tenantID.(uint64) { + c.Error(errors.NewForbiddenError("No permission to access source knowledge base")) + return + } + + // Validate target KB + targetKB, err := h.kbService.GetKnowledgeBaseByID(ctx, req.TargetKBID) + if err != nil { + if goerrors.Is(err, repository.ErrKnowledgeBaseNotFound) { + c.Error(errors.NewNotFoundError("Target knowledge base not found")) + return + } + c.Error(errors.NewInternalServerError(err.Error())) + return + } + if targetKB.TenantID != tenantID.(uint64) { + c.Error(errors.NewForbiddenError("No permission to access target knowledge base")) + return + } + + // Validate type match + if sourceKB.Type != targetKB.Type { + c.Error(errors.NewBadRequestError("Source and target knowledge bases must be the same type")) + return + } + + // Validate embedding model match + if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID { + c.Error(errors.NewBadRequestError("Source and target must use the same embedding model")) + return + } + + // Validate all knowledge IDs belong to source KB and are in completed status + for _, kID := range req.KnowledgeIDs { + knowledge, err := h.kgService.GetKnowledgeByID(ctx, kID) + if err != nil { + c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s not found", kID))) + return + } + if knowledge.KnowledgeBaseID != req.SourceKBID { + c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s does not belong to the source knowledge base", kID))) + return + } + if knowledge.ParseStatus != types.ParseStatusCompleted { + c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s is not in completed status (current: %s)", kID, knowledge.ParseStatus))) + return + } + } + + // Generate task ID + taskID := utils.GenerateTaskID("kg_move", tenantID.(uint64), req.SourceKBID) + + // Create move payload + payload := types.KnowledgeMovePayload{ + TenantID: tenantID.(uint64), + TaskID: taskID, + KnowledgeIDs: req.KnowledgeIDs, + SourceKBID: req.SourceKBID, + TargetKBID: req.TargetKBID, + Mode: req.Mode, + } + + payloadBytes, err := json.Marshal(payload) + if err != nil { + logger.Errorf(ctx, "MoveKnowledge: failed to marshal payload: %v", err) + c.Error(errors.NewInternalServerError("Failed to create task")) + return + } + + // Enqueue move task + task := asynq.NewTask(types.TypeKnowledgeMove, payloadBytes, + asynq.TaskID(taskID), asynq.Queue("default"), asynq.MaxRetry(3)) + info, err := h.asynqClient.Enqueue(task) + if err != nil { + logger.Errorf(ctx, "MoveKnowledge: failed to enqueue task: %v", err) + c.Error(errors.NewInternalServerError("Failed to enqueue task")) + return + } + + logger.Infof(ctx, "MoveKnowledge: task enqueued: %s, asynq_id: %s, source: %s, target: %s, count: %d", + taskID, info.ID, secutils.SanitizeForLog(req.SourceKBID), secutils.SanitizeForLog(req.TargetKBID), len(req.KnowledgeIDs)) + + // Save initial progress + initialProgress := &types.KnowledgeMoveProgress{ + TaskID: taskID, + SourceKBID: req.SourceKBID, + TargetKBID: req.TargetKBID, + Status: types.KBCloneStatusPending, + Total: len(req.KnowledgeIDs), + Progress: 0, + Message: "Task queued, waiting to start...", + CreatedAt: time.Now().Unix(), + UpdatedAt: time.Now().Unix(), + } + if err := h.kgService.SaveKnowledgeMoveProgress(ctx, initialProgress); err != nil { + logger.Warnf(ctx, "MoveKnowledge: failed to save initial progress: %v", err) + } + + c.JSON(http.StatusOK, gin.H{ + "success": true, + "data": MoveKnowledgeResponse{ + TaskID: taskID, + SourceKBID: req.SourceKBID, + TargetKBID: req.TargetKBID, + KnowledgeCount: len(req.KnowledgeIDs), + Message: "Knowledge move task started", + }, + }) +} + +// GetKnowledgeMoveProgress retrieves the progress of a knowledge move task. +func (h *KnowledgeHandler) GetKnowledgeMoveProgress(c *gin.Context) { + ctx := c.Request.Context() + + taskID := c.Param("task_id") + if taskID == "" { + c.Error(errors.NewBadRequestError("Task ID cannot be empty")) + return + } + + progress, err := h.kgService.GetKnowledgeMoveProgress(ctx, taskID) + if err != nil { + logger.ErrorWithFields(ctx, err, nil) + c.Error(err) + return + } + + c.JSON(http.StatusOK, gin.H{ + "success": true, + "data": progress, + }) +} diff --git a/internal/handler/knowledgebase.go b/internal/handler/knowledgebase.go index 80e9ef35..c06d88b1 100644 --- a/internal/handler/knowledgebase.go +++ b/internal/handler/knowledgebase.go @@ -778,3 +778,66 @@ func validateExtractConfig(config *types.ExtractConfig) error { return nil } + +// ListMoveTargets returns knowledge bases eligible as move targets for the given source KB. +// Filters: same Type, same EmbeddingModelID, different ID, not temporary. +func (h *KnowledgeBaseHandler) ListMoveTargets(c *gin.Context) { + ctx := c.Request.Context() + + sourceKBID := c.Param("id") + if sourceKBID == "" { + c.Error(apperrors.NewBadRequestError("Knowledge base ID is required")) + return + } + + tenantID, exists := c.Get(types.TenantIDContextKey.String()) + if !exists { + c.Error(apperrors.NewUnauthorizedError("Unauthorized")) + return + } + + // Get source knowledge base + sourceKB, err := h.service.GetKnowledgeBaseByID(ctx, sourceKBID) + if err != nil { + if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) { + c.Error(errors.NewNotFoundError("Source knowledge base not found")) + return + } + c.Error(errors.NewInternalServerError(err.Error())) + return + } + if sourceKB.TenantID != tenantID.(uint64) { + c.Error(errors.NewForbiddenError("No permission to access this knowledge base")) + return + } + + // Get all knowledge bases + allKBs, err := h.service.ListKnowledgeBases(ctx) + if err != nil { + c.Error(errors.NewInternalServerError(err.Error())) + return + } + + // Filter eligible targets + targets := make([]*types.KnowledgeBase, 0) + for _, kb := range allKBs { + if kb.ID == sourceKBID { + continue + } + if kb.IsTemporary { + continue + } + if kb.Type != sourceKB.Type { + continue + } + if kb.EmbeddingModelID != sourceKB.EmbeddingModelID { + continue + } + targets = append(targets, kb) + } + + c.JSON(http.StatusOK, gin.H{ + "success": true, + "data": targets, + }) +} \ No newline at end of file diff --git a/internal/router/router.go b/internal/router/router.go index 72973701..1c98b2de 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -199,6 +199,10 @@ func RegisterKnowledgeRoutes(r *gin.RouterGroup, handler *handler.KnowledgeHandl k.PUT("/tags", handler.UpdateKnowledgeTagBatch) // 搜索知识 k.GET("/search", handler.SearchKnowledge) + // 移动知识到其他知识库 + k.POST("/move", handler.MoveKnowledge) + // 获取知识移动进度 + k.GET("/move/progress/:task_id", handler.GetKnowledgeMoveProgress) } } @@ -254,6 +258,8 @@ func RegisterKnowledgeBaseRoutes(r *gin.RouterGroup, handler *handler.KnowledgeB kb.POST("/copy", handler.CopyKnowledgeBase) // 获取知识库复制进度 kb.GET("/copy/progress/:task_id", handler.GetKBCloneProgress) + // 获取可移动目标知识库列表 + kb.GET("/:id/move-targets", handler.ListMoveTargets) } } diff --git a/internal/router/sync_task.go b/internal/router/sync_task.go index 6da7049b..170b673a 100644 --- a/internal/router/sync_task.go +++ b/internal/router/sync_task.go @@ -90,6 +90,7 @@ func RegisterSyncHandlers(params SyncTaskParams) { params.Executor.RegisterHandler(types.TypeQuestionGeneration, params.KnowledgeService.ProcessQuestionGeneration) params.Executor.RegisterHandler(types.TypeSummaryGeneration, params.KnowledgeService.ProcessSummaryGeneration) params.Executor.RegisterHandler(types.TypeKBClone, params.KnowledgeService.ProcessKBClone) + params.Executor.RegisterHandler(types.TypeKnowledgeMove, params.KnowledgeService.ProcessKnowledgeMove) params.Executor.RegisterHandler(types.TypeKnowledgeListDelete, params.KnowledgeService.ProcessKnowledgeListDelete) params.Executor.RegisterHandler(types.TypeIndexDelete, params.TagService.ProcessIndexDelete) params.Executor.RegisterHandler(types.TypeKBDelete, params.KnowledgeBaseService.ProcessKBDelete) diff --git a/internal/router/task.go b/internal/router/task.go index 63b4cd2b..978d74a3 100644 --- a/internal/router/task.go +++ b/internal/router/task.go @@ -90,6 +90,9 @@ func RunAsynqServer(params AsynqTaskParams) *asynq.ServeMux { // Register KB clone handler mux.HandleFunc(types.TypeKBClone, params.KnowledgeService.ProcessKBClone) + // Register knowledge move handler + mux.HandleFunc(types.TypeKnowledgeMove, params.KnowledgeService.ProcessKnowledgeMove) + // Register knowledge list delete handler mux.HandleFunc(types.TypeKnowledgeListDelete, params.KnowledgeService.ProcessKnowledgeListDelete) diff --git a/internal/types/extract_graph.go b/internal/types/extract_graph.go index 7a2b785c..9069cd39 100644 --- a/internal/types/extract_graph.go +++ b/internal/types/extract_graph.go @@ -10,6 +10,7 @@ const ( TypeIndexDelete = "index:delete" // 索引删除任务 TypeKBDelete = "kb:delete" // 知识库删除任务 TypeKnowledgeListDelete = "knowledge:list_delete" // 批量删除知识任务 + TypeKnowledgeMove = "knowledge:move" // 知识移动任务 TypeDataTableSummary = "datatable:summary" // 表格摘要任务 TypeImageMultimodal = "image:multimodal" // 图片多模态处理任务(OCR + VLM Caption) ) @@ -98,6 +99,32 @@ type KnowledgeListDeletePayload struct { KnowledgeIDs []string `json:"knowledge_ids"` } +// KnowledgeMovePayload represents the knowledge move task payload +type KnowledgeMovePayload struct { + TenantID uint64 `json:"tenant_id"` + TaskID string `json:"task_id"` + KnowledgeIDs []string `json:"knowledge_ids"` + SourceKBID string `json:"source_kb_id"` + TargetKBID string `json:"target_kb_id"` + Mode string `json:"mode"` // "reuse_vectors" or "reparse" +} + +// KnowledgeMoveProgress represents the progress of a knowledge move task +type KnowledgeMoveProgress struct { + TaskID string `json:"task_id"` + SourceKBID string `json:"source_kb_id"` + TargetKBID string `json:"target_kb_id"` + Status KBCloneTaskStatus `json:"status"` + Progress int `json:"progress"` // 0-100 + Total int `json:"total"` // 总知识数 + Processed int `json:"processed"` // 已处理数 + Failed int `json:"failed"` // 失败数 + Message string `json:"message"` // 状态消息 + Error string `json:"error"` // 错误信息 + CreatedAt int64 `json:"created_at"` // 任务创建时间 + UpdatedAt int64 `json:"updated_at"` // 最后更新时间 +} + // ImageMultimodalPayload represents the image multimodal processing task payload. type ImageMultimodalPayload struct { TenantID uint64 `json:"tenant_id"` diff --git a/internal/types/interfaces/chunk.go b/internal/types/interfaces/chunk.go index 8fed3a50..74940d2e 100644 --- a/internal/types/interfaces/chunk.go +++ b/internal/types/interfaces/chunk.go @@ -58,6 +58,8 @@ type ChunkRepository interface { DeleteChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string) error // DeleteByKnowledgeList deletes all chunks for a knowledge list DeleteByKnowledgeList(ctx context.Context, tenantID uint64, knowledgeIDs []string) error + // MoveChunksByKnowledgeID updates knowledge_base_id for all chunks of a knowledge item + MoveChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string, targetKBID string) error // DeleteChunksByTagID deletes all chunks with the specified tag ID // Returns the IDs of deleted chunks for index cleanup DeleteChunksByTagID(ctx context.Context, tenantID uint64, kbID string, tagID string, excludeIDs []string) ([]string, error) diff --git a/internal/types/interfaces/knowledge.go b/internal/types/interfaces/knowledge.go index 6a37461c..c6cda924 100644 --- a/internal/types/interfaces/knowledge.go +++ b/internal/types/interfaces/knowledge.go @@ -139,12 +139,18 @@ type KnowledgeService interface { ProcessSummaryGeneration(ctx context.Context, t *asynq.Task) error // ProcessKBClone handles Asynq knowledge base clone tasks ProcessKBClone(ctx context.Context, t *asynq.Task) error + // ProcessKnowledgeMove handles Asynq knowledge move tasks + ProcessKnowledgeMove(ctx context.Context, t *asynq.Task) error // ProcessKnowledgeListDelete handles Asynq knowledge list delete tasks ProcessKnowledgeListDelete(ctx context.Context, t *asynq.Task) error // GetKBCloneProgress retrieves the progress of a knowledge base clone task GetKBCloneProgress(ctx context.Context, taskID string) (*types.KBCloneProgress, error) // SaveKBCloneProgress saves the progress of a knowledge base clone task SaveKBCloneProgress(ctx context.Context, progress *types.KBCloneProgress) error + // GetKnowledgeMoveProgress retrieves the progress of a knowledge move task + GetKnowledgeMoveProgress(ctx context.Context, taskID string) (*types.KnowledgeMoveProgress, error) + // SaveKnowledgeMoveProgress saves the progress of a knowledge move task + SaveKnowledgeMoveProgress(ctx context.Context, progress *types.KnowledgeMoveProgress) error // GetFAQImportProgress retrieves the progress of an FAQ import task GetFAQImportProgress(ctx context.Context, taskID string) (*types.FAQImportProgress, error) // UpdateLastFAQImportResultDisplayStatus updates the display status of FAQ import result