fix(upload): 修复流式上传中的文件名处理逻辑

- 修正预上传接口调用时传递正确的文件总数而非固定值-1
- 移除导入配置中文件分割时的文件扩展名保留逻辑
- 删除流式上传选项中的fileExtension参数定义
- 移除流式上传实现中的文件扩展名处理相关代码
- 简化新文件名生成逻辑，不再附加扩展名后缀

Makefile.offline.mk

@@ -0,0 +1,304 @@
+# ============================================================================
+# Makefile 离线构建扩展
+# 将此文件内容追加到主 Makefile 末尾，或单独包含使用
+# ============================================================================
+
+# 离线构建配置
+CACHE_DIR ?= ./build-cache
+OFFLINE_VERSION ?= latest
+
+# 创建 buildx 构建器（如果不存在）
+.PHONY: ensure-buildx
+ensure-buildx:
+	@if ! docker buildx inspect offline-builder > /dev/null 2>&1; then \
+		echo "创建 buildx 构建器..."; \
+		docker buildx create --name offline-builder --driver docker-container --use 2>/dev/null || docker buildx use offline-builder; \
+	else \
+		docker buildx use offline-builder 2>/dev/null || true; \
+	fi
+
+# ========== 离线缓存导出（有网环境） ==========
+
+.PHONY: offline-export
+offline-export: ensure-buildx
+	@echo "======================================"
+	@echo "导出离线构建缓存..."
+	@echo "======================================"
+	@mkdir -p $(CACHE_DIR)/buildkit $(CACHE_DIR)/images $(CACHE_DIR)/resources
+	@$(MAKE) _offline-export-base-images
+	@$(MAKE) _offline-export-cache
+	@$(MAKE) _offline-export-resources
+	@$(MAKE) _offline-package
+
+.PHONY: _offline-export-base-images
+_offline-export-base-images:
+	@echo ""
+	@echo "1. 导出基础镜像..."
+	@bash -c 'images=( \
+		"maven:3-eclipse-temurin-21" \
+		"maven:3-eclipse-temurin-8" \
+		"eclipse-temurin:21-jdk" \
+		"mysql:8" \
+		"node:20-alpine" \
+		"nginx:1.29" \
+		"ghcr.nju.edu.cn/astral-sh/uv:python3.11-bookworm" \
+		"ghcr.nju.edu.cn/astral-sh/uv:python3.12-bookworm" \
+		"ghcr.nju.edu.cn/astral-sh/uv:latest" \
+		"python:3.12-slim" \
+		"python:3.11-slim" \
+		"gcr.nju.edu.cn/distroless/nodejs20-debian12" \
+	); for img in "$${images[@]}"; do echo "  Pulling $$img..."; docker pull "$$img" 2>/dev/null || true; done'
+	@echo "  Saving base images..."
+	@docker save -o $(CACHE_DIR)/images/base-images.tar \
+		maven:3-eclipse-temurin-21 \
+		maven:3-eclipse-temurin-8 \
+		eclipse-temurin:21-jdk \
+		mysql:8 \
+		node:20-alpine \
+		nginx:1.29 \
+		ghcr.nju.edu.cn/astral-sh/uv:python3.11-bookworm \
+		ghcr.nju.edu.cn/astral-sh/uv:python3.12-bookworm \
+		ghcr.nju.edu.cn/astral-sh/uv:latest \
+		python:3.12-slim \
+		python:3.11-slim \
+		gcr.nju.edu.cn/distroless/nodejs20-debian12 2>/dev/null || echo "  Warning: Some images may not exist"
+
+.PHONY: _offline-export-cache
+_offline-export-cache:
+	@echo ""
+	@echo "2. 导出 BuildKit 缓存..."
+	@echo "   backend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/backend-cache,mode=max -f scripts/images/backend/Dockerfile -t datamate-backend:cache . 2>/dev/null || echo "   Warning: backend cache export failed"
+	@echo "   backend-python..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/backend-python-cache,mode=max -f scripts/images/backend-python/Dockerfile -t datamate-backend-python:cache . 2>/dev/null || echo "   Warning: backend-python cache export failed"
+	@echo "   database..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/database-cache,mode=max -f scripts/images/database/Dockerfile -t datamate-database:cache . 2>/dev/null || echo "   Warning: database cache export failed"
+	@echo "   frontend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/frontend-cache,mode=max -f scripts/images/frontend/Dockerfile -t datamate-frontend:cache . 2>/dev/null || echo "   Warning: frontend cache export failed"
+	@echo "   gateway..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/gateway-cache,mode=max -f scripts/images/gateway/Dockerfile -t datamate-gateway:cache . 2>/dev/null || echo "   Warning: gateway cache export failed"
+	@echo "   runtime..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/runtime-cache,mode=max -f scripts/images/runtime/Dockerfile -t datamate-runtime:cache . 2>/dev/null || echo "   Warning: runtime cache export failed"
+	@echo "   deer-flow-backend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/deer-flow-backend-cache,mode=max -f scripts/images/deer-flow-backend/Dockerfile -t deer-flow-backend:cache . 2>/dev/null || echo "   Warning: deer-flow-backend cache export failed"
+	@echo "   deer-flow-frontend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/deer-flow-frontend-cache,mode=max -f scripts/images/deer-flow-frontend/Dockerfile -t deer-flow-frontend:cache . 2>/dev/null || echo "   Warning: deer-flow-frontend cache export failed"
+	@echo "   mineru..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/mineru-cache,mode=max -f scripts/images/mineru/Dockerfile -t datamate-mineru:cache . 2>/dev/null || echo "   Warning: mineru cache export failed"
+
+.PHONY: _offline-export-resources
+_offline-export-resources:
+	@echo ""
+	@echo "3. 预下载外部资源..."
+	@mkdir -p $(CACHE_DIR)/resources/models
+	@echo "   PaddleOCR model..."
+	@wget -q -O $(CACHE_DIR)/resources/models/ch_ppocr_mobile_v2.0_cls_infer.tar \
+		https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar 2>/dev/null || echo "   Warning: PaddleOCR model download failed"
+	@echo "   spaCy model..."
+	@wget -q -O $(CACHE_DIR)/resources/models/zh_core_web_sm-3.8.0-py3-none-any.whl \
+		https://ghproxy.net/https://github.com/explosion/spacy-models/releases/download/zh_core_web_sm-3.8.0/zh_core_web_sm-3.8.0-py3-none-any.whl 2>/dev/null || echo "   Warning: spaCy model download failed"
+	@echo "   DataX source..."
+	@if [ ! -d "$(CACHE_DIR)/resources/DataX" ]; then \
+		git clone --depth 1 https://gitee.com/alibaba/DataX.git $(CACHE_DIR)/resources/DataX 2>/dev/null || echo "   Warning: DataX clone failed"; \
+	fi
+	@echo "   deer-flow source..."
+	@if [ ! -d "$(CACHE_DIR)/resources/deer-flow" ]; then \
+		git clone --depth 1 https://ghproxy.net/https://github.com/ModelEngine-Group/deer-flow.git $(CACHE_DIR)/resources/deer-flow 2>/dev/null || echo "   Warning: deer-flow clone failed"; \
+	fi
+
+.PHONY: _offline-package
+_offline-package:
+	@echo ""
+	@echo "4. 打包缓存..."
+	@cd $(CACHE_DIR) && tar -czf "build-cache-$$(date +%Y%m%d).tar.gz" buildkit images resources 2>/dev/null && cd - > /dev/null
+	@echo ""
+	@echo "======================================"
+	@echo "✓ 缓存导出完成！"
+	@echo "======================================"
+	@echo "传输文件: $(CACHE_DIR)/build-cache-$$(date +%Y%m%d).tar.gz"
+
+# ========== 离线构建（无网环境） ==========
+
+.PHONY: offline-setup
+offline-setup:
+	@echo "======================================"
+	@echo "设置离线构建环境..."
+	@echo "======================================"
+	@if [ ! -d "$(CACHE_DIR)" ]; then \
+		echo "查找并解压缓存包..."; \
+		cache_file=$$(ls -t build-cache-*.tar.gz 2>/dev/null | head -1); \
+		if [ -z "$$cache_file" ]; then \
+			echo "错误: 未找到缓存压缩包 (build-cache-*.tar.gz)"; \
+			exit 1; \
+		fi; \
+		echo "解压 $$cache_file..."; \
+		tar -xzf "$$cache_file"; \
+	else \
+		echo "缓存目录已存在: $(CACHE_DIR)"; \
+	fi
+	@echo ""
+	@echo "加载基础镜像..."
+	@if [ -f "$(CACHE_DIR)/images/base-images.tar" ]; then \
+		docker load -i $(CACHE_DIR)/images/base-images.tar; \
+	else \
+		echo "警告: 基础镜像文件不存在，假设已手动加载"; \
+	fi
+	@$(MAKE) ensure-buildx
+	@echo ""
+	@echo "✓ 离线环境准备完成"
+
+.PHONY: offline-build
+offline-build: offline-setup
+	@echo ""
+	@echo "======================================"
+	@echo "开始离线构建..."
+	@echo "======================================"
+	@$(MAKE) _offline-build-services
+
+.PHONY: _offline-build-services
+_offline-build-services: ensure-buildx
+	@echo ""
+	@echo "构建 datamate-database..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/database-cache \
+		--pull=false \
+		-f scripts/images/database/Dockerfile \
+		-t datamate-database:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-gateway..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/gateway-cache \
+		--pull=false \
+		-f scripts/images/gateway/Dockerfile \
+		-t datamate-gateway:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-backend..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/backend-cache \
+		--pull=false \
+		-f scripts/images/backend/Dockerfile \
+		-t datamate-backend:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-frontend..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/frontend-cache \
+		--pull=false \
+		-f scripts/images/frontend/Dockerfile \
+		-t datamate-frontend:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-runtime..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/runtime-cache \
+		--pull=false \
+		--build-arg RESOURCES_DIR=$(CACHE_DIR)/resources \
+		-f scripts/images/runtime/Dockerfile \
+		-t datamate-runtime:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-backend-python..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/backend-python-cache \
+		--pull=false \
+		--build-arg RESOURCES_DIR=$(CACHE_DIR)/resources \
+		-f scripts/images/backend-python/Dockerfile \
+		-t datamate-backend-python:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "======================================"
+	@echo "✓ 离线构建完成"
+	@echo "======================================"
+
+# 单个服务离线构建 (BuildKit)
+.PHONY: %-offline-build
+%-offline-build: offline-setup ensure-buildx
+	@echo "离线构建 $*..."
+	@if [ ! -d "$(CACHE_DIR)/buildkit/$*-cache" ]; then \
+		echo "错误: $* 的缓存不存在"; \
+		exit 1; \
+	fi
+	@$(eval IMAGE_NAME := $(if $(filter deer-flow%,$*),$*,datamate-$*))
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/$*-cache \
+		--pull=false \
+		$(if $(filter runtime backend-python deer-flow%,$*),--build-arg RESOURCES_DIR=$(CACHE_DIR)/resources,) \
+		-f scripts/images/$*/Dockerfile \
+		-t $(IMAGE_NAME):$(OFFLINE_VERSION) \
+		--load .
+
+# 传统 Docker 构建（不使用 BuildKit，更稳定）
+.PHONY: offline-build-classic
+offline-build-classic: offline-setup
+	@echo "使用传统 docker build 进行离线构建..."
+	@bash scripts/offline/build-offline-classic.sh $(CACHE_DIR) $(OFFLINE_VERSION)
+
+# 诊断离线环境
+.PHONY: offline-diagnose
+offline-diagnose:
+	@bash scripts/offline/diagnose.sh $(CACHE_DIR)
+
+# 构建 APT 预装基础镜像（有网环境）
+.PHONY: offline-build-base-images
+offline-build-base-images:
+	@echo "构建 APT 预装基础镜像..."
+	@bash scripts/offline/build-base-images.sh $(CACHE_DIR)
+
+# 使用预装基础镜像进行离线构建（推荐）
+.PHONY: offline-build-final
+offline-build-final: offline-setup
+	@echo "使用预装 APT 包的基础镜像进行离线构建..."
+	@bash scripts/offline/build-offline-final.sh $(CACHE_DIR) $(OFFLINE_VERSION)
+
+# 完整离线导出（包含 APT 预装基础镜像）
+.PHONY: offline-export-full
+offline-export-full:
+	@echo "======================================"
+	@echo "完整离线缓存导出（含 APT 预装基础镜像）"
+	@echo "======================================"
+	@$(MAKE) offline-build-base-images
+	@$(MAKE) offline-export
+	@echo ""
+	@echo "导出完成！传输时请包含以下文件:"
+	@echo "  - build-cache/images/base-images-with-apt.tar"
+	@echo "  - build-cache-YYYYMMDD.tar.gz"
+
+# ========== 帮助 ==========
+
+.PHONY: help-offline
+help-offline:
+	@echo "离线构建命令:"
+	@echo ""
+	@echo "【有网环境】"
+	@echo "  make offline-export [CACHE_DIR=./build-cache]       - 导出构建缓存"
+	@echo "  make offline-export-full                            - 导出完整缓存（含 APT 预装基础镜像）"
+	@echo "  make offline-build-base-images                      - 构建 APT 预装基础镜像"
+	@echo ""
+	@echo "【无网环境】"
+	@echo "  make offline-setup [CACHE_DIR=./build-cache]        - 解压并准备离线缓存"
+	@echo "  make offline-build-final                            - 使用预装基础镜像构建（推荐，解决 APT 问题）"
+	@echo "  make offline-build-classic                          - 使用传统 docker build"
+	@echo "  make offline-build                                  - 使用 BuildKit 构建"
+	@echo "  make offline-diagnose                               - 诊断离线构建环境"
+	@echo "  make <service>-offline-build                        - 离线构建单个服务"
+	@echo ""
+	@echo "【完整工作流程（推荐）】"
+	@echo "  # 1. 有网环境导出完整缓存"
+	@echo "  make offline-export-full"
+	@echo ""
+	@echo "  # 2. 传输到无网环境（需要传输两个文件）"
+	@echo "  scp build-cache/images/base-images-with-apt.tar user@offline-server:/path/"
+	@echo "  scp build-cache-*.tar.gz user@offline-server:/path/"
+	@echo ""
+	@echo "  # 3. 无网环境构建"
+	@echo "  tar -xzf build-cache-*.tar.gz"
+	@echo "  docker load -i build-cache/images/base-images-with-apt.tar"
+	@echo "  make offline-build-final"

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetApplicationService.java

@@ -1,5 +1,6 @@
 package com.datamate.datamanagement.application;
 
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.datamate.common.domain.utils.ChunksSaver;
@@ -19,8 +20,11 @@ import com.datamate.datamanagement.infrastructure.exception.DataManagementErrorC
 import com.datamate.datamanagement.infrastructure.persistence.mapper.TagMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 import com.datamate.datamanagement.interfaces.converter.DatasetConverter;
 import com.datamate.datamanagement.interfaces.dto.*;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
@@ -53,6 +57,7 @@ public class DatasetApplicationService {
     private static final int SIMILAR_DATASET_MAX_LIMIT = 50;
     private static final int SIMILAR_DATASET_CANDIDATE_FACTOR = 5;
     private static final int SIMILAR_DATASET_CANDIDATE_MAX = 100;
+    private static final String DERIVED_METADATA_KEY = "derived_from_file_id";
     private final DatasetRepository datasetRepository;
     private final TagMapper tagMapper;
     private final DatasetFileRepository datasetFileRepository;
@@ -73,7 +78,7 @@ public class DatasetApplicationService {
         Dataset dataset = DatasetConverter.INSTANCE.convertToDataset(createDatasetRequest);
         Dataset parentDataset = resolveParentDataset(createDatasetRequest.getParentDatasetId(), dataset.getId());
         dataset.setParentDatasetId(parentDataset == null ? null : parentDataset.getId());
-        dataset.initCreateParam(datasetBasePath, parentDataset == null ? null : parentDataset.getPath());
+        dataset.initCreateParam(datasetBasePath);
         // 处理标签
         Set<Tag> processedTags = Optional.ofNullable(createDatasetRequest.getTags())
             .filter(CollectionUtils::isNotEmpty)
@@ -97,6 +102,7 @@ public class DatasetApplicationService {
     public Dataset updateDataset(String datasetId, UpdateDatasetRequest updateDatasetRequest) {
         Dataset dataset = datasetRepository.getById(datasetId);
         BusinessAssert.notNull(dataset, DataManagementErrorCode.DATASET_NOT_FOUND);
+        
         if (StringUtils.hasText(updateDatasetRequest.getName())) {
             dataset.setName(updateDatasetRequest.getName());
         }
@@ -109,13 +115,31 @@ public class DatasetApplicationService {
         if (Objects.nonNull(updateDatasetRequest.getStatus())) {
             dataset.setStatus(updateDatasetRequest.getStatus());
         }
-        if (updateDatasetRequest.getParentDatasetId() != null) {
+        if (updateDatasetRequest.isParentDatasetIdProvided()) {
+            // 保存原始的 parentDatasetId 值，用于比较是否发生了变化
+            String originalParentDatasetId = dataset.getParentDatasetId();
+
+            // 处理父数据集变更：仅当请求显式包含 parentDatasetId 时处理
+            // handleParentChange 内部通过 normalizeParentId 方法将空字符串和 null 都转换为 null
+            // 这样既支持设置新的父数据集，也支持清除关联
             handleParentChange(dataset, updateDatasetRequest.getParentDatasetId());
+
+            // 检查 parentDatasetId 是否发生了变化
+            if (!Objects.equals(originalParentDatasetId, dataset.getParentDatasetId())) {
+                // 使用 LambdaUpdateWrapper 显式地更新 parentDatasetId 字段
+                // 这样即使值为 null 也能被正确更新到数据库
+                datasetRepository.update(null, new LambdaUpdateWrapper<Dataset>()
+                    .eq(Dataset::getId, datasetId)
+                    .set(Dataset::getParentDatasetId, dataset.getParentDatasetId()));
+            }
         }
+        
         if (StringUtils.hasText(updateDatasetRequest.getDataSource())) {
             // 数据源id不为空，使用异步线程进行文件扫盘落库
             processDataSourceAsync(dataset.getId(), updateDatasetRequest.getDataSource());
         }
+        
+        // 更新其他字段（不包括 parentDatasetId，因为它已经在上面的代码中更新了）
         datasetRepository.updateById(dataset);
         return dataset;
     }
@@ -142,6 +166,7 @@ public class DatasetApplicationService {
         BusinessAssert.notNull(dataset, DataManagementErrorCode.DATASET_NOT_FOUND);
         List<DatasetFile> datasetFiles = datasetFileRepository.findAllByDatasetId(datasetId);
         dataset.setFiles(datasetFiles);
+        applyVisibleFileCounts(Collections.singletonList(dataset));
         return dataset;
     }
 
@@ -153,6 +178,7 @@ public class DatasetApplicationService {
         IPage<Dataset> page = new Page<>(query.getPage(), query.getSize());
         page = datasetRepository.findByCriteria(page, query);
         String datasetPvcName = getDatasetPvcName();
+        applyVisibleFileCounts(page.getRecords());
         List<DatasetResponse> datasetResponses = DatasetConverter.INSTANCE.convertToResponse(page.getRecords());
         datasetResponses.forEach(dataset -> dataset.setPvcName(datasetPvcName));
         return PagedResponse.of(datasetResponses, page.getCurrent(), page.getTotal(), page.getPages());
@@ -200,6 +226,7 @@ public class DatasetApplicationService {
             })
             .limit(safeLimit)
             .toList();
+        applyVisibleFileCounts(sorted);
         List<DatasetResponse> responses = DatasetConverter.INSTANCE.convertToResponse(sorted);
         responses.forEach(item -> item.setPvcName(datasetPvcName));
         return responses;
@@ -291,7 +318,9 @@ public class DatasetApplicationService {
 
     private void handleParentChange(Dataset dataset, String parentDatasetId) {
         String normalized = normalizeParentId(parentDatasetId);
-        if (Objects.equals(dataset.getParentDatasetId(), normalized)) {
+        String expectedPath = buildDatasetPath(datasetBasePath, dataset.getId());
+        if (Objects.equals(dataset.getParentDatasetId(), normalized)
+            && Objects.equals(dataset.getPath(), expectedPath)) {
             return;
         }
         long childCount = datasetRepository.countByParentId(dataset.getId());
@@ -299,8 +328,7 @@ public class DatasetApplicationService {
             throw BusinessException.of(DataManagementErrorCode.DATASET_HAS_CHILDREN);
         }
         Dataset parent = normalized == null ? null : resolveParentDataset(normalized, dataset.getId());
-        String newPath = buildDatasetPath(parent == null ? datasetBasePath : parent.getPath(), dataset.getId());
-        moveDatasetPath(dataset, newPath);
+        moveDatasetPath(dataset, expectedPath);
         dataset.setParentDatasetId(parent == null ? null : parent.getId());
     }
 
@@ -344,6 +372,61 @@ public class DatasetApplicationService {
         dataset.setPath(newPath);
     }
 
+    private void applyVisibleFileCounts(List<Dataset> datasets) {
+        if (CollectionUtils.isEmpty(datasets)) {
+            return;
+        }
+        List<String> datasetIds = datasets.stream()
+            .filter(Objects::nonNull)
+            .map(Dataset::getId)
+            .filter(StringUtils::hasText)
+            .toList();
+        if (datasetIds.isEmpty()) {
+            return;
+        }
+        Map<String, Long> countMap = datasetFileRepository.countNonDerivedByDatasetIds(datasetIds).stream()
+            .filter(Objects::nonNull)
+            .collect(Collectors.toMap(
+                DatasetFileCount::getDatasetId,
+                count -> Optional.ofNullable(count.getFileCount()).orElse(0L),
+                (left, right) -> left
+            ));
+        for (Dataset dataset : datasets) {
+            if (dataset == null || !StringUtils.hasText(dataset.getId())) {
+                continue;
+            }
+            Long visibleCount = countMap.get(dataset.getId());
+            dataset.setFileCount(visibleCount != null ? visibleCount : 0L);
+        }
+    }
+
+    private List<DatasetFile> filterVisibleFiles(List<DatasetFile> files) {
+        if (CollectionUtils.isEmpty(files)) {
+            return Collections.emptyList();
+        }
+        return files.stream()
+            .filter(file -> !isDerivedFile(file))
+            .collect(Collectors.toList());
+    }
+
+    private boolean isDerivedFile(DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return false;
+        }
+        String metadata = datasetFile.getMetadata();
+        if (!StringUtils.hasText(metadata)) {
+            return false;
+        }
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            Map<String, Object> metadataMap = mapper.readValue(metadata, new TypeReference<Map<String, Object>>() {});
+            return metadataMap.get(DERIVED_METADATA_KEY) != null;
+        } catch (Exception e) {
+            log.debug("Failed to parse dataset file metadata for derived detection: {}", datasetFile.getId(), e);
+            return false;
+        }
+    }
+
     /**
      * 获取数据集统计信息
      */
@@ -356,27 +439,29 @@ public class DatasetApplicationService {
 
         Map<String, Object> statistics = new HashMap<>();
 
-        // 基础统计
-        Long totalFiles = datasetFileRepository.countByDatasetId(datasetId);
-        Long completedFiles = datasetFileRepository.countCompletedByDatasetId(datasetId);
+        List<DatasetFile> allFiles = datasetFileRepository.findAllByDatasetId(datasetId);
+        List<DatasetFile> visibleFiles = filterVisibleFiles(allFiles);
+        long totalFiles = visibleFiles.size();
+        long completedFiles = visibleFiles.stream()
+            .filter(file -> "COMPLETED".equalsIgnoreCase(file.getStatus()))
+            .count();
         Long totalSize = datasetFileRepository.sumSizeByDatasetId(datasetId);
 
-        statistics.put("totalFiles", totalFiles != null ? totalFiles.intValue() : 0);
-        statistics.put("completedFiles", completedFiles != null ? completedFiles.intValue() : 0);
+        statistics.put("totalFiles", (int) totalFiles);
+        statistics.put("completedFiles", (int) completedFiles);
         statistics.put("totalSize", totalSize != null ? totalSize : 0L);
 
         // 完成率计算
         float completionRate = 0.0f;
-        if (totalFiles != null && totalFiles > 0) {
-            completionRate = (completedFiles != null ? completedFiles.floatValue() : 0.0f) / totalFiles.floatValue() * 100.0f;
+        if (totalFiles > 0) {
+            completionRate = ((float) completedFiles) / (float) totalFiles * 100.0f;
         }
         statistics.put("completionRate", completionRate);
 
         // 文件类型分布统计
         Map<String, Integer> fileTypeDistribution = new HashMap<>();
-        List<DatasetFile> allFiles = datasetFileRepository.findAllByDatasetId(datasetId);
-        if (allFiles != null) {
-            for (DatasetFile file : allFiles) {
+        if (!visibleFiles.isEmpty()) {
+            for (DatasetFile file : visibleFiles) {
                 String fileType = file.getFileType() != null ? file.getFileType() : "unknown";
                 fileTypeDistribution.put(fileType, fileTypeDistribution.getOrDefault(fileType, 0) + 1);
             }
@@ -385,8 +470,8 @@ public class DatasetApplicationService {
 
         // 状态分布统计
         Map<String, Integer> statusDistribution = new HashMap<>();
-        if (allFiles != null) {
-            for (DatasetFile file : allFiles) {
+        if (!visibleFiles.isEmpty()) {
+            for (DatasetFile file : visibleFiles) {
                 String status = file.getStatus() != null ? file.getStatus() : "unknown";
                 statusDistribution.put(status, statusDistribution.getOrDefault(status, 0) + 1);
             }
@@ -413,33 +498,32 @@ public class DatasetApplicationService {
     public void processDataSourceAsync(String datasetId, String dataSourceId) {
         try {
             log.info("Initiating data source file scanning, dataset ID: {}, collection task ID: {}", datasetId, dataSourceId);
-            List<String> filePaths = getFilePaths(dataSourceId);
+            CollectionTaskDetailResponse taskDetail = collectionTaskClient.getTaskDetail(dataSourceId).getData();
+            if (taskDetail == null) {
+                log.warn("Fail to get collection task detail, task ID: {}", dataSourceId);
+                return;
+            }
+            Path targetPath = Paths.get(taskDetail.getTargetPath());
+            if (!Files.exists(targetPath) || !Files.isDirectory(targetPath)) {
+                log.warn("Target path not exists or is not a directory: {}", taskDetail.getTargetPath());
+                return;
+            }
+            List<String> filePaths = scanFilePaths(targetPath);
             if (CollectionUtils.isEmpty(filePaths)) {
                 return;
             }
-            datasetFileApplicationService.copyFilesToDatasetDir(datasetId, new CopyFilesRequest(filePaths));
+            datasetFileApplicationService.copyFilesToDatasetDirWithSourceRoot(datasetId, targetPath, filePaths);
             log.info("Success file scan, total files: {}", filePaths.size());
         } catch (Exception e) {
             log.error("处理数据源文件扫描失败，数据集ID: {}, 数据源ID: {}", datasetId, dataSourceId, e);
         }
     }
 
-    private List<String> getFilePaths(String dataSourceId) {
-        CollectionTaskDetailResponse taskDetail = collectionTaskClient.getTaskDetail(dataSourceId).getData();
-        if (taskDetail == null) {
-            log.warn("Fail to get collection task detail, task ID: {}", dataSourceId);
-            return Collections.emptyList();
-        }
-        Path targetPath = Paths.get(taskDetail.getTargetPath());
-        if (!Files.exists(targetPath) || !Files.isDirectory(targetPath)) {
-            log.warn("Target path not exists or is not a directory: {}", taskDetail.getTargetPath());
-            return Collections.emptyList();
-        }
-
-        try (Stream<Path> paths = Files.walk(targetPath, 1)) {
+    private List<String> scanFilePaths(Path targetPath) {
+        try (Stream<Path> paths = Files.walk(targetPath)) {
             return paths
-                .filter(Files::isRegularFile)  // 只保留文件，排除目录
-                .map(Path::toString)           // 转换为字符串路径
+                .filter(Files::isRegularFile)
+                .map(Path::toString)
                 .collect(Collectors.toList());
         } catch (IOException e) {
             log.error("Fail to scan directory: {}", targetPath, e);

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFileApplicationService.java

@@ -28,6 +28,7 @@ import com.datamate.datamanagement.interfaces.dto.CopyFilesRequest;
 import com.datamate.datamanagement.interfaces.dto.CreateDirectoryRequest;
 import com.datamate.datamanagement.interfaces.dto.UploadFileRequest;
 import com.datamate.datamanagement.interfaces.dto.UploadFilesPreRequest;
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.servlet.http.HttpServletResponse;
@@ -42,6 +43,8 @@ import org.springframework.core.io.UrlResource;
 import org.springframework.http.HttpHeaders;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import java.io.File;
 import java.io.IOException;
@@ -70,12 +73,22 @@ public class DatasetFileApplicationService {
     private static final String PDF_FILE_TYPE = "pdf";
     private static final String DOC_FILE_TYPE = "doc";
     private static final String DOCX_FILE_TYPE = "docx";
-    private static final Set<String> DOCUMENT_TEXT_FILE_TYPES = Set.of(PDF_FILE_TYPE, DOC_FILE_TYPE, DOCX_FILE_TYPE);
+    private static final String XLS_FILE_TYPE = "xls";
+    private static final String XLSX_FILE_TYPE = "xlsx";
+    private static final Set<String> DOCUMENT_TEXT_FILE_TYPES = Set.of(
+        PDF_FILE_TYPE,
+        DOC_FILE_TYPE,
+        DOCX_FILE_TYPE,
+        XLS_FILE_TYPE,
+        XLSX_FILE_TYPE
+    );
+    private static final String DERIVED_METADATA_KEY = "derived_from_file_id";
 
-    private final DatasetFileRepository datasetFileRepository;
-    private final DatasetRepository datasetRepository;
-    private final FileService fileService;
-    private final PdfTextExtractAsyncService pdfTextExtractAsyncService;
+    private final DatasetFileRepository datasetFileRepository;
+    private final DatasetRepository datasetRepository;
+    private final FileService fileService;
+    private final PdfTextExtractAsyncService pdfTextExtractAsyncService;
+    private final DatasetFilePreviewService datasetFilePreviewService;
 
     @Value("${datamate.data-management.base-path:/dataset}")
     private String datasetBasePath;
@@ -84,15 +97,17 @@ public class DatasetFileApplicationService {
     private DuplicateMethod duplicateMethod;
 
     @Autowired
-    public DatasetFileApplicationService(DatasetFileRepository datasetFileRepository,
-                                         DatasetRepository datasetRepository,
-                                         FileService fileService,
-                                         PdfTextExtractAsyncService pdfTextExtractAsyncService) {
-        this.datasetFileRepository = datasetFileRepository;
-        this.datasetRepository = datasetRepository;
-        this.fileService = fileService;
-        this.pdfTextExtractAsyncService = pdfTextExtractAsyncService;
-    }
+    public DatasetFileApplicationService(DatasetFileRepository datasetFileRepository,
+                                         DatasetRepository datasetRepository,
+                                         FileService fileService,
+                                         PdfTextExtractAsyncService pdfTextExtractAsyncService,
+                                         DatasetFilePreviewService datasetFilePreviewService) {
+        this.datasetFileRepository = datasetFileRepository;
+        this.datasetRepository = datasetRepository;
+        this.fileService = fileService;
+        this.pdfTextExtractAsyncService = pdfTextExtractAsyncService;
+        this.datasetFilePreviewService = datasetFilePreviewService;
+    }
 
     /**
      * 获取数据集文件列表
@@ -111,7 +126,7 @@ public class DatasetFileApplicationService {
      * @param status                状态过滤
      * @param name                  文件名模糊查询
      * @param hasAnnotation         是否有标注
-     * @param excludeSourceDocuments 是否排除已被转换为TXT的源文档（PDF/DOC/DOCX）
+     * @param excludeSourceDocuments 是否排除源文档（PDF/DOC/DOCX/XLS/XLSX）
      * @param pagingQuery           分页参数
      * @return 分页文件列表
      */
@@ -122,19 +137,15 @@ public class DatasetFileApplicationService {
         IPage<DatasetFile> files = datasetFileRepository.findByCriteria(datasetId, fileType, status, name, hasAnnotation, page);
         
         if (excludeSourceDocuments) {
-            // 查询所有作为衍生TXT文件源的文档文件ID
-            List<String> sourceFileIds = datasetFileRepository.findSourceFileIdsWithDerivedFiles(datasetId);
-            if (!sourceFileIds.isEmpty()) {
-                // 过滤掉源文件
-                List<DatasetFile> filteredRecords = files.getRecords().stream()
-                        .filter(file -> !sourceFileIds.contains(file.getId()))
-                        .collect(Collectors.toList());
-                
-                // 重新构建分页结果
-                Page<DatasetFile> filteredPage = new Page<>(files.getCurrent(), files.getSize(), files.getTotal());
-                filteredPage.setRecords(filteredRecords);
-                return PagedResponse.of(filteredPage);
-            }
+            // 过滤掉源文档文件（PDF/DOC/DOCX/XLS/XLSX），用于标注场景只展示派生文件
+            List<DatasetFile> filteredRecords = files.getRecords().stream()
+                .filter(file -> !isSourceDocument(file))
+                .collect(Collectors.toList());
+
+            // 重新构建分页结果
+            Page<DatasetFile> filteredPage = new Page<>(files.getCurrent(), files.getSize(), files.getTotal());
+            filteredPage.setRecords(filteredRecords);
+            return PagedResponse.of(filteredPage);
         }
         
         return PagedResponse.of(files);
@@ -144,7 +155,7 @@ public class DatasetFileApplicationService {
      * 获取数据集文件列表
      */
     @Transactional(readOnly = true)
-    public PagedResponse<DatasetFile> getDatasetFilesWithDirectory(String datasetId, String prefix, PagingQuery pagingQuery) {
+    public PagedResponse<DatasetFile> getDatasetFilesWithDirectory(String datasetId, String prefix, boolean excludeDerivedFiles, PagingQuery pagingQuery) {
         Dataset dataset = datasetRepository.getById(datasetId);
         int page = Math.max(pagingQuery.getPage(), 1);
         int size = pagingQuery.getSize() == null || pagingQuery.getSize() < 0 ? 20 : pagingQuery.getSize();
@@ -153,15 +164,36 @@ public class DatasetFileApplicationService {
         }
         String datasetPath = dataset.getPath();
         Path queryPath = Path.of(dataset.getPath() + File.separator + prefix);
-        Map<String, DatasetFile> datasetFilesMap = datasetFileRepository.findAllByDatasetId(datasetId)
-            .stream().collect(Collectors.toMap(DatasetFile::getFilePath, Function.identity()));
+        Map<String, DatasetFile> datasetFilesMap = datasetFileRepository.findAllByDatasetId(datasetId)
+            .stream()
+            .filter(file -> file.getFilePath() != null)
+            .collect(Collectors.toMap(
+                file -> normalizeFilePath(file.getFilePath()),
+                Function.identity(),
+                (left, right) -> left
+            ));
+        Set<String> derivedFilePaths = excludeDerivedFiles
+            ? datasetFilesMap.values().stream()
+                .filter(this::isDerivedFile)
+                .map(DatasetFile::getFilePath)
+                .map(this::normalizeFilePath)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toSet())
+            : Collections.emptySet();
+        // 如果目录不存在，直接返回空结果（数据集刚创建时目录可能还未生成）
+        if (!Files.exists(queryPath)) {
+            return new PagedResponse<>(page, size, 0, 0, Collections.emptyList());
+        }
         try (Stream<Path> pathStream = Files.list(queryPath)) {
-            List<Path> allFiles = pathStream
-                .filter(path -> path.toString().startsWith(datasetPath))
-                .sorted(Comparator
-                    .comparing((Path path) -> !Files.isDirectory(path))
-                    .thenComparing(path -> path.getFileName().toString()))
-                .collect(Collectors.toList());
+            List<Path> allFiles = pathStream
+                .filter(path -> path.toString().startsWith(datasetPath))
+                .filter(path -> !excludeDerivedFiles
+                    || Files.isDirectory(path)
+                    || !derivedFilePaths.contains(normalizeFilePath(path.toString())))
+                .sorted(Comparator
+                    .comparing((Path path) -> !Files.isDirectory(path))
+                    .thenComparing(path -> path.getFileName().toString()))
+                .collect(Collectors.toList());
 
             // 计算分页
             int total = allFiles.size();
@@ -176,7 +208,9 @@ public class DatasetFileApplicationService {
             if (fromIndex < total) {
                 pageData = allFiles.subList(fromIndex, toIndex);
             }
-            List<DatasetFile> datasetFiles = pageData.stream().map(path -> getDatasetFile(path, datasetFilesMap)).toList();
+            List<DatasetFile> datasetFiles = pageData.stream()
+                .map(path -> getDatasetFile(path, datasetFilesMap, excludeDerivedFiles, derivedFilePaths))
+                .toList();
 
             return new PagedResponse<>(page, size, total, totalPages, datasetFiles);
         } catch (IOException e) {
@@ -185,9 +219,12 @@ public class DatasetFileApplicationService {
         }
     }
 
-    private DatasetFile getDatasetFile(Path path, Map<String, DatasetFile> datasetFilesMap) {
-        DatasetFile datasetFile = new DatasetFile();
-        LocalDateTime localDateTime = LocalDateTime.now();
+    private DatasetFile getDatasetFile(Path path,
+                                       Map<String, DatasetFile> datasetFilesMap,
+                                       boolean excludeDerivedFiles,
+                                       Set<String> derivedFilePaths) {
+        DatasetFile datasetFile = new DatasetFile();
+        LocalDateTime localDateTime = LocalDateTime.now();
         try {
             localDateTime = Files.getLastModifiedTime(path).toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
         } catch (IOException e) {
@@ -206,23 +243,32 @@ public class DatasetFileApplicationService {
                 long fileCount;
                 long totalSize;
 
-                try (Stream<Path> walk = Files.walk(path)) {
-                    fileCount = walk.filter(Files::isRegularFile).count();
-                }
-
-                try (Stream<Path> walk = Files.walk(path)) {
-                    totalSize = walk
-                        .filter(Files::isRegularFile)
-                        .mapToLong(p -> {
-                            try {
-                                return Files.size(p);
-                            } catch (IOException e) {
-                                log.error("get file size error", e);
-                                return 0L;
-                            }
-                        })
-                        .sum();
-                }
+                try (Stream<Path> walk = Files.walk(path)) {
+                    Stream<Path> fileStream = walk.filter(Files::isRegularFile);
+                    if (excludeDerivedFiles && !derivedFilePaths.isEmpty()) {
+                        fileStream = fileStream.filter(filePath ->
+                            !derivedFilePaths.contains(normalizeFilePath(filePath.toString())));
+                    }
+                    fileCount = fileStream.count();
+                }
+
+                try (Stream<Path> walk = Files.walk(path)) {
+                    Stream<Path> fileStream = walk.filter(Files::isRegularFile);
+                    if (excludeDerivedFiles && !derivedFilePaths.isEmpty()) {
+                        fileStream = fileStream.filter(filePath ->
+                            !derivedFilePaths.contains(normalizeFilePath(filePath.toString())));
+                    }
+                    totalSize = fileStream
+                        .mapToLong(p -> {
+                            try {
+                                return Files.size(p);
+                            } catch (IOException e) {
+                                log.error("get file size error", e);
+                                return 0L;
+                            }
+                        })
+                        .sum();
+                }
 
                 datasetFile.setFileCount(fileCount);
                 datasetFile.setFileSize(totalSize);
@@ -230,15 +276,55 @@ public class DatasetFileApplicationService {
                 log.error("stat directory info error", e);
             }
         } else {
-            DatasetFile exist = datasetFilesMap.get(path.toString());
-            if (exist == null) {
-                datasetFile.setId("file-" + datasetFile.getFileName());
-                datasetFile.setFileSize(path.toFile().length());
-            } else {
+            DatasetFile exist = datasetFilesMap.get(normalizeFilePath(path.toString()));
+            if (exist == null) {
+                datasetFile.setId("file-" + datasetFile.getFileName());
+                datasetFile.setFileSize(path.toFile().length());
+            } else {
                 datasetFile = exist;
             }
         }
-        return datasetFile;
+        return datasetFile;
+    }
+
+    private String normalizeFilePath(String filePath) {
+        if (filePath == null || filePath.isBlank()) {
+            return null;
+        }
+        try {
+            return Paths.get(filePath).toAbsolutePath().normalize().toString();
+        } catch (Exception e) {
+            return filePath.replace("\\", "/");
+        }
+    }
+
+    private boolean isSourceDocument(DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return false;
+        }
+        String fileType = datasetFile.getFileType();
+        if (fileType == null || fileType.isBlank()) {
+            return false;
+        }
+        return DOCUMENT_TEXT_FILE_TYPES.contains(fileType.toLowerCase(Locale.ROOT));
+    }
+
+    private boolean isDerivedFile(DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return false;
+        }
+        String metadata = datasetFile.getMetadata();
+        if (metadata == null || metadata.isBlank()) {
+            return false;
+        }
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            Map<String, Object> metadataMap = mapper.readValue(metadata, new TypeReference<Map<String, Object>>() {});
+            return metadataMap.get(DERIVED_METADATA_KEY) != null;
+        } catch (Exception e) {
+            log.debug("Failed to parse dataset file metadata for derived detection: {}", datasetFile.getId(), e);
+            return false;
+        }
     }
 
     /**
@@ -260,18 +346,19 @@ public class DatasetFileApplicationService {
      * 删除文件
      */
     @Transactional
-    public void deleteDatasetFile(String datasetId, String fileId) {
-        DatasetFile file = getDatasetFile(datasetId, fileId);
-        Dataset dataset = datasetRepository.getById(datasetId);
-        dataset.setFiles(new ArrayList<>(Collections.singleton(file)));
-        datasetFileRepository.removeById(fileId);
-        dataset.removeFile(file);
-        datasetRepository.updateById(dataset);
-        // 删除文件时，上传到数据集中的文件会同时删除数据库中的记录和文件系统中的文件，归集过来的文件仅删除数据库中的记录
-        if (file.getFilePath().startsWith(dataset.getPath())) {
-            try {
-                Path filePath = Paths.get(file.getFilePath());
-                Files.deleteIfExists(filePath);
+    public void deleteDatasetFile(String datasetId, String fileId) {
+        DatasetFile file = getDatasetFile(datasetId, fileId);
+        Dataset dataset = datasetRepository.getById(datasetId);
+        dataset.setFiles(new ArrayList<>(Collections.singleton(file)));
+        datasetFileRepository.removeById(fileId);
+        dataset.removeFile(file);
+        datasetRepository.updateById(dataset);
+        datasetFilePreviewService.deletePreviewFileQuietly(datasetId, fileId);
+        // 删除文件时，上传到数据集中的文件会同时删除数据库中的记录和文件系统中的文件，归集过来的文件仅删除数据库中的记录
+        if (file.getFilePath().startsWith(dataset.getPath())) {
+            try {
+                Path filePath = Paths.get(file.getFilePath());
+                Files.deleteIfExists(filePath);
             } catch (IOException ex) {
                 throw BusinessException.of(SystemErrorCode.FILE_SYSTEM_ERROR);
             }
@@ -637,9 +724,10 @@ public class DatasetFileApplicationService {
             })
             .collect(Collectors.toList());
 
-        for (DatasetFile file : filesToDelete) {
-            datasetFileRepository.removeById(file.getId());
-        }
+        for (DatasetFile file : filesToDelete) {
+            datasetFileRepository.removeById(file.getId());
+            datasetFilePreviewService.deletePreviewFileQuietly(datasetId, file.getId());
+        }
 
         // 删除文件系统中的目录
         try {
@@ -739,6 +827,71 @@ public class DatasetFileApplicationService {
         return copiedFiles;
     }
 
+    /**
+     * 复制文件到数据集目录（保留相对路径，适用于数据源导入）
+     *
+     * @param datasetId 数据集id
+     * @param sourceRoot 数据源根目录
+     * @param sourcePaths 源文件路径列表
+     * @return 复制的文件列表
+     */
+    @Transactional
+    public List<DatasetFile> copyFilesToDatasetDirWithSourceRoot(String datasetId, Path sourceRoot, List<String> sourcePaths) {
+        Dataset dataset = datasetRepository.getById(datasetId);
+        BusinessAssert.notNull(dataset, SystemErrorCode.RESOURCE_NOT_FOUND);
+
+        Path normalizedRoot = sourceRoot.toAbsolutePath().normalize();
+        List<DatasetFile> copiedFiles = new ArrayList<>();
+        List<DatasetFile> existDatasetFiles = datasetFileRepository.findAllByDatasetId(datasetId);
+        dataset.setFiles(existDatasetFiles);
+        Map<String, DatasetFile> copyTargets = new LinkedHashMap<>();
+
+        for (String sourceFilePath : sourcePaths) {
+            if (sourceFilePath == null || sourceFilePath.isBlank()) {
+                continue;
+            }
+            Path sourcePath = Paths.get(sourceFilePath).toAbsolutePath().normalize();
+            if (!sourcePath.startsWith(normalizedRoot)) {
+                log.warn("Source file path is out of root: {}", sourceFilePath);
+                continue;
+            }
+            if (!Files.exists(sourcePath) || !Files.isRegularFile(sourcePath)) {
+                log.warn("Source file does not exist or is not a regular file: {}", sourceFilePath);
+                continue;
+            }
+
+            Path relativePath = normalizedRoot.relativize(sourcePath);
+            String fileName = sourcePath.getFileName().toString();
+            File sourceFile = sourcePath.toFile();
+            LocalDateTime currentTime = LocalDateTime.now();
+            Path targetPath = Paths.get(dataset.getPath(), relativePath.toString());
+
+            DatasetFile datasetFile = DatasetFile.builder()
+                .id(UUID.randomUUID().toString())
+                .datasetId(datasetId)
+                .fileName(fileName)
+                .fileType(AnalyzerUtils.getExtension(fileName))
+                .fileSize(sourceFile.length())
+                .filePath(targetPath.toString())
+                .uploadTime(currentTime)
+                .lastAccessTime(currentTime)
+                .build();
+            setDatasetFileId(datasetFile, dataset);
+            dataset.addFile(datasetFile);
+            copiedFiles.add(datasetFile);
+            copyTargets.put(sourceFilePath, datasetFile);
+        }
+
+        if (copiedFiles.isEmpty()) {
+            return copiedFiles;
+        }
+        datasetFileRepository.saveOrUpdateBatch(copiedFiles, 100);
+        dataset.active();
+        datasetRepository.updateById(dataset);
+        CompletableFuture.runAsync(() -> copyFilesToDatasetDirWithRelativePath(copyTargets, dataset, normalizedRoot));
+        return copiedFiles;
+    }
+
     private void copyFilesToDatasetDir(List<String> sourcePaths, Dataset dataset) {
         for (String sourcePath : sourcePaths) {
             Path sourceFilePath = Paths.get(sourcePath);
@@ -757,6 +910,35 @@ public class DatasetFileApplicationService {
         }
     }
 
+    private void copyFilesToDatasetDirWithRelativePath(
+        Map<String, DatasetFile> copyTargets,
+        Dataset dataset,
+        Path sourceRoot
+    ) {
+        Path datasetRoot = Paths.get(dataset.getPath()).toAbsolutePath().normalize();
+        Path normalizedRoot = sourceRoot.toAbsolutePath().normalize();
+        for (Map.Entry<String, DatasetFile> entry : copyTargets.entrySet()) {
+            Path sourcePath = Paths.get(entry.getKey()).toAbsolutePath().normalize();
+            if (!sourcePath.startsWith(normalizedRoot)) {
+                log.warn("Source file path is out of root: {}", sourcePath);
+                continue;
+            }
+            Path relativePath = normalizedRoot.relativize(sourcePath);
+            Path targetFilePath = datasetRoot.resolve(relativePath).normalize();
+            if (!targetFilePath.startsWith(datasetRoot)) {
+                log.warn("Target file path is out of dataset path: {}", targetFilePath);
+                continue;
+            }
+            try {
+                Files.createDirectories(targetFilePath.getParent());
+                Files.copy(sourcePath, targetFilePath);
+                triggerPdfTextExtraction(dataset, entry.getValue());
+            } catch (IOException e) {
+                log.error("Failed to copy file from {} to {}", sourcePath, targetFilePath, e);
+            }
+        }
+    }
+
     /**
      * 添加文件到数据集（仅创建数据库记录，不执行文件系统操作）
      *
@@ -824,6 +1006,20 @@ public class DatasetFileApplicationService {
         if (fileType == null || !DOCUMENT_TEXT_FILE_TYPES.contains(fileType.toLowerCase(Locale.ROOT))) {
             return;
         }
-        pdfTextExtractAsyncService.extractPdfText(dataset.getId(), datasetFile.getId());
+        String datasetId = dataset.getId();
+        String fileId = datasetFile.getId();
+        if (datasetId == null || fileId == null) {
+            return;
+        }
+        if (TransactionSynchronizationManager.isSynchronizationActive()) {
+            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+                @Override
+                public void afterCommit() {
+                    pdfTextExtractAsyncService.extractPdfText(datasetId, fileId);
+                }
+            });
+            return;
+        }
+        pdfTextExtractAsyncService.extractPdfText(datasetId, fileId);
     }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFilePreviewAsyncService.java

@@ -0,0 +1,171 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Set;
+
+/**
+ * 数据集文件预览转换异步任务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DatasetFilePreviewAsyncService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String DATASET_PREVIEW_DIR = "dataset-previews";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final int MAX_ERROR_LENGTH = 500;
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final DatasetFileRepository datasetFileRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Async
+    public void convertPreviewAsync(String fileId) {
+        if (StringUtils.isBlank(fileId)) {
+            return;
+        }
+        DatasetFile file = datasetFileRepository.getById(fileId);
+        if (file == null) {
+            return;
+        }
+        String extension = resolveFileExtension(resolveOriginalName(file));
+        if (!OFFICE_EXTENSIONS.contains(extension)) {
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, null, "仅支持 DOC/DOCX 转换");
+            return;
+        }
+        if (StringUtils.isBlank(file.getFilePath())) {
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, null, "源文件路径为空");
+            return;
+        }
+        Path sourcePath = Paths.get(file.getFilePath()).toAbsolutePath().normalize();
+        if (!Files.exists(sourcePath) || !Files.isRegularFile(sourcePath)) {
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, null, "源文件不存在");
+            return;
+        }
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+        String previewRelativePath = StringUtils.defaultIfBlank(
+            previewInfo.pdfPath(),
+            resolvePreviewRelativePath(file.getDatasetId(), file.getId())
+        );
+        Path targetPath = resolvePreviewStoragePath(previewRelativePath);
+
+        try {
+            ensureParentDirectory(targetPath);
+            LibreOfficeConverter.convertToPdf(sourcePath, targetPath);
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.READY, previewRelativePath, null);
+        } catch (Exception e) {
+            log.error("dataset preview convert failed, fileId: {}", file.getId(), e);
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, previewRelativePath, trimError(e.getMessage()));
+        }
+    }
+
+    private void updatePreviewStatus(
+        DatasetFile file,
+        KnowledgeItemPreviewStatus status,
+        String previewRelativePath,
+        String error
+    ) {
+        if (file == null) {
+            return;
+        }
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            file.getMetadata(),
+            objectMapper,
+            status,
+            previewRelativePath,
+            error,
+            nowText()
+        );
+        file.setMetadata(updatedMetadata);
+        datasetFileRepository.updateById(file);
+    }
+
+    private String resolveOriginalName(DatasetFile file) {
+        if (file == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(file.getFileName())) {
+            return file.getFileName();
+        }
+        if (StringUtils.isNotBlank(file.getFilePath())) {
+            return Paths.get(file.getFilePath()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewRelativePath(String datasetId, String fileId) {
+        String relativePath = Paths.get(DATASET_PREVIEW_DIR, datasetId, fileId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    private Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        if (!target.startsWith(root)) {
+            throw new IllegalArgumentException("invalid preview path");
+        }
+        return target;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private void ensureParentDirectory(Path targetPath) {
+        try {
+            Path parent = targetPath.getParent();
+            if (parent != null) {
+                Files.createDirectories(parent);
+            }
+        } catch (Exception e) {
+            throw new IllegalStateException("创建预览目录失败", e);
+        }
+    }
+
+    private String trimError(String error) {
+        if (StringUtils.isBlank(error)) {
+            return "";
+        }
+        if (error.length() <= MAX_ERROR_LENGTH) {
+            return error;
+        }
+        return error.substring(0, MAX_ERROR_LENGTH);
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFilePreviewService.java

@@ -0,0 +1,233 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.common.infrastructure.exception.BusinessAssert;
+import com.datamate.common.infrastructure.exception.CommonErrorCode;
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
+import com.datamate.datamanagement.interfaces.dto.DatasetFilePreviewStatusResponse;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * 数据集文件预览转换服务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DatasetFilePreviewService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String DATASET_PREVIEW_DIR = "dataset-previews";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final DatasetFileRepository datasetFileRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final DatasetFilePreviewAsyncService datasetFilePreviewAsyncService;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    public DatasetFilePreviewStatusResponse getPreviewStatus(String datasetId, String fileId) {
+        DatasetFile file = requireDatasetFile(datasetId, fileId);
+        assertOfficeDocument(file);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && !previewPdfExists(file, previewInfo)) {
+            previewInfo = markPreviewFailed(file, previewInfo, "预览文件不存在");
+        }
+
+        return buildResponse(previewInfo);
+    }
+
+    public DatasetFilePreviewStatusResponse ensurePreview(String datasetId, String fileId) {
+        DatasetFile file = requireDatasetFile(datasetId, fileId);
+        assertOfficeDocument(file);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && previewPdfExists(file, previewInfo)) {
+            return buildResponse(previewInfo);
+        }
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.PROCESSING) {
+            return buildResponse(previewInfo);
+        }
+
+        String previewRelativePath = resolvePreviewRelativePath(file.getDatasetId(), file.getId());
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            file.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.PROCESSING,
+            previewRelativePath,
+            null,
+            nowText()
+        );
+        file.setMetadata(updatedMetadata);
+        datasetFileRepository.updateById(file);
+        datasetFilePreviewAsyncService.convertPreviewAsync(file.getId());
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo refreshed = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(updatedMetadata, objectMapper);
+        return buildResponse(refreshed);
+    }
+
+    public boolean isOfficeDocument(String fileName) {
+        String extension = resolveFileExtension(fileName);
+        return StringUtils.isNotBlank(extension) && OFFICE_EXTENSIONS.contains(extension.toLowerCase());
+    }
+
+    public PreviewFile resolveReadyPreviewFile(String datasetId, DatasetFile file) {
+        if (file == null) {
+            return null;
+        }
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+        if (previewInfo.status() != KnowledgeItemPreviewStatus.READY) {
+            return null;
+        }
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(datasetId, file.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        if (!Files.exists(filePath) || !Files.isRegularFile(filePath)) {
+            markPreviewFailed(file, previewInfo, "预览文件不存在");
+            return null;
+        }
+        String previewName = resolvePreviewPdfName(file);
+        return new PreviewFile(filePath, previewName);
+    }
+
+    public void deletePreviewFileQuietly(String datasetId, String fileId) {
+        String relativePath = resolvePreviewRelativePath(datasetId, fileId);
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        try {
+            Files.deleteIfExists(filePath);
+        } catch (Exception e) {
+            log.warn("delete dataset preview pdf error, fileId: {}", fileId, e);
+        }
+    }
+
+    private DatasetFilePreviewStatusResponse buildResponse(KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        DatasetFilePreviewStatusResponse response = new DatasetFilePreviewStatusResponse();
+        KnowledgeItemPreviewStatus status = previewInfo.status() == null
+            ? KnowledgeItemPreviewStatus.PENDING
+            : previewInfo.status();
+        response.setStatus(status);
+        response.setPreviewError(previewInfo.error());
+        response.setUpdatedAt(previewInfo.updatedAt());
+        return response;
+    }
+
+    private DatasetFile requireDatasetFile(String datasetId, String fileId) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(datasetId), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(StringUtils.isNotBlank(fileId), CommonErrorCode.PARAM_ERROR);
+        DatasetFile datasetFile = datasetFileRepository.getById(fileId);
+        BusinessAssert.notNull(datasetFile, CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(Objects.equals(datasetFile.getDatasetId(), datasetId), CommonErrorCode.PARAM_ERROR);
+        return datasetFile;
+    }
+
+    private void assertOfficeDocument(DatasetFile file) {
+        BusinessAssert.notNull(file, CommonErrorCode.PARAM_ERROR);
+        String extension = resolveFileExtension(resolveOriginalName(file));
+        BusinessAssert.isTrue(OFFICE_EXTENSIONS.contains(extension), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private String resolveOriginalName(DatasetFile file) {
+        if (file == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(file.getFileName())) {
+            return file.getFileName();
+        }
+        if (StringUtils.isNotBlank(file.getFilePath())) {
+            return Paths.get(file.getFilePath()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewPdfName(DatasetFile file) {
+        String originalName = resolveOriginalName(file);
+        if (StringUtils.isBlank(originalName)) {
+            return "预览.pdf";
+        }
+        int dotIndex = originalName.lastIndexOf('.');
+        if (dotIndex <= 0) {
+            return originalName + PREVIEW_FILE_SUFFIX;
+        }
+        return originalName.substring(0, dotIndex) + PREVIEW_FILE_SUFFIX;
+    }
+
+    private boolean previewPdfExists(DatasetFile file, KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(file.getDatasetId(), file.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        return Files.exists(filePath) && Files.isRegularFile(filePath);
+    }
+
+    private KnowledgeItemPreviewMetadataHelper.PreviewInfo markPreviewFailed(
+        DatasetFile file,
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo,
+        String error
+    ) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(file.getDatasetId(), file.getId()));
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            file.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.FAILED,
+            relativePath,
+            error,
+            nowText()
+        );
+        file.setMetadata(updatedMetadata);
+        datasetFileRepository.updateById(file);
+        return KnowledgeItemPreviewMetadataHelper.readPreviewInfo(updatedMetadata, objectMapper);
+    }
+
+    private String resolvePreviewRelativePath(String datasetId, String fileId) {
+        String relativePath = Paths.get(DATASET_PREVIEW_DIR, datasetId, fileId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        BusinessAssert.isTrue(target.startsWith(root), CommonErrorCode.PARAM_ERROR);
+        return target;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        BusinessAssert.isTrue(StringUtils.isNotBlank(uploadDir), CommonErrorCode.PARAM_ERROR);
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+
+    public record PreviewFile(Path filePath, String fileName) {
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeDirectoryApplicationService.java

@@ -0,0 +1,142 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.common.infrastructure.exception.BusinessAssert;
+import com.datamate.common.infrastructure.exception.CommonErrorCode;
+import com.datamate.datamanagement.common.enums.KnowledgeStatusType;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
+import com.datamate.datamanagement.infrastructure.exception.DataManagementErrorCode;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemDirectoryRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeSetRepository;
+import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeDirectoryRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * 知识条目目录应用服务
+ */
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class KnowledgeDirectoryApplicationService {
+    private static final String PATH_SEPARATOR = "/";
+    private static final String INVALID_PATH_SEGMENT = "..";
+
+    private final KnowledgeItemDirectoryRepository knowledgeItemDirectoryRepository;
+    private final KnowledgeItemRepository knowledgeItemRepository;
+    private final KnowledgeSetRepository knowledgeSetRepository;
+
+    @Transactional(readOnly = true)
+    public List<KnowledgeItemDirectory> getKnowledgeDirectories(String setId, KnowledgeDirectoryQuery query) {
+        BusinessAssert.notNull(query, CommonErrorCode.PARAM_ERROR);
+        query.setSetId(setId);
+        return knowledgeItemDirectoryRepository.findByCriteria(query);
+    }
+
+    public KnowledgeItemDirectory createKnowledgeDirectory(String setId, CreateKnowledgeDirectoryRequest request) {
+        BusinessAssert.notNull(request, CommonErrorCode.PARAM_ERROR);
+        KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
+        BusinessAssert.isTrue(!isReadOnlyStatus(knowledgeSet.getStatus()),
+            DataManagementErrorCode.KNOWLEDGE_SET_STATUS_ERROR);
+
+        String directoryName = normalizeDirectoryName(request.getDirectoryName());
+        validateDirectoryName(directoryName);
+
+        String parentPrefix = normalizeRelativePathPrefix(request.getParentPrefix());
+        String relativePath = normalizeRelativePathValue(parentPrefix + directoryName);
+        validateRelativePath(relativePath);
+
+        BusinessAssert.isTrue(!knowledgeItemRepository.existsBySetIdAndRelativePath(setId, relativePath),
+            CommonErrorCode.PARAM_ERROR);
+
+        KnowledgeItemDirectory existing = knowledgeItemDirectoryRepository.findBySetIdAndPath(setId, relativePath);
+        if (existing != null) {
+            return existing;
+        }
+
+        KnowledgeItemDirectory directory = new KnowledgeItemDirectory();
+        directory.setId(UUID.randomUUID().toString());
+        directory.setSetId(setId);
+        directory.setName(directoryName);
+        directory.setRelativePath(relativePath);
+        knowledgeItemDirectoryRepository.save(directory);
+        return directory;
+    }
+
+    public void deleteKnowledgeDirectory(String setId, String relativePath) {
+        KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
+        BusinessAssert.isTrue(!isReadOnlyStatus(knowledgeSet.getStatus()),
+            DataManagementErrorCode.KNOWLEDGE_SET_STATUS_ERROR);
+
+        String normalized = normalizeRelativePathValue(relativePath);
+        validateRelativePath(normalized);
+
+        knowledgeItemRepository.removeByRelativePathPrefix(setId, normalized);
+        knowledgeItemDirectoryRepository.removeByRelativePathPrefix(setId, normalized);
+    }
+
+    private KnowledgeSet requireKnowledgeSet(String setId) {
+        KnowledgeSet knowledgeSet = knowledgeSetRepository.getById(setId);
+        BusinessAssert.notNull(knowledgeSet, DataManagementErrorCode.KNOWLEDGE_SET_NOT_FOUND);
+        return knowledgeSet;
+    }
+
+    private boolean isReadOnlyStatus(KnowledgeStatusType status) {
+        return status == KnowledgeStatusType.ARCHIVED || status == KnowledgeStatusType.DEPRECATED;
+    }
+
+    private String normalizeDirectoryName(String name) {
+        return StringUtils.trimToEmpty(name);
+    }
+
+    private void validateDirectoryName(String name) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(name), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!name.contains(PATH_SEPARATOR), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!name.contains("\\"), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!name.contains(INVALID_PATH_SEGMENT), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private void validateRelativePath(String relativePath) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!relativePath.contains(INVALID_PATH_SEGMENT), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private String normalizeRelativePathPrefix(String prefix) {
+        if (StringUtils.isBlank(prefix)) {
+            return "";
+        }
+        String normalized = prefix.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        validateRelativePath(normalized);
+        return normalized + PATH_SEPARATOR;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemApplicationService.java

@@ -16,15 +16,20 @@ import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
 import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
 import com.datamate.datamanagement.infrastructure.exception.DataManagementErrorCode;
+import com.datamate.datamanagement.infrastructure.persistence.mapper.TagMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeSetRepository;
 import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeItemRequest;
+import com.datamate.datamanagement.interfaces.dto.DeleteKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.ImportKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeManagementStatisticsResponse;
 import com.datamate.datamanagement.interfaces.dto.ReplaceKnowledgeItemFileRequest;
 import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeItemRequest;
 import com.datamate.datamanagement.interfaces.dto.UploadKnowledgeItemsRequest;
@@ -71,16 +76,20 @@ public class KnowledgeItemApplicationService {
     private static final String EXPORT_FILE_PREFIX = "knowledge_set_";
     private static final String EXPORT_FILE_SUFFIX = ".zip";
     private static final String EXPORT_CONTENT_TYPE = "application/zip";
+    private static final String PREVIEW_PDF_CONTENT_TYPE = "application/pdf";
     private static final int MAX_FILE_BASE_LENGTH = 120;
     private static final int MAX_TITLE_LENGTH = 200;
     private static final String KNOWLEDGE_ITEM_UPLOAD_DIR = "knowledge-items";
     private static final String DEFAULT_FILE_EXTENSION = "bin";
+    private static final String PATH_SEPARATOR = "/";
 
     private final KnowledgeItemRepository knowledgeItemRepository;
     private final KnowledgeSetRepository knowledgeSetRepository;
     private final DatasetRepository datasetRepository;
     private final DatasetFileRepository datasetFileRepository;
     private final DataManagementProperties dataManagementProperties;
+    private final TagMapper tagMapper;
+    private final KnowledgeItemPreviewService knowledgeItemPreviewService;
 
     public KnowledgeItem createKnowledgeItem(String setId, CreateKnowledgeItemRequest request) {
         KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
@@ -109,6 +118,7 @@ public class KnowledgeItemApplicationService {
 
         List<MultipartFile> files = request.getFiles();
         BusinessAssert.isTrue(CollectionUtils.isNotEmpty(files), CommonErrorCode.PARAM_ERROR);
+        String parentPrefix = normalizeRelativePathPrefix(request.getParentPrefix());
 
         Path uploadRoot = resolveUploadRootPath();
         Path setDir = uploadRoot.resolve(KNOWLEDGE_ITEM_UPLOAD_DIR).resolve(setId).normalize();
@@ -142,6 +152,7 @@ public class KnowledgeItemApplicationService {
             knowledgeItem.setContentType(KnowledgeContentType.FILE);
             knowledgeItem.setSourceType(KnowledgeSourceType.FILE_UPLOAD);
             knowledgeItem.setSourceFileId(trimToLength(safeOriginalName, MAX_TITLE_LENGTH));
+            knowledgeItem.setRelativePath(buildRelativePath(parentPrefix, safeOriginalName));
 
             items.add(knowledgeItem);
         }
@@ -167,6 +178,9 @@ public class KnowledgeItemApplicationService {
         if (request.getContentType() != null) {
             knowledgeItem.setContentType(request.getContentType());
         }
+        if (request.getMetadata() != null) {
+            knowledgeItem.setMetadata(request.getMetadata());
+        }
 
         knowledgeItemRepository.updateById(knowledgeItem);
         return knowledgeItem;
@@ -179,6 +193,22 @@ public class KnowledgeItemApplicationService {
         knowledgeItemRepository.removeById(itemId);
     }
 
+    public void deleteKnowledgeItems(String setId, DeleteKnowledgeItemsRequest request) {
+        BusinessAssert.notNull(request, CommonErrorCode.PARAM_ERROR);
+        List<String> ids = request.getIds();
+        BusinessAssert.isTrue(CollectionUtils.isNotEmpty(ids), CommonErrorCode.PARAM_ERROR);
+
+        List<KnowledgeItem> items = knowledgeItemRepository.listByIds(ids);
+        BusinessAssert.isTrue(CollectionUtils.isNotEmpty(items), DataManagementErrorCode.KNOWLEDGE_ITEM_NOT_FOUND);
+        BusinessAssert.isTrue(items.size() == ids.size(), DataManagementErrorCode.KNOWLEDGE_ITEM_NOT_FOUND);
+
+        boolean allMatch = items.stream().allMatch(item -> Objects.equals(item.getSetId(), setId));
+        BusinessAssert.isTrue(allMatch, CommonErrorCode.PARAM_ERROR);
+
+        List<String> deleteIds = items.stream().map(KnowledgeItem::getId).toList();
+        knowledgeItemRepository.removeByIds(deleteIds);
+    }
+
     @Transactional(readOnly = true)
     public KnowledgeItem getKnowledgeItem(String setId, String itemId) {
         KnowledgeItem knowledgeItem = knowledgeItemRepository.getById(itemId);
@@ -196,6 +226,40 @@ public class KnowledgeItemApplicationService {
         return PagedResponse.of(responses, page.getCurrent(), page.getTotal(), page.getPages());
     }
 
+    @Transactional(readOnly = true)
+    public KnowledgeManagementStatisticsResponse getKnowledgeManagementStatistics() {
+        KnowledgeManagementStatisticsResponse response = new KnowledgeManagementStatisticsResponse();
+        response.setTotalKnowledgeSets(knowledgeSetRepository.count());
+
+        long totalFiles = knowledgeItemRepository.countBySourceTypes(List.of(
+            KnowledgeSourceType.DATASET_FILE,
+            KnowledgeSourceType.FILE_UPLOAD
+        ));
+        response.setTotalFiles(totalFiles);
+
+        long datasetFileSize = safeLong(knowledgeItemRepository.sumDatasetFileSize());
+        long uploadFileSize = calculateUploadFileTotalSize();
+        response.setTotalSize(datasetFileSize + uploadFileSize);
+        response.setTotalTags(safeLong(tagMapper.countKnowledgeSetTags()));
+
+        return response;
+    }
+
+    @Transactional(readOnly = true)
+    public PagedResponse<KnowledgeItemSearchResponse> searchKnowledgeItems(KnowledgeItemSearchQuery query) {
+        BusinessAssert.notNull(query, CommonErrorCode.PARAM_ERROR);
+        String keyword = StringUtils.trimToEmpty(query.getKeyword());
+        BusinessAssert.isTrue(StringUtils.isNotBlank(keyword), CommonErrorCode.PARAM_ERROR);
+
+        IPage<KnowledgeItemSearchResponse> page = new Page<>(query.getPage(), query.getSize());
+        IPage<KnowledgeItemSearchResponse> result = knowledgeItemRepository.searchFileItems(page, keyword);
+        List<KnowledgeItemSearchResponse> responses = result.getRecords()
+            .stream()
+            .map(this::normalizeSearchResponse)
+            .toList();
+        return PagedResponse.of(responses, result.getCurrent(), result.getTotal(), result.getPages());
+    }
+
     public List<KnowledgeItem> importKnowledgeItems(String setId, ImportKnowledgeItemsRequest request) {
         KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
         BusinessAssert.isTrue(!isReadOnlyStatus(knowledgeSet.getStatus()),
@@ -220,6 +284,7 @@ public class KnowledgeItemApplicationService {
             knowledgeItem.setSourceType(KnowledgeSourceType.DATASET_FILE);
             knowledgeItem.setSourceDatasetId(dataset.getId());
             knowledgeItem.setSourceFileId(datasetFile.getId());
+            knowledgeItem.setRelativePath(resolveDatasetFileRelativePath(dataset, datasetFile));
 
             items.add(knowledgeItem);
         }
@@ -271,7 +336,7 @@ public class KnowledgeItemApplicationService {
 
         String relativePath = knowledgeItem.getContent();
         BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
-        Path filePath = resolveKnowledgeItemStoragePath(relativePath);
+        Path filePath = resolveKnowledgeItemStoragePathWithFallback(relativePath);
         BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
 
         String downloadName = StringUtils.isNotBlank(knowledgeItem.getSourceFileId())
@@ -304,12 +369,32 @@ public class KnowledgeItemApplicationService {
 
         String relativePath = knowledgeItem.getContent();
         BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
-        Path filePath = resolveKnowledgeItemStoragePath(relativePath);
-        BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
-
         String previewName = StringUtils.isNotBlank(knowledgeItem.getSourceFileId())
             ? knowledgeItem.getSourceFileId()
-            : filePath.getFileName().toString();
+            : Paths.get(relativePath).getFileName().toString();
+
+        if (knowledgeItemPreviewService.isOfficeDocument(previewName)) {
+            KnowledgeItemPreviewService.PreviewFile previewFile = knowledgeItemPreviewService.resolveReadyPreviewFile(setId, knowledgeItem);
+            if (previewFile == null) {
+                response.setStatus(HttpServletResponse.SC_CONFLICT);
+                return;
+            }
+            response.setContentType(PREVIEW_PDF_CONTENT_TYPE);
+            response.setCharacterEncoding(StandardCharsets.UTF_8.name());
+            response.setHeader(HttpHeaders.CONTENT_DISPOSITION,
+                "inline; filename=\"" + URLEncoder.encode(previewFile.fileName(), StandardCharsets.UTF_8) + "\"");
+            try (InputStream inputStream = Files.newInputStream(previewFile.filePath())) {
+                inputStream.transferTo(response.getOutputStream());
+                response.flushBuffer();
+            } catch (IOException e) {
+                log.error("preview knowledge item pdf error, itemId: {}", itemId, e);
+                throw BusinessException.of(SystemErrorCode.FILE_SYSTEM_ERROR);
+            }
+            return;
+        }
+
+        Path filePath = resolveKnowledgeItemStoragePathWithFallback(relativePath);
+        BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
 
         String contentType = null;
         try {
@@ -382,7 +467,10 @@ public class KnowledgeItemApplicationService {
             knowledgeItem.setContentType(KnowledgeContentType.FILE);
             knowledgeItem.setSourceType(KnowledgeSourceType.FILE_UPLOAD);
             knowledgeItem.setSourceFileId(sourceFileId);
+            knowledgeItem.setRelativePath(resolveReplacedRelativePath(knowledgeItem.getRelativePath(), sourceFileId));
+            knowledgeItem.setMetadata(knowledgeItemPreviewService.clearPreviewMetadata(knowledgeItem.getMetadata()));
             knowledgeItemRepository.updateById(knowledgeItem);
+            knowledgeItemPreviewService.deletePreviewFileQuietly(setId, knowledgeItem.getId());
             deleteFile(oldFilePath);
         } catch (Exception e) {
             deleteFileQuietly(targetPath);
@@ -447,11 +535,221 @@ public class KnowledgeItemApplicationService {
         return target;
     }
 
+    private Path resolveKnowledgeItemStoragePathWithFallback(String relativePath) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
+        String normalizedInput = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        Path root = resolveUploadRootPath();
+        java.util.LinkedHashSet<Path> candidates = new java.util.LinkedHashSet<>();
+
+        Path inputPath = Paths.get(normalizedInput.replace(PATH_SEPARATOR, File.separator));
+        if (inputPath.isAbsolute()) {
+            Path normalizedAbsolute = inputPath.toAbsolutePath().normalize();
+            if (normalizedAbsolute.startsWith(root)) {
+                candidates.add(normalizedAbsolute);
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            BusinessAssert.isTrue(!candidates.isEmpty(), CommonErrorCode.PARAM_ERROR);
+        } else {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, normalizedRelative));
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && !normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)
+                    && !normalizedRelative.equals(KNOWLEDGE_ITEM_UPLOAD_DIR)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR + normalizedRelative));
+            }
+        }
+
+        if (root.getFileName() != null && KNOWLEDGE_ITEM_UPLOAD_DIR.equals(root.getFileName().toString())) {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)) {
+                String withoutPrefix = normalizedRelative.substring(KNOWLEDGE_ITEM_UPLOAD_DIR.length() + PATH_SEPARATOR.length());
+                if (StringUtils.isNotBlank(withoutPrefix)) {
+                    candidates.add(buildKnowledgeItemStoragePath(root, withoutPrefix));
+                }
+            }
+        }
+
+        Path fallback = null;
+        for (Path candidate : candidates) {
+            if (fallback == null) {
+                fallback = candidate;
+            }
+            if (Files.exists(candidate) && Files.isRegularFile(candidate)) {
+                return candidate;
+            }
+        }
+        BusinessAssert.notNull(fallback, CommonErrorCode.PARAM_ERROR);
+        return fallback;
+    }
+
+    private Path buildKnowledgeItemStoragePath(Path root, String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace(PATH_SEPARATOR, File.separator);
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        BusinessAssert.isTrue(target.startsWith(root), CommonErrorCode.PARAM_ERROR);
+        return target;
+    }
+
+    private String extractRelativePathFromSegment(String rawPath, String segment) {
+        if (StringUtils.isBlank(rawPath) || StringUtils.isBlank(segment)) {
+            return null;
+        }
+        String normalized = rawPath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        String segmentPrefix = segment + PATH_SEPARATOR;
+        int index = normalized.indexOf(segmentPrefix);
+        if (index < 0) {
+            return segment.equals(normalized) ? segment : null;
+        }
+        return normalizeRelativePathValue(normalized.substring(index));
+    }
+
+    private KnowledgeItemSearchResponse normalizeSearchResponse(KnowledgeItemSearchResponse item) {
+        BusinessAssert.notNull(item, CommonErrorCode.PARAM_ERROR);
+        if (item.getSourceType() == KnowledgeSourceType.FILE_UPLOAD) {
+            item.setFileSize(resolveUploadFileSize(item.getContent()));
+            if (StringUtils.isBlank(item.getFileName())) {
+                item.setFileName(item.getSourceFileId());
+            }
+        }
+        if (item.getSourceType() == KnowledgeSourceType.DATASET_FILE) {
+            if (item.getFileSize() == null) {
+                item.setFileSize(0L);
+            }
+            if (StringUtils.isBlank(item.getFileName())) {
+                item.setFileName(item.getSourceFileId());
+            }
+        }
+        item.setContent(null);
+        return item;
+    }
+
+    private long calculateUploadFileTotalSize() {
+        List<KnowledgeItem> items = knowledgeItemRepository.findFileUploadItems();
+        if (CollectionUtils.isEmpty(items)) {
+            return 0L;
+        }
+        long total = 0L;
+        for (KnowledgeItem item : items) {
+            total += resolveUploadFileSize(item.getContent());
+        }
+        return total;
+    }
+
+    private long resolveUploadFileSize(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return 0L;
+        }
+        try {
+            Path filePath = resolveKnowledgeItemStoragePath(relativePath);
+            if (!Files.exists(filePath) || !Files.isRegularFile(filePath)) {
+                return 0L;
+            }
+            return Files.size(filePath);
+        } catch (Exception e) {
+            log.warn("resolve knowledge item file size error, path: {}", relativePath, e);
+            return 0L;
+        }
+    }
+
+    private long safeLong(Long value) {
+        return value == null ? 0L : value;
+    }
+
     private String buildRelativeFilePath(String setId, String storedName) {
         String relativePath = Paths.get(KNOWLEDGE_ITEM_UPLOAD_DIR, setId, storedName).toString();
         return relativePath.replace(File.separatorChar, '/');
     }
 
+    private String buildRelativePath(String parentPrefix, String fileName) {
+        String safeName = sanitizeFileName(fileName);
+        if (StringUtils.isBlank(safeName)) {
+            safeName = "file";
+        }
+        String normalizedPrefix = normalizeRelativePathPrefix(parentPrefix);
+        return normalizedPrefix + safeName;
+    }
+
+    private String normalizeRelativePathPrefix(String prefix) {
+        if (StringUtils.isBlank(prefix)) {
+            return "";
+        }
+        String normalized = prefix.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        BusinessAssert.isTrue(!normalized.contains(".."), CommonErrorCode.PARAM_ERROR);
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        return normalized + PATH_SEPARATOR;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+
+    private String resolveDatasetFileRelativePath(Dataset dataset, DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return "";
+        }
+        String fileName = StringUtils.defaultIfBlank(datasetFile.getFileName(), datasetFile.getId());
+        String datasetPath = dataset == null ? null : dataset.getPath();
+        String filePath = datasetFile.getFilePath();
+        if (StringUtils.isBlank(datasetPath) || StringUtils.isBlank(filePath)) {
+            return buildRelativePath("", fileName);
+        }
+        try {
+            Path datasetRoot = Paths.get(datasetPath).toAbsolutePath().normalize();
+            Path targetPath = Paths.get(filePath).toAbsolutePath().normalize();
+            if (targetPath.startsWith(datasetRoot)) {
+                Path relative = datasetRoot.relativize(targetPath);
+                String relativeValue = relative.toString().replace(File.separatorChar, '/');
+                String normalized = normalizeRelativePathValue(relativeValue);
+                if (!normalized.contains("..") && StringUtils.isNotBlank(normalized)) {
+                    return normalized;
+                }
+            }
+        } catch (Exception e) {
+            log.warn("resolve dataset file relative path failed, fileId: {}", datasetFile.getId(), e);
+        }
+        return buildRelativePath("", fileName);
+    }
+
+    private String resolveReplacedRelativePath(String existingRelativePath, String newFileName) {
+        String normalized = normalizeRelativePathValue(existingRelativePath);
+        if (StringUtils.isBlank(normalized)) {
+            return buildRelativePath("", newFileName);
+        }
+        int lastIndex = normalized.lastIndexOf(PATH_SEPARATOR);
+        String parentPrefix = lastIndex >= 0 ? normalized.substring(0, lastIndex + 1) : "";
+        return buildRelativePath(parentPrefix, newFileName);
+    }
+
     private void createDirectories(Path path) {
         try {
             Files.createDirectories(path);

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemPreviewAsyncService.java

@@ -0,0 +1,275 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Set;
+
+/**
+ * 知识条目预览转换异步任务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class KnowledgeItemPreviewAsyncService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String KNOWLEDGE_ITEM_UPLOAD_DIR = "knowledge-items";
+    private static final String PREVIEW_SUB_DIR = "preview";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final int MAX_ERROR_LENGTH = 500;
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final KnowledgeItemRepository knowledgeItemRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Async
+    public void convertPreviewAsync(String itemId) {
+        if (StringUtils.isBlank(itemId)) {
+            return;
+        }
+        KnowledgeItem item = knowledgeItemRepository.getById(itemId);
+        if (item == null) {
+            return;
+        }
+        String extension = resolveFileExtension(resolveOriginalName(item));
+        if (!OFFICE_EXTENSIONS.contains(extension)) {
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, null, "仅支持 DOC/DOCX 转换");
+            return;
+        }
+        if (StringUtils.isBlank(item.getContent())) {
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, null, "源文件路径为空");
+            return;
+        }
+        Path sourcePath = resolveKnowledgeItemStoragePath(item.getContent());
+        if (!Files.exists(sourcePath) || !Files.isRegularFile(sourcePath)) {
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, null, "源文件不存在");
+            return;
+        }
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+        String previewRelativePath = StringUtils.defaultIfBlank(
+            previewInfo.pdfPath(),
+            resolvePreviewRelativePath(item.getSetId(), item.getId())
+        );
+        Path targetPath = resolvePreviewStoragePath(previewRelativePath);
+        ensureParentDirectory(targetPath);
+
+        try {
+            LibreOfficeConverter.convertToPdf(sourcePath, targetPath);
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.READY, previewRelativePath, null);
+        } catch (Exception e) {
+            log.error("preview convert failed, itemId: {}", item.getId(), e);
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, previewRelativePath, trimError(e.getMessage()));
+        }
+    }
+
+    private void updatePreviewStatus(
+        KnowledgeItem item,
+        KnowledgeItemPreviewStatus status,
+        String previewRelativePath,
+        String error
+    ) {
+        if (item == null) {
+            return;
+        }
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            item.getMetadata(),
+            objectMapper,
+            status,
+            previewRelativePath,
+            error,
+            nowText()
+        );
+        item.setMetadata(updatedMetadata);
+        knowledgeItemRepository.updateById(item);
+    }
+
+    private String resolveOriginalName(KnowledgeItem item) {
+        if (item == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(item.getSourceFileId())) {
+            return item.getSourceFileId();
+        }
+        if (StringUtils.isNotBlank(item.getContent())) {
+            return Paths.get(item.getContent()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewRelativePath(String setId, String itemId) {
+        String relativePath = Paths.get(KNOWLEDGE_ITEM_UPLOAD_DIR, setId, PREVIEW_SUB_DIR, itemId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    private Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        if (!target.startsWith(root)) {
+            throw new IllegalArgumentException("invalid preview path");
+        }
+        return target;
+    }
+
+    private Path resolveKnowledgeItemStoragePath(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            throw new IllegalArgumentException("invalid knowledge item path");
+        }
+        String normalizedInput = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        Path root = resolveUploadRootPath();
+        java.util.LinkedHashSet<Path> candidates = new java.util.LinkedHashSet<>();
+
+        Path inputPath = Paths.get(normalizedInput.replace(PATH_SEPARATOR, java.io.File.separator));
+        if (inputPath.isAbsolute()) {
+            Path normalizedAbsolute = inputPath.toAbsolutePath().normalize();
+            if (normalizedAbsolute.startsWith(root)) {
+                candidates.add(normalizedAbsolute);
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            if (candidates.isEmpty()) {
+                throw new IllegalArgumentException("invalid knowledge item path");
+            }
+        } else {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, normalizedRelative));
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && !normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)
+                    && !normalizedRelative.equals(KNOWLEDGE_ITEM_UPLOAD_DIR)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR + normalizedRelative));
+            }
+        }
+
+        if (root.getFileName() != null && KNOWLEDGE_ITEM_UPLOAD_DIR.equals(root.getFileName().toString())) {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)) {
+                String withoutPrefix = normalizedRelative.substring(KNOWLEDGE_ITEM_UPLOAD_DIR.length() + PATH_SEPARATOR.length());
+                if (StringUtils.isNotBlank(withoutPrefix)) {
+                    candidates.add(buildKnowledgeItemStoragePath(root, withoutPrefix));
+                }
+            }
+        }
+
+        Path fallback = null;
+        for (Path candidate : candidates) {
+            if (fallback == null) {
+                fallback = candidate;
+            }
+            if (Files.exists(candidate) && Files.isRegularFile(candidate)) {
+                return candidate;
+            }
+        }
+        if (fallback == null) {
+            throw new IllegalArgumentException("invalid knowledge item path");
+        }
+        return fallback;
+    }
+
+    private Path buildKnowledgeItemStoragePath(Path root, String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace(PATH_SEPARATOR, java.io.File.separator);
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        if (!target.startsWith(root)) {
+            throw new IllegalArgumentException("invalid knowledge item path");
+        }
+        return target;
+    }
+
+    private String extractRelativePathFromSegment(String rawPath, String segment) {
+        if (StringUtils.isBlank(rawPath) || StringUtils.isBlank(segment)) {
+            return null;
+        }
+        String normalized = rawPath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        String segmentPrefix = segment + PATH_SEPARATOR;
+        int index = normalized.indexOf(segmentPrefix);
+        if (index < 0) {
+            return segment.equals(normalized) ? segment : null;
+        }
+        return normalizeRelativePathValue(normalized.substring(index));
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private void ensureParentDirectory(Path targetPath) {
+        try {
+            Path parent = targetPath.getParent();
+            if (parent != null) {
+                Files.createDirectories(parent);
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException("创建预览目录失败", e);
+        }
+    }
+
+    private String trimError(String error) {
+        if (StringUtils.isBlank(error)) {
+            return "";
+        }
+        if (error.length() <= MAX_ERROR_LENGTH) {
+            return error;
+        }
+        return error.substring(0, MAX_ERROR_LENGTH);
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemPreviewMetadataHelper.java

@@ -0,0 +1,134 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * 知识条目预览元数据解析与写入辅助类
+ */
+public final class KnowledgeItemPreviewMetadataHelper {
+    public static final String PREVIEW_STATUS_KEY = "previewStatus";
+    public static final String PREVIEW_PDF_PATH_KEY = "previewPdfPath";
+    public static final String PREVIEW_ERROR_KEY = "previewError";
+    public static final String PREVIEW_UPDATED_AT_KEY = "previewUpdatedAt";
+
+    private KnowledgeItemPreviewMetadataHelper() {
+    }
+
+    public static PreviewInfo readPreviewInfo(String metadata, ObjectMapper objectMapper) {
+        if (StringUtils.isBlank(metadata) || objectMapper == null) {
+            return PreviewInfo.empty();
+        }
+        try {
+            JsonNode node = objectMapper.readTree(metadata);
+            if (node == null || !node.isObject()) {
+                return PreviewInfo.empty();
+            }
+            String statusText = textValue(node, PREVIEW_STATUS_KEY);
+            KnowledgeItemPreviewStatus status = parseStatus(statusText);
+            return new PreviewInfo(
+                status,
+                textValue(node, PREVIEW_PDF_PATH_KEY),
+                textValue(node, PREVIEW_ERROR_KEY),
+                textValue(node, PREVIEW_UPDATED_AT_KEY)
+            );
+        } catch (Exception ignore) {
+            return PreviewInfo.empty();
+        }
+    }
+
+    public static String applyPreviewInfo(
+        String metadata,
+        ObjectMapper objectMapper,
+        KnowledgeItemPreviewStatus status,
+        String pdfPath,
+        String error,
+        String updatedAt
+    ) {
+        if (objectMapper == null) {
+            return metadata;
+        }
+        ObjectNode root = parseRoot(metadata, objectMapper);
+        if (status == null) {
+            root.remove(PREVIEW_STATUS_KEY);
+        } else {
+            root.put(PREVIEW_STATUS_KEY, status.name());
+        }
+        if (StringUtils.isBlank(pdfPath)) {
+            root.remove(PREVIEW_PDF_PATH_KEY);
+        } else {
+            root.put(PREVIEW_PDF_PATH_KEY, pdfPath);
+        }
+        if (StringUtils.isBlank(error)) {
+            root.remove(PREVIEW_ERROR_KEY);
+        } else {
+            root.put(PREVIEW_ERROR_KEY, error);
+        }
+        if (StringUtils.isBlank(updatedAt)) {
+            root.remove(PREVIEW_UPDATED_AT_KEY);
+        } else {
+            root.put(PREVIEW_UPDATED_AT_KEY, updatedAt);
+        }
+        return root.size() == 0 ? null : root.toString();
+    }
+
+    public static String clearPreviewInfo(String metadata, ObjectMapper objectMapper) {
+        if (objectMapper == null) {
+            return metadata;
+        }
+        ObjectNode root = parseRoot(metadata, objectMapper);
+        root.remove(PREVIEW_STATUS_KEY);
+        root.remove(PREVIEW_PDF_PATH_KEY);
+        root.remove(PREVIEW_ERROR_KEY);
+        root.remove(PREVIEW_UPDATED_AT_KEY);
+        return root.size() == 0 ? null : root.toString();
+    }
+
+    private static ObjectNode parseRoot(String metadata, ObjectMapper objectMapper) {
+        if (StringUtils.isBlank(metadata)) {
+            return objectMapper.createObjectNode();
+        }
+        try {
+            JsonNode node = objectMapper.readTree(metadata);
+            if (node instanceof ObjectNode objectNode) {
+                return objectNode;
+            }
+        } catch (Exception ignore) {
+            return objectMapper.createObjectNode();
+        }
+        return objectMapper.createObjectNode();
+    }
+
+    private static String textValue(JsonNode node, String key) {
+        if (node == null || StringUtils.isBlank(key)) {
+            return null;
+        }
+        JsonNode value = node.get(key);
+        return value == null || value.isNull() ? null : value.asText();
+    }
+
+    private static KnowledgeItemPreviewStatus parseStatus(String statusText) {
+        if (StringUtils.isBlank(statusText)) {
+            return null;
+        }
+        try {
+            return KnowledgeItemPreviewStatus.valueOf(statusText);
+        } catch (Exception ignore) {
+            return null;
+        }
+    }
+
+    public record PreviewInfo(
+        KnowledgeItemPreviewStatus status,
+        String pdfPath,
+        String error,
+        String updatedAt
+    ) {
+        public static PreviewInfo empty() {
+            return new PreviewInfo(null, null, null, null);
+        }
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemPreviewService.java

@@ -0,0 +1,244 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.common.infrastructure.exception.BusinessAssert;
+import com.datamate.common.infrastructure.exception.CommonErrorCode;
+import com.datamate.datamanagement.common.enums.KnowledgeContentType;
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPreviewStatusResponse;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * 知识条目预览转换服务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class KnowledgeItemPreviewService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String KNOWLEDGE_ITEM_UPLOAD_DIR = "knowledge-items";
+    private static final String PREVIEW_SUB_DIR = "preview";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final KnowledgeItemRepository knowledgeItemRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final KnowledgeItemPreviewAsyncService knowledgeItemPreviewAsyncService;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    public KnowledgeItemPreviewStatusResponse getPreviewStatus(String setId, String itemId) {
+        KnowledgeItem item = requireKnowledgeItem(setId, itemId);
+        assertOfficeDocument(item);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && !previewPdfExists(item, previewInfo)) {
+            previewInfo = markPreviewFailed(item, previewInfo, "预览文件不存在");
+        }
+
+        return buildResponse(previewInfo);
+    }
+
+    public KnowledgeItemPreviewStatusResponse ensurePreview(String setId, String itemId) {
+        KnowledgeItem item = requireKnowledgeItem(setId, itemId);
+        assertOfficeDocument(item);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && previewPdfExists(item, previewInfo)) {
+            return buildResponse(previewInfo);
+        }
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.PROCESSING) {
+            return buildResponse(previewInfo);
+        }
+
+        String previewRelativePath = resolvePreviewRelativePath(item.getSetId(), item.getId());
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            item.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.PROCESSING,
+            previewRelativePath,
+            null,
+            nowText()
+        );
+        item.setMetadata(updatedMetadata);
+        knowledgeItemRepository.updateById(item);
+        knowledgeItemPreviewAsyncService.convertPreviewAsync(item.getId());
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo refreshed = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(updatedMetadata, objectMapper);
+        return buildResponse(refreshed);
+    }
+
+    public boolean isOfficeDocument(String fileName) {
+        String extension = resolveFileExtension(fileName);
+        return StringUtils.isNotBlank(extension) && OFFICE_EXTENSIONS.contains(extension.toLowerCase());
+    }
+
+    public PreviewFile resolveReadyPreviewFile(String setId, KnowledgeItem item) {
+        if (item == null) {
+            return null;
+        }
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+        if (previewInfo.status() != KnowledgeItemPreviewStatus.READY) {
+            return null;
+        }
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(setId, item.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        if (!Files.exists(filePath) || !Files.isRegularFile(filePath)) {
+            markPreviewFailed(item, previewInfo, "预览文件不存在");
+            return null;
+        }
+        String previewName = resolvePreviewPdfName(item);
+        return new PreviewFile(filePath, previewName);
+    }
+
+    public String clearPreviewMetadata(String metadata) {
+        return KnowledgeItemPreviewMetadataHelper.clearPreviewInfo(metadata, objectMapper);
+    }
+
+    public void deletePreviewFileQuietly(String setId, String itemId) {
+        String relativePath = resolvePreviewRelativePath(setId, itemId);
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        try {
+            Files.deleteIfExists(filePath);
+        } catch (Exception e) {
+            log.warn("delete preview pdf error, itemId: {}", itemId, e);
+        }
+    }
+
+    private KnowledgeItemPreviewStatusResponse buildResponse(KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        KnowledgeItemPreviewStatusResponse response = new KnowledgeItemPreviewStatusResponse();
+        KnowledgeItemPreviewStatus status = previewInfo.status() == null
+            ? KnowledgeItemPreviewStatus.PENDING
+            : previewInfo.status();
+        response.setStatus(status);
+        response.setPreviewError(previewInfo.error());
+        response.setUpdatedAt(previewInfo.updatedAt());
+        return response;
+    }
+
+    private KnowledgeItem requireKnowledgeItem(String setId, String itemId) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(setId), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(StringUtils.isNotBlank(itemId), CommonErrorCode.PARAM_ERROR);
+        KnowledgeItem knowledgeItem = knowledgeItemRepository.getById(itemId);
+        BusinessAssert.notNull(knowledgeItem, CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(Objects.equals(knowledgeItem.getSetId(), setId), CommonErrorCode.PARAM_ERROR);
+        return knowledgeItem;
+    }
+
+    private void assertOfficeDocument(KnowledgeItem item) {
+        BusinessAssert.notNull(item, CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(
+            item.getContentType() == KnowledgeContentType.FILE || item.getSourceType() == KnowledgeSourceType.FILE_UPLOAD,
+            CommonErrorCode.PARAM_ERROR
+        );
+        String extension = resolveFileExtension(resolveOriginalName(item));
+        BusinessAssert.isTrue(OFFICE_EXTENSIONS.contains(extension), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private String resolveOriginalName(KnowledgeItem item) {
+        if (item == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(item.getSourceFileId())) {
+            return item.getSourceFileId();
+        }
+        if (StringUtils.isNotBlank(item.getContent())) {
+            return Paths.get(item.getContent()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewPdfName(KnowledgeItem item) {
+        String originalName = resolveOriginalName(item);
+        if (StringUtils.isBlank(originalName)) {
+            return "预览.pdf";
+        }
+        int dotIndex = originalName.lastIndexOf('.');
+        if (dotIndex <= 0) {
+            return originalName + PREVIEW_FILE_SUFFIX;
+        }
+        return originalName.substring(0, dotIndex) + PREVIEW_FILE_SUFFIX;
+    }
+
+    private boolean previewPdfExists(KnowledgeItem item, KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(item.getSetId(), item.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        return Files.exists(filePath) && Files.isRegularFile(filePath);
+    }
+
+    private KnowledgeItemPreviewMetadataHelper.PreviewInfo markPreviewFailed(
+        KnowledgeItem item,
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo,
+        String error
+    ) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(item.getSetId(), item.getId()));
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            item.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.FAILED,
+            relativePath,
+            error,
+            nowText()
+        );
+        item.setMetadata(updatedMetadata);
+        knowledgeItemRepository.updateById(item);
+        return KnowledgeItemPreviewMetadataHelper.readPreviewInfo(updatedMetadata, objectMapper);
+    }
+
+    private String resolvePreviewRelativePath(String setId, String itemId) {
+        String relativePath = Paths.get(KNOWLEDGE_ITEM_UPLOAD_DIR, setId, PREVIEW_SUB_DIR, itemId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    private Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        BusinessAssert.isTrue(target.startsWith(root), CommonErrorCode.PARAM_ERROR);
+        return target;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        BusinessAssert.isTrue(StringUtils.isNotBlank(uploadDir), CommonErrorCode.PARAM_ERROR);
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+
+    public record PreviewFile(Path filePath, String fileName) {
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/LibreOfficeConverter.java

@@ -0,0 +1,93 @@
+package com.datamate.datamanagement.application;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * LibreOffice 文档转换工具
+ */
+public final class LibreOfficeConverter {
+    private static final String LIBREOFFICE_COMMAND = "soffice";
+    private static final Duration CONVERT_TIMEOUT = Duration.ofMinutes(5);
+    private static final int MAX_OUTPUT_LENGTH = 500;
+
+    private LibreOfficeConverter() {
+    }
+
+    public static void convertToPdf(Path sourcePath, Path targetPath) throws Exception {
+        Path outputDir = targetPath.getParent();
+        List<String> command = List.of(
+            LIBREOFFICE_COMMAND,
+            "--headless",
+            "--nologo",
+            "--nolockcheck",
+            "--nodefault",
+            "--nofirststartwizard",
+            "--convert-to",
+            "pdf",
+            "--outdir",
+            outputDir.toString(),
+            sourcePath.toString()
+        );
+        ProcessBuilder processBuilder = new ProcessBuilder(command);
+        processBuilder.redirectErrorStream(true);
+        Process process = processBuilder.start();
+        boolean finished = process.waitFor(CONVERT_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS);
+        String output = readProcessOutput(process.getInputStream());
+        if (!finished) {
+            process.destroyForcibly();
+            throw new IllegalStateException("LibreOffice 转换超时");
+        }
+        if (process.exitValue() != 0) {
+            throw new IllegalStateException("LibreOffice 转换失败: " + output);
+        }
+        Path generated = outputDir.resolve(stripExtension(sourcePath.getFileName().toString()) + ".pdf");
+        if (!Files.exists(generated)) {
+            throw new IllegalStateException("LibreOffice 输出文件不存在");
+        }
+        if (!generated.equals(targetPath)) {
+            Files.move(generated, targetPath, StandardCopyOption.REPLACE_EXISTING);
+        }
+    }
+
+    private static String readProcessOutput(InputStream inputStream) throws IOException {
+        if (inputStream == null) {
+            return "";
+        }
+        byte[] buffer = new byte[1024];
+        StringBuilder builder = new StringBuilder();
+        int total = 0;
+        int read;
+        while ((read = inputStream.read(buffer)) >= 0) {
+            if (read == 0) {
+                continue;
+            }
+            int remaining = MAX_OUTPUT_LENGTH - total;
+            if (remaining <= 0) {
+                break;
+            }
+            int toAppend = Math.min(remaining, read);
+            builder.append(new String(buffer, 0, toAppend, StandardCharsets.UTF_8));
+            total += toAppend;
+            if (total >= MAX_OUTPUT_LENGTH) {
+                break;
+            }
+        }
+        return builder.toString();
+    }
+
+    private static String stripExtension(String fileName) {
+        if (fileName == null || fileName.isBlank()) {
+            return "preview";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        return dotIndex <= 0 ? fileName : fileName.substring(0, dotIndex);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/common/enums/KnowledgeItemPreviewStatus.java

@@ -0,0 +1,11 @@
+package com.datamate.datamanagement.common.enums;
+
+/**
+ * 知识条目预览转换状态
+ */
+public enum KnowledgeItemPreviewStatus {
+    PENDING,
+    PROCESSING,
+    READY,
+    FAILED
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/domain/model/dataset/Dataset.java

@@ -114,9 +114,9 @@ public class Dataset extends BaseEntity<String> {
         this.updatedAt = LocalDateTime.now();
     }
 
-    public void initCreateParam(String datasetBasePath, String parentPath) {
+    public void initCreateParam(String datasetBasePath) {
         this.id = UUID.randomUUID().toString();
-        String basePath = normalizeBasePath(parentPath != null && !parentPath.isBlank() ? parentPath : datasetBasePath);
+        String basePath = normalizeBasePath(datasetBasePath);
         this.path = basePath + File.separator + this.id;
         if (this.status == null) {
             this.status = DatasetStatusType.DRAFT;

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/domain/model/knowledge/KnowledgeItem.java

@@ -38,4 +38,12 @@ public class KnowledgeItem extends BaseEntity<String> {
      * 来源文件ID
      */
     private String sourceFileId;
+    /**
+     * 相对路径（用于目录展示）
+     */
+    private String relativePath;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/domain/model/knowledge/KnowledgeItemDirectory.java

@@ -0,0 +1,29 @@
+package com.datamate.datamanagement.domain.model.knowledge;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.datamate.common.domain.model.base.BaseEntity;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目目录实体（与数据库表 t_dm_knowledge_item_directories 对齐）
+ */
+@Getter
+@Setter
+@TableName(value = "t_dm_knowledge_item_directories", autoResultMap = true)
+public class KnowledgeItemDirectory extends BaseEntity<String> {
+    /**
+     * 所属知识集ID
+     */
+    private String setId;
+
+    /**
+     * 目录名称
+     */
+    private String name;
+
+    /**
+     * 目录相对路径
+     */
+    private String relativePath;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/exception/DataManagementErrorCode.java

@@ -42,9 +42,9 @@ public enum DataManagementErrorCode implements ErrorCode {
      */
     DIRECTORY_NOT_FOUND("data_management.0007", "目录不存在"),
     /**
-     * 存在子数据集
+     * 存在关联数据集
      */
-    DATASET_HAS_CHILDREN("data_management.0008", "存在子数据集，禁止删除或移动"),
+    DATASET_HAS_CHILDREN("data_management.0008", "存在关联数据集，禁止删除或移动"),
     /**
      * 数据集文件不存在
      */

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/DatasetFileMapper.java

@@ -2,6 +2,7 @@ package com.datamate.datamanagement.infrastructure.persistence.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.session.RowBounds;
@@ -17,6 +18,7 @@ public interface DatasetFileMapper extends BaseMapper<DatasetFile> {
     Long countByDatasetId(@Param("datasetId") String datasetId);
     Long countCompletedByDatasetId(@Param("datasetId") String datasetId);
     Long sumSizeByDatasetId(@Param("datasetId") String datasetId);
+    Long countNonDerivedByDatasetId(@Param("datasetId") String datasetId);
     DatasetFile findByDatasetIdAndFileName(@Param("datasetId") String datasetId, @Param("fileName") String fileName);
     List<DatasetFile> findAllByDatasetId(@Param("datasetId") String datasetId);
     List<DatasetFile> findByCriteria(@Param("datasetId") String datasetId,
@@ -38,4 +40,12 @@ public interface DatasetFileMapper extends BaseMapper<DatasetFile> {
      * @return 源文件ID列表
      */
     List<String> findSourceFileIdsWithDerivedFiles(@Param("datasetId") String datasetId);
+
+    /**
+     * 批量统计排除衍生文件后的文件数
+     *
+     * @param datasetIds 数据集ID列表
+     * @return 文件数统计列表
+     */
+    List<DatasetFileCount> countNonDerivedByDatasetIds(@Param("datasetIds") List<String> datasetIds);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/KnowledgeItemDirectoryMapper.java

@@ -0,0 +1,9 @@
+package com.datamate.datamanagement.infrastructure.persistence.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface KnowledgeItemDirectoryMapper extends BaseMapper<KnowledgeItemDirectory> {
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/KnowledgeItemMapper.java

@@ -1,9 +1,52 @@
 package com.datamate.datamanagement.infrastructure.persistence.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
 
 @Mapper
 public interface KnowledgeItemMapper extends BaseMapper<KnowledgeItem> {
+    @Select("""
+        SELECT
+            ki.id AS id,
+            ki.set_id AS setId,
+            ks.name AS setName,
+            ki.content_type AS contentType,
+            ki.source_type AS sourceType,
+            ki.source_dataset_id AS sourceDatasetId,
+            ki.source_file_id AS sourceFileId,
+            CASE
+                WHEN ki.source_type = 'DATASET_FILE' THEN df.file_name
+                ELSE ki.source_file_id
+            END AS fileName,
+            df.file_size AS fileSize,
+            CASE
+                WHEN ki.source_type = 'FILE_UPLOAD' THEN ki.content
+                ELSE NULL
+            END AS content,
+            ki.relative_path AS relativePath,
+            ki.created_at AS createdAt,
+            ki.updated_at AS updatedAt
+        FROM t_dm_knowledge_items ki
+        LEFT JOIN t_dm_knowledge_sets ks ON ki.set_id = ks.id
+        LEFT JOIN t_dm_dataset_files df ON ki.source_file_id = df.id AND ki.source_type = 'DATASET_FILE'
+        WHERE (ki.source_type = 'FILE_UPLOAD' AND (ki.source_file_id LIKE CONCAT('%', #{keyword}, '%')
+           OR ki.relative_path LIKE CONCAT('%', #{keyword}, '%')))
+           OR (ki.source_type = 'DATASET_FILE' AND (df.file_name LIKE CONCAT('%', #{keyword}, '%')
+           OR ki.relative_path LIKE CONCAT('%', #{keyword}, '%')))
+        ORDER BY ki.created_at DESC
+        """)
+    IPage<KnowledgeItemSearchResponse> searchFileItems(IPage<?> page, @Param("keyword") String keyword);
+
+    @Select("""
+        SELECT COALESCE(SUM(df.file_size), 0)
+        FROM t_dm_knowledge_items ki
+        LEFT JOIN t_dm_dataset_files df ON ki.source_file_id = df.id
+        WHERE ki.source_type = 'DATASET_FILE'
+        """)
+    Long sumDatasetFileSize();
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/TagMapper.java

@@ -14,6 +14,7 @@ public interface TagMapper {
     List<Tag> findByIdIn(@Param("ids") List<String> ids);
     List<Tag> findByKeyword(@Param("keyword") String keyword);
     List<Tag> findAllByOrderByUsageCountDesc();
+    Long countKnowledgeSetTags();
 
     int insert(Tag tag);
     int update(Tag tag);

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/DatasetFileRepository.java

@@ -3,6 +3,7 @@ package com.datamate.datamanagement.infrastructure.persistence.repository;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.repository.IRepository;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 
 import java.util.List;
 
@@ -15,6 +16,8 @@ import java.util.List;
 public interface DatasetFileRepository extends IRepository<DatasetFile> {
     Long countByDatasetId(String datasetId);
 
+    Long countNonDerivedByDatasetId(String datasetId);
+
     Long countCompletedByDatasetId(String datasetId);
 
     Long sumSizeByDatasetId(String datasetId);
@@ -36,4 +39,6 @@ public interface DatasetFileRepository extends IRepository<DatasetFile> {
      * @return 源文件ID列表
      */
     List<String> findSourceFileIdsWithDerivedFiles(String datasetId);
+
+    List<DatasetFileCount> countNonDerivedByDatasetIds(List<String> datasetIds);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/KnowledgeItemDirectoryRepository.java

@@ -0,0 +1,18 @@
+package com.datamate.datamanagement.infrastructure.persistence.repository;
+
+import com.baomidou.mybatisplus.extension.repository.IRepository;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+
+import java.util.List;
+
+/**
+ * 知识条目目录仓储接口
+ */
+public interface KnowledgeItemDirectoryRepository extends IRepository<KnowledgeItemDirectory> {
+    List<KnowledgeItemDirectory> findByCriteria(KnowledgeDirectoryQuery query);
+
+    KnowledgeItemDirectory findBySetIdAndPath(String setId, String relativePath);
+
+    int removeByRelativePathPrefix(String setId, String relativePath);
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/KnowledgeItemRepository.java

@@ -2,8 +2,11 @@ package com.datamate.datamanagement.infrastructure.persistence.repository;
 
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.repository.IRepository;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
 import java.util.List;
 
 /**
@@ -15,4 +18,16 @@ public interface KnowledgeItemRepository extends IRepository<KnowledgeItem> {
     long countBySetId(String setId);
 
     List<KnowledgeItem> findAllBySetId(String setId);
+
+    long countBySourceTypes(List<KnowledgeSourceType> sourceTypes);
+
+    List<KnowledgeItem> findFileUploadItems();
+
+    IPage<KnowledgeItemSearchResponse> searchFileItems(IPage<?> page, String keyword);
+
+    Long sumDatasetFileSize();
+
+    boolean existsBySetIdAndRelativePath(String setId, String relativePath);
+
+    int removeByRelativePathPrefix(String setId, String relativePath);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/dto/DatasetFileCount.java

@@ -0,0 +1,18 @@
+package com.datamate.datamanagement.infrastructure.persistence.repository.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * 数据集文件数统计结果
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class DatasetFileCount {
+    private String datasetId;
+    private Long fileCount;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/impl/DatasetFileRepositoryImpl.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.extension.repository.CrudRepository;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
 import com.datamate.datamanagement.infrastructure.persistence.mapper.DatasetFileMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 import org.springframework.util.StringUtils;
@@ -30,6 +31,11 @@ public class DatasetFileRepositoryImpl extends CrudRepository<DatasetFileMapper,
         return datasetFileMapper.selectCount(new LambdaQueryWrapper<DatasetFile>().eq(DatasetFile::getDatasetId, datasetId));
     }
 
+    @Override
+    public Long countNonDerivedByDatasetId(String datasetId) {
+        return datasetFileMapper.countNonDerivedByDatasetId(datasetId);
+    }
+
     @Override
     public Long countCompletedByDatasetId(String datasetId) {
         return datasetFileMapper.countCompletedByDatasetId(datasetId);
@@ -71,4 +77,9 @@ public class DatasetFileRepositoryImpl extends CrudRepository<DatasetFileMapper,
         // 使用 MyBatis 的 @Select 注解或直接调用 mapper 方法
         return datasetFileMapper.findSourceFileIdsWithDerivedFiles(datasetId);
     }
+
+    @Override
+    public List<DatasetFileCount> countNonDerivedByDatasetIds(List<String> datasetIds) {
+        return datasetFileMapper.countNonDerivedByDatasetIds(datasetIds);
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/impl/KnowledgeItemDirectoryRepositoryImpl.java

@@ -0,0 +1,96 @@
+package com.datamate.datamanagement.infrastructure.persistence.repository.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.repository.CrudRepository;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.infrastructure.persistence.mapper.KnowledgeItemDirectoryMapper;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemDirectoryRepository;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * 知识条目目录仓储实现类
+ */
+@Repository
+@RequiredArgsConstructor
+public class KnowledgeItemDirectoryRepositoryImpl
+    extends CrudRepository<KnowledgeItemDirectoryMapper, KnowledgeItemDirectory>
+    implements KnowledgeItemDirectoryRepository {
+
+    private static final String PATH_SEPARATOR = "/";
+    private final KnowledgeItemDirectoryMapper knowledgeItemDirectoryMapper;
+
+    @Override
+    public List<KnowledgeItemDirectory> findByCriteria(KnowledgeDirectoryQuery query) {
+        String relativePath = normalizeRelativePathPrefix(query.getRelativePath());
+        LambdaQueryWrapper<KnowledgeItemDirectory> wrapper = new LambdaQueryWrapper<KnowledgeItemDirectory>()
+            .eq(StringUtils.isNotBlank(query.getSetId()), KnowledgeItemDirectory::getSetId, query.getSetId())
+            .likeRight(StringUtils.isNotBlank(relativePath), KnowledgeItemDirectory::getRelativePath, relativePath);
+
+        if (StringUtils.isNotBlank(query.getKeyword())) {
+            wrapper.and(w -> w.like(KnowledgeItemDirectory::getName, query.getKeyword())
+                .or()
+                .like(KnowledgeItemDirectory::getRelativePath, query.getKeyword()));
+        }
+
+        wrapper.orderByAsc(KnowledgeItemDirectory::getRelativePath);
+        return knowledgeItemDirectoryMapper.selectList(wrapper);
+    }
+
+    @Override
+    public KnowledgeItemDirectory findBySetIdAndPath(String setId, String relativePath) {
+        return knowledgeItemDirectoryMapper.selectOne(new LambdaQueryWrapper<KnowledgeItemDirectory>()
+            .eq(KnowledgeItemDirectory::getSetId, setId)
+            .eq(KnowledgeItemDirectory::getRelativePath, relativePath));
+    }
+
+    @Override
+    public int removeByRelativePathPrefix(String setId, String relativePath) {
+        String normalized = normalizeRelativePathValue(relativePath);
+        if (StringUtils.isBlank(normalized)) {
+            return 0;
+        }
+        String prefix = normalizeRelativePathPrefix(normalized);
+        LambdaQueryWrapper<KnowledgeItemDirectory> wrapper = new LambdaQueryWrapper<KnowledgeItemDirectory>()
+            .eq(KnowledgeItemDirectory::getSetId, setId)
+            .and(w -> w.eq(KnowledgeItemDirectory::getRelativePath, normalized)
+                .or()
+                .likeRight(KnowledgeItemDirectory::getRelativePath, prefix));
+        return knowledgeItemDirectoryMapper.delete(wrapper);
+    }
+
+    private String normalizeRelativePathPrefix(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        if (!normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized + PATH_SEPARATOR;
+        }
+        return normalized;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/impl/KnowledgeItemRepositoryImpl.java

@@ -3,10 +3,12 @@ package com.datamate.datamanagement.infrastructure.persistence.repository.impl;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.repository.CrudRepository;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.infrastructure.persistence.mapper.KnowledgeItemMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Repository;
@@ -19,21 +21,26 @@ import java.util.List;
 @Repository
 @RequiredArgsConstructor
 public class KnowledgeItemRepositoryImpl extends CrudRepository<KnowledgeItemMapper, KnowledgeItem> implements KnowledgeItemRepository {
+    private static final String PATH_SEPARATOR = "/";
     private final KnowledgeItemMapper knowledgeItemMapper;
 
     @Override
     public IPage<KnowledgeItem> findByCriteria(IPage<KnowledgeItem> page, KnowledgeItemPagingQuery query) {
+        String relativePath = normalizeRelativePathPrefix(query.getRelativePath());
         LambdaQueryWrapper<KnowledgeItem> wrapper = new LambdaQueryWrapper<KnowledgeItem>()
             .eq(StringUtils.isNotBlank(query.getSetId()), KnowledgeItem::getSetId, query.getSetId())
             .eq(query.getContentType() != null, KnowledgeItem::getContentType, query.getContentType())
             .eq(query.getSourceType() != null, KnowledgeItem::getSourceType, query.getSourceType())
             .eq(StringUtils.isNotBlank(query.getSourceDatasetId()), KnowledgeItem::getSourceDatasetId, query.getSourceDatasetId())
-            .eq(StringUtils.isNotBlank(query.getSourceFileId()), KnowledgeItem::getSourceFileId, query.getSourceFileId());
+            .eq(StringUtils.isNotBlank(query.getSourceFileId()), KnowledgeItem::getSourceFileId, query.getSourceFileId())
+            .likeRight(StringUtils.isNotBlank(relativePath), KnowledgeItem::getRelativePath, relativePath);
 
         if (StringUtils.isNotBlank(query.getKeyword())) {
             wrapper.and(w -> w.like(KnowledgeItem::getSourceFileId, query.getKeyword())
                 .or()
-                .like(KnowledgeItem::getContent, query.getKeyword()));
+                .like(KnowledgeItem::getContent, query.getKeyword())
+                .or()
+                .like(KnowledgeItem::getRelativePath, query.getKeyword()));
         }
 
         wrapper.orderByDesc(KnowledgeItem::getCreatedAt);
@@ -52,4 +59,83 @@ public class KnowledgeItemRepositoryImpl extends CrudRepository<KnowledgeItemMap
             .eq(KnowledgeItem::getSetId, setId)
             .orderByDesc(KnowledgeItem::getCreatedAt));
     }
+
+    @Override
+    public long countBySourceTypes(List<KnowledgeSourceType> sourceTypes) {
+        return knowledgeItemMapper.selectCount(new LambdaQueryWrapper<KnowledgeItem>()
+            .in(KnowledgeItem::getSourceType, sourceTypes));
+    }
+
+    @Override
+    public List<KnowledgeItem> findFileUploadItems() {
+        return knowledgeItemMapper.selectList(new LambdaQueryWrapper<KnowledgeItem>()
+            .eq(KnowledgeItem::getSourceType, KnowledgeSourceType.FILE_UPLOAD)
+            .select(KnowledgeItem::getId, KnowledgeItem::getContent, KnowledgeItem::getSourceFileId));
+    }
+
+    @Override
+    public IPage<KnowledgeItemSearchResponse> searchFileItems(IPage<?> page, String keyword) {
+        return knowledgeItemMapper.searchFileItems(page, keyword);
+    }
+
+    @Override
+    public Long sumDatasetFileSize() {
+        return knowledgeItemMapper.sumDatasetFileSize();
+    }
+
+    @Override
+    public boolean existsBySetIdAndRelativePath(String setId, String relativePath) {
+        if (StringUtils.isBlank(setId) || StringUtils.isBlank(relativePath)) {
+            return false;
+        }
+        return knowledgeItemMapper.selectCount(new LambdaQueryWrapper<KnowledgeItem>()
+            .eq(KnowledgeItem::getSetId, setId)
+            .eq(KnowledgeItem::getRelativePath, relativePath)) > 0;
+    }
+
+    @Override
+    public int removeByRelativePathPrefix(String setId, String relativePath) {
+        String normalized = normalizeRelativePathValue(relativePath);
+        if (StringUtils.isBlank(setId) || StringUtils.isBlank(normalized)) {
+            return 0;
+        }
+        String prefix = normalizeRelativePathPrefix(normalized);
+        LambdaQueryWrapper<KnowledgeItem> wrapper = new LambdaQueryWrapper<KnowledgeItem>()
+            .eq(KnowledgeItem::getSetId, setId)
+            .and(w -> w.eq(KnowledgeItem::getRelativePath, normalized)
+                .or()
+                .likeRight(KnowledgeItem::getRelativePath, prefix));
+        return knowledgeItemMapper.delete(wrapper);
+    }
+
+    private String normalizeRelativePathPrefix(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        if (!normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized + PATH_SEPARATOR;
+        }
+        return normalized;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/converter/KnowledgeConverter.java

@@ -1,9 +1,11 @@
 package com.datamate.datamanagement.interfaces.converter;
 
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeItemRequest;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeSetRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeSetResponse;
 import org.mapstruct.Mapper;
@@ -31,4 +33,8 @@ public interface KnowledgeConverter {
     KnowledgeItemResponse convertToResponse(KnowledgeItem knowledgeItem);
 
     List<KnowledgeItemResponse> convertItemResponses(List<KnowledgeItem> items);
+
+    KnowledgeDirectoryResponse convertToResponse(KnowledgeItemDirectory directory);
+
+    List<KnowledgeDirectoryResponse> convertDirectoryResponses(List<KnowledgeItemDirectory> directories);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/CreateKnowledgeDirectoryRequest.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 创建知识条目目录请求
+ */
+@Getter
+@Setter
+public class CreateKnowledgeDirectoryRequest {
+
+    /** 父级前缀路径，例如 "docs/"，为空表示知识集根目录 */
+    private String parentPrefix;
+
+    /** 新建目录名称 */
+    @NotBlank
+    private String directoryName;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/CreateKnowledgeItemRequest.java

@@ -34,4 +34,8 @@ public class CreateKnowledgeItemRequest {
      * 来源文件ID（用于标注同步等场景）
      */
     private String sourceFileId;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/DatasetFilePreviewStatusResponse.java

@@ -0,0 +1,16 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 数据集文件预览状态响应
+ */
+@Getter
+@Setter
+public class DatasetFilePreviewStatusResponse {
+    private KnowledgeItemPreviewStatus status;
+    private String previewError;
+    private String updatedAt;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/DeleteKnowledgeItemsRequest.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+/**
+ * 批量删除知识条目请求
+ */
+@Getter
+@Setter
+public class DeleteKnowledgeItemsRequest {
+    /**
+     * 知识条目ID列表
+     */
+    @NotEmpty(message = "知识条目ID不能为空")
+    private List<String> ids;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeDirectoryQuery.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目目录查询参数
+ */
+@Getter
+@Setter
+public class KnowledgeDirectoryQuery {
+    /** 所属知识集ID */
+    private String setId;
+
+    /** 目录相对路径前缀 */
+    private String relativePath;
+
+    /** 搜索关键字 */
+    private String keyword;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeDirectoryResponse.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * 知识条目目录响应
+ */
+@Getter
+@Setter
+public class KnowledgeDirectoryResponse {
+    private String id;
+    private String setId;
+    private String name;
+    private String relativePath;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemPagingQuery.java

@@ -41,4 +41,8 @@ public class KnowledgeItemPagingQuery extends PagingQuery {
      * 来源文件ID
      */
     private String sourceFileId;
+    /**
+     * 相对路径前缀
+     */
+    private String relativePath;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemPreviewStatusResponse.java

@@ -0,0 +1,16 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目预览状态响应
+ */
+@Getter
+@Setter
+public class KnowledgeItemPreviewStatusResponse {
+    private KnowledgeItemPreviewStatus status;
+    private String previewError;
+    private String updatedAt;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemResponse.java

@@ -20,6 +20,14 @@ public class KnowledgeItemResponse {
     private KnowledgeSourceType sourceType;
     private String sourceDatasetId;
     private String sourceFileId;
+    /**
+     * 相对路径（用于目录展示）
+     */
+    private String relativePath;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
     private LocalDateTime createdAt;
     private LocalDateTime updatedAt;
     private String createdBy;

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemSearchQuery.java

@@ -0,0 +1,17 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.common.interfaces.PagingQuery;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目文件搜索请求
+ */
+@Getter
+@Setter
+public class KnowledgeItemSearchQuery extends PagingQuery {
+    /**
+     * 文件名关键词
+     */
+    private String keyword;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemSearchResponse.java

@@ -0,0 +1,35 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.datamanagement.common.enums.KnowledgeContentType;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * 知识条目文件搜索响应
+ */
+@Getter
+@Setter
+public class KnowledgeItemSearchResponse {
+    private String id;
+    private String setId;
+    private String setName;
+    private KnowledgeContentType contentType;
+    private KnowledgeSourceType sourceType;
+    private String sourceDatasetId;
+    private String sourceFileId;
+    private String fileName;
+    private Long fileSize;
+    /**
+     * 相对路径（用于目录展示）
+     */
+    private String relativePath;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+
+    @JsonIgnore
+    private String content;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeManagementStatisticsResponse.java

@@ -0,0 +1,16 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识管理统计响应
+ */
+@Getter
+@Setter
+public class KnowledgeManagementStatisticsResponse {
+    private Long totalKnowledgeSets = 0L;
+    private Long totalFiles = 0L;
+    private Long totalSize = 0L;
+    private Long totalTags = 0L;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UpdateDatasetRequest.java

@@ -1,8 +1,10 @@
 package com.datamate.datamanagement.interfaces.dto;
 
 import com.datamate.datamanagement.common.enums.DatasetStatusType;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Size;
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -24,9 +26,18 @@ public class UpdateDatasetRequest {
     /** 归集任务id */
     private String dataSource;
     /** 父数据集ID */
+    @Setter(AccessLevel.NONE)
     private String parentDatasetId;
+    @JsonIgnore
+    @Setter(AccessLevel.NONE)
+    private boolean parentDatasetIdProvided;
     /** 标签列表 */
     private List<String> tags;
     /** 数据集状态 */
     private DatasetStatusType status;
+
+    public void setParentDatasetId(String parentDatasetId) {
+        this.parentDatasetIdProvided = true;
+        this.parentDatasetId = parentDatasetId;
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UpdateKnowledgeItemRequest.java

@@ -18,4 +18,8 @@ public class UpdateKnowledgeItemRequest {
      * 内容类型
      */
     private KnowledgeContentType contentType;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UploadKnowledgeItemsRequest.java

@@ -17,4 +17,8 @@ public class UploadKnowledgeItemsRequest {
      */
     @NotEmpty(message = "文件列表不能为空")
     private List<MultipartFile> files;
+    /**
+     * 目录前缀（用于目录上传）
+     */
+    private String parentPrefix;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/DatasetFileController.java

@@ -5,20 +5,23 @@ import com.datamate.common.infrastructure.common.Response;
 import com.datamate.common.infrastructure.exception.SystemErrorCode;
 import com.datamate.common.interfaces.PagedResponse;
 import com.datamate.common.interfaces.PagingQuery;
-import com.datamate.datamanagement.application.DatasetFileApplicationService;
+import com.datamate.datamanagement.application.DatasetFileApplicationService;
+import com.datamate.datamanagement.application.DatasetFilePreviewService;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
 import com.datamate.datamanagement.interfaces.converter.DatasetConverter;
-import com.datamate.datamanagement.interfaces.dto.AddFilesRequest;
-import com.datamate.datamanagement.interfaces.dto.CopyFilesRequest;
-import com.datamate.datamanagement.interfaces.dto.CreateDirectoryRequest;
-import com.datamate.datamanagement.interfaces.dto.DatasetFileResponse;
-import com.datamate.datamanagement.interfaces.dto.UploadFileRequest;
-import com.datamate.datamanagement.interfaces.dto.UploadFilesPreRequest;
+import com.datamate.datamanagement.interfaces.dto.AddFilesRequest;
+import com.datamate.datamanagement.interfaces.dto.CopyFilesRequest;
+import com.datamate.datamanagement.interfaces.dto.CreateDirectoryRequest;
+import com.datamate.datamanagement.interfaces.dto.DatasetFilePreviewStatusResponse;
+import com.datamate.datamanagement.interfaces.dto.DatasetFileResponse;
+import com.datamate.datamanagement.interfaces.dto.UploadFileRequest;
+import com.datamate.datamanagement.interfaces.dto.UploadFilesPreRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import jakarta.validation.Valid;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.core.io.Resource;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.UrlResource;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -36,32 +39,41 @@ import java.util.List;
 @RequestMapping("/data-management/datasets/{datasetId}/files")
 public class DatasetFileController {
 
-    private final DatasetFileApplicationService datasetFileApplicationService;
+    private final DatasetFileApplicationService datasetFileApplicationService;
+    private final DatasetFilePreviewService datasetFilePreviewService;
 
     @Autowired
-    public DatasetFileController(DatasetFileApplicationService datasetFileApplicationService) {
-        this.datasetFileApplicationService = datasetFileApplicationService;
-    }
+    public DatasetFileController(DatasetFileApplicationService datasetFileApplicationService,
+                                 DatasetFilePreviewService datasetFilePreviewService) {
+        this.datasetFileApplicationService = datasetFileApplicationService;
+        this.datasetFilePreviewService = datasetFilePreviewService;
+    }
 
     @GetMapping
-    public Response<PagedResponse<DatasetFile>> getDatasetFiles(
-            @PathVariable("datasetId") String datasetId,
-            @RequestParam(value = "isWithDirectory", required = false) boolean isWithDirectory,
-            @RequestParam(value = "page", required = false, defaultValue = "0") Integer page,
-            @RequestParam(value = "size", required = false, defaultValue = "20") Integer size,
-            @RequestParam(value = "prefix", required = false, defaultValue = "") String prefix,
-            @RequestParam(value = "status", required = false) String status,
-            @RequestParam(value = "hasAnnotation", required = false) Boolean hasAnnotation,
-            @RequestParam(value = "excludeSourceDocuments", required = false, defaultValue = "false") Boolean excludeSourceDocuments) {
-        PagingQuery pagingQuery = new PagingQuery(page, size);
-        PagedResponse<DatasetFile> filesPage;
-        if (isWithDirectory) {
-            filesPage = datasetFileApplicationService.getDatasetFilesWithDirectory(datasetId, prefix, pagingQuery);
-        } else {
-            filesPage = datasetFileApplicationService.getDatasetFiles(datasetId, null, status, null, hasAnnotation, 
-                    Boolean.TRUE.equals(excludeSourceDocuments), pagingQuery);
-        }
-        return Response.ok(filesPage);
+    public Response<PagedResponse<DatasetFile>> getDatasetFiles(
+            @PathVariable("datasetId") String datasetId,
+            @RequestParam(value = "isWithDirectory", required = false) boolean isWithDirectory,
+            @RequestParam(value = "page", required = false, defaultValue = "0") Integer page,
+            @RequestParam(value = "size", required = false, defaultValue = "20") Integer size,
+            @RequestParam(value = "prefix", required = false, defaultValue = "") String prefix,
+            @RequestParam(value = "status", required = false) String status,
+            @RequestParam(value = "hasAnnotation", required = false) Boolean hasAnnotation,
+            @RequestParam(value = "excludeSourceDocuments", required = false, defaultValue = "false") Boolean excludeSourceDocuments,
+            @RequestParam(value = "excludeDerivedFiles", required = false, defaultValue = "false") Boolean excludeDerivedFiles) {
+        PagingQuery pagingQuery = new PagingQuery(page, size);
+        PagedResponse<DatasetFile> filesPage;
+        if (isWithDirectory) {
+            filesPage = datasetFileApplicationService.getDatasetFilesWithDirectory(
+                datasetId,
+                prefix,
+                Boolean.TRUE.equals(excludeDerivedFiles),
+                pagingQuery
+            );
+        } else {
+            filesPage = datasetFileApplicationService.getDatasetFiles(datasetId, null, status, null, hasAnnotation, 
+                    Boolean.TRUE.equals(excludeSourceDocuments), pagingQuery);
+        }
+        return Response.ok(filesPage);
     }
 
     @GetMapping("/{fileId}")
@@ -108,15 +120,28 @@ public class DatasetFileController {
         }
     }
 
-    @IgnoreResponseWrap
-    @GetMapping(value = "/{fileId}/preview", produces = MediaType.ALL_VALUE)
-    public ResponseEntity<Resource> previewDatasetFileById(@PathVariable("datasetId") String datasetId,
-                                                           @PathVariable("fileId") String fileId) {
-        try {
-            DatasetFile datasetFile = datasetFileApplicationService.getDatasetFile(datasetId, fileId);
-            Resource resource = datasetFileApplicationService.downloadFile(datasetId, fileId);
-            MediaType mediaType = MediaTypeFactory.getMediaType(resource)
-                    .orElse(MediaType.APPLICATION_OCTET_STREAM);
+    @IgnoreResponseWrap
+    @GetMapping(value = "/{fileId}/preview", produces = MediaType.ALL_VALUE)
+    public ResponseEntity<Resource> previewDatasetFileById(@PathVariable("datasetId") String datasetId,
+                                                           @PathVariable("fileId") String fileId) {
+        try {
+            DatasetFile datasetFile = datasetFileApplicationService.getDatasetFile(datasetId, fileId);
+            if (datasetFilePreviewService.isOfficeDocument(datasetFile.getFileName())) {
+                DatasetFilePreviewService.PreviewFile previewFile = datasetFilePreviewService
+                    .resolveReadyPreviewFile(datasetId, datasetFile);
+                if (previewFile == null) {
+                    return ResponseEntity.status(HttpStatus.CONFLICT).build();
+                }
+                Resource previewResource = new UrlResource(previewFile.filePath().toUri());
+                return ResponseEntity.ok()
+                        .contentType(MediaType.APPLICATION_PDF)
+                        .header(HttpHeaders.CONTENT_DISPOSITION,
+                                "inline; filename=\"" + previewFile.fileName() + "\"")
+                        .body(previewResource);
+            }
+            Resource resource = datasetFileApplicationService.downloadFile(datasetId, fileId);
+            MediaType mediaType = MediaTypeFactory.getMediaType(resource)
+                    .orElse(MediaType.APPLICATION_OCTET_STREAM);
 
             return ResponseEntity.ok()
                     .contentType(mediaType)
@@ -127,8 +152,20 @@ public class DatasetFileController {
             return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
         } catch (Exception e) {
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
-        }
-    }
+        }
+    }
+
+    @GetMapping("/{fileId}/preview/status")
+    public DatasetFilePreviewStatusResponse getDatasetFilePreviewStatus(@PathVariable("datasetId") String datasetId,
+                                                                        @PathVariable("fileId") String fileId) {
+        return datasetFilePreviewService.getPreviewStatus(datasetId, fileId);
+    }
+
+    @PostMapping("/{fileId}/preview/convert")
+    public DatasetFilePreviewStatusResponse convertDatasetFilePreview(@PathVariable("datasetId") String datasetId,
+                                                                      @PathVariable("fileId") String fileId) {
+        return datasetFilePreviewService.ensurePreview(datasetId, fileId);
+    }
 
     @IgnoreResponseWrap
     @GetMapping(value = "/download", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/DatasetTypeController.java

@@ -23,7 +23,7 @@ public class DatasetTypeController {
     public List<DatasetTypeResponse> getDatasetTypes() {
         return Arrays.asList(
             createDatasetType("IMAGE", "图像数据集", "用于机器学习的图像数据集", Arrays.asList("jpg", "jpeg", "png", "bmp", "gif")),
-            createDatasetType("TEXT", "文本数据集", "用于文本分析的文本数据集", Arrays.asList("txt", "csv", "json", "xml")),
+            createDatasetType("TEXT", "文本数据集", "用于文本分析的文本数据集", Arrays.asList("txt", "csv", "xls", "xlsx", "json", "xml")),
             createDatasetType("AUDIO", "音频数据集", "用于音频处理的音频数据集", Arrays.asList("wav", "mp3", "flac", "aac")),
             createDatasetType("VIDEO", "视频数据集", "用于视频分析的视频数据集", Arrays.asList("mp4", "avi", "mov", "mkv")),
             createDatasetType("MULTIMODAL", "多模态数据集", "包含多种数据类型的数据集", List.of("*"))

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeDirectoryController.java

@@ -0,0 +1,43 @@
+package com.datamate.datamanagement.interfaces.rest;
+
+import com.datamate.datamanagement.application.KnowledgeDirectoryApplicationService;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
+import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeDirectoryRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 知识条目目录 REST 控制器
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/data-management/knowledge-sets/{setId}/directories")
+public class KnowledgeDirectoryController {
+    private final KnowledgeDirectoryApplicationService knowledgeDirectoryApplicationService;
+
+    @GetMapping
+    public List<KnowledgeDirectoryResponse> getKnowledgeDirectories(@PathVariable("setId") String setId,
+                                                                   KnowledgeDirectoryQuery query) {
+        List<KnowledgeItemDirectory> directories = knowledgeDirectoryApplicationService.getKnowledgeDirectories(setId, query);
+        return KnowledgeConverter.INSTANCE.convertDirectoryResponses(directories);
+    }
+
+    @PostMapping
+    public KnowledgeDirectoryResponse createKnowledgeDirectory(@PathVariable("setId") String setId,
+                                                              @RequestBody @Valid CreateKnowledgeDirectoryRequest request) {
+        KnowledgeItemDirectory directory = knowledgeDirectoryApplicationService.createKnowledgeDirectory(setId, request);
+        return KnowledgeConverter.INSTANCE.convertToResponse(directory);
+    }
+
+    @DeleteMapping
+    public void deleteKnowledgeDirectory(@PathVariable("setId") String setId,
+                                         @RequestParam("relativePath") String relativePath) {
+        knowledgeDirectoryApplicationService.deleteKnowledgeDirectory(setId, relativePath);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeItemController.java

@@ -3,11 +3,14 @@ package com.datamate.datamanagement.interfaces.rest;
 import com.datamate.common.infrastructure.common.IgnoreResponseWrap;
 import com.datamate.common.interfaces.PagedResponse;
 import com.datamate.datamanagement.application.KnowledgeItemApplicationService;
+import com.datamate.datamanagement.application.KnowledgeItemPreviewService;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeItemRequest;
+import com.datamate.datamanagement.interfaces.dto.DeleteKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.ImportKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPreviewStatusResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
 import com.datamate.datamanagement.interfaces.dto.ReplaceKnowledgeItemFileRequest;
 import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeItemRequest;
@@ -30,6 +33,7 @@ import java.util.List;
 @RequestMapping("/data-management/knowledge-sets/{setId}/items")
 public class KnowledgeItemController {
     private final KnowledgeItemApplicationService knowledgeItemApplicationService;
+    private final KnowledgeItemPreviewService knowledgeItemPreviewService;
 
     @GetMapping
     public PagedResponse<KnowledgeItemResponse> getKnowledgeItems(@PathVariable("setId") String setId,
@@ -80,6 +84,18 @@ public class KnowledgeItemController {
         knowledgeItemApplicationService.previewKnowledgeItemFile(setId, itemId, response);
     }
 
+    @GetMapping("/{itemId}/preview/status")
+    public KnowledgeItemPreviewStatusResponse getKnowledgeItemPreviewStatus(@PathVariable("setId") String setId,
+                                                                            @PathVariable("itemId") String itemId) {
+        return knowledgeItemPreviewService.getPreviewStatus(setId, itemId);
+    }
+
+    @PostMapping("/{itemId}/preview/convert")
+    public KnowledgeItemPreviewStatusResponse convertKnowledgeItemPreview(@PathVariable("setId") String setId,
+                                                                          @PathVariable("itemId") String itemId) {
+        return knowledgeItemPreviewService.ensurePreview(setId, itemId);
+    }
+
     @GetMapping("/{itemId}")
     public KnowledgeItemResponse getKnowledgeItemById(@PathVariable("setId") String setId,
                                                       @PathVariable("itemId") String itemId) {
@@ -108,4 +124,10 @@ public class KnowledgeItemController {
                                     @PathVariable("itemId") String itemId) {
         knowledgeItemApplicationService.deleteKnowledgeItem(setId, itemId);
     }
+
+    @PostMapping("/batch-delete")
+    public void deleteKnowledgeItems(@PathVariable("setId") String setId,
+                                     @RequestBody @Valid DeleteKnowledgeItemsRequest request) {
+        knowledgeItemApplicationService.deleteKnowledgeItems(setId, request);
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeItemSearchController.java

@@ -0,0 +1,27 @@
+package com.datamate.datamanagement.interfaces.rest;
+
+import com.datamate.common.interfaces.PagedResponse;
+import com.datamate.datamanagement.application.KnowledgeItemApplicationService;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 知识条目搜索控制器
+ */
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/data-management/knowledge-items")
+public class KnowledgeItemSearchController {
+    private final KnowledgeItemApplicationService knowledgeItemApplicationService;
+
+    @GetMapping("/search")
+    public PagedResponse<KnowledgeItemSearchResponse> search(KnowledgeItemSearchQuery query) {
+        return knowledgeItemApplicationService.searchKnowledgeItems(query);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeSetController.java

@@ -1,10 +1,12 @@
 package com.datamate.datamanagement.interfaces.rest;
 
 import com.datamate.common.interfaces.PagedResponse;
+import com.datamate.datamanagement.application.KnowledgeItemApplicationService;
 import com.datamate.datamanagement.application.KnowledgeSetApplicationService;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
 import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeSetRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeManagementStatisticsResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeSetPagingQuery;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeSetResponse;
 import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeSetRequest;
@@ -22,6 +24,7 @@ import org.springframework.web.bind.annotation.*;
 @RequestMapping("/data-management/knowledge-sets")
 public class KnowledgeSetController {
     private final KnowledgeSetApplicationService knowledgeSetApplicationService;
+    private final KnowledgeItemApplicationService knowledgeItemApplicationService;
 
     @GetMapping
     public PagedResponse<KnowledgeSetResponse> getKnowledgeSets(KnowledgeSetPagingQuery query) {
@@ -51,4 +54,9 @@ public class KnowledgeSetController {
     public void deleteKnowledgeSet(@PathVariable("setId") String setId) {
         knowledgeSetApplicationService.deleteKnowledgeSet(setId);
     }
+
+    @GetMapping("/statistics")
+    public KnowledgeManagementStatisticsResponse getKnowledgeManagementStatistics() {
+        return knowledgeItemApplicationService.getKnowledgeManagementStatistics();
+    }
 }

backend/services/data-management-service/src/main/resources/mappers/DatasetFileMapper.xml

@@ -42,6 +42,13 @@
         SELECT COUNT(*) FROM t_dm_dataset_files WHERE dataset_id = #{datasetId}
     </select>
 
+    <select id="countNonDerivedByDatasetId" parameterType="string" resultType="long">
+        SELECT COUNT(*)
+        FROM t_dm_dataset_files
+        WHERE dataset_id = #{datasetId}
+          AND (metadata IS NULL OR JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NULL)
+    </select>
+
     <select id="countCompletedByDatasetId" parameterType="string" resultType="long">
         SELECT COUNT(*) FROM t_dm_dataset_files WHERE dataset_id = #{datasetId} AND status = 'COMPLETED'
     </select>
@@ -110,4 +117,16 @@
           AND metadata IS NOT NULL
           AND JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NOT NULL
     </select>
+
+    <select id="countNonDerivedByDatasetIds" resultType="com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount">
+        SELECT dataset_id AS datasetId,
+               COUNT(*) AS fileCount
+        FROM t_dm_dataset_files
+        WHERE dataset_id IN
+        <foreach collection="datasetIds" item="datasetId" open="(" separator="," close=")">
+            #{datasetId}
+        </foreach>
+          AND (metadata IS NULL OR JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NULL)
+        GROUP BY dataset_id
+    </select>
 </mapper>

backend/services/data-management-service/src/main/resources/mappers/DatasetMapper.xml

@@ -145,9 +145,10 @@
 
     <select id="getAllDatasetStatistics" resultType="com.datamate.datamanagement.interfaces.dto.AllDatasetStatisticsResponse">
       SELECT
-        COUNT(*) AS total_datasets,
-        SUM(size_bytes) AS total_size,
-        SUM(file_count) AS total_files
-      FROM t_dm_datasets;
+        (SELECT COUNT(*) FROM t_dm_datasets) AS total_datasets,
+        (SELECT COALESCE(SUM(size_bytes), 0) FROM t_dm_datasets) AS total_size,
+        (SELECT COUNT(*)
+         FROM t_dm_dataset_files
+         WHERE metadata IS NULL OR JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NULL) AS total_files
     </select>
 </mapper>

backend/services/data-management-service/src/main/resources/mappers/TagMapper.xml

@@ -53,6 +53,19 @@
         ORDER BY usage_count DESC, name ASC
     </select>
 
+    <select id="countKnowledgeSetTags" resultType="long">
+        SELECT COUNT(DISTINCT t.id)
+        FROM t_dm_tags t
+        WHERE EXISTS (
+            SELECT 1
+            FROM t_dm_knowledge_sets ks
+            WHERE ks.tags IS NOT NULL
+              AND JSON_VALID(ks.tags) = 1
+              AND JSON_LENGTH(ks.tags) > 0
+              AND JSON_SEARCH(ks.tags, 'one', t.name, NULL, '$[*].name') IS NOT NULL
+        )
+    </select>
+
     <insert id="insert" parameterType="com.datamate.datamanagement.domain.model.dataset.Tag">
         INSERT INTO t_dm_tags (id, name, description, category, color, usage_count)
         VALUES (#{id}, #{name}, #{description}, #{category}, #{color}, #{usageCount})

backend/services/main-application/src/main/java/com/datamate/main/config/SecurityConfig.java

@@ -17,6 +17,7 @@ public class SecurityConfig {
     @Bean
     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
         http.csrf(csrf -> csrf.disable())
+            .headers(headers -> headers.frameOptions(frameOptions -> frameOptions.disable()))
             .authorizeHttpRequests(authz -> authz
                 .anyRequest().permitAll()  // 允许所有请求无需认证
             );

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/application/KnowledgeBaseService.java

@@ -36,7 +36,9 @@ import org.springframework.util.StringUtils;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 /**
  * 知识库服务类
@@ -47,6 +49,7 @@ import java.util.Optional;
 @Service
 @RequiredArgsConstructor
 public class KnowledgeBaseService {
+    private static final String PATH_SEPARATOR = "/";
     private final KnowledgeBaseRepository knowledgeBaseRepository;
     private final RagFileRepository ragFileRepository;
     private final ApplicationEventPublisher eventPublisher;
@@ -137,6 +140,7 @@ public class KnowledgeBaseService {
         return PagedResponse.of(respList, page.getCurrent(), page.getTotal(), page.getPages());
     }
 
+
     @Transactional(rollbackFor = Exception.class)
     public void addFiles(AddFilesReq request) {
         KnowledgeBase knowledgeBase = Optional.ofNullable(knowledgeBaseRepository.getById(request.getKnowledgeBaseId()))
@@ -146,6 +150,7 @@ public class KnowledgeBaseService {
             ragFile.setKnowledgeBaseId(knowledgeBase.getId());
             ragFile.setFileId(fileInfo.id());
             ragFile.setFileName(fileInfo.fileName());
+            ragFile.setRelativePath(normalizeRelativePath(fileInfo.relativePath()));
             ragFile.setStatus(FileStatus.UNPROCESSED);
             return ragFile;
         }).toList();
@@ -153,6 +158,17 @@ public class KnowledgeBaseService {
         eventPublisher.publishEvent(new DataInsertedEvent(knowledgeBase, request));
     }
 
+    private String normalizeRelativePath(String relativePath) {
+        if (!StringUtils.hasText(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        return normalized;
+    }
+
     public PagedResponse<RagFile> listFiles(String knowledgeBaseId, RagFileReq request) {
         IPage<RagFile> page = new Page<>(request.getPage(), request.getSize());
         request.setKnowledgeBaseId(knowledgeBaseId);
@@ -160,6 +176,41 @@ public class KnowledgeBaseService {
         return PagedResponse.of(page.getRecords(), page.getCurrent(), page.getTotal(), page.getPages());
     }
 
+    public PagedResponse<KnowledgeBaseFileSearchResp> searchFiles(KnowledgeBaseFileSearchReq request) {
+        IPage<RagFile> page = new Page<>(request.getPage(), request.getSize());
+        page = ragFileRepository.searchPage(page, request);
+        List<RagFile> records = page.getRecords();
+        if (records.isEmpty()) {
+            return PagedResponse.of(Collections.emptyList(), page.getCurrent(), page.getTotal(), page.getPages());
+        }
+
+        List<String> knowledgeBaseIds = records.stream()
+                .map(RagFile::getKnowledgeBaseId)
+                .filter(StringUtils::hasText)
+                .distinct()
+                .toList();
+        Map<String, String> knowledgeBaseNameMap = knowledgeBaseRepository.listByIds(knowledgeBaseIds).stream()
+                .collect(Collectors.toMap(KnowledgeBase::getId, KnowledgeBase::getName));
+
+        List<KnowledgeBaseFileSearchResp> responses = records.stream()
+                .map(file -> {
+                    KnowledgeBaseFileSearchResp resp = new KnowledgeBaseFileSearchResp();
+                    resp.setId(file.getId());
+                    resp.setKnowledgeBaseId(file.getKnowledgeBaseId());
+                    resp.setKnowledgeBaseName(knowledgeBaseNameMap.getOrDefault(file.getKnowledgeBaseId(), ""));
+                    resp.setFileName(file.getFileName());
+                    resp.setRelativePath(file.getRelativePath());
+                    resp.setChunkCount(file.getChunkCount());
+                    resp.setStatus(file.getStatus());
+                    resp.setCreatedAt(file.getCreatedAt());
+                    resp.setUpdatedAt(file.getUpdatedAt());
+                    return resp;
+                })
+                .toList();
+
+        return PagedResponse.of(responses, page.getCurrent(), page.getTotal(), page.getPages());
+    }
+
     @Transactional(rollbackFor = Exception.class)
     public void deleteFiles(String knowledgeBaseId, DeleteFilesReq request) {
         KnowledgeBase knowledgeBase = Optional.ofNullable(knowledgeBaseRepository.getById(knowledgeBaseId))
@@ -222,4 +273,4 @@ public class KnowledgeBaseService {
         });
         return searchResults;
     }
-}
+}

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/domain/model/RagFile.java

@@ -28,6 +28,10 @@ public class RagFile extends BaseEntity<String> {
      * 文件名
      */
     private String fileName;
+    /**
+     * 相对路径
+     */
+    private String relativePath;
     /**
      * 文件ID
      */

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/domain/repository/RagFileRepository.java

@@ -3,6 +3,7 @@ package com.datamate.rag.indexer.domain.repository;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.repository.IRepository;
 import com.datamate.rag.indexer.domain.model.RagFile;
+import com.datamate.rag.indexer.interfaces.dto.KnowledgeBaseFileSearchReq;
 import com.datamate.rag.indexer.interfaces.dto.RagFileReq;
 
 import java.util.List;
@@ -21,4 +22,6 @@ public interface RagFileRepository extends IRepository<RagFile> {
     List<RagFile> findAllByKnowledgeBaseId(String knowledgeBaseId);
 
     IPage<RagFile> page(IPage<RagFile> page, RagFileReq request);
+
+    IPage<RagFile> searchPage(IPage<RagFile> page, KnowledgeBaseFileSearchReq request);
 }

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/infrastructure/persistence/impl/RagFileRepositoryImpl.java

@@ -6,6 +6,7 @@ import com.datamate.rag.indexer.domain.model.FileStatus;
 import com.datamate.rag.indexer.domain.model.RagFile;
 import com.datamate.rag.indexer.domain.repository.RagFileRepository;
 import com.datamate.rag.indexer.infrastructure.persistence.mapper.RagFileMapper;
+import com.datamate.rag.indexer.interfaces.dto.KnowledgeBaseFileSearchReq;
 import com.datamate.rag.indexer.interfaces.dto.RagFileReq;
 import org.springframework.stereotype.Repository;
 import org.springframework.util.StringUtils;
@@ -20,6 +21,7 @@ import java.util.List;
  */
 @Repository
 public class RagFileRepositoryImpl extends CrudRepository<RagFileMapper, RagFile> implements RagFileRepository {
+    private static final String PATH_SEPARATOR = "/";
     @Override
     public void removeByKnowledgeBaseId(String knowledgeBaseId) {
         lambdaUpdate().eq(RagFile::getKnowledgeBaseId, knowledgeBaseId).remove();
@@ -45,6 +47,27 @@ public class RagFileRepositoryImpl extends CrudRepository<RagFileMapper, RagFile
         return lambdaQuery()
                 .eq(RagFile::getKnowledgeBaseId, request.getKnowledgeBaseId())
                 .like(StringUtils.hasText(request.getFileName()), RagFile::getFileName, request.getFileName())
+                .likeRight(StringUtils.hasText(request.getRelativePath()), RagFile::getRelativePath, normalizeRelativePath(request.getRelativePath()))
                 .page(page);
     }
+
+    @Override
+    public IPage<RagFile> searchPage(IPage<RagFile> page, KnowledgeBaseFileSearchReq request) {
+        return lambdaQuery()
+                .eq(StringUtils.hasText(request.getKnowledgeBaseId()), RagFile::getKnowledgeBaseId, request.getKnowledgeBaseId())
+                .like(StringUtils.hasText(request.getFileName()), RagFile::getFileName, request.getFileName())
+                .likeRight(StringUtils.hasText(request.getRelativePath()), RagFile::getRelativePath, normalizeRelativePath(request.getRelativePath()))
+                .page(page);
+    }
+
+    private String normalizeRelativePath(String relativePath) {
+        if (!StringUtils.hasText(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        return normalized;
+    }
 }

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/interfaces/KnowledgeBaseController.java

@@ -80,6 +80,7 @@ public class KnowledgeBaseController {
         return knowledgeBaseService.list(request);
     }
 
+
     /**
      * 添加文件到知识库
      *
@@ -105,6 +106,17 @@ public class KnowledgeBaseController {
         return knowledgeBaseService.listFiles(knowledgeBaseId, request);
     }
 
+    /**
+     * 全库检索知识库文件（跨知识库）
+     *
+     * @param request 检索请求
+     * @return 文件列表
+     */
+    @GetMapping("/files/search")
+    public PagedResponse<KnowledgeBaseFileSearchResp> searchFiles(KnowledgeBaseFileSearchReq request) {
+        return knowledgeBaseService.searchFiles(request);
+    }
+
     /**
      * 删除知识库文件
      *
@@ -141,4 +153,4 @@ public class KnowledgeBaseController {
     public List<SearchResp.SearchResult> retrieve(@RequestBody @Valid RetrieveReq request) {
         return knowledgeBaseService.retrieve(request);
     }
-}
+}

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/interfaces/dto/AddFilesReq.java

@@ -21,6 +21,6 @@ public class AddFilesReq {
     private String delimiter;
     private List<FileInfo> files;
 
-    public record FileInfo(String id, String fileName) {
+    public record FileInfo(String id, String fileName, String relativePath) {
     }
 }

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/interfaces/dto/KnowledgeBaseFileSearchReq.java

@@ -0,0 +1,19 @@
+package com.datamate.rag.indexer.interfaces.dto;
+
+import com.datamate.common.interfaces.PagingQuery;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识库文件全库检索请求
+ *
+ * @author dallas
+ * @since 2026-01-30
+ */
+@Getter
+@Setter
+public class KnowledgeBaseFileSearchReq extends PagingQuery {
+    private String fileName;
+    private String relativePath;
+    private String knowledgeBaseId;
+}

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/interfaces/dto/KnowledgeBaseFileSearchResp.java

@@ -0,0 +1,27 @@
+package com.datamate.rag.indexer.interfaces.dto;
+
+import com.datamate.rag.indexer.domain.model.FileStatus;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * 知识库文件全库检索响应
+ *
+ * @author dallas
+ * @since 2026-01-30
+ */
+@Getter
+@Setter
+public class KnowledgeBaseFileSearchResp {
+    private String id;
+    private String knowledgeBaseId;
+    private String knowledgeBaseName;
+    private String fileName;
+    private String relativePath;
+    private Integer chunkCount;
+    private FileStatus status;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/interfaces/dto/RagFileReq.java

@@ -14,5 +14,6 @@ import lombok.Setter;
 @Getter
 public class RagFileReq extends PagingQuery {
     private String fileName;
+    private String relativePath;
     private String knowledgeBaseId;
 }

backend/shared/domain-common/src/main/java/com/datamate/common/domain/service/FileService.java

@@ -21,7 +21,7 @@ import java.util.UUID;
  */
 @Component
 public class FileService {
-    private static final int DEFAULT_TIMEOUT = 120;
+    private static final int DEFAULT_TIMEOUT = 1800;
 
     private final ChunkUploadRequestMapper chunkUploadRequestMapper;
 

deployment/docker/datamate/backend.conf

@@ -5,7 +5,7 @@ server {
     access_log /var/log/datamate/frontend/access.log main;
     error_log /var/log/datamate/frontend/error.log notice;
 
-    client_max_body_size 1024M;
+    client_max_body_size 0;
 
     add_header Set-Cookie "NEXT_LOCALE=zh";
 

deployment/docker/datamate/docker-compose.yml

@@ -11,6 +11,7 @@ services:
       - log_volume:/var/log/datamate
       - operator-upload-volume:/operators/upload
       - operator-runtime-volume:/operators/extract
+      - uploads_volume:/uploads
     networks: [ datamate ]
     depends_on:
       - datamate-database
@@ -154,6 +155,8 @@ services:
     profiles: [ data-juicer ]
 
 volumes:
+  uploads_volume:
+    name: datamate-uploads-volume
   dataset_volume:
     name: datamate-dataset-volume
   flow_volume:

deployment/docker/milvus/docker-compose.yml

@@ -1,7 +1,7 @@
 services:
   etcd:
     container_name: milvus-etcd
-    image: quay.io/coreos/etcd:v3.5.18
+    image: quay.nju.edu.cn/coreos/etcd:v3.5.18
     environment:
       - ETCD_AUTO_COMPACTION_MODE=revision
       - ETCD_AUTO_COMPACTION_RETENTION=1000

frontend/public/lsf/lsf.html

@@ -169,6 +169,33 @@
           }
         }
 
+        function isAnnotationObject(value) {
+          if (!value || typeof value !== "object") return false;
+          return typeof value.serializeAnnotation === "function" || typeof value.serialize === "function";
+        }
+
+        function resolveSelectedAnnotation(store) {
+          if (!store) return null;
+          const annotations = Array.isArray(store.annotations) ? store.annotations : [];
+          if (isAnnotationObject(store.selectedAnnotation)) {
+            return store.selectedAnnotation;
+          }
+          if (isAnnotationObject(store.selected)) {
+            return store.selected;
+          }
+          const selectedId = store.selected;
+          if (selectedId !== undefined && selectedId !== null && annotations.length) {
+            const matched = annotations.find((ann) => ann && String(ann.id) === String(selectedId));
+            if (isAnnotationObject(matched)) {
+              return matched;
+            }
+          }
+          if (annotations.length && isAnnotationObject(annotations[0])) {
+            return annotations[0];
+          }
+          return null;
+        }
+
         function exportSelectedAnnotation() {
           if (!lsInstance) {
             throw new Error("LabelStudio 未初始化");
@@ -179,10 +206,10 @@
             throw new Error("无法访问 annotationStore");
           }
 
-          const selected =
-            store.selected ||
-            store.selectedAnnotation ||
-            (Array.isArray(store.annotations) && store.annotations.length ? store.annotations[0] : null);
+          const selected = resolveSelectedAnnotation(store);
+          if (!selected) {
+            throw new Error("未找到可导出的标注对象");
+          }
 
           let serialized = null;
           if (selected && typeof selected.serializeAnnotation === "function") {
@@ -197,6 +224,10 @@
               ? { id: selected?.id || serialized.id || "draft", ...serialized }
               : { id: selected?.id || "draft", result: (selected && selected.result) || [] };
 
+          if (!Array.isArray(annotationPayload.result) && Array.isArray(annotationPayload.results)) {
+            annotationPayload.result = annotationPayload.results;
+          }
+
           // 最小化对齐 Label Studio Server 的字段（DataMate 侧会原样存储）
           const taskId = typeof currentTask?.id === "number" ? currentTask.id : Number(currentTask?.id) || null;
           const fileId = currentTask?.data?.file_id || currentTask?.data?.fileId || null;
@@ -226,6 +257,52 @@
           };
         }
 
+        function isSaveAndNextShortcut(event) {
+          if (!event || event.defaultPrevented || event.isComposing) return false;
+          const key = event.key;
+          const code = event.code;
+          const isEnter = key === "Enter" || code === "Enter" || code === "NumpadEnter";
+          if (!isEnter) return false;
+          if (!(event.ctrlKey || event.metaKey)) return false;
+          if (event.shiftKey || event.altKey) return false;
+          return true;
+        }
+
+        function isSaveShortcut(event) {
+          if (!event || event.defaultPrevented || event.isComposing) return false;
+          const key = event.key;
+          const code = event.code;
+          const isS = key === "s" || key === "S" || code === "KeyS";
+          if (!isS) return false;
+          if (!(event.ctrlKey || event.metaKey)) return false;
+          if (event.shiftKey || event.altKey) return false;
+          return true;
+        }
+
+        function handleSaveAndNextShortcut(event) {
+          if (!isSaveAndNextShortcut(event) || event.repeat) return;
+          event.preventDefault();
+          event.stopPropagation();
+          try {
+            const raw = exportSelectedAnnotation();
+            postToParent("LS_SAVE_AND_NEXT", raw);
+          } catch (e) {
+            postToParent("LS_ERROR", { message: e?.message || String(e) });
+          }
+        }
+
+        function handleSaveShortcut(event) {
+          if (!isSaveShortcut(event) || event.repeat) return;
+          event.preventDefault();
+          event.stopPropagation();
+          try {
+            const raw = exportSelectedAnnotation();
+            postToParent("LS_EXPORT_RESULT", raw);
+          } catch (e) {
+            postToParent("LS_ERROR", { message: e?.message || String(e) });
+          }
+        }
+
         function initLabelStudio(payload) {
           if (!window.LabelStudio) {
             throw new Error("LabelStudio 未加载（请检查静态资源/网络）");
@@ -296,6 +373,9 @@
           });
         }
 
+        window.addEventListener("keydown", handleSaveAndNextShortcut);
+        window.addEventListener("keydown", handleSaveShortcut);
+
         window.addEventListener("message", (event) => {
           if (event.origin !== ORIGIN) return;
 

frontend/src/components/AddTagPopover.tsx

@@ -1,17 +1,17 @@
 import { Button, Input, Popover, theme, Tag, Empty } from "antd";
 import { PlusOutlined } from "@ant-design/icons";
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 
 interface Tag {
-  id: number;
+  id?: string | number;
   name: string;
-  color: string;
+  color?: string;
 }
 
 interface AddTagPopoverProps {
   tags: Tag[];
   onFetchTags?: () => Promise<Tag[]>;
-  onAddTag?: (tag: Tag) => void;
+  onAddTag?: (tagName: string) => void;
   onCreateAndTag?: (tagName: string) => void;
 }
 
@@ -27,20 +27,23 @@ export default function AddTagPopover({
   const [newTag, setNewTag] = useState("");
   const [allTags, setAllTags] = useState<Tag[]>([]);
 
-  const tagsSet = useMemo(() => new Set(tags.map((tag) => tag.id)), [tags]);
+  const tagsSet = useMemo(
+    () => new Set(tags.map((tag) => (tag.id ?? tag.name))),
+    [tags]
+  );
 
-  const fetchTags = async () => {
+  const fetchTags = useCallback(async () => {
     if (onFetchTags && showPopover) {
       const data = await onFetchTags?.();
       setAllTags(data || []);
     }
-  };
+  }, [onFetchTags, showPopover]);
   useEffect(() => {
     fetchTags();
-  }, [showPopover]);
+  }, [fetchTags]);
 
   const availableTags = useMemo(() => {
-    return allTags.filter((tag) => !tagsSet.has(tag.id));
+    return allTags.filter((tag) => !tagsSet.has(tag.id ?? tag.name));
   }, [allTags, tagsSet]);
 
   const handleCreateAndAddTag = () => {

frontend/src/components/CardView.tsx

@@ -276,7 +276,7 @@ function CardView<T extends BaseCardDataType>(props: CardViewProps<T>) {
                     {formatDateTime(item?.updatedAt)}
                   </div>
                 </div>
-                {operations && (
+                {operations && ops(item).length > 0 && (
                   <ActionDropdown
                     actions={ops(item)}
                     onAction={(key) => {

frontend/src/components/DetailHeader.tsx

@@ -22,44 +22,51 @@ interface OperationItem {
   danger?: boolean;
 }
 
-interface TagConfig {
-  showAdd: boolean;
-  tags: { id: number; name: string; color: string }[];
-  onFetchTags?: () => Promise<{
-    data: { id: number; name: string; color: string }[];
-  }>;
-  onAddTag?: (tag: { id: number; name: string; color: string }) => void;
-  onCreateAndTag?: (tagName: string) => void;
-}
-interface DetailHeaderProps<T> {
-  data: T;
-  statistics: StatisticItem[];
-  operations: OperationItem[];
-  tagConfig?: TagConfig;
-}
-
-function DetailHeader<T>({
-  data = {} as T,
-  statistics,
-  operations,
-  tagConfig,
-}: DetailHeaderProps<T>): React.ReactNode {
+interface TagConfig {
+  showAdd: boolean;
+  tags: { id?: string | number; name: string; color?: string }[];
+  onFetchTags?: () => Promise<{ id?: string | number; name: string; color?: string }[]>;
+  onAddTag?: (tagName: string) => void;
+  onCreateAndTag?: (tagName: string) => void;
+}
+interface DetailHeaderData {
+  name?: string;
+  description?: string;
+  status?: { color?: string; icon?: React.ReactNode; label?: string };
+  tags?: { id?: string | number; name?: string }[];
+  icon?: React.ReactNode;
+  iconColor?: string;
+}
+
+interface DetailHeaderProps<T extends DetailHeaderData> {
+  data: T;
+  statistics: StatisticItem[];
+  operations: OperationItem[];
+  tagConfig?: TagConfig;
+}
+
+function DetailHeader<T extends DetailHeaderData>({
+  data = {} as T,
+  statistics,
+  operations,
+  tagConfig,
+}: DetailHeaderProps<T>): React.ReactNode {
   return (
     <Card>
       <div className="flex items-start justify-between">
         <div className="flex items-start gap-4 flex-1">
           <div
             className={`w-16 h-16 text-white rounded-lg flex-center shadow-lg ${
-              (data as any)?.iconColor
-                ? ""
-                : "bg-gradient-to-br from-sky-300 to-blue-500 text-white"
-            }`}
-            style={(data as any)?.iconColor ? { backgroundColor: (data as any).iconColor } : undefined}
-          >
-            {<div className="w-[2.8rem] h-[2.8rem] text-gray-50">{(data as any)?.icon}</div> || (
-              <Database className="w-8 h-8 text-white" />
-            )}
-          </div>
+              data?.iconColor
+                ? ""
+                : "bg-gradient-to-br from-sky-300 to-blue-500 text-white"
+            }`}
+            style={data?.iconColor ? { backgroundColor: data.iconColor } : undefined}
+          >
+            {<div className="w-[2.8rem] h-[2.8rem] text-gray-50">{data?.icon}</div> || (
+              <Database className="w-8 h-8 text-white" />
+            )}
+          </div>
           <div className="flex-1">
             <div className="flex items-center gap-3 mb-2">
               <h1 className="text-lg font-bold text-gray-900">{data?.name}</h1>

frontend/src/components/ProtectedRoute.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Navigate, useLocation, Outlet } from 'react-router';
+import { useAppSelector } from '@/store/hooks';
+
+interface ProtectedRouteProps {
+  children?: React.ReactNode;
+}
+
+const ProtectedRoute: React.FC<ProtectedRouteProps> = ({ children }) => {
+  const { isAuthenticated } = useAppSelector((state) => state.auth);
+  const location = useLocation();
+
+  if (!isAuthenticated) {
+    // Redirect to the login page, but save the current location they were trying to go to
+    return <Navigate to="/login" state={{ from: location }} replace />;
+  }
+
+  return children ? <>{children}</> : <Outlet />;
+};
+
+export default ProtectedRoute;

frontend/src/components/TopLoadingBar.tsx

@@ -4,6 +4,7 @@ const TopLoadingBar = () => {
   const [isVisible, setIsVisible] = useState(false);
   const [progress, setProgress] = useState(0);
   const intervalRef = useRef(null);
+  const timeoutRef = useRef(null);
 
   useEffect(() => {
     // 监听全局事件
@@ -33,8 +34,13 @@ const TopLoadingBar = () => {
         clearInterval(intervalRef.current);
         intervalRef.current = null;
       }
+      // 清除旧的timeout
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = null;
+      }
       setProgress(100);
-      setTimeout(() => {
+      timeoutRef.current = setTimeout(() => {
         setIsVisible(false);
         setProgress(0);
       }, 300);
@@ -49,6 +55,9 @@ const TopLoadingBar = () => {
       if (intervalRef.current) {
         clearInterval(intervalRef.current);
       }
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
       window.removeEventListener("loading:show", handleShow);
       window.removeEventListener("loading:hide", handleHide);
     };

frontend/src/components/business/DatasetFileTransfer.tsx

@@ -22,11 +22,10 @@ interface DatasetFileTransferProps
   onDatasetSelect?: (dataset: Dataset | null) => void;
   datasetTypeFilter?: DatasetType;
   hasAnnotationFilter?: boolean;
-  /**
-   * 是否排除已被转换为TXT的源文档文件（PDF/DOC/DOCX）
-   * 默认为 true，当 datasetTypeFilter 为 TEXT 时自动启用
-   */
-  excludeSourceDocuments?: boolean;
+  /**
+   * 是否排除源文档文件（PDF/DOC/DOCX/XLS/XLSX），文本标注默认启用
+   */
+  excludeSourceDocuments?: boolean;
 }
 
 const fileCols = [

frontend/src/hooks/useSliceUpload.tsx

@@ -1,198 +1,348 @@
-import { TaskItem } from "@/pages/DataManagement/dataset.model";
-import { calculateSHA256, checkIsFilesExist } from "@/utils/file.util";
-import { App } from "antd";
-import { useRef, useState } from "react";
-
-export function useFileSliceUpload(
-  {
-    preUpload,
-    uploadChunk,
-    cancelUpload,
-  }: {
-    preUpload: (id: string, params: any) => Promise<{ data: number }>;
-    uploadChunk: (id: string, formData: FormData, config: any) => Promise<any>;
-    cancelUpload: ((reqId: number) => Promise<any>) | null;
-  },
-  showTaskCenter = true // 上传时是否显示任务中心
-) {
-  const { message } = App.useApp();
-  const [taskList, setTaskList] = useState<TaskItem[]>([]);
-  const taskListRef = useRef<TaskItem[]>([]); // 用于固定任务顺序
-
-  const createTask = (detail: any = {}) => {
-    const { dataset } = detail;
-    const title = `上传数据集: ${dataset.name} `;
-    const controller = new AbortController();
-    const task: TaskItem = {
-      key: dataset.id,
-      title,
-      percent: 0,
-      reqId: -1,
-      controller,
-      size: 0,
-      updateEvent: detail.updateEvent,
-      hasArchive: detail.hasArchive,
-      prefix: detail.prefix,
-    };
-    taskListRef.current = [task, ...taskListRef.current];
-
-    setTaskList(taskListRef.current);
-    return task;
-  };
-
-  const updateTaskList = (task: TaskItem) => {
-    taskListRef.current = taskListRef.current.map((item) =>
-      item.key === task.key ? task : item
-    );
-    setTaskList(taskListRef.current);
-  };
-
-  const removeTask = (task: TaskItem) => {
-    const { key } = task;
-    taskListRef.current = taskListRef.current.filter(
-      (item) => item.key !== key
-    );
-    setTaskList(taskListRef.current);
-    if (task.isCancel && task.cancelFn) {
-      task.cancelFn();
-    }
-    if (task.updateEvent) {
-      // 携带前缀信息，便于刷新后仍停留在当前目录
-      window.dispatchEvent(
-        new CustomEvent(task.updateEvent, {
-          detail: { prefix: (task as any).prefix },
-        })
-      );
-    }
-    if (showTaskCenter) {
-      window.dispatchEvent(
-        new CustomEvent("show:task-popover", { detail: { show: false } })
-      );
-    }
-  };
-
-  async function buildFormData({ file, reqId, i, j }) {
-    const formData = new FormData();
-    const { slices, name, size } = file;
-    const checkSum = await calculateSHA256(slices[j]);
-    formData.append("file", slices[j]);
-    formData.append("reqId", reqId.toString());
-    formData.append("fileNo", (i + 1).toString());
-    formData.append("chunkNo", (j + 1).toString());
-    formData.append("fileName", name);
-    formData.append("fileSize", size.toString());
-    formData.append("totalChunkNum", slices.length.toString());
-    formData.append("checkSumHex", checkSum);
-    return formData;
-  }
-
-  async function uploadSlice(task: TaskItem, fileInfo) {
-    if (!task) {
-      return;
-    }
-    const { reqId, key } = task;
-    const { loaded, i, j, files, totalSize } = fileInfo;
-    const formData = await buildFormData({
-      file: files[i],
-      i,
-      j,
-      reqId,
-    });
-
-    let newTask = { ...task };
-    await uploadChunk(key, formData, {
-      onUploadProgress: (e) => {
-        const loadedSize = loaded + e.loaded;
-        const curPercent = Number((loadedSize / totalSize) * 100).toFixed(2);
-
-        newTask = {
-          ...newTask,
-          ...taskListRef.current.find((item) => item.key === key),
-          size: loadedSize,
-          percent: curPercent >= 100 ? 99.99 : curPercent,
-        };
-        updateTaskList(newTask);
-      },
-    });
-  }
-
-  async function uploadFile({ task, files, totalSize }) {
-    console.log('[useSliceUpload] Calling preUpload with prefix:', task.prefix);
-    const { data: reqId } = await preUpload(task.key, {
-      totalFileNum: files.length,
-      totalSize,
-      datasetId: task.key,
-      hasArchive: task.hasArchive,
-      prefix: task.prefix,
-    });
-    console.log('[useSliceUpload] PreUpload response reqId:', reqId);
-
-    const newTask: TaskItem = {
-      ...task,
-      reqId,
-      isCancel: false,
-      cancelFn: () => {
-        task.controller.abort();
-        cancelUpload?.(reqId);
-        if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
-      },
-    };
-    updateTaskList(newTask);
-    if (showTaskCenter) {
-      window.dispatchEvent(
-        new CustomEvent("show:task-popover", { detail: { show: true } })
-      );
-    }
-    // // 更新数据状态
-    if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
-
-    let loaded = 0;
-    for (let i = 0; i < files.length; i++) {
-      const { slices } = files[i];
-      for (let j = 0; j < slices.length; j++) {
-        await uploadSlice(newTask, {
-          loaded,
-          i,
-          j,
-          files,
-          totalSize,
-        });
-        loaded += slices[j].size;
-      }
-    }
-    removeTask(newTask);
-  }
-
-  const handleUpload = async ({ task, files }) => {
-    const isErrorFile = await checkIsFilesExist(files);
-    if (isErrorFile) {
-      message.error("文件被修改或删除，请重新选择文件上传");
-      removeTask({
-        ...task,
-        isCancel: false,
-        ...taskListRef.current.find((item) => item.key === task.key),
-      });
-      return;
-    }
-
-    try {
-      const totalSize = files.reduce((acc, file) => acc + file.size, 0);
-      await uploadFile({ task, files, totalSize });
-    } catch (err) {
-      console.error(err);
-      message.error("文件上传失败，请稍后重试");
-      removeTask({
-        ...task,
-        isCancel: true,
-        ...taskListRef.current.find((item) => item.key === task.key),
-      });
-    }
-  };
-
-  return {
-    taskList,
-    createTask,
-    removeTask,
-    handleUpload,
-  };
-}
+import { TaskItem } from "@/pages/DataManagement/dataset.model";
+import { calculateSHA256, checkIsFilesExist, streamSplitAndUpload, StreamUploadResult } from "@/utils/file.util";
+import { App } from "antd";
+import { useRef, useState } from "react";
+
+export function useFileSliceUpload(
+  {
+    preUpload,
+    uploadChunk,
+    cancelUpload,
+  }: {
+    preUpload: (id: string, params: Record<string, unknown>) => Promise<{ data: number }>;
+    uploadChunk: (id: string, formData: FormData, config: Record<string, unknown>) => Promise<unknown>;
+    cancelUpload: ((reqId: number) => Promise<unknown>) | null;
+  },
+  showTaskCenter = true, // 上传时是否显示任务中心
+  enableStreamUpload = true // 是否启用流式分割上传
+) {
+  const { message } = App.useApp();
+  const [taskList, setTaskList] = useState<TaskItem[]>([]);
+  const taskListRef = useRef<TaskItem[]>([]); // 用于固定任务顺序
+
+  const createTask = (detail: Record<string, unknown> = {}) => {
+    const { dataset } = detail;
+    const title = `上传数据集: ${dataset.name} `;
+    const controller = new AbortController();
+    const task: TaskItem = {
+      key: dataset.id,
+      title,
+      percent: 0,
+      reqId: -1,
+      controller,
+      size: 0,
+      updateEvent: detail.updateEvent,
+      hasArchive: detail.hasArchive,
+      prefix: detail.prefix,
+    };
+    taskListRef.current = [task, ...taskListRef.current];
+
+    setTaskList(taskListRef.current);
+    
+    // 立即显示任务中心，让用户感知上传已开始
+    if (showTaskCenter) {
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: true } })
+      );
+    }
+    
+    return task;
+  };
+
+  const updateTaskList = (task: TaskItem) => {
+    taskListRef.current = taskListRef.current.map((item) =>
+      item.key === task.key ? task : item
+    );
+    setTaskList(taskListRef.current);
+  };
+
+  const removeTask = (task: TaskItem) => {
+    const { key } = task;
+    taskListRef.current = taskListRef.current.filter(
+      (item) => item.key !== key
+    );
+    setTaskList(taskListRef.current);
+    if (task.isCancel && task.cancelFn) {
+      task.cancelFn();
+    }
+    if (task.updateEvent) {
+      // 携带前缀信息，便于刷新后仍停留在当前目录
+      window.dispatchEvent(
+        new CustomEvent(task.updateEvent, {
+          detail: { prefix: task.prefix },
+        })
+      );
+    }
+    if (showTaskCenter) {
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: false } })
+      );
+    }
+  };
+
+  async function buildFormData({ file, reqId, i, j }: { file: { slices: Blob[]; name: string; size: number }; reqId: number; i: number; j: number }) {
+    const formData = new FormData();
+    const { slices, name, size } = file;
+    const checkSum = await calculateSHA256(slices[j]);
+    formData.append("file", slices[j]);
+    formData.append("reqId", reqId.toString());
+    formData.append("fileNo", (i + 1).toString());
+    formData.append("chunkNo", (j + 1).toString());
+    formData.append("fileName", name);
+    formData.append("fileSize", size.toString());
+    formData.append("totalChunkNum", slices.length.toString());
+    formData.append("checkSumHex", checkSum);
+    return formData;
+  }
+
+  async function uploadSlice(task: TaskItem, fileInfo: { loaded: number; i: number; j: number; files: { slices: Blob[]; name: string; size: number }[]; totalSize: number }) {
+    if (!task) {
+      return;
+    }
+    const { reqId, key } = task;
+    const { loaded, i, j, files, totalSize } = fileInfo;
+    const formData = await buildFormData({
+      file: files[i],
+      i,
+      j,
+      reqId,
+    });
+
+    let newTask = { ...task };
+    await uploadChunk(key, formData, {
+      onUploadProgress: (e) => {
+        const loadedSize = loaded + e.loaded;
+        const curPercent = Number((loadedSize / totalSize) * 100).toFixed(2);
+
+        newTask = {
+          ...newTask,
+          ...taskListRef.current.find((item) => item.key === key),
+          size: loadedSize,
+          percent: curPercent >= 100 ? 99.99 : curPercent,
+        };
+        updateTaskList(newTask);
+      },
+    });
+  }
+
+  async function uploadFile({ task, files, totalSize }: { task: TaskItem; files: { slices: Blob[]; name: string; size: number; originFile: Blob }[]; totalSize: number }) {
+    console.log('[useSliceUpload] Calling preUpload with prefix:', task.prefix);
+    const { data: reqId } = await preUpload(task.key, {
+      totalFileNum: files.length,
+      totalSize,
+      datasetId: task.key,
+      hasArchive: task.hasArchive,
+      prefix: task.prefix,
+    });
+    console.log('[useSliceUpload] PreUpload response reqId:', reqId);
+
+    const newTask: TaskItem = {
+      ...task,
+      reqId,
+      isCancel: false,
+      cancelFn: () => {
+        task.controller.abort();
+        cancelUpload?.(reqId);
+        if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
+      },
+    };
+    updateTaskList(newTask);
+    // 注意：show:task-popover 事件已在 createTask 中触发，此处不再重复触发
+    // // 更新数据状态
+    if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
+
+    let loaded = 0;
+    for (let i = 0; i < files.length; i++) {
+      const { slices } = files[i];
+      for (let j = 0; j < slices.length; j++) {
+        await uploadSlice(newTask, {
+          loaded,
+          i,
+          j,
+          files,
+          totalSize,
+        });
+        loaded += slices[j].size;
+      }
+    }
+    removeTask(newTask);
+  }
+
+  const handleUpload = async ({ task, files }: { task: TaskItem; files: { slices: Blob[]; name: string; size: number; originFile: Blob }[] }) => {
+    const isErrorFile = await checkIsFilesExist(files);
+    if (isErrorFile) {
+      message.error("文件被修改或删除，请重新选择文件上传");
+      removeTask({
+        ...task,
+        isCancel: false,
+        ...taskListRef.current.find((item) => item.key === task.key),
+      });
+      return;
+    }
+
+    try {
+      const totalSize = files.reduce((acc, file) => acc + file.size, 0);
+      await uploadFile({ task, files, totalSize });
+    } catch (err) {
+      console.error(err);
+      message.error("文件上传失败，请稍后重试");
+      removeTask({
+        ...task,
+        isCancel: true,
+        ...taskListRef.current.find((item) => item.key === task.key),
+      });
+    }
+  };
+
+  /**
+   * 流式分割上传处理
+   * 用于大文件按行分割并立即上传的场景
+   */
+  const handleStreamUpload = async ({ task, files }: { task: TaskItem; files: File[] }) => {
+    try {
+      console.log('[useSliceUpload] Starting stream upload for', files.length, 'files');
+      
+      // 预上传，获取 reqId
+      const totalSize = files.reduce((acc, file) => acc + file.size, 0);
+      const { data: reqId } = await preUpload(task.key, {
+        totalFileNum: files.length,
+        totalSize,
+        datasetId: task.key,
+        hasArchive: task.hasArchive,
+        prefix: task.prefix,
+      });
+      
+      console.log('[useSliceUpload] Stream upload preUpload response reqId:', reqId);
+
+      const newTask: TaskItem = {
+        ...task,
+        reqId,
+        isCancel: false,
+        cancelFn: () => {
+          task.controller.abort();
+          cancelUpload?.(reqId);
+          if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
+        },
+      };
+      updateTaskList(newTask);
+
+      let totalUploadedLines = 0;
+      let totalProcessedBytes = 0;
+      const results: StreamUploadResult[] = [];
+
+      // 逐个处理文件
+      for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        console.log(`[useSliceUpload] Processing file ${i + 1}/${files.length}: ${file.name}`);
+        
+        const result = await streamSplitAndUpload(
+          file,
+          (formData, config) => uploadChunk(task.key, formData, config),
+          (currentBytes, totalBytes, uploadedLines) => {
+            // 更新进度
+            const overallBytes = totalProcessedBytes + currentBytes;
+            const curPercent = Number((overallBytes / totalSize) * 100).toFixed(2);
+            
+            const updatedTask: TaskItem = {
+              ...newTask,
+              ...taskListRef.current.find((item) => item.key === task.key),
+              size: overallBytes,
+              percent: curPercent >= 100 ? 99.99 : curPercent,
+              streamUploadInfo: {
+                currentFile: file.name,
+                fileIndex: i + 1,
+                totalFiles: files.length,
+                uploadedLines: totalUploadedLines + uploadedLines,
+              },
+            };
+            updateTaskList(updatedTask);
+          },
+          1024 * 1024, // 1MB chunk size
+          {
+            reqId,
+            hasArchive: task.hasArchive,
+            prefix: task.prefix,
+            signal: task.controller.signal,
+            maxConcurrency: 3,
+          }
+        );
+        
+        results.push(result);
+        totalUploadedLines += result.uploadedCount;
+        totalProcessedBytes += file.size;
+        
+        console.log(`[useSliceUpload] File ${file.name} processed, uploaded ${result.uploadedCount} lines`);
+      }
+
+      console.log('[useSliceUpload] Stream upload completed, total lines:', totalUploadedLines);
+      removeTask(newTask);
+      
+      message.success(`成功上传 ${totalUploadedLines} 个文件（按行分割）`);
+    } catch (err) {
+      console.error('[useSliceUpload] Stream upload error:', err);
+      if (err.message === "Upload cancelled") {
+        message.info("上传已取消");
+      } else {
+        message.error("文件上传失败，请稍后重试");
+      }
+      removeTask({
+        ...task,
+        isCancel: true,
+        ...taskListRef.current.find((item) => item.key === task.key),
+      });
+    }
+  };
+
+  /**
+   * 注册流式上传事件监听
+   * 返回注销函数
+   */
+  const registerStreamUploadListener = () => {
+    if (!enableStreamUpload) return () => {};
+
+    const streamUploadHandler = async (e: Event) => {
+      const customEvent = e as CustomEvent;
+      const { dataset, files, updateEvent, hasArchive, prefix } = customEvent.detail;
+      
+      const controller = new AbortController();
+      const task: TaskItem = {
+        key: dataset.id,
+        title: `上传数据集: ${dataset.name} (按行分割)`,
+        percent: 0,
+        reqId: -1,
+        controller,
+        size: 0,
+        updateEvent,
+        hasArchive,
+        prefix,
+      };
+      
+      taskListRef.current = [task, ...taskListRef.current];
+      setTaskList(taskListRef.current);
+      
+      // 显示任务中心
+      if (showTaskCenter) {
+        window.dispatchEvent(
+          new CustomEvent("show:task-popover", { detail: { show: true } })
+        );
+      }
+      
+      await handleStreamUpload({ task, files });
+    };
+
+    window.addEventListener("upload:dataset-stream", streamUploadHandler);
+    
+    return () => {
+      window.removeEventListener("upload:dataset-stream", streamUploadHandler);
+    };
+  };
+
+  return {
+    taskList,
+    createTask,
+    removeTask,
+    handleUpload,
+    handleStreamUpload,
+    registerStreamUploadListener,
+  };
+}

frontend/src/pages/Agent/Agent.tsx

@@ -151,6 +151,15 @@ export default function AgentPage() {
   const [isTyping, setIsTyping] = useState(false);
   const messagesEndRef = useRef<HTMLDivElement>(null);
   const inputRef = useRef<any>(null);
+  const timeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
 
   const scrollToBottom = () => {
     messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
@@ -174,8 +183,13 @@ export default function AgentPage() {
     setInputValue("");
     setIsTyping(true);
 
+    // 清理旧的 timeout
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+
     // 模拟AI响应
-    setTimeout(() => {
+    timeoutRef.current = setTimeout(() => {
       const response = generateResponse(content);
       const assistantMessage: Message = {
         id: (Date.now() + 1).toString(),

frontend/src/pages/ContentGeneration/ContentGenerationPage.tsx

@@ -3,7 +3,9 @@
  * 通过 iframe 加载外部页面
  */
 export default function ContentGenerationPage() {
-  const iframeUrl = "http://192.168.0.8:3000";
+  const iframeUrl = "/api#/meeting";
+
+  window.localStorage.setItem("geeker-user", '{"token":"123","userInfo":{"name":"xteam"},"loginFrom":null,"loginData":null}');
 
   return (
     <div className="h-full w-full flex flex-col">
@@ -16,6 +18,11 @@ export default function ContentGenerationPage() {
           className="w-full h-full border-0"
           title="内容生成"
           sandbox="allow-same-origin allow-scripts allow-popups allow-forms allow-downloads"
+	  style={{marginLeft: "-220px",
+		  marginTop: "-66px",
+	          width: "calc(100% + 233px)",
+		  height: "calc(100% + 108px)"
+	  }}
         />
       </div>
     </div>

frontend/src/pages/DataAnnotation/Annotate/LabelStudioTextEditor.tsx

@@ -9,6 +9,7 @@ import {
   listEditorTasksUsingGet,
   upsertEditorAnnotationUsingPut,
 } from "../annotation.api";
+import { AnnotationResultStatus } from "../annotation.model";
 
 type EditorProjectInfo = {
   projectId: string;
@@ -26,6 +27,8 @@ type EditorTaskListItem = {
   fileType?: string | null;
   hasAnnotation: boolean;
   annotationUpdatedAt?: string | null;
+  annotationStatus?: AnnotationResultStatus | null;
+  segmentStats?: SegmentStats;
 };
 
 type LsfMessage = {
@@ -43,6 +46,11 @@ type SegmentInfo = {
   chunkIndex: number;
 };
 
+type SegmentStats = {
+  done: number;
+  total: number;
+};
+
 type ApiResponse<T> = {
   code?: number;
   message?: string;
@@ -88,6 +96,13 @@ type SwitchDecision = "save" | "discard" | "cancel";
 const LSF_IFRAME_SRC = "/lsf/lsf.html";
 const TASK_PAGE_START = 0;
 const TASK_PAGE_SIZE = 200;
+const NO_ANNOTATION_LABEL = "无标注";
+const NOT_APPLICABLE_LABEL = "不适用";
+const NO_ANNOTATION_CONFIRM_TITLE = "没有标注任何内容";
+const NO_ANNOTATION_CONFIRM_OK_TEXT = "设为无标注并保存";
+const NOT_APPLICABLE_CONFIRM_TEXT = "设为不适用并保存";
+const NO_ANNOTATION_CONFIRM_CANCEL_TEXT = "继续标注";
+const SAVE_AND_NEXT_LABEL = "保存并跳转到下一段/下一条";
 
 type NormalizedTaskList = {
   items: EditorTaskListItem[];
@@ -103,6 +118,17 @@ const resolveSegmentIndex = (value: unknown) => {
   return Number.isFinite(parsed) ? parsed : undefined;
 };
 
+const isSaveShortcut = (event: KeyboardEvent) => {
+  if (event.defaultPrevented || event.isComposing) return false;
+  const key = event.key;
+  const code = event.code;
+  const isS = key === "s" || key === "S" || code === "KeyS";
+  if (!isS) return false;
+  if (!(event.ctrlKey || event.metaKey)) return false;
+  if (event.shiftKey || event.altKey) return false;
+  return true;
+};
+
 const normalizePayload = (payload: unknown): ExportPayload | undefined => {
   if (!payload || typeof payload !== "object") return undefined;
   return payload as ExportPayload;
@@ -119,6 +145,40 @@ const resolvePayloadMessage = (payload: unknown) => {
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   !!value && typeof value === "object" && !Array.isArray(value);
 
+const isAnnotationResultEmpty = (annotation?: Record<string, unknown>) => {
+  if (!annotation) return true;
+  if (!("result" in annotation)) return true;
+  const result = (annotation as { result?: unknown }).result;
+  if (!Array.isArray(result)) return false;
+  return result.length === 0;
+};
+
+const resolveTaskStatusMeta = (item: EditorTaskListItem) => {
+  const segmentSummary = resolveSegmentSummary(item);
+  if (segmentSummary) {
+    if (segmentSummary.done >= segmentSummary.total) {
+      return { text: "已标注", type: "success" as const };
+    }
+    if (segmentSummary.done > 0) {
+      return { text: "标注中", type: "warning" as const };
+    }
+    return { text: "未标注", type: "secondary" as const };
+  }
+  if (!item.hasAnnotation) {
+    return { text: "未标注", type: "secondary" as const };
+  }
+  if (item.annotationStatus === AnnotationResultStatus.NO_ANNOTATION) {
+    return { text: NO_ANNOTATION_LABEL, type: "warning" as const };
+  }
+  if (item.annotationStatus === AnnotationResultStatus.NOT_APPLICABLE) {
+    return { text: NOT_APPLICABLE_LABEL, type: "warning" as const };
+  }
+  if (item.annotationStatus === AnnotationResultStatus.IN_PROGRESS) {
+    return { text: "标注中", type: "warning" as const };
+  }
+  return { text: "已标注", type: "success" as const };
+};
+
 const normalizeSnapshotValue = (value: unknown, seen: WeakSet<object>): unknown => {
   if (!value || typeof value !== "object") return value;
   const obj = value as object;
@@ -144,6 +204,7 @@ const stableStringify = (value: unknown) => {
 
 const buildAnnotationSnapshot = (annotation?: Record<string, unknown>) => {
   if (!annotation) return "";
+  if (isAnnotationResultEmpty(annotation)) return "";
   const cleaned: Record<string, unknown> = { ...annotation };
   delete cleaned.updated_at;
   delete cleaned.updatedAt;
@@ -155,6 +216,25 @@ const buildAnnotationSnapshot = (annotation?: Record<string, unknown>) => {
 const buildSnapshotKey = (fileId: string, segmentIndex?: number) =>
   `${fileId}::${segmentIndex ?? "full"}`;
 
+const buildSegmentStats = (segmentList?: SegmentInfo[] | null): SegmentStats | null => {
+  if (!Array.isArray(segmentList) || segmentList.length === 0) return null;
+  const total = segmentList.length;
+  const done = segmentList.reduce((count, seg) => count + (seg.hasAnnotation ? 1 : 0), 0);
+  return { done, total };
+};
+
+const normalizeSegmentStats = (stats?: SegmentStats | null): SegmentStats | null => {
+  if (!stats) return null;
+  const total = Number(stats.total);
+  const done = Number(stats.done);
+  if (!Number.isFinite(total) || total <= 0) return null;
+  const safeDone = Math.min(Math.max(done, 0), total);
+  return { done: safeDone, total };
+};
+
+const resolveSegmentSummary = (item: EditorTaskListItem) =>
+  normalizeSegmentStats(item.segmentStats);
+
 const mergeTaskItems = (base: EditorTaskListItem[], next: EditorTaskListItem[]) => {
   if (next.length === 0) return base;
   const seen = new Set(base.map((item) => item.fileId));
@@ -205,6 +285,9 @@ export default function LabelStudioTextEditor() {
   const exportCheckSeqRef = useRef(0);
   const savedSnapshotsRef = useRef<Record<string, string>>({});
   const pendingAutoAdvanceRef = useRef(false);
+  const segmentStatsCacheRef = useRef<Record<string, SegmentStats>>({});
+  const segmentStatsSeqRef = useRef(0);
+  const segmentStatsLoadingRef = useRef<Set<string>>(new Set());
 
   const [loadingProject, setLoadingProject] = useState(true);
   const [loadingTasks, setLoadingTasks] = useState(false);
@@ -247,6 +330,100 @@ export default function LabelStudioTextEditor() {
     win.postMessage({ type, payload }, origin);
   }, [origin]);
 
+  const applySegmentStats = useCallback((fileId: string, stats: SegmentStats | null) => {
+    if (!fileId) return;
+    const normalized = normalizeSegmentStats(stats);
+    setTasks((prev) =>
+      prev.map((item) =>
+        item.fileId === fileId
+          ? { ...item, segmentStats: normalized || undefined }
+          : item
+      )
+    );
+  }, []);
+
+  const updateSegmentStatsCache = useCallback((fileId: string, stats: SegmentStats | null) => {
+    if (!fileId) return;
+    const normalized = normalizeSegmentStats(stats);
+    if (normalized) {
+      segmentStatsCacheRef.current[fileId] = normalized;
+    } else {
+      delete segmentStatsCacheRef.current[fileId];
+    }
+    applySegmentStats(fileId, normalized);
+  }, [applySegmentStats]);
+
+  const fetchSegmentStatsForFile = useCallback(async (fileId: string, seq: number) => {
+    if (!projectId || !fileId) return;
+    if (segmentStatsCacheRef.current[fileId] || segmentStatsLoadingRef.current.has(fileId)) return;
+    segmentStatsLoadingRef.current.add(fileId);
+    try {
+      const resp = (await getEditorTaskUsingGet(projectId, fileId, {
+        segmentIndex: 0,
+      })) as ApiResponse<EditorTaskResponse>;
+      if (segmentStatsSeqRef.current !== seq) return;
+      const data = resp?.data;
+      if (!data?.segmented) return;
+      const stats = buildSegmentStats(data.segments);
+      if (!stats) return;
+      segmentStatsCacheRef.current[fileId] = stats;
+      applySegmentStats(fileId, stats);
+    } catch (e) {
+      console.error(e);
+    } finally {
+      segmentStatsLoadingRef.current.delete(fileId);
+    }
+  }, [applySegmentStats, projectId]);
+
+  const prefetchSegmentStats = useCallback((items: EditorTaskListItem[]) => {
+    if (!projectId) return;
+    const fileIds = items
+      .map((item) => item.fileId)
+      .filter((fileId) => fileId && !segmentStatsCacheRef.current[fileId]);
+    if (fileIds.length === 0) return;
+    const seq = segmentStatsSeqRef.current;
+    let cursor = 0;
+    const workerCount = Math.min(3, fileIds.length);
+    const runWorker = async () => {
+      while (cursor < fileIds.length && segmentStatsSeqRef.current === seq) {
+        const fileId = fileIds[cursor];
+        cursor += 1;
+        await fetchSegmentStatsForFile(fileId, seq);
+      }
+    };
+    void Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+  }, [fetchSegmentStatsForFile, projectId]);
+
+  const confirmEmptyAnnotationStatus = useCallback(() => {
+    return new Promise<AnnotationResultStatus | null>((resolve) => {
+      let resolved = false;
+      let modalInstance: { destroy: () => void } | null = null;
+      const settle = (value: AnnotationResultStatus | null) => {
+        if (resolved) return;
+        resolved = true;
+        resolve(value);
+        if (modalInstance) modalInstance.destroy();
+      };
+      const handleNotApplicable = () => settle(AnnotationResultStatus.NOT_APPLICABLE);
+      modalInstance = modal.confirm({
+        title: NO_ANNOTATION_CONFIRM_TITLE,
+        content: (
+          <div className="flex flex-col gap-2">
+            <Typography.Text>当前未发现任何标注内容。</Typography.Text>
+            <Typography.Text type="secondary">如确认为无标注或不适用，可继续保存。</Typography.Text>
+            <Button type="link" style={{ padding: 0, height: "auto" }} onClick={handleNotApplicable}>
+              {NOT_APPLICABLE_CONFIRM_TEXT}
+            </Button>
+          </div>
+        ),
+        okText: NO_ANNOTATION_CONFIRM_OK_TEXT,
+        cancelText: NO_ANNOTATION_CONFIRM_CANCEL_TEXT,
+        onOk: () => settle(AnnotationResultStatus.NO_ANNOTATION),
+        onCancel: () => settle(null),
+      });
+    });
+  }, [modal]);
+
   const loadProject = useCallback(async () => {
     setLoadingProject(true);
     try {
@@ -268,8 +445,13 @@ export default function LabelStudioTextEditor() {
   }, [message, projectId]);
 
   const updateTaskSelection = useCallback((items: EditorTaskListItem[]) => {
+    const isCompleted = (item: EditorTaskListItem) => {
+      const summary = resolveSegmentSummary(item);
+      if (summary) return summary.done >= summary.total;
+      return item.hasAnnotation;
+    };
     const defaultFileId =
-      items.find((item) => !item.hasAnnotation)?.fileId || items[0]?.fileId || "";
+      items.find((item) => !isCompleted(item))?.fileId || items[0]?.fileId || "";
     setSelectedFileId((prev) => {
       if (prev && items.some((item) => item.fileId === prev)) return prev;
       return defaultFileId;
@@ -326,6 +508,9 @@ export default function LabelStudioTextEditor() {
     if (mode === "reset") {
       prefetchSeqRef.current += 1;
       setPrefetching(false);
+      segmentStatsSeqRef.current += 1;
+      segmentStatsCacheRef.current = {};
+      segmentStatsLoadingRef.current = new Set();
     }
     if (mode === "append") {
       setLoadingMore(true);
@@ -410,13 +595,16 @@ export default function LabelStudioTextEditor() {
         ? resolveSegmentIndex(data.currentSegmentIndex) ?? 0
         : undefined;
       if (data?.segmented) {
+        const stats = buildSegmentStats(data.segments);
         setSegmented(true);
         setSegments(data.segments || []);
         setCurrentSegmentIndex(segmentIndex ?? 0);
+        updateSegmentStatsCache(fileId, stats);
       } else {
         setSegmented(false);
         setSegments([]);
         setCurrentSegmentIndex(0);
+        updateSegmentStatsCache(fileId, null);
       }
 
       const taskData = {
@@ -476,7 +664,7 @@ export default function LabelStudioTextEditor() {
     } finally {
       if (seq === initSeqRef.current) setLoadingTaskDetail(false);
     }
-  }, [iframeReady, message, postToIframe, project, projectId]);
+  }, [iframeReady, message, postToIframe, project, projectId, updateSegmentStatsCache]);
 
   const advanceAfterSave = useCallback(async (fileId: string, segmentIndex?: number) => {
     if (!fileId) return;
@@ -539,11 +727,31 @@ export default function LabelStudioTextEditor() {
           ? currentSegmentIndex
           : undefined;
 
+    const annotationRecord = annotation as Record<string, unknown>;
+    const currentTask = tasks.find((item) => item.fileId === String(fileId));
+    const currentStatus = currentTask?.annotationStatus;
+    let resolvedStatus: AnnotationResultStatus;
+    if (isAnnotationResultEmpty(annotationRecord)) {
+      if (
+        currentStatus === AnnotationResultStatus.NO_ANNOTATION ||
+        currentStatus === AnnotationResultStatus.NOT_APPLICABLE
+      ) {
+        resolvedStatus = currentStatus;
+      } else {
+        const selectedStatus = await confirmEmptyAnnotationStatus();
+        if (!selectedStatus) return false;
+        resolvedStatus = selectedStatus;
+      }
+    } else {
+      resolvedStatus = AnnotationResultStatus.ANNOTATED;
+    }
+
     setSaving(true);
     try {
       const resp = (await upsertEditorAnnotationUsingPut(projectId, String(fileId), {
         annotation,
         segmentIndex,
+        annotationStatus: resolvedStatus,
       })) as ApiResponse<UpsertAnnotationResponse>;
       const updatedAt = resp?.data?.updatedAt;
       message.success("标注已保存");
@@ -553,6 +761,7 @@ export default function LabelStudioTextEditor() {
             ? {
                 ...item,
                 hasAnnotation: true,
+                annotationStatus: resolvedStatus,
                 annotationUpdatedAt: updatedAt || item.annotationUpdatedAt,
               }
             : item
@@ -565,13 +774,13 @@ export default function LabelStudioTextEditor() {
 
       // 分段模式下更新当前段落的标注状态
       if (segmented && segmentIndex !== undefined) {
-        setSegments((prev) =>
-          prev.map((seg) =>
-            seg.idx === segmentIndex
-              ? { ...seg, hasAnnotation: true }
-              : seg
-          )
+        const nextSegments = segments.map((seg) =>
+          seg.idx === segmentIndex
+            ? { ...seg, hasAnnotation: true }
+            : seg
         );
+        setSegments(nextSegments);
+        updateSegmentStatsCache(String(fileId), buildSegmentStats(nextSegments));
       }
       if (options?.autoAdvance) {
         await advanceAfterSave(String(fileId), segmentIndex);
@@ -586,11 +795,15 @@ export default function LabelStudioTextEditor() {
     }
   }, [
     advanceAfterSave,
+    confirmEmptyAnnotationStatus,
     currentSegmentIndex,
     message,
     projectId,
     segmented,
+    segments,
     selectedFileId,
+    tasks,
+    updateSegmentStatsCache,
   ]);
 
   const requestExportForCheck = useCallback(() => {
@@ -650,14 +863,27 @@ export default function LabelStudioTextEditor() {
     });
   }, [modal]);
 
-  const requestExport = () => {
+  const requestExport = useCallback((autoAdvance: boolean) => {
     if (!selectedFileId) {
       message.warning("请先选择文件");
       return;
     }
-    pendingAutoAdvanceRef.current = true;
+    pendingAutoAdvanceRef.current = autoAdvance;
     postToIframe("LS_EXPORT", {});
-  };
+  }, [message, postToIframe, selectedFileId]);
+
+  useEffect(() => {
+    const handleSaveShortcut = (event: KeyboardEvent) => {
+      if (!isSaveShortcut(event) || event.repeat) return;
+      if (saving || loadingTaskDetail || segmentSwitching) return;
+      if (!iframeReady || !lsReady) return;
+      event.preventDefault();
+      event.stopPropagation();
+      requestExport(false);
+    };
+    window.addEventListener("keydown", handleSaveShortcut);
+    return () => window.removeEventListener("keydown", handleSaveShortcut);
+  }, [iframeReady, loadingTaskDetail, lsReady, requestExport, saving, segmentSwitching]);
 
   // 段落切换处理
   const handleSegmentChange = useCallback(async (newIndex: number) => {
@@ -754,6 +980,9 @@ export default function LabelStudioTextEditor() {
     setSegments([]);
     setCurrentSegmentIndex(0);
     savedSnapshotsRef.current = {};
+    segmentStatsSeqRef.current += 1;
+    segmentStatsCacheRef.current = {};
+    segmentStatsLoadingRef.current = new Set();
     if (exportCheckRef.current?.timer) {
       window.clearTimeout(exportCheckRef.current.timer);
     }
@@ -767,6 +996,12 @@ export default function LabelStudioTextEditor() {
     loadTasks({ mode: "reset" });
   }, [project?.supported, loadTasks]);
 
+  useEffect(() => {
+    if (!segmented) return;
+    if (tasks.length === 0) return;
+    prefetchSegmentStats(tasks);
+  }, [prefetchSegmentStats, segmented, tasks]);
+
   useEffect(() => {
     if (!selectedFileId) return;
     initEditorForFile(selectedFileId);
@@ -826,6 +1061,15 @@ export default function LabelStudioTextEditor() {
     [segmentTreeData]
   );
 
+  const inProgressSegmentedCount = useMemo(() => {
+    if (tasks.length === 0) return 0;
+    return tasks.reduce((count, item) => {
+      const summary = resolveSegmentSummary(item);
+      if (!summary) return count;
+      return summary.done < summary.total ? count + 1 : count;
+    }, 0);
+  }, [tasks]);
+
   const handleSegmentSelect = useCallback((keys: Array<string | number>) => {
     const [first] = keys;
     if (first === undefined || first === null) return;
@@ -865,6 +1109,12 @@ export default function LabelStudioTextEditor() {
         return;
       }
 
+      if (msg.type === "LS_SAVE_AND_NEXT") {
+        pendingAutoAdvanceRef.current = false;
+        saveFromExport(payload, { autoAdvance: true });
+        return;
+      }
+
       if (msg.type === "LS_EXPORT_CHECK_RESULT") {
         const pending = exportCheckRef.current;
         if (!pending) return;
@@ -897,6 +1147,8 @@ export default function LabelStudioTextEditor() {
   }, [message, origin, saveFromExport]);
 
   const canLoadMore = taskTotalPages > 0 && taskPage + 1 < taskTotalPages;
+  const saveDisabled =
+    !iframeReady || !selectedFileId || saving || segmentSwitching || loadingTaskDetail;
   const loadMoreNode = canLoadMore ? (
     <div className="p-2 text-center">
       <Button
@@ -960,7 +1212,7 @@ export default function LabelStudioTextEditor() {
   return (
     <div className="h-full flex flex-col">
       {/* 顶部工具栏 */}
-      <div className="flex items-center justify-between px-3 py-2 border-b border-gray-200 bg-white">
+      <div className="grid grid-cols-[1fr_auto_1fr] items-center px-3 py-2 border-b border-gray-200 bg-white">
         <div className="flex items-center gap-2">
           <Button icon={<LeftOutlined />} onClick={() => navigate("/data/annotation")}>
             返回
@@ -974,7 +1226,18 @@ export default function LabelStudioTextEditor() {
             标注编辑器
           </Typography.Title>
         </div>
-        <div className="flex items-center gap-2">
+        <div className="flex items-center justify-center">
+          <Button
+            type="primary"
+            icon={<SaveOutlined />}
+            loading={saving}
+            disabled={saveDisabled}
+            onClick={() => requestExport(true)}
+          >
+            {SAVE_AND_NEXT_LABEL}
+          </Button>
+        </div>
+        <div className="flex items-center gap-2 justify-end">
           <Button
             icon={<ReloadOutlined />}
             loading={loadingTasks}
@@ -983,11 +1246,10 @@ export default function LabelStudioTextEditor() {
             刷新
           </Button>
           <Button
-            type="primary"
             icon={<SaveOutlined />}
             loading={saving}
-            disabled={!iframeReady || !selectedFileId}
-            onClick={requestExport}
+            disabled={saveDisabled}
+            onClick={() => requestExport(false)}
           >
             保存
           </Button>
@@ -1001,8 +1263,13 @@ export default function LabelStudioTextEditor() {
           className="border-r border-gray-200 bg-gray-50 flex flex-col transition-all duration-200 min-h-0"
           style={{ width: sidebarCollapsed ? 0 : 240, overflow: "hidden" }}
         >
-          <div className="px-3 py-2 border-b border-gray-200 bg-white font-medium text-sm">
-            文件列表
+          <div className="px-3 py-2 border-b border-gray-200 bg-white font-medium text-sm flex items-center justify-between gap-2">
+            <span>文件列表</span>
+            {segmented && (
+              <Tag color="orange" style={{ margin: 0 }}>
+                标注中 {inProgressSegmentedCount}
+              </Tag>
+            )}
           </div>
           <div className="flex-1 min-h-0 overflow-auto">
             <List
@@ -1010,37 +1277,45 @@ export default function LabelStudioTextEditor() {
               size="small"
               dataSource={tasks}
               loadMore={loadMoreNode}
-              renderItem={(item) => (
-                <List.Item
-                  key={item.fileId}
-                  className="cursor-pointer hover:bg-blue-50"
-                  style={{
-                    background: item.fileId === selectedFileId ? "#e6f4ff" : undefined,
-                    padding: "8px 12px",
-                    borderBottom: "1px solid #f0f0f0",
-                  }}
-                  onClick={() => setSelectedFileId(item.fileId)}
-                >
-                  <div className="flex flex-col w-full gap-1">
-                    <Typography.Text ellipsis style={{ fontSize: 13 }}>
-                      {item.fileName}
-                    </Typography.Text>
-                    <div className="flex items-center justify-between">
-                      <Typography.Text
-                        type={item.hasAnnotation ? "success" : "secondary"}
-                        style={{ fontSize: 11 }}
-                      >
-                        {item.hasAnnotation ? "已标注" : "未标注"}
-                      </Typography.Text>
-                      {item.annotationUpdatedAt && (
-                        <Typography.Text type="secondary" style={{ fontSize: 10 }}>
-                          {item.annotationUpdatedAt}
+              renderItem={(item) => {
+                const segmentSummary = resolveSegmentSummary(item);
+                const statusMeta = resolveTaskStatusMeta(item);
+                return (
+                  <List.Item
+                    key={item.fileId}
+                    className="cursor-pointer hover:bg-blue-50"
+                    style={{
+                      background: item.fileId === selectedFileId ? "#e6f4ff" : undefined,
+                      padding: "8px 12px",
+                      borderBottom: "1px solid #f0f0f0",
+                    }}
+                    onClick={() => setSelectedFileId(item.fileId)}
+                  >
+                    <div className="flex flex-col w-full gap-1">
+                        <Typography.Text ellipsis style={{ fontSize: 13 }}>
+                          {item.fileName}
                         </Typography.Text>
-                      )}
+                        <div className="flex items-center justify-between">
+                          <div className="flex items-center gap-2">
+                            <Typography.Text type={statusMeta.type} style={{ fontSize: 11 }}>
+                              {statusMeta.text}
+                            </Typography.Text>
+                            {segmentSummary && (
+                              <Typography.Text type="secondary" style={{ fontSize: 10 }}>
+                                已标注 {segmentSummary.done}/{segmentSummary.total}
+                              </Typography.Text>
+                            )}
+                          </div>
+                          {item.annotationUpdatedAt && (
+                            <Typography.Text type="secondary" style={{ fontSize: 10 }}>
+                              {item.annotationUpdatedAt}
+                            </Typography.Text>
+                          )}
+                      </div>
                     </div>
-                  </div>
-                </List.Item>
-              )}
+                  </List.Item>
+                );
+              }}
             />
           </div>
           {segmented && (

frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx

@@ -6,6 +6,12 @@ import TextArea from "antd/es/input/TextArea";
 import { useEffect, useMemo, useState } from "react";
 import type { ReactNode } from "react";
 import { Eye } from "lucide-react";
+import {
+  PREVIEW_TEXT_MAX_LENGTH,
+  resolvePreviewFileType,
+  truncatePreviewText,
+  type PreviewFileType,
+} from "@/utils/filePreview";
 import {
   createAnnotationTaskUsingPost,
   getAnnotationTaskByIdUsingGet,
@@ -13,7 +19,8 @@ import {
   queryAnnotationTemplatesUsingGet,
 } from "../../annotation.api";
 import { DatasetType, type Dataset } from "@/pages/DataManagement/dataset.model";
-import { DataType, type AnnotationTemplate, type AnnotationTask } from "../../annotation.model";
+import { DataType, type AnnotationTemplate } from "../../annotation.model";
+import type { AnnotationTaskListItem } from "../../annotation.const";
 import LabelStudioEmbed from "@/components/business/LabelStudioEmbed";
 import TemplateConfigurationTreeEditor from "../../components/TemplateConfigurationTreeEditor";
 import { useTagConfig } from "@/hooks/useTagConfig";
@@ -23,7 +30,7 @@ interface AnnotationTaskDialogProps {
   onClose: () => void;
   onRefresh: () => void;
   /** 编辑模式：传入要编辑的任务数据 */
-  editTask?: AnnotationTask | null;
+  editTask?: AnnotationTaskListItem | null;
 }
 
 type DatasetOption = Dataset & { icon?: ReactNode };
@@ -53,6 +60,8 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
   !!value && typeof value === "object" && !Array.isArray(value);
 
 const DEFAULT_SEGMENTATION_ENABLED = true;
+const FILE_PREVIEW_MAX_HEIGHT = 500;
+const PREVIEW_MODAL_WIDTH = "80vw";
 const SEGMENTATION_OPTIONS = [
   { label: "需要切片段", value: true },
   { label: "不需要切片段", value: false },
@@ -116,7 +125,7 @@ export default function CreateAnnotationTask({
   const [fileContent, setFileContent] = useState("");
   const [fileContentLoading, setFileContentLoading] = useState(false);
   const [previewFileName, setPreviewFileName] = useState("");
-  const [previewFileType, setPreviewFileType] = useState<"text" | "image" | "video" | "audio">("text");
+  const [previewFileType, setPreviewFileType] = useState<PreviewFileType>("text");
   const [previewMediaUrl, setPreviewMediaUrl] = useState("");
 
   // 任务详情加载状态（编辑模式）
@@ -275,7 +284,7 @@ export default function CreateAnnotationTask({
     }
     setDatasetPreviewLoading(true);
     try {
-      // 对于文本数据集，排除已被转换为TXT的源文档文件（PDF/DOC/DOCX）
+      // 对于文本数据集，排除源文档文件（PDF/DOC/DOCX/XLS/XLSX）
       const params: { page: number; size: number; excludeSourceDocuments?: boolean } = { page: 0, size: 10 };
       if (isTextDataset) {
         params.excludeSourceDocuments = true;
@@ -297,57 +306,32 @@ export default function CreateAnnotationTask({
 
   // 预览文件内容
   const handlePreviewFileContent = async (file: DatasetPreviewFile) => {
-    const fileName = file.fileName?.toLowerCase() || '';
-
-    // 文件类型扩展名映射
-    const textExtensions = ['.json', '.jsonl', '.txt', '.csv', '.tsv', '.xml', '.md', '.yaml', '.yml'];
-    const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg'];
-    const videoExtensions = ['.mp4', '.webm', '.ogg', '.mov', '.avi'];
-    const audioExtensions = ['.mp3', '.wav', '.ogg', '.aac', '.flac', '.m4a'];
-
-    const isTextFile = textExtensions.some(ext => fileName.endsWith(ext));
-    const isImageFile = imageExtensions.some(ext => fileName.endsWith(ext));
-    const isVideoFile = videoExtensions.some(ext => fileName.endsWith(ext));
-    const isAudioFile = audioExtensions.some(ext => fileName.endsWith(ext));
-
-    if (!isTextFile && !isImageFile && !isVideoFile && !isAudioFile) {
+    const fileType = resolvePreviewFileType(file.fileName);
+    if (!fileType) {
       message.warning("不支持预览该文件类型");
       return;
     }
 
     setFileContentLoading(true);
     setPreviewFileName(file.fileName);
+    setPreviewFileType(fileType);
+    setFileContent("");
+    setPreviewMediaUrl("");
 
-    const fileUrl = `/api/data-management/datasets/${selectedDatasetId}/files/${file.id}/download`;
+    const previewUrl = `/api/data-management/datasets/${selectedDatasetId}/files/${file.id}/preview`;
 
     try {
-      if (isTextFile) {
+      if (fileType === "text") {
         // 文本文件：获取内容
-        const response = await fetch(fileUrl);
+        const response = await fetch(previewUrl);
         if (!response.ok) {
           throw new Error('下载失败');
         }
         const text = await response.text();
-        // 限制预览内容长度
-        const maxLength = 50000;
-        if (text.length > maxLength) {
-          setFileContent(text.substring(0, maxLength) + '\n\n... (内容过长，仅显示前 50000 字符)');
-        } else {
-          setFileContent(text);
-        }
-        setPreviewFileType("text");
-      } else if (isImageFile) {
-        // 图片文件：直接使用 URL
-        setPreviewMediaUrl(fileUrl);
-        setPreviewFileType("image");
-      } else if (isVideoFile) {
-        // 视频文件：使用 URL
-        setPreviewMediaUrl(fileUrl);
-        setPreviewFileType("video");
-      } else if (isAudioFile) {
-        // 音频文件：使用 URL
-        setPreviewMediaUrl(fileUrl);
-        setPreviewFileType("audio");
+        setFileContent(truncatePreviewText(text, PREVIEW_TEXT_MAX_LENGTH));
+      } else {
+        // 媒体/PDF 文件：直接使用预览地址
+        setPreviewMediaUrl(previewUrl);
       }
       setFileContentVisible(true);
     } catch (error) {
@@ -846,7 +830,7 @@ export default function CreateAnnotationTask({
         open={showPreview}
         onCancel={() => setShowPreview(false)}
         title="标注界面预览"
-        width={1000}
+        width={PREVIEW_MODAL_WIDTH}
         footer={[
           <Button key="close" onClick={() => setShowPreview(false)}>
             关闭
@@ -871,14 +855,14 @@ export default function CreateAnnotationTask({
         open={datasetPreviewVisible}
         onCancel={() => setDatasetPreviewVisible(false)}
         title="数据集预览（前10条文件）"
-        width={700}
+        width={PREVIEW_MODAL_WIDTH}
         footer={[
           <Button key="close" onClick={() => setDatasetPreviewVisible(false)}>
             关闭
           </Button>
         ]}
       >
-        <div className="mb-2 text-xs text-gray-500">点击文件名可预览文件内容（支持文本、图片、音频、视频）</div>
+        <div className="mb-2 text-xs text-gray-500">点击文件名可预览文件内容（支持文本、图片、音频、视频、PDF）</div>
         <Table
           dataSource={datasetPreviewData}
           columns={[
@@ -928,7 +912,7 @@ export default function CreateAnnotationTask({
           setFileContent("");
         }}
         title={`文件预览：${previewFileName}`}
-        width={previewFileType === "text" ? 800 : 700}
+        width={PREVIEW_MODAL_WIDTH}
         footer={[
           <Button key="close" onClick={() => {
             setFileContentVisible(false);
@@ -942,7 +926,7 @@ export default function CreateAnnotationTask({
         {previewFileType === "text" && (
           <pre
             style={{
-              maxHeight: '500px',
+              maxHeight: `${FILE_PREVIEW_MAX_HEIGHT}px`,
               overflow: 'auto',
               backgroundColor: '#f5f5f5',
               padding: '12px',
@@ -960,16 +944,23 @@ export default function CreateAnnotationTask({
             <img
               src={previewMediaUrl}
               alt={previewFileName}
-              style={{ maxWidth: '100%', maxHeight: '500px', objectFit: 'contain' }}
+              style={{ maxWidth: '100%', maxHeight: `${FILE_PREVIEW_MAX_HEIGHT}px`, objectFit: 'contain' }}
             />
           </div>
         )}
+        {previewFileType === "pdf" && (
+          <iframe
+            src={previewMediaUrl}
+            title={previewFileName || "PDF 预览"}
+            style={{ width: '100%', height: `${FILE_PREVIEW_MAX_HEIGHT}px`, border: 'none' }}
+          />
+        )}
         {previewFileType === "video" && (
           <div style={{ textAlign: 'center' }}>
             <video
               src={previewMediaUrl}
               controls
-              style={{ maxWidth: '100%', maxHeight: '500px' }}
+              style={{ maxWidth: '100%', maxHeight: `${FILE_PREVIEW_MAX_HEIGHT}px` }}
             >
               您的浏览器不支持视频播放
             </video>

frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { Card, Button, Table, message, Modal, Tabs } from "antd";
+import { Card, Button, Table, Tag, message, Modal, Tabs } from "antd";
 import {
   PlusOutlined,
   EditOutlined,
@@ -10,27 +10,39 @@ import {
 import { useNavigate } from "react-router";
 import { SearchControls } from "@/components/SearchControls";
 import CardView from "@/components/CardView";
-import type { AnnotationTask } from "../annotation.model";
 import useFetchData from "@/hooks/useFetchData";
 import {
   deleteAnnotationTaskByIdUsingDelete,
   queryAnnotationTasksUsingGet,
 } from "../annotation.api";
-import { mapAnnotationTask } from "../annotation.const";
+import {
+  AnnotationTypeMap,
+  mapAnnotationTask,
+  type AnnotationTaskListItem,
+} from "../annotation.const";
 import CreateAnnotationTask from "../Create/components/CreateAnnotationTaskDialog";
 import ExportAnnotationDialog from "./ExportAnnotationDialog";
 import { ColumnType } from "antd/es/table";
 import { TemplateList } from "../Template";
 // Note: DevelopmentInProgress intentionally not used here
 
+type AnnotationTaskRowKey = string | number;
+type AnnotationTaskOperation = {
+  key: string;
+  label: string;
+  icon: JSX.Element;
+  danger?: boolean;
+  onClick: (task: AnnotationTaskListItem) => void;
+};
+
 export default function DataAnnotation() {
   // return <DevelopmentInProgress showTime="2025.10.30" />;
   const navigate = useNavigate();
   const [activeTab, setActiveTab] = useState("tasks");
   const [viewMode, setViewMode] = useState<"list" | "card">("list");
   const [showCreateDialog, setShowCreateDialog] = useState(false);
-  const [exportTask, setExportTask] = useState<AnnotationTask | null>(null);
-  const [editTask, setEditTask] = useState<AnnotationTask | null>(null);
+  const [exportTask, setExportTask] = useState<AnnotationTaskListItem | null>(null);
+  const [editTask, setEditTask] = useState<AnnotationTaskListItem | null>(null);
 
   const {
     loading,
@@ -40,13 +52,16 @@ export default function DataAnnotation() {
     fetchData,
     handleFiltersChange,
     handleKeywordChange,
-  } = useFetchData(queryAnnotationTasksUsingGet, mapAnnotationTask, 30000, true, [], 0);
+  } = useFetchData<AnnotationTaskListItem>(queryAnnotationTasksUsingGet, mapAnnotationTask, 30000, true, [], 0);
 
-  const [selectedRowKeys, setSelectedRowKeys] = useState<(string | number)[]>([]);
-  const [selectedRows, setSelectedRows] = useState<any[]>([]);
+  const [selectedRowKeys, setSelectedRowKeys] = useState<AnnotationTaskRowKey[]>([]);
+  const [selectedRows, setSelectedRows] = useState<AnnotationTaskListItem[]>([]);
 
-  const handleAnnotate = (task: AnnotationTask) => {
-    const projectId = (task as any)?.id;
+  const toSafeCount = (value: unknown) =>
+    typeof value === "number" && Number.isFinite(value) ? value : 0;
+
+  const handleAnnotate = (task: AnnotationTaskListItem) => {
+    const projectId = task.id;
     if (!projectId) {
       message.error("无法进入标注：缺少标注项目ID");
       return;
@@ -54,15 +69,15 @@ export default function DataAnnotation() {
     navigate(`/data/annotation/annotate/${projectId}`);
   };
 
-  const handleExport = (task: AnnotationTask) => {
+  const handleExport = (task: AnnotationTaskListItem) => {
     setExportTask(task);
   };
 
-  const handleEdit = (task: AnnotationTask) => {
+  const handleEdit = (task: AnnotationTaskListItem) => {
     setEditTask(task);
   };
 
-  const handleDelete = (task: AnnotationTask) => {
+  const handleDelete = (task: AnnotationTaskListItem) => {
     Modal.confirm({
       title: `确认删除标注任务「${task.name}」吗？`,
       content: "删除标注任务不会删除对应数据集，但会删除该任务的所有标注结果。",
@@ -110,7 +125,7 @@ export default function DataAnnotation() {
     });
   };
 
-  const operations = [
+  const operations: AnnotationTaskOperation[] = [
     {
       key: "annotate",
       label: "标注",
@@ -142,24 +157,45 @@ export default function DataAnnotation() {
     },
   ];
 
-  const columns: ColumnType<any>[] = [
+  const columns: ColumnType<AnnotationTaskListItem>[] = [
+    {
+      title: "序号",
+      key: "index",
+      width: 80,
+      align: "center" as const,
+      render: (_value: unknown, _record: AnnotationTaskListItem, index: number) => {
+        const current = pagination.current ?? 1;
+        const pageSize = pagination.pageSize ?? tableData.length ?? 0;
+        return (current - 1) * pageSize + index + 1;
+      },
+    },
     {
       title: "任务名称",
       dataIndex: "name",
       key: "name",
       fixed: "left" as const,
     },
-    {
-      title: "任务ID",
-      dataIndex: "id",
-      key: "id",
-    },
     {
       title: "数据集",
       dataIndex: "datasetName",
       key: "datasetName",
       width: 180,
     },
+    {
+      title: "标注类型",
+      dataIndex: "labelingType",
+      key: "labelingType",
+      width: 160,
+      render: (value?: string) => {
+        if (!value) {
+          return "-";
+        }
+        const label =
+          AnnotationTypeMap[value as keyof typeof AnnotationTypeMap]?.label ||
+          value;
+        return <Tag color="geekblue">{label}</Tag>;
+      },
+    },
     {
       title: "数据量",
       dataIndex: "totalCount",
@@ -173,9 +209,21 @@ export default function DataAnnotation() {
       key: "annotatedCount",
       width: 100,
       align: "center" as const,
-      render: (value: number, record: any) => {
-        const total = record.totalCount || 0;
-        const annotated = value || 0;
+      render: (value: number, record: AnnotationTaskListItem) => {
+        const total = toSafeCount(record.totalCount ?? record.total_count);
+        const annotatedRaw = toSafeCount(
+          value ?? record.annotatedCount ?? record.annotated_count
+        );
+        const segmentationEnabled =
+          record.segmentationEnabled ?? record.segmentation_enabled;
+        const inProgressRaw = segmentationEnabled
+          ? toSafeCount(record.inProgressCount ?? record.in_progress_count)
+          : 0;
+        const shouldExcludeInProgress =
+          total > 0 && annotatedRaw + inProgressRaw > total;
+        const annotated = shouldExcludeInProgress
+          ? Math.max(annotatedRaw - inProgressRaw, 0)
+          : annotatedRaw;
         const percent = total > 0 ? Math.round((annotated / total) * 100) : 0;
         return (
           <span title={`${annotated}/${total} (${percent}%)`}>
@@ -184,6 +232,23 @@ export default function DataAnnotation() {
         );
       },
     },
+    {
+      title: "标注中",
+      dataIndex: "inProgressCount",
+      key: "inProgressCount",
+      width: 100,
+      align: "center" as const,
+      render: (value: number, record: AnnotationTaskListItem) => {
+        const segmentationEnabled =
+          record.segmentationEnabled ?? record.segmentation_enabled;
+        if (!segmentationEnabled) return "-";
+        const resolved =
+          Number.isFinite(value)
+            ? value
+            : record.inProgressCount ?? record.in_progress_count ?? 0;
+        return resolved;
+      },
+    },
     {
       title: "创建时间",
       dataIndex: "createdAt",
@@ -202,14 +267,14 @@ export default function DataAnnotation() {
       fixed: "right" as const,
       width: 150,
       dataIndex: "actions",
-      render: (_: any, task: any) => (
+      render: (_value: unknown, task: AnnotationTaskListItem) => (
         <div className="flex items-center justify-center space-x-1">
           {operations.map((operation) => (
             <Button
               key={operation.key}
               type="text"
               icon={operation.icon}
-              onClick={() => (operation?.onClick as any)?.(task)}
+              onClick={() => operation.onClick(task)}
               title={operation.label}
             />
           ))}
@@ -282,9 +347,9 @@ export default function DataAnnotation() {
                       pagination={pagination}
                       rowSelection={{
                         selectedRowKeys,
-                        onChange: (keys, rows) => {
-                          setSelectedRowKeys(keys as (string | number)[]);
-                          setSelectedRows(rows as any[]);
+                        onChange: (keys: AnnotationTaskRowKey[], rows: AnnotationTaskListItem[]) => {
+                          setSelectedRowKeys(keys);
+                          setSelectedRows(rows);
                         },
                       }}
                       scroll={{ x: "max-content", y: "calc(100vh - 24rem)" }}
@@ -293,7 +358,7 @@ export default function DataAnnotation() {
                 ) : (
                   <CardView
                     data={tableData}
-                    operations={operations as any}
+                    operations={operations}
                     pagination={pagination}
                     loading={loading}
                   />
@@ -327,4 +392,4 @@ export default function DataAnnotation() {
       />
     </div>
   );
-}
+}

frontend/src/pages/DataAnnotation/Home/ExportAnnotationDialog.tsx

@@ -106,13 +106,6 @@ export default function ExportAnnotationDialog({
       const values = await form.validateFields();
       setExporting(true);
 
-      const blob = await downloadAnnotationsUsingGet(
-        projectId,
-        values.format,
-        values.onlyAnnotated,
-        values.includeData
-      );
-
       // 获取文件名
       const formatExt: Record<ExportFormat, string> = {
         json: "json",
@@ -124,15 +117,14 @@ export default function ExportAnnotationDialog({
       const ext = formatExt[values.format as ExportFormat] || "json";
       const filename = `${projectName}_annotations.${ext}`;
 
-      // 下载文件
-      const url = window.URL.createObjectURL(blob as Blob);
-      const a = document.createElement("a");
-      a.href = url;
-      a.download = filename;
-      document.body.appendChild(a);
-      a.click();
-      window.URL.revokeObjectURL(url);
-      document.body.removeChild(a);
+      // 下载文件（download函数内部已处理下载逻辑）
+      await downloadAnnotationsUsingGet(
+        projectId,
+        values.format,
+        values.onlyAnnotated,
+        values.includeData,
+        filename
+      );
 
       message.success("导出成功");
       onClose();
@@ -186,14 +178,15 @@ export default function ExportAnnotationDialog({
             <Select
               options={FORMAT_OPTIONS.map((opt) => ({
                 label: (
-                  <div>
+                  <div className="py-1">
                     <div className="font-medium">{opt.label}</div>
                     <div className="text-xs text-gray-400">{opt.description}</div>
                   </div>
                 ),
                 value: opt.value,
+                simpleLabel: opt.label,
               }))}
-              optionLabelProp="label"
+              optionLabelProp="simpleLabel"
             />
           </Form.Item>
 

frontend/src/pages/DataAnnotation/Template/TemplateDetail.tsx

@@ -43,14 +43,6 @@ const TemplateDetail: React.FC<TemplateDetailProps> = ({
                 <Descriptions.Item label="样式">
                     {template.style}
                 </Descriptions.Item>
-                <Descriptions.Item label="类型">
-                    <Tag color={template.builtIn ? "gold" : "default"}>
-                        {template.builtIn ? "系统内置" : "自定义"}
-                    </Tag>
-                </Descriptions.Item>
-                <Descriptions.Item label="版本">
-                    {template.version}
-                </Descriptions.Item>
                 <Descriptions.Item label="创建时间" span={2}>
                     {new Date(template.createdAt).toLocaleString()}
                 </Descriptions.Item>

frontend/src/pages/DataAnnotation/Template/TemplateForm.tsx

@@ -36,6 +36,7 @@ const TemplateForm: React.FC<TemplateFormProps> = ({
     const [form] = Form.useForm();
     const [loading, setLoading] = useState(false);
     const [labelConfig, setLabelConfig] = useState("");
+    const selectedDataType = Form.useWatch("dataType", form);
 
     useEffect(() => {
         if (visible && template && mode === "edit") {
@@ -96,8 +97,12 @@ const TemplateForm: React.FC<TemplateFormProps> = ({
             } else {
                 message.error(response.message || `模板${mode === "create" ? "创建" : "更新"}失败`);
             }
-        } catch (error: any) {
-            if (error.errorFields) {
+        } catch (error: unknown) {
+            const hasErrorFields =
+                typeof error === "object" &&
+                error !== null &&
+                "errorFields" in error;
+            if (hasErrorFields) {
                 message.error("请填写所有必填字段");
             } else {
                 message.error(`模板${mode === "create" ? "创建" : "更新"}失败`);
@@ -195,6 +200,7 @@ const TemplateForm: React.FC<TemplateFormProps> = ({
                         value={labelConfig}
                         onChange={setLabelConfig}
                         height={420}
+                        dataType={selectedDataType}
                     />
                 </div>
             </Form>

frontend/src/pages/DataAnnotation/Template/TemplateList.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React, { useState, useEffect } from "react";
 import {
     Button,
     Table,
@@ -32,7 +32,16 @@ import {
   TemplateTypeMap
 } from "@/pages/DataAnnotation/annotation.const.tsx";
 
+const TEMPLATE_ADMIN_KEY = "datamate_template_admin";
+
 const TemplateList: React.FC = () => {
+    const [isAdmin, setIsAdmin] = useState(false);
+
+    useEffect(() => {
+        // 检查 localStorage 中是否存在特殊键
+        const hasAdminKey = localStorage.getItem(TEMPLATE_ADMIN_KEY) !== null;
+        setIsAdmin(hasAdminKey);
+    }, []);
     const filterOptions = [
       {
         key: "category",
@@ -225,23 +234,7 @@ const TemplateList: React.FC = () => {
                 <Tag color={getCategoryColor(category)}>{ClassificationMap[category as keyof typeof ClassificationMap]?.label || category}</Tag>
             ),
         },
-        {
-            title: "类型",
-            dataIndex: "builtIn",
-            key: "builtIn",
-            width: 100,
-            render: (builtIn: boolean) => (
-                <Tag color={builtIn ? "gold" : "default"}>
-                    {builtIn ? "系统内置" : "自定义"}
-                </Tag>
-            ),
-        },
-        {
-            title: "版本",
-            dataIndex: "version",
-            key: "version",
-            width: 80,
-        },
+
         {
             title: "创建时间",
             dataIndex: "createdAt",
@@ -263,29 +256,31 @@ const TemplateList: React.FC = () => {
                             onClick={() => handleView(record)}
                         />
                     </Tooltip>
-                    <>
-                        <Tooltip title="编辑">
-                            <Button
-                                type="link"
-                                icon={<EditOutlined />}
-                                onClick={() => handleEdit(record)}
-                            />
-                        </Tooltip>
-                        <Popconfirm
-                            title="确定要删除这个模板吗？"
-                            onConfirm={() => handleDelete(record.id)}
-                            okText="确定"
-                            cancelText="取消"
-                        >
-                            <Tooltip title="删除">
+                    {isAdmin && (
+                        <>
+                            <Tooltip title="编辑">
                                 <Button
                                     type="link"
-                                    danger
-                                    icon={<DeleteOutlined />}
+                                    icon={<EditOutlined />}
+                                    onClick={() => handleEdit(record)}
                                 />
                             </Tooltip>
-                        </Popconfirm>
-                    </>
+                            <Popconfirm
+                                title="确定要删除这个模板吗？"
+                                onConfirm={() => handleDelete(record.id)}
+                                okText="确定"
+                                cancelText="取消"
+                            >
+                                <Tooltip title="删除">
+                                    <Button
+                                        type="link"
+                                        danger
+                                        icon={<DeleteOutlined />}
+                                    />
+                                </Tooltip>
+                            </Popconfirm>
+                        </>
+                    )}
                 </Space>
             ),
         },
@@ -310,11 +305,13 @@ const TemplateList: React.FC = () => {
                 </div>
 
                 {/* Right side: Create button */}
-                <div className="flex items-center gap-2">
-                    <Button type="primary" icon={<PlusOutlined />} onClick={handleCreate}>
-                        创建模板
-                    </Button>
-                </div>
+                {isAdmin && (
+                    <div className="flex items-center gap-2">
+                        <Button type="primary" icon={<PlusOutlined />} onClick={handleCreate}>
+                            创建模板
+                        </Button>
+                    </div>
+                )}
             </div>
 
             <Card>

frontend/src/pages/DataAnnotation/Template/VisualTemplateBuilder.tsx

@@ -18,6 +18,7 @@ import {
 import { TagBrowser } from "./components";
 
 const { Paragraph } = Typography;
+const PREVIEW_DRAWER_WIDTH = "80vw";
 
 interface VisualTemplateBuilderProps {
     onSave?: (templateCode: string) => void;
@@ -129,7 +130,7 @@ const VisualTemplateBuilder: React.FC<VisualTemplateBuilderProps> = ({
             <Drawer
                 title="模板代码预览"
                 placement="right"
-                width={600}
+                width={PREVIEW_DRAWER_WIDTH}
                 open={previewVisible}
                 onClose={() => setPreviewVisible(false)}
             >

frontend/src/pages/DataAnnotation/annotation.api.ts

@@ -109,12 +109,13 @@ export function downloadAnnotationsUsingGet(
   projectId: string,
   format: ExportFormat = "json",
   onlyAnnotated: boolean = true,
-  includeData: boolean = false
+  includeData: boolean = false,
+  filename?: string
 ) {
   const params = new URLSearchParams({
     format,
     only_annotated: String(onlyAnnotated),
     include_data: String(includeData),
   });
-  return download(`/api/annotation/export/projects/${projectId}/download?${params.toString()}`);
+  return download(`/api/annotation/export/projects/${projectId}/download?${params.toString()}`, null, filename);
 }

frontend/src/pages/DataAnnotation/annotation.const.tsx

@@ -6,6 +6,71 @@ import {
   CloseCircleOutlined,
 } from "@ant-design/icons";
 
+type AnnotationTaskStatistics = {
+  accuracy?: number | string;
+  averageTime?: number | string;
+  reviewCount?: number | string;
+};
+
+type AnnotationTaskPayload = {
+  id?: string;
+  labelingProjId?: string;
+  labelingProjectId?: string;
+  projId?: string;
+  labeling_project_id?: string;
+  name?: string;
+  description?: string;
+  datasetId?: string;
+  datasetName?: string;
+  dataset_name?: string;
+  labelingType?: string;
+  labeling_type?: string;
+  template?: {
+    labelingType?: string;
+    labeling_type?: string;
+  };
+  totalCount?: number;
+  total_count?: number;
+  annotatedCount?: number;
+  annotated_count?: number;
+  inProgressCount?: number;
+  in_progress_count?: number;
+  segmentationEnabled?: boolean;
+  segmentation_enabled?: boolean;
+  createdAt?: string;
+  created_at?: string;
+  updatedAt?: string;
+  updated_at?: string;
+  status?: string;
+  statistics?: AnnotationTaskStatistics;
+  [key: string]: unknown;
+};
+
+export type AnnotationTaskListItem = {
+  id?: string;
+  labelingProjId?: string;
+  projId?: string;
+  name?: string;
+  description?: string;
+  datasetId?: string;
+  datasetName?: string;
+  labelingType?: string;
+  totalCount?: number;
+  annotatedCount?: number;
+  inProgressCount?: number;
+  segmentationEnabled?: boolean;
+  createdAt?: string;
+  updatedAt?: string;
+  icon?: JSX.Element;
+  iconColor?: string;
+  status?: {
+    label: string;
+    color: string;
+  };
+  statistics?: { label: string; value: string | number }[];
+  [key: string]: unknown;
+};
+
 export const AnnotationTaskStatusMap = {
   [AnnotationTaskStatus.ACTIVE]: {
     label: "活跃",
@@ -27,9 +92,16 @@ export const AnnotationTaskStatusMap = {
   },
 };
 
-export function mapAnnotationTask(task: any) {
+export function mapAnnotationTask(task: AnnotationTaskPayload): AnnotationTaskListItem {
   // Normalize labeling project id from possible backend field names
   const labelingProjId = task?.labelingProjId || task?.labelingProjectId || task?.projId || task?.labeling_project_id || "";
+  const segmentationEnabled = task?.segmentationEnabled ?? task?.segmentation_enabled ?? false;
+  const inProgressCount = task?.inProgressCount ?? task?.in_progress_count ?? 0;
+  const labelingType =
+    task?.labelingType ||
+    task?.labeling_type ||
+    task?.template?.labelingType ||
+    task?.template?.labeling_type;
 
   const statsArray = task?.statistics
     ? [
@@ -45,6 +117,9 @@ export function mapAnnotationTask(task: any) {
     // provide consistent field for components
     labelingProjId,
     projId: labelingProjId,
+    segmentationEnabled,
+    inProgressCount,
+    labelingType,
     name: task.name,
     description: task.description || "",
     datasetName: task.datasetName || task.dataset_name || "-",
@@ -478,4 +553,4 @@ export const TemplateTypeMap = {
     label: "自定义",
     value: TemplateType.CUSTOM
   },
-}
+}

frontend/src/pages/DataAnnotation/annotation.model.ts

@@ -8,6 +8,13 @@ export enum AnnotationTaskStatus {
   SKIPPED = "skipped",
 }
 
+export enum AnnotationResultStatus {
+  ANNOTATED = "ANNOTATED",
+  IN_PROGRESS = "IN_PROGRESS",
+  NO_ANNOTATION = "NO_ANNOTATION",
+  NOT_APPLICABLE = "NOT_APPLICABLE",
+}
+
 export interface AnnotationTask {
   id: string;
   name: string;
@@ -52,7 +59,7 @@ export interface ObjectDefinition {
 export interface TemplateConfiguration {
   labels: LabelDefinition[];
   objects: ObjectDefinition[];
-  metadata?: Record<string, any>;
+  metadata?: Record<string, unknown>;
 }
 
 export interface AnnotationTemplate {

frontend/src/pages/DataAnnotation/components/TemplateConfigurationTreeEditor.tsx

@@ -22,6 +22,7 @@ import {
   getObjectDisplayName,
   type LabelStudioTagConfig,
 } from "../annotation.tagconfig";
+import { DataType } from "../annotation.model";
 
 const { Text, Title } = Typography;
 
@@ -44,10 +45,22 @@ interface TemplateConfigurationTreeEditorProps {
   readOnly?: boolean;
   readOnlyStructure?: boolean;
   height?: number | string;
+  dataType?: DataType;
 }
 
 const DEFAULT_ROOT_TAG = "View";
 const CHILD_TAGS = ["Label", "Choice", "Relation", "Item", "Path", "Channel"];
+const OBJECT_TAGS_BY_DATA_TYPE: Record<DataType, string[]> = {
+  [DataType.TEXT]: ["Text", "Paragraphs", "Markdown"],
+  [DataType.IMAGE]: ["Image", "Bitmask"],
+  [DataType.AUDIO]: ["Audio", "AudioPlus"],
+  [DataType.VIDEO]: ["Video"],
+  [DataType.PDF]: ["PDF"],
+  [DataType.TIMESERIES]: ["Timeseries", "TimeSeries", "Vector"],
+  [DataType.CHAT]: ["Chat"],
+  [DataType.HTML]: ["HyperText", "Markdown"],
+  [DataType.TABLE]: ["Table", "Vector"],
+};
 
 const createId = () =>
   `node_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -247,18 +260,34 @@ const createNode = (
     attrs[attr] = "";
   });
 
-  if (objectConfig && attrs.name !== undefined) {
+  if (objectConfig) {
     const name = getDefaultName(tag);
-    attrs.name = name;
-    if (attrs.value !== undefined) {
-      attrs.value = `$${name}`;
+    if (!attrs.name) {
+      attrs.name = name;
+    }
+    if (!attrs.value) {
+      attrs.value = `$${attrs.name}`;
     }
   }
 
-  if (controlConfig && attrs.name !== undefined) {
-    attrs.name = getDefaultName(tag);
-    if (attrs.toName !== undefined) {
-      attrs.toName = objectNames[0] || "";
+  if (controlConfig) {
+    const isLabeling = controlConfig.category === "labeling";
+
+    if (isLabeling) {
+      if (!attrs.name) {
+        attrs.name = getDefaultName(tag);
+      }
+      if (!attrs.toName) {
+        attrs.toName = objectNames[0] || "";
+      }
+    } else {
+      // For layout controls, only fill if required
+      if (attrs.name !== undefined && !attrs.name) {
+        attrs.name = getDefaultName(tag);
+      }
+      if (attrs.toName !== undefined && !attrs.toName) {
+        attrs.toName = objectNames[0] || "";
+      }
     }
   }
 
@@ -420,14 +449,13 @@ const TemplateConfigurationTreeEditor = ({
   readOnly = false,
   readOnlyStructure = false,
   height = 420,
+  dataType,
 }: TemplateConfigurationTreeEditorProps) => {
   const { config } = useTagConfig(false);
   const [tree, setTree] = useState<XmlNode>(() => createEmptyTree());
   const [selectedId, setSelectedId] = useState<string>(tree.id);
   const [parseError, setParseError] = useState<string | null>(null);
   const lastSerialized = useRef<string>("");
-  const [addChildTag, setAddChildTag] = useState<string | undefined>();
-  const [addSiblingTag, setAddSiblingTag] = useState<string | undefined>();
 
   useEffect(() => {
     if (!value) {
@@ -498,11 +526,17 @@ const TemplateConfigurationTreeEditor = ({
 
   const objectOptions = useMemo(() => {
     if (!config?.objects) return [];
-    return Object.keys(config.objects).map((tag) => ({
+    const options = Object.keys(config.objects).map((tag) => ({
       value: tag,
       label: getObjectDisplayName(tag),
     }));
-  }, [config]);
+    if (!dataType) return options;
+    const allowedTags = OBJECT_TAGS_BY_DATA_TYPE[dataType];
+    if (!allowedTags) return options;
+    const allowedSet = new Set(allowedTags);
+    const filtered = options.filter((option) => allowedSet.has(option.value));
+    return filtered.length > 0 ? filtered : options;
+  }, [config, dataType]);
 
   const tagOptions = useMemo(() => {
     const options = [] as {
@@ -763,9 +797,8 @@ const TemplateConfigurationTreeEditor = ({
             <Select
               placeholder="添加子节点"
               options={tagOptions}
-              value={addChildTag}
+              value={null}
               onChange={(value) => {
-                setAddChildTag(undefined);
                 handleAddNode(value, "child");
               }}
               disabled={isStructureLocked}
@@ -773,9 +806,8 @@ const TemplateConfigurationTreeEditor = ({
             <Select
               placeholder="添加同级节点"
               options={tagOptions}
-              value={addSiblingTag}
+              value={null}
               onChange={(value) => {
-                setAddSiblingTag(undefined);
                 handleAddNode(value, "sibling");
               }}
               disabled={isStructureLocked || selectedNode.id === tree.id}

frontend/src/pages/DataEvaluation/Create/PreviewPrompt.tsx

@@ -7,6 +7,8 @@ interface PreviewPromptModalProps {
   evaluationPrompt: string;
 }
 
+const PREVIEW_MODAL_WIDTH = "80vw";
+
 const PreviewPromptModal: React.FC<PreviewPromptModalProps> = ({ previewVisible, onCancel, evaluationPrompt }) => {
   return (
     <Modal
@@ -24,7 +26,7 @@ const PreviewPromptModal: React.FC<PreviewPromptModalProps> = ({ previewVisible,
           关闭
         </Button>
       ]}
-      width={800}
+      width={PREVIEW_MODAL_WIDTH}
     >
       <div style={{
         background: '#f5f5f5',

frontend/src/pages/DataManagement/Create/CreateDataset.tsx

@@ -78,7 +78,11 @@ export default function DatasetCreate() {
             onValuesChange={handleValuesChange}
             layout="vertical"
           >
-            <BasicInformation data={newDataset} setData={setNewDataset} />
+            <BasicInformation
+              data={newDataset}
+              setData={setNewDataset}
+              hidden={["dataSource"]}
+            />
           </Form>
         </div>
         <div className="flex gap-2 justify-end p-6 border-top">

frontend/src/pages/DataManagement/Create/EditDataset.tsx

@@ -96,7 +96,7 @@ export default function EditDataset({
         <BasicInformation
           data={newDataset}
           setData={setNewDataset}
-          hidden={["datasetType"]}
+          hidden={["datasetType", "dataSource"]}
         />
       </Form>
     </Modal>

frontend/src/pages/DataManagement/Create/components/BasicInformation.tsx

@@ -11,10 +11,12 @@ export default function BasicInformation({
   data,
   setData,
   hidden = [],
+  datasetTypeOptions = datasetTypes,
 }: {
   data: DatasetFormData;
   setData: Dispatch<SetStateAction<DatasetFormData>>;
   hidden?: string[];
+  datasetTypeOptions?: DatasetTypeOption[];
 }) {
   const [tagOptions, setTagOptions] = useState<DatasetTagOption[]>([]);
   const [collectionOptions, setCollectionOptions] = useState<SelectOption[]>([]);
@@ -39,6 +41,7 @@ export default function BasicInformation({
 
   // 获取归集任务
   const fetchCollectionTasks = useCallback(async () => {
+    if (hidden.includes("dataSource")) return;
     try {
       const res = await queryTasksUsingGet({ page: 0, size: 100 });
       const tasks = Array.isArray(res?.data?.content)
@@ -52,7 +55,7 @@ export default function BasicInformation({
     } catch (error) {
       console.error("Error fetching collection tasks:", error);
     }
-  }, []);
+  }, [hidden]);
 
   const fetchParentDatasets = useCallback(async () => {
     if (hidden.includes("parentDatasetId")) return;
@@ -73,7 +76,7 @@ export default function BasicInformation({
           value: dataset.id,
         }));
       setParentDatasetOptions([
-        { label: "根数据集", value: "" },
+        { label: "无关联数据集", value: "" },
         ...options,
       ]);
     } catch (error) {
@@ -101,11 +104,11 @@ export default function BasicInformation({
         </Form.Item>
       )}
       {!hidden.includes("parentDatasetId") && (
-        <Form.Item name="parentDatasetId" label="父数据集">
+        <Form.Item name="parentDatasetId" label="关联数据集">
           <Select
             className="w-full"
             options={parentDatasetOptions}
-            placeholder="选择父数据集（仅支持一层）"
+            placeholder="选择关联数据集（仅支持一层）"
           />
         </Form.Item>
       )}
@@ -118,7 +121,7 @@ export default function BasicInformation({
           rules={[{ required: true, message: "请选择数据集类型" }]}
         >
           <RadioCard
-            options={datasetTypes}
+            options={datasetTypeOptions}
             value={data.type}
             onChange={(datasetType) => setData({ ...data, datasetType })}
           />
@@ -148,6 +151,8 @@ type DatasetFormData = Partial<Dataset> & {
   parentDatasetId?: string;
 };
 
+type DatasetTypeOption = (typeof datasetTypes)[number];
+
 type DatasetTagOption = {
   label: string;
   value: string;

frontend/src/pages/DataManagement/Detail/DatasetDetail.tsx

@@ -1,195 +1,216 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-import { Breadcrumb, App, Tabs, Table, Tag } from "antd";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Breadcrumb, App, Tabs, Table, Tag } from "antd";
 import {
-  ReloadOutlined,
-  DownloadOutlined,
-  EditOutlined,
-  DeleteOutlined,
-  PlusOutlined,
-} from "@ant-design/icons";
+  ReloadOutlined,
+  DownloadOutlined,
+  EditOutlined,
+  DeleteOutlined,
+  PlusOutlined,
+} from "@ant-design/icons";
 import DetailHeader from "@/components/DetailHeader";
 import { mapDataset, datasetTypeMap } from "../dataset.const";
 import type { Dataset } from "@/pages/DataManagement/dataset.model";
 import { Link, useNavigate, useParams } from "react-router";
 import { useFilesOperation } from "./useFilesOperation";
-import {
-  createDatasetTagUsingPost,
-  deleteDatasetByIdUsingDelete,
-  downloadDatasetUsingGet,
-  queryDatasetByIdUsingGet,
-  queryDatasetsUsingGet,
-  queryDatasetTagsUsingGet,
-  querySimilarDatasetsUsingGet,
-  updateDatasetByIdUsingPut,
-} from "../dataset.api";
+import {
+  createDatasetTagUsingPost,
+  deleteDatasetByIdUsingDelete,
+  downloadDatasetUsingGet,
+  queryDatasetByIdUsingGet,
+  queryDatasetsUsingGet,
+  queryDatasetTagsUsingGet,
+  querySimilarDatasetsUsingGet,
+  updateDatasetByIdUsingPut,
+} from "../dataset.api";
 import DataQuality from "./components/DataQuality";
 import DataLineageFlow from "./components/DataLineageFlow";
 import Overview from "./components/Overview";
 import { Activity, Clock, File, FileType } from "lucide-react";
 import EditDataset from "../Create/EditDataset";
-import ImportConfiguration from "./components/ImportConfiguration";
-
-const SIMILAR_DATASET_LIMIT = 4;
-
-export default function DatasetDetail() {
-  const { id } = useParams(); // 获取动态路由参数
-  const navigate = useNavigate();
-  const [activeTab, setActiveTab] = useState("overview");
-  const { message } = App.useApp();
-  const [showEditDialog, setShowEditDialog] = useState(false);
-
-  const [dataset, setDataset] = useState<Dataset>({} as Dataset);
-  const [parentDataset, setParentDataset] = useState<Dataset | null>(null);
-  const [childDatasets, setChildDatasets] = useState<Dataset[]>([]);
-  const [childDatasetsLoading, setChildDatasetsLoading] = useState(false);
-  const [similarDatasets, setSimilarDatasets] = useState<Dataset[]>([]);
-  const [similarDatasetsLoading, setSimilarDatasetsLoading] = useState(false);
-  const [similarTagNames, setSimilarTagNames] = useState<string[]>([]);
-  const similarRequestRef = useRef(0);
-  const filesOperation = useFilesOperation(dataset);
+import ImportConfiguration from "./components/ImportConfiguration";
+import CardView from "@/components/CardView";
 
-  const [showUploadDialog, setShowUploadDialog] = useState(false);
-  const normalizeTagNames = (
-    tags?: Array<string | { name?: string | null } | null>
-  ) => {
-    if (!tags || tags.length === 0) {
-      return [];
-    }
-    const names = tags
-      .map((tag) => (typeof tag === "string" ? tag : tag?.name))
-      .filter((name): name is string => !!name && name.trim().length > 0)
-      .map((name) => name.trim());
-    return Array.from(new Set(names));
-  };
-  const fetchSimilarDatasets = async (currentDataset: Dataset) => {
-    const requestId = similarRequestRef.current + 1;
-    similarRequestRef.current = requestId;
-    if (!currentDataset?.id) {
-      setSimilarDatasets([]);
-      setSimilarTagNames([]);
-      setSimilarDatasetsLoading(false);
-      return;
-    }
-    const tagNames = normalizeTagNames(
-      currentDataset.tags as Array<string | { name?: string }>
-    );
-    setSimilarTagNames(tagNames);
-    setSimilarDatasets([]);
-    if (tagNames.length === 0) {
-      setSimilarDatasetsLoading(false);
-      return;
-    }
-    setSimilarDatasetsLoading(true);
-    try {
-      const { data } = await querySimilarDatasetsUsingGet(currentDataset.id, {
-        limit: SIMILAR_DATASET_LIMIT,
-      });
-      if (similarRequestRef.current !== requestId) {
-        return;
-      }
-      const list = Array.isArray(data) ? data : [];
-      setSimilarDatasets(list.map((item) => mapDataset(item)));
-    } catch (error) {
-      console.error("Failed to fetch similar datasets:", error);
-    } finally {
-      if (similarRequestRef.current === requestId) {
-        setSimilarDatasetsLoading(false);
-      }
-    }
-  };
-  const navigateItems = useMemo(() => {
-    const items = [
-      {
-        title: <Link to="/data/management">数据管理</Link>,
-      },
-    ];
-    if (parentDataset) {
-      items.push({
-        title: (
-          <Link to={`/data/management/detail/${parentDataset.id}`}>
-            {parentDataset.name}
-          </Link>
-        ),
-      });
-    }
-    items.push({
-      title: dataset.name || "数据集详情",
-    });
-    return items;
-  }, [dataset, parentDataset]);
-  const tabList = useMemo(() => {
-    const items = [
-      {
-        key: "overview",
-        label: "概览",
-      },
-    ];
-    if (!dataset?.parentDatasetId) {
-      items.push({
-        key: "children",
-        label: "子数据集",
-      });
-    }
-    return items;
-  }, [dataset?.parentDatasetId]);
-  const handleCreateChildDataset = () => {
-    if (!dataset?.id) {
-      return;
-    }
-    navigate("/data/management/create", {
-      state: { parentDatasetId: dataset.id },
-    });
-  };
-  const fetchChildDatasets = async (parentId?: string) => {
-    if (!parentId) {
-      setChildDatasets([]);
-      return;
-    }
-    setChildDatasetsLoading(true);
-    try {
-      const { data: res } = await queryDatasetsUsingGet({
-        parentDatasetId: parentId,
-        page: 1,
-        size: 1000,
-      });
-      const list = res?.content || res?.data || [];
-      setChildDatasets(list.map((item) => mapDataset(item)));
-    } finally {
-      setChildDatasetsLoading(false);
-    }
-  };
-  const fetchDataset = async () => {
-    if (!id) {
-      return;
-    }
-    const { data } = await queryDatasetByIdUsingGet(id);
-    const mapped = mapDataset(data);
-    setDataset(mapped);
-    fetchSimilarDatasets(mapped);
-    if (data?.parentDatasetId) {
-      const { data: parentData } = await queryDatasetByIdUsingGet(
-        data.parentDatasetId
-      );
-      setParentDataset(mapDataset(parentData));
-      setChildDatasets([]);
-    } else {
-      setParentDataset(null);
-      await fetchChildDatasets(data?.id);
-    }
-  };
+const SIMILAR_DATASET_LIMIT = 4;
+const SIMILAR_TAGS_PREVIEW_LIMIT = 3;
 
-  useEffect(() => {
-    if (!id) {
-      return;
-    }
-    fetchDataset();
-    filesOperation.fetchFiles("", 1, 10); // 从根目录开始，第一页
-  }, [id]);
-  useEffect(() => {
-    if (dataset?.parentDatasetId && activeTab === "children") {
-      setActiveTab("overview");
-    }
-  }, [activeTab, dataset?.parentDatasetId]);
+export default function DatasetDetail() {
+  const { id } = useParams(); // 获取动态路由参数
+  const navigate = useNavigate();
+  const [activeTab, setActiveTab] = useState("overview");
+  const { message } = App.useApp();
+  const [showEditDialog, setShowEditDialog] = useState(false);
+
+  const [dataset, setDataset] = useState<Dataset>({} as Dataset);
+  const [parentDataset, setParentDataset] = useState<Dataset | null>(null);
+  const [childDatasets, setChildDatasets] = useState<Dataset[]>([]);
+  const [childDatasetsLoading, setChildDatasetsLoading] = useState(false);
+  const [similarDatasets, setSimilarDatasets] = useState<Dataset[]>([]);
+  const [similarDatasetsLoading, setSimilarDatasetsLoading] = useState(false);
+  const [similarTagNames, setSimilarTagNames] = useState<string[]>([]);
+  const similarRequestRef = useRef(0);
+  const filesOperation = useFilesOperation(dataset);
+
+  const [showUploadDialog, setShowUploadDialog] = useState(false);
+  const normalizeTagNames = (
+    tags?: Array<string | { name?: string | null } | null>
+  ) => {
+    if (!tags || tags.length === 0) {
+      return [];
+    }
+    const names = tags
+      .map((tag) => (typeof tag === "string" ? tag : tag?.name))
+      .filter((name): name is string => !!name && name.trim().length > 0)
+      .map((name) => name.trim());
+    return Array.from(new Set(names));
+  };
+  const fetchSimilarDatasets = async (currentDataset: Dataset) => {
+    const requestId = similarRequestRef.current + 1;
+    similarRequestRef.current = requestId;
+    if (!currentDataset?.id) {
+      setSimilarDatasets([]);
+      setSimilarTagNames([]);
+      setSimilarDatasetsLoading(false);
+      return;
+    }
+    const tagNames = normalizeTagNames(
+      currentDataset.tags as Array<string | { name?: string }>
+    );
+    setSimilarTagNames(tagNames);
+    setSimilarDatasets([]);
+    if (tagNames.length === 0) {
+      setSimilarDatasetsLoading(false);
+      return;
+    }
+    setSimilarDatasetsLoading(true);
+    try {
+      const { data } = await querySimilarDatasetsUsingGet(currentDataset.id, {
+        limit: SIMILAR_DATASET_LIMIT,
+      });
+      if (similarRequestRef.current !== requestId) {
+        return;
+      }
+      const list = Array.isArray(data) ? data : [];
+      setSimilarDatasets(list.map((item) => mapDataset(item)));
+    } catch (error) {
+      console.error("Failed to fetch similar datasets:", error);
+    } finally {
+      if (similarRequestRef.current === requestId) {
+        setSimilarDatasetsLoading(false);
+      }
+    }
+  };
+
+  const similarTagsSummary = useMemo(() => {
+    if (!similarTagNames || similarTagNames.length === 0) {
+      return "";
+    }
+    const visibleTags = similarTagNames.slice(0, SIMILAR_TAGS_PREVIEW_LIMIT);
+    const hiddenCount = similarTagNames.length - visibleTags.length;
+    if (hiddenCount > 0) {
+      return `${visibleTags.join("、")} 等 ${similarTagNames.length} 个`;
+    }
+    return visibleTags.join("、");
+  }, [similarTagNames]);
+
+  const navigateItems = useMemo(() => {
+    const items = [
+      {
+        title: <Link to="/data/management">数据管理</Link>,
+      },
+    ];
+    if (parentDataset) {
+      items.push({
+        title: (
+          <Link to={`/data/management/detail/${parentDataset.id}`}>
+            {parentDataset.name}
+          </Link>
+        ),
+      });
+    }
+    items.push({
+      title: dataset.name || "数据集详情",
+    });
+    return items;
+  }, [dataset, parentDataset]);
+  const tabList = useMemo(() => {
+    const items = [
+      {
+        key: "overview",
+        label: "概览",
+      },
+    ];
+    if (!dataset?.parentDatasetId) {
+      items.push({
+        key: "children",
+        label: "关联数据集",
+      });
+    }
+    return items;
+  }, [dataset?.parentDatasetId]);
+  const handleCreateChildDataset = () => {
+    if (!dataset?.id) {
+      return;
+    }
+    navigate("/data/management/create", {
+      state: { parentDatasetId: dataset.id },
+    });
+  };
+  const fetchChildDatasets = async (parentId?: string) => {
+    if (!parentId) {
+      setChildDatasets([]);
+      return;
+    }
+    setChildDatasetsLoading(true);
+    try {
+      const { data: res } = await queryDatasetsUsingGet({
+        parentDatasetId: parentId,
+        page: 1,
+        size: 1000,
+      });
+      const list = res?.content || res?.data || [];
+      setChildDatasets(list.map((item) => mapDataset(item)));
+    } finally {
+      setChildDatasetsLoading(false);
+    }
+  };
+  const fetchDataset = async () => {
+    if (!id) {
+      return;
+    }
+    const { data } = await queryDatasetByIdUsingGet(id);
+    const mapped = mapDataset(data);
+    setDataset(mapped);
+    fetchSimilarDatasets(mapped);
+    if (data?.parentDatasetId) {
+      const { data: parentData } = await queryDatasetByIdUsingGet(
+        data.parentDatasetId
+      );
+      setParentDataset(mapDataset(parentData));
+      setChildDatasets([]);
+    } else {
+      setParentDataset(null);
+      await fetchChildDatasets(data?.id);
+    }
+  };
+
+  useEffect(() => {
+    if (!id) {
+      return;
+    }
+    fetchDataset();
+  }, [id]);
+
+  useEffect(() => {
+    if (dataset?.id) {
+      filesOperation.fetchFiles("", 1, 10); // 从根目录开始，第一页
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [dataset?.id]);
+  useEffect(() => {
+    if (dataset?.parentDatasetId && activeTab === "children") {
+      setActiveTab("overview");
+    }
+  }, [activeTab, dataset?.parentDatasetId]);
 
   const handleRefresh = async (showMessage = true, prefixOverride?: string) => {
     fetchDataset();
@@ -261,22 +282,22 @@ export default function DatasetDetail() {
   ];
 
   // 数据集操作列表
-  const operations = [
-    ...(dataset?.id && !dataset.parentDatasetId
-      ? [
-          {
-            key: "create-child",
-            label: "创建子数据集",
-            icon: <PlusOutlined />,
-            onClick: handleCreateChildDataset,
-          },
-        ]
-      : []),
-    {
-      key: "edit",
-      label: "编辑",
-      icon: <EditOutlined />,
-      onClick: () => {
+  const operations = [
+    ...(dataset?.id && !dataset.parentDatasetId
+      ? [
+          {
+            key: "create-child",
+            label: "创建关联数据集",
+            icon: <PlusOutlined />,
+            onClick: handleCreateChildDataset,
+          },
+        ]
+      : []),
+    {
+      key: "edit",
+      label: "编辑",
+      icon: <EditOutlined />,
+      onClick: () => {
         setShowEditDialog(true);
       },
     },
@@ -314,55 +335,55 @@ export default function DatasetDetail() {
       icon: <DeleteOutlined />,
       onClick: handleDeleteDataset,
     },
-  ];
-  const childColumns = [
-    {
-      title: "名称",
-      dataIndex: "name",
-      key: "name",
-      render: (_: string, record: Dataset) => (
-        <Link to={`/data/management/detail/${record.id}`}>{record.name}</Link>
-      ),
-    },
-    {
-      title: "类型",
-      dataIndex: "datasetType",
-      key: "datasetType",
-      width: 120,
-      render: (value: string) => datasetTypeMap[value]?.label || "未知",
-    },
-    {
-      title: "状态",
-      dataIndex: "status",
-      key: "status",
-      width: 120,
-      render: (status) =>
-        status ? <Tag color={status.color}>{status.label}</Tag> : "-",
-    },
-    {
-      title: "文件数",
-      dataIndex: "fileCount",
-      key: "fileCount",
-      width: 120,
-      render: (value?: number) => value ?? 0,
-    },
-    {
-      title: "大小",
-      dataIndex: "size",
-      key: "size",
-      width: 140,
-      render: (value?: string) => value || "0 B",
-    },
-    {
-      title: "更新时间",
-      dataIndex: "updatedAt",
-      key: "updatedAt",
-      width: 180,
-    },
-  ];
+  ];
+  const childColumns = [
+    {
+      title: "名称",
+      dataIndex: "name",
+      key: "name",
+      render: (_: string, record: Dataset) => (
+        <Link to={`/data/management/detail/${record.id}`}>{record.name}</Link>
+      ),
+    },
+    {
+      title: "类型",
+      dataIndex: "datasetType",
+      key: "datasetType",
+      width: 120,
+      render: (value: string) => datasetTypeMap[value]?.label || "未知",
+    },
+    {
+      title: "状态",
+      dataIndex: "status",
+      key: "status",
+      width: 120,
+      render: (status) =>
+        status ? <Tag color={status.color}>{status.label}</Tag> : "-",
+    },
+    {
+      title: "文件数",
+      dataIndex: "fileCount",
+      key: "fileCount",
+      width: 120,
+      render: (value?: number) => value ?? 0,
+    },
+    {
+      title: "大小",
+      dataIndex: "size",
+      key: "size",
+      width: 140,
+      render: (value?: string) => value || "0 B",
+    },
+    {
+      title: "更新时间",
+      dataIndex: "updatedAt",
+      key: "updatedAt",
+      width: 180,
+    },
+  ];
 
   return (
-    <div className="h-full flex flex-col gap-4">
+    <div className="h-full flex flex-col gap-4 overflow-hidden">
       <Breadcrumb items={navigateItems} />
       {/* Header */}
       <DetailHeader
@@ -398,42 +419,67 @@ export default function DatasetDetail() {
           },
         }}
       />
-      <div className="flex-overflow-auto p-6 pt-2 bg-white rounded-md shadow">
-        <Tabs activeKey={activeTab} items={tabList} onChange={setActiveTab} />
-        <div className="h-full overflow-auto">
-          {activeTab === "overview" && (
-            <Overview
-              dataset={dataset}
-              filesOperation={filesOperation}
-              fetchDataset={fetchDataset}
-              onUpload={() => setShowUploadDialog(true)}
-              similarDatasets={similarDatasets}
-              similarDatasetsLoading={similarDatasetsLoading}
-              similarTags={similarTagNames}
-            />
-          )}
-          {activeTab === "children" && (
-            <div className="pt-4">
-              <div className="flex items-center justify-between mb-3">
-                <h2 className="text-base font-semibold">子数据集</h2>
-                <span className="text-xs text-gray-500">
-                  共 {childDatasets.length} 个
-                </span>
-              </div>
-              <Table
-                rowKey="id"
-                columns={childColumns}
-                dataSource={childDatasets}
-                loading={childDatasetsLoading}
-                pagination={false}
-                locale={{ emptyText: "暂无子数据集" }}
-              />
-            </div>
-          )}
-          {activeTab === "lineage" && <DataLineageFlow dataset={dataset} />}
-          {activeTab === "quality" && <DataQuality />}
-        </div>
-      </div>
+      <div className="flex-1 overflow-auto">
+        <div className="p-6 pt-2 bg-white rounded-md shadow mb-4">
+          <Tabs activeKey={activeTab} items={tabList} onChange={setActiveTab} />
+          <div className="">
+            {activeTab === "overview" && (
+              <Overview
+                dataset={dataset}
+                filesOperation={filesOperation}
+                fetchDataset={fetchDataset}
+                onUpload={() => setShowUploadDialog(true)}
+              />
+            )}
+            {activeTab === "children" && (
+              <div className="pt-4">
+                <div className="flex items-center justify-between mb-3">
+                  <h2 className="text-base font-semibold">关联数据集</h2>
+                  <span className="text-xs text-gray-500">
+                    共 {childDatasets.length} 个
+                  </span>
+                </div>
+                <Table
+                  rowKey="id"
+                  columns={childColumns}
+                  dataSource={childDatasets}
+                  loading={childDatasetsLoading}
+                  pagination={false}
+                  locale={{ emptyText: "暂无关联数据集" }}
+                />
+              </div>
+            )}
+            {activeTab === "lineage" && <DataLineageFlow dataset={dataset} />}
+            {activeTab === "quality" && <DataQuality />}
+          </div>
+        </div>
+
+        {/* 相似数据集 */}
+        <div className="bg-white rounded-md shadow p-6 mb-4">
+          <div className="flex items-center justify-between mb-3">
+            <h2 className="text-base font-semibold">相似数据集</h2>
+            {similarTagsSummary && (
+              <span className="text-xs text-gray-500">
+                匹配标签：{similarTagsSummary}
+              </span>
+            )}
+          </div>
+          <CardView
+            data={similarDatasets}
+            loading={similarDatasetsLoading}
+            operations={[]}
+            pagination={{
+              current: 1,
+              pageSize: similarDatasets.length || 10,
+              total: similarDatasets.length || 0,
+              style: { display: "none" },
+            }}
+            onView={(item) => {
+              navigate(`/data/management/detail/${item.id}`);
+            }}
+          />
+        </div>
+      </div>
       <ImportConfiguration
         data={dataset}
         open={showUploadDialog}

frontend/src/pages/DataManagement/Detail/components/ImportConfiguration.tsx

@@ -1,351 +1,530 @@
-import { Select, Input, Form, Radio, Modal, Button, UploadFile, Switch, Tooltip } from "antd";
-import { InboxOutlined, QuestionCircleOutlined } from "@ant-design/icons";
-import { dataSourceOptions } from "../../dataset.const";
-import { Dataset, DataSource } from "../../dataset.model";
-import { useEffect, useState } from "react";
-import { queryTasksUsingGet } from "@/pages/DataCollection/collection.apis";
-import { updateDatasetByIdUsingPut } from "../../dataset.api";
-import { sliceFile } from "@/utils/file.util";
-import Dragger from "antd/es/upload/Dragger";
-
-/**
- * 按行分割文件
- * @param file 原始文件
- * @returns 分割后的文件列表，每行一个文件
- */
-async function splitFileByLines(file: UploadFile): Promise<UploadFile[]> {
-  const originFile = (file as any).originFileObj || file;
-  if (!originFile || typeof originFile.text !== "function") {
-    return [file];
-  }
-
-  const text = await originFile.text();
-  if (!text) return [file];
-
-  // 按行分割并过滤空行
-  const lines = text.split(/\r?\n/).filter((line: string) => line.trim() !== "");
-  if (lines.length === 0) return [];
-
-  // 生成文件名：原文件名_序号.扩展名
-  const nameParts = file.name.split(".");
-  const ext = nameParts.length > 1 ? "." + nameParts.pop() : "";
-  const baseName = nameParts.join(".");
-  const padLength = String(lines.length).length;
-
-  return lines.map((line: string, index: number) => {
-    const newFileName = `${baseName}_${String(index + 1).padStart(padLength, "0")}${ext}`;
-    const blob = new Blob([line], { type: "text/plain" });
-    const newFile = new File([blob], newFileName, { type: "text/plain" });
-    return {
-      uid: `${file.uid}-${index}`,
-      name: newFileName,
-      size: newFile.size,
-      type: "text/plain",
-      originFileObj: newFile as any,
-    } as UploadFile;
-  });
-}
-
-export default function ImportConfiguration({
-  data,
-  open,
-  onClose,
-  updateEvent = "update:dataset",
-  prefix,
-}: {
-  data: Dataset | null;
-  open: boolean;
-  onClose: () => void;
-  updateEvent?: string;
-  prefix?: string;
-}) {
-  const [form] = Form.useForm();
-  const [collectionOptions, setCollectionOptions] = useState([]);
-  const [importConfig, setImportConfig] = useState<any>({
-    source: DataSource.UPLOAD,
-    hasArchive: true,
-    splitByLine: false,
-  });
-  const [currentPrefix, setCurrentPrefix] = useState<string>("");
-
-  // 本地上传文件相关逻辑
-
-  const handleUpload = async (dataset: Dataset) => {
-    let filesToUpload = form.getFieldValue("files") || [];
-
-    // 如果启用分行分割，处理文件
-    if (importConfig.splitByLine) {
-      const splitResults = await Promise.all(
-        filesToUpload.map((file) => splitFileByLines(file))
-      );
-      filesToUpload = splitResults.flat();
-    }
-
-    // 计算分片列表
-    const sliceList = filesToUpload.map((file) => {
-      const originFile = (file as any).originFileObj || file;
-      const slices = sliceFile(originFile);
-      return {
-        originFile: originFile,  // 传入真正的 File/Blob 对象
-        slices,
-        name: file.name,
-        size: originFile.size || 0,
-      };
-    });
-
-    console.log("[ImportConfiguration] Uploading with currentPrefix:", currentPrefix);
-    window.dispatchEvent(
-      new CustomEvent("upload:dataset", {
-        detail: {
-          dataset,
-          files: sliceList,
-          updateEvent,
-          hasArchive: importConfig.hasArchive,
-          prefix: currentPrefix,
-        },
-      })
-    );
-  };
-
-  const fetchCollectionTasks = async () => {
-    if (importConfig.source !== DataSource.COLLECTION) return;
-    try {
-      const res = await queryTasksUsingGet({ page: 0, size: 100 });
-      const options = res.data.content.map((task: any) => ({
-        label: task.name,
-        value: task.id,
-      }));
-      setCollectionOptions(options);
-    } catch (error) {
-      console.error("Error fetching collection tasks:", error);
-    }
-  };
-
-  const resetState = () => {
-    console.log('[ImportConfiguration] resetState called, preserving currentPrefix:', currentPrefix);
-    form.resetFields();
-    form.setFieldsValue({ files: null });
-    setImportConfig({
-      source: importConfig.source ? importConfig.source : DataSource.UPLOAD,
-      hasArchive: true,
-      splitByLine: false,
-    });
-    console.log('[ImportConfiguration] resetState done, currentPrefix still:', currentPrefix);
-  };
-
-  const handleImportData = async () => {
-    if (!data) return;
-    console.log('[ImportConfiguration] handleImportData called, currentPrefix:', currentPrefix);
-    if (importConfig.source === DataSource.UPLOAD) {
-      await handleUpload(data);
-    } else if (importConfig.source === DataSource.COLLECTION) {
-      await updateDatasetByIdUsingPut(data.id, {
-        ...importConfig,
-      });
-    }
-    onClose();
-  };
-
-  useEffect(() => {
-    if (open) {
-      setCurrentPrefix(prefix || "");
-      console.log('[ImportConfiguration] Modal opened with prefix:', prefix);
-      resetState();
-      fetchCollectionTasks();
-    }
-  }, [open]);
-
-  // Separate effect for fetching collection tasks when source changes
-  useEffect(() => {
-    if (open && importConfig.source === DataSource.COLLECTION) {
-      fetchCollectionTasks();
-    }
-  }, [importConfig.source]);
-
-  return (
-    <Modal
-      title="导入数据"
-      open={open}
-      width={600}
-      onCancel={() => {
-        onClose();
-        resetState();
-      }}
-      maskClosable={false}
-      footer={
-        <>
-          <Button onClick={onClose}>取消</Button>
-          <Button
-            type="primary"
-            disabled={!importConfig?.files?.length && !importConfig.dataSource}
-            onClick={handleImportData}
-          >
-            确定
-          </Button>
-        </>
-      }
-    >
-      <Form
-        form={form}
-        layout="vertical"
-        initialValues={importConfig || {}}
-        onValuesChange={(_, allValues) => setImportConfig(allValues)}
-      >
-        <Form.Item
-          label="数据源"
-          name="source"
-          rules={[{ required: true, message: "请选择数据源" }]}
-        >
-          <Radio.Group
-            buttonStyle="solid"
-            options={dataSourceOptions}
-            optionType="button"
-          />
-        </Form.Item>
-        {importConfig?.source === DataSource.COLLECTION && (
-          <Form.Item name="dataSource" label="归集任务" required>
-            <Select placeholder="请选择归集任务" options={collectionOptions} />
-          </Form.Item>
-        )}
-
-        {/* obs import */}
-        {importConfig?.source === DataSource.OBS && (
-          <div className="grid grid-cols-2 gap-3 p-4 bg-blue-50 rounded-lg">
-            <Form.Item
-              name="endpoint"
-              rules={[{ required: true }]}
-              label="Endpoint"
-            >
-              <Input
-                className="h-8 text-xs"
-                placeholder="obs.cn-north-4.myhuaweicloud.com"
-              />
-            </Form.Item>
-            <Form.Item
-              name="bucket"
-              rules={[{ required: true }]}
-              label="Bucket"
-            >
-              <Input className="h-8 text-xs" placeholder="my-bucket" />
-            </Form.Item>
-            <Form.Item
-              name="accessKey"
-              rules={[{ required: true }]}
-              label="Access Key"
-            >
-              <Input className="h-8 text-xs" placeholder="Access Key" />
-            </Form.Item>
-            <Form.Item
-              name="secretKey"
-              rules={[{ required: true }]}
-              label="Secret Key"
-            >
-              <Input
-                type="password"
-                className="h-8 text-xs"
-                placeholder="Secret Key"
-              />
-            </Form.Item>
-          </div>
-        )}
-
-        {/* Local Upload Component */}
-        {importConfig?.source === DataSource.UPLOAD && (
-          <>
-            <Form.Item
-              label="自动解压上传的压缩包"
-              name="hasArchive"
-              valuePropName="checked"
-            >
-              <Switch />
-            </Form.Item>
-            <Form.Item
-              label={
-                <span>
-                  按分行分割{" "}
-                  <Tooltip title="选中后，文本文件的每一行将被分割成独立文件">
-                    <QuestionCircleOutlined style={{ color: "#999" }} />
-                  </Tooltip>
-                </span>
-              }
-              name="splitByLine"
-              valuePropName="checked"
-            >
-              <Switch />
-            </Form.Item>
-            <Form.Item
-              label="上传文件"
-              name="files"
-              valuePropName="fileList"
-              getValueFromEvent={(e: any) => {
-                if (Array.isArray(e)) {
-                  return e;
-                }
-                return e && e.fileList;
-              }}
-              rules={[
-                {
-                  required: true,
-                  message: "请上传文件",
-                },
-              ]}
-            >
-              <Dragger
-                className="w-full"
-                beforeUpload={() => false}
-                multiple
-              >
-                <p className="ant-upload-drag-icon">
-                  <InboxOutlined />
-                </p>
-                <p className="ant-upload-text">本地文件上传</p>
-                <p className="ant-upload-hint">拖拽文件到此处或点击选择文件</p>
-              </Dragger>
-            </Form.Item>
-          </>
-        )}
-
-        {/* Target Configuration */}
-        {importConfig?.target && importConfig?.target !== DataSource.UPLOAD && (
-          <div className="space-y-3 p-4 bg-blue-50 rounded-lg">
-            {importConfig?.target === DataSource.DATABASE && (
-              <div className="grid grid-cols-2 gap-3">
-                <Form.Item
-                  name="databaseType"
-                  rules={[{ required: true }]}
-                  label="数据库类型"
-                >
-                  <Select
-                    className="w-full"
-                    options={[
-                      { label: "MySQL", value: "mysql" },
-                      { label: "PostgreSQL", value: "postgresql" },
-                      { label: "MongoDB", value: "mongodb" },
-                    ]}
-                  ></Select>
-                </Form.Item>
-                <Form.Item
-                  name="tableName"
-                  rules={[{ required: true }]}
-                  label="表名"
-                >
-                  <Input className="h-8 text-xs" placeholder="dataset_table" />
-                </Form.Item>
-                <Form.Item
-                  name="connectionString"
-                  rules={[{ required: true }]}
-                  label="连接字符串"
-                >
-                  <Input
-                    className="h-8 text-xs col-span-2"
-                    placeholder="数据库连接字符串"
-                  />
-                </Form.Item>
-              </div>
-            )}
-          </div>
-        )}
-      </Form>
-    </Modal>
-  );
-}
+import { Select, Input, Form, Radio, Modal, Button, UploadFile, Switch, Tooltip } from "antd";
+import { InboxOutlined, QuestionCircleOutlined } from "@ant-design/icons";
+import { dataSourceOptions } from "../../dataset.const";
+import { Dataset, DatasetType, DataSource } from "../../dataset.model";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { queryTasksUsingGet } from "@/pages/DataCollection/collection.apis";
+import { updateDatasetByIdUsingPut } from "../../dataset.api";
+import { sliceFile, shouldStreamUpload } from "@/utils/file.util";
+import Dragger from "antd/es/upload/Dragger";
+
+const TEXT_FILE_MIME_PREFIX = "text/";
+const TEXT_FILE_MIME_TYPES = new Set([
+  "application/json",
+  "application/xml",
+  "application/csv",
+  "application/ndjson",
+  "application/x-ndjson",
+  "application/x-yaml",
+  "application/yaml",
+  "application/javascript",
+  "application/x-javascript",
+  "application/sql",
+]);
+const TEXT_FILE_EXTENSIONS = new Set([
+  ".txt",
+  ".md",
+  ".csv",
+  ".tsv",
+  ".json",
+  ".jsonl",
+  ".ndjson",
+  ".log",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".sql",
+]);
+
+function getUploadFileName(file: UploadFile): string {
+  if (file.name) return file.name;
+  const originFile = file.originFileObj;
+  if (originFile instanceof File && originFile.name) {
+    return originFile.name;
+  }
+  return "";
+}
+
+function getUploadFileType(file: UploadFile): string {
+  if (file.type) return file.type;
+  const originFile = file.originFileObj;
+  if (originFile instanceof File && typeof originFile.type === "string") {
+    return originFile.type;
+  }
+  return "";
+}
+
+function isTextUploadFile(file: UploadFile): boolean {
+  const mimeType = getUploadFileType(file).toLowerCase();
+  if (mimeType) {
+    if (mimeType.startsWith(TEXT_FILE_MIME_PREFIX)) return true;
+    if (TEXT_FILE_MIME_TYPES.has(mimeType)) return true;
+  }
+
+  const fileName = getUploadFileName(file);
+  const dotIndex = fileName.lastIndexOf(".");
+  if (dotIndex < 0) return false;
+  const ext = fileName.slice(dotIndex).toLowerCase();
+  return TEXT_FILE_EXTENSIONS.has(ext);
+}
+
+/**
+ * 按行分割文件
+ * @param file 原始文件
+ * @returns 分割后的文件列表，每行一个文件
+ */
+async function splitFileByLines(file: UploadFile): Promise<UploadFile[]> {
+  if (!isTextUploadFile(file)) {
+    return [file];
+  }
+
+  const originFile = file.originFileObj ?? file;
+  if (!(originFile instanceof File) || typeof originFile.text !== "function") {
+    return [file];
+  }
+
+  const text = await originFile.text();
+  if (!text) return [file];
+
+  // 按行分割并过滤空行
+  const lines = text.split(/\r?\n/).filter((line: string) => line.trim() !== "");
+  if (lines.length === 0) return [];
+
+  // 生成文件名：原文件名_序号（不保留后缀）
+  const nameParts = file.name.split(".");
+  if (nameParts.length > 1) {
+    nameParts.pop();
+  }
+  const baseName = nameParts.join(".");
+  const padLength = String(lines.length).length;
+
+  return lines.map((line: string, index: number) => {
+    const newFileName = `${baseName}_${String(index + 1).padStart(padLength, "0")}`;
+    const blob = new Blob([line], { type: "text/plain" });
+    const newFile = new File([blob], newFileName, { type: "text/plain" });
+    return {
+      uid: `${file.uid}-${index}`,
+      name: newFileName,
+      size: newFile.size,
+      type: "text/plain",
+      originFileObj: newFile as UploadFile["originFileObj"],
+    } as UploadFile;
+  });
+}
+
+type SelectOption = {
+  label: string;
+  value: string;
+};
+
+type CollectionTask = {
+  id: string;
+  name: string;
+};
+
+type ImportConfig = {
+  source: DataSource;
+  hasArchive: boolean;
+  splitByLine: boolean;
+  files?: UploadFile[];
+  dataSource?: string;
+  target?: DataSource;
+  [key: string]: unknown;
+};
+
+export default function ImportConfiguration({
+  data,
+  open,
+  onClose,
+  updateEvent = "update:dataset",
+  prefix,
+}: {
+  data: Dataset | null;
+  open: boolean;
+  onClose: () => void;
+  updateEvent?: string;
+  prefix?: string;
+}) {
+  const [form] = Form.useForm();
+  const [collectionOptions, setCollectionOptions] = useState<SelectOption[]>([]);
+  const availableSourceOptions = dataSourceOptions.filter(
+    (option) => option.value !== DataSource.COLLECTION
+  );
+  const [importConfig, setImportConfig] = useState<ImportConfig>({
+    source: DataSource.UPLOAD,
+    hasArchive: true,
+    splitByLine: false,
+  });
+  const [currentPrefix, setCurrentPrefix] = useState<string>("");
+  const hasNonTextFile = useMemo(() => {
+    const files = importConfig.files ?? [];
+    if (files.length === 0) return false;
+    return files.some((file) => !isTextUploadFile(file));
+  }, [importConfig.files]);
+  const isTextDataset = data?.datasetType === DatasetType.TEXT;
+
+  // 本地上传文件相关逻辑
+
+  const handleUpload = async (dataset: Dataset) => {
+    const filesToUpload =
+      (form.getFieldValue("files") as UploadFile[] | undefined) || [];
+
+    // 如果启用分行分割，对大文件使用流式处理
+    if (importConfig.splitByLine && !hasNonTextFile) {
+      // 检查是否有大文件需要流式分割上传
+      const filesForStreamUpload: File[] = [];
+      const filesForNormalUpload: UploadFile[] = [];
+
+      for (const file of filesToUpload) {
+        const originFile = file.originFileObj ?? file;
+        if (originFile instanceof File && shouldStreamUpload(originFile)) {
+          filesForStreamUpload.push(originFile);
+        } else {
+          filesForNormalUpload.push(file);
+        }
+      }
+
+      // 大文件使用流式分割上传
+      if (filesForStreamUpload.length > 0) {
+        window.dispatchEvent(
+          new CustomEvent("upload:dataset-stream", {
+            detail: {
+              dataset,
+              files: filesForStreamUpload,
+              updateEvent,
+              hasArchive: importConfig.hasArchive,
+              prefix: currentPrefix,
+            },
+          })
+        );
+      }
+
+      // 小文件使用传统分割方式
+      if (filesForNormalUpload.length > 0) {
+        const splitResults = await Promise.all(
+          filesForNormalUpload.map((file) => splitFileByLines(file))
+        );
+        const smallFilesToUpload = splitResults.flat();
+        
+        // 计算分片列表
+        const sliceList = smallFilesToUpload.map((file) => {
+          const originFile = (file.originFileObj ?? file) as Blob;
+          const slices = sliceFile(originFile);
+          return {
+            originFile: originFile,
+            slices,
+            name: file.name,
+            size: originFile.size || 0,
+          };
+        });
+
+        console.log("[ImportConfiguration] Uploading small files with currentPrefix:", currentPrefix);
+        window.dispatchEvent(
+          new CustomEvent("upload:dataset", {
+            detail: {
+              dataset,
+              files: sliceList,
+              updateEvent,
+              hasArchive: importConfig.hasArchive,
+              prefix: currentPrefix,
+            },
+          })
+        );
+      }
+      return;
+    }
+
+    // 未启用分行分割，使用普通上传
+    // 计算分片列表
+    const sliceList = filesToUpload.map((file) => {
+      const originFile = (file.originFileObj ?? file) as Blob;
+      const slices = sliceFile(originFile);
+      return {
+        originFile: originFile,  // 传入真正的 File/Blob 对象
+        slices,
+        name: file.name,
+        size: originFile.size || 0,
+      };
+    });
+
+    console.log("[ImportConfiguration] Uploading with currentPrefix:", currentPrefix);
+    window.dispatchEvent(
+      new CustomEvent("upload:dataset", {
+        detail: {
+          dataset,
+          files: sliceList,
+          updateEvent,
+          hasArchive: importConfig.hasArchive,
+          prefix: currentPrefix,
+        },
+      })
+    );
+  };
+
+  const fetchCollectionTasks = useCallback(async () => {
+    if (importConfig.source !== DataSource.COLLECTION) return;
+    try {
+      const res = await queryTasksUsingGet({ page: 0, size: 100 });
+      const tasks = Array.isArray(res?.data?.content)
+        ? (res.data.content as CollectionTask[])
+        : [];
+      const options = tasks.map((task) => ({
+        label: task.name,
+        value: task.id,
+      }));
+      setCollectionOptions(options);
+    } catch (error) {
+      console.error("Error fetching collection tasks:", error);
+    }
+  }, [importConfig.source]);
+
+  const resetState = useCallback(() => {
+    console.log('[ImportConfiguration] resetState called, preserving currentPrefix:', currentPrefix);
+    form.resetFields();
+    form.setFieldsValue({ files: null });
+    setImportConfig({
+      source: DataSource.UPLOAD,
+      hasArchive: true,
+      splitByLine: false,
+    });
+    console.log('[ImportConfiguration] resetState done, currentPrefix still:', currentPrefix);
+  }, [currentPrefix, form]);
+
+  const handleImportData = async () => {
+    if (!data) return;
+    console.log('[ImportConfiguration] handleImportData called, currentPrefix:', currentPrefix);
+    if (importConfig.source === DataSource.UPLOAD) {
+      // 立即显示任务中心，让用户感知上传已开始（在文件分割等耗时操作之前）
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: true } })
+      );
+      await handleUpload(data);
+    } else if (importConfig.source === DataSource.COLLECTION) {
+      await updateDatasetByIdUsingPut(data.id, {
+        ...importConfig,
+      });
+    }
+    onClose();
+  };
+
+  useEffect(() => {
+    if (open) {
+      setCurrentPrefix(prefix || "");
+      console.log('[ImportConfiguration] Modal opened with prefix:', prefix);
+      resetState();
+      fetchCollectionTasks();
+    }
+  }, [fetchCollectionTasks, open, prefix, resetState]);
+
+  useEffect(() => {
+    if (!importConfig.files?.length) return;
+    if (!importConfig.splitByLine) return;
+    if (!hasNonTextFile) return;
+    form.setFieldsValue({ splitByLine: false });
+    setImportConfig((prev) => ({ ...prev, splitByLine: false }));
+  }, [form, hasNonTextFile, importConfig.files, importConfig.splitByLine]);
+
+  // Separate effect for fetching collection tasks when source changes
+  useEffect(() => {
+    if (open && importConfig.source === DataSource.COLLECTION) {
+      fetchCollectionTasks();
+    }
+  }, [fetchCollectionTasks, importConfig.source, open]);
+
+  return (
+    <Modal
+      title="导入数据"
+      open={open}
+      width={600}
+      onCancel={() => {
+        onClose();
+        resetState();
+      }}
+      maskClosable={false}
+      footer={
+        <>
+          <Button onClick={onClose}>取消</Button>
+          <Button
+            type="primary"
+            disabled={!importConfig?.files?.length && !importConfig.dataSource}
+            onClick={handleImportData}
+          >
+            确定
+          </Button>
+        </>
+      }
+    >
+      <Form
+        form={form}
+        layout="vertical"
+        initialValues={importConfig || {}}
+        onValuesChange={(_, allValues) => setImportConfig(allValues)}
+      >
+        <Form.Item
+          label="数据源"
+          name="source"
+          rules={[{ required: true, message: "请选择数据源" }]}
+        >
+            <Radio.Group
+              buttonStyle="solid"
+              options={availableSourceOptions}
+              optionType="button"
+            />
+          </Form.Item>
+        {importConfig?.source === DataSource.COLLECTION && (
+          <Form.Item name="dataSource" label="归集任务" required>
+            <Select placeholder="请选择归集任务" options={collectionOptions} />
+          </Form.Item>
+        )}
+
+        {/* obs import */}
+        {importConfig?.source === DataSource.OBS && (
+          <div className="grid grid-cols-2 gap-3 p-4 bg-blue-50 rounded-lg">
+            <Form.Item
+              name="endpoint"
+              rules={[{ required: true }]}
+              label="Endpoint"
+            >
+              <Input
+                className="h-8 text-xs"
+                placeholder="obs.cn-north-4.myhuaweicloud.com"
+              />
+            </Form.Item>
+            <Form.Item
+              name="bucket"
+              rules={[{ required: true }]}
+              label="Bucket"
+            >
+              <Input className="h-8 text-xs" placeholder="my-bucket" />
+            </Form.Item>
+            <Form.Item
+              name="accessKey"
+              rules={[{ required: true }]}
+              label="Access Key"
+            >
+              <Input className="h-8 text-xs" placeholder="Access Key" />
+            </Form.Item>
+            <Form.Item
+              name="secretKey"
+              rules={[{ required: true }]}
+              label="Secret Key"
+            >
+              <Input
+                type="password"
+                className="h-8 text-xs"
+                placeholder="Secret Key"
+              />
+            </Form.Item>
+          </div>
+        )}
+
+        {/* Local Upload Component */}
+        {importConfig?.source === DataSource.UPLOAD && (
+          <>
+            <Form.Item
+              label="自动解压上传的压缩包"
+              name="hasArchive"
+              valuePropName="checked"
+            >
+              <Switch />
+            </Form.Item>
+            {isTextDataset && (
+              <Form.Item
+                label={
+                  <span>
+                    按分行分割{" "}
+                    <Tooltip
+                      title={
+                        hasNonTextFile
+                          ? "已选择非文本文件，无法按行分割"
+                          : "选中后，文本文件的每一行将被分割成独立文件"
+                      }
+                    >
+                      <QuestionCircleOutlined style={{ color: "#999" }} />
+                    </Tooltip>
+                  </span>
+                }
+                name="splitByLine"
+                valuePropName="checked"
+              >
+                <Switch disabled={hasNonTextFile} />
+              </Form.Item>
+            )}
+            <Form.Item
+              label="上传文件"
+              name="files"
+              valuePropName="fileList"
+              getValueFromEvent={(
+                event: { fileList?: UploadFile[] } | UploadFile[]
+              ) => {
+                if (Array.isArray(event)) {
+                  return event;
+                }
+                return event?.fileList;
+              }}
+              rules={[
+                {
+                  required: true,
+                  message: "请上传文件",
+                },
+              ]}
+            >
+              <Dragger
+                className="w-full"
+                beforeUpload={() => false}
+                multiple
+              >
+                <p className="ant-upload-drag-icon">
+                  <InboxOutlined />
+                </p>
+                <p className="ant-upload-text">本地文件上传</p>
+                <p className="ant-upload-hint">拖拽文件到此处或点击选择文件</p>
+              </Dragger>
+            </Form.Item>
+          </>
+        )}
+
+        {/* Target Configuration */}
+        {importConfig?.target && importConfig?.target !== DataSource.UPLOAD && (
+          <div className="space-y-3 p-4 bg-blue-50 rounded-lg">
+            {importConfig?.target === DataSource.DATABASE && (
+              <div className="grid grid-cols-2 gap-3">
+                <Form.Item
+                  name="databaseType"
+                  rules={[{ required: true }]}
+                  label="数据库类型"
+                >
+                  <Select
+                    className="w-full"
+                    options={[
+                      { label: "MySQL", value: "mysql" },
+                      { label: "PostgreSQL", value: "postgresql" },
+                      { label: "MongoDB", value: "mongodb" },
+                    ]}
+                  ></Select>
+                </Form.Item>
+                <Form.Item
+                  name="tableName"
+                  rules={[{ required: true }]}
+                  label="表名"
+                >
+                  <Input className="h-8 text-xs" placeholder="dataset_table" />
+                </Form.Item>
+                <Form.Item
+                  name="connectionString"
+                  rules={[{ required: true }]}
+                  label="连接字符串"
+                >
+                  <Input
+                    className="h-8 text-xs col-span-2"
+                    placeholder="数据库连接字符串"
+                  />
+                </Form.Item>
+              </div>
+            )}
+          </div>
+        )}
+      </Form>
+    </Modal>
+  );
+}

frontend/src/pages/DataManagement/Detail/components/Overview.tsx

@@ -4,152 +4,69 @@ import {
   Descriptions,
   DescriptionsProps,
   Modal,
+  Spin,
   Table,
   Input,
-  Tag,
 } from "antd";
-import { formatBytes, formatDateTime } from "@/utils/unit";
-import { Download, Trash2, Folder, File } from "lucide-react";
-import { datasetTypeMap } from "../../dataset.const";
-import type { Dataset, DatasetFile } from "@/pages/DataManagement/dataset.model";
-import { Link } from "react-router";
-import type { useFilesOperation } from "../useFilesOperation";
-
-type DatasetFileRow = DatasetFile & {
-  fileSize?: number;
-  fileCount?: number;
-  uploadTime?: string;
-};
-
-const PREVIEW_MAX_HEIGHT = 500;
+import { formatBytes, formatDateTime } from "@/utils/unit";
+import { Download, Trash2, Folder, File } from "lucide-react";
+import { datasetTypeMap } from "../../dataset.const";
+import type { Dataset, DatasetFile } from "@/pages/DataManagement/dataset.model";
+import type { useFilesOperation } from "../useFilesOperation";
+
+type DatasetFileRow = DatasetFile & {
+  fileSize?: number;
+  fileCount?: number;
+  uploadTime?: string;
+};
+
+const PREVIEW_MAX_HEIGHT = 500;
 const PREVIEW_MODAL_WIDTH = {
-  text: 800,
-  media: 700,
+  text: "80vw",
+  media: "80vw",
 };
-const PREVIEW_TEXT_FONT_SIZE = 12;
-const PREVIEW_TEXT_PADDING = 12;
-const PREVIEW_AUDIO_PADDING = 40;
-const SIMILAR_TAGS_PREVIEW_LIMIT = 3;
-const SIMILAR_DATASET_TAG_PREVIEW_LIMIT = 4;
-
-type OverviewProps = {
-  dataset: Dataset;
-  filesOperation: ReturnType<typeof useFilesOperation>;
-  fetchDataset: () => void;
-  onUpload?: () => void;
-  similarDatasets: Dataset[];
-  similarDatasetsLoading: boolean;
-  similarTags: string[];
-};
-
-export default function Overview({
-  dataset,
-  filesOperation,
-  fetchDataset,
-  onUpload,
-  similarDatasets,
-  similarDatasetsLoading,
-  similarTags,
-}: OverviewProps) {
-  const { modal, message } = App.useApp();
+const PREVIEW_TEXT_FONT_SIZE = 12;
+const PREVIEW_TEXT_PADDING = 12;
+const PREVIEW_AUDIO_PADDING = 40;
+
+type OverviewProps = {
+  dataset: Dataset;
+  filesOperation: ReturnType<typeof useFilesOperation>;
+  fetchDataset: () => void;
+  onUpload?: () => void;
+};
+
+export default function Overview({
+  dataset,
+  filesOperation,
+  fetchDataset,
+  onUpload,
+}: OverviewProps) {
+  const { modal, message } = App.useApp();
   const {
-    fileList,
-    pagination,
-    selectedFiles,
-    previewVisible,
-    previewFileName,
-    previewContent,
+    fileList,
+    pagination,
+    selectedFiles,
+    previewVisible,
+    previewFileName,
+    previewContent,
     previewFileType,
     previewMediaUrl,
     previewLoading,
+    officePreviewStatus,
+    officePreviewError,
     closePreview,
-    handleDeleteFile,
-    handleDownloadFile,
-    handleBatchDeleteFiles,
-    handleBatchExport,
-    handleCreateDirectory,
-    handleDownloadDirectory,
-    handleDeleteDirectory,
-    handlePreviewFile,
-  } = filesOperation;
-  const similarTagsSummary = (() => {
-    if (!similarTags || similarTags.length === 0) {
-      return "";
-    }
-    const visibleTags = similarTags.slice(0, SIMILAR_TAGS_PREVIEW_LIMIT);
-    const hiddenCount = similarTags.length - visibleTags.length;
-    if (hiddenCount > 0) {
-      return `${visibleTags.join("、")} 等 ${similarTags.length} 个`;
-    }
-    return visibleTags.join("、");
-  })();
-  const renderDatasetTags = (
-    tags?: Array<string | { name?: string; color?: string } | null>
-  ) => {
-    if (!tags || tags.length === 0) {
-      return "-";
-    }
-    const visibleTags = tags.slice(0, SIMILAR_DATASET_TAG_PREVIEW_LIMIT);
-    const hiddenCount = tags.length - visibleTags.length;
-    return (
-      <div className="flex flex-wrap gap-1">
-        {visibleTags.map((tag, index) => {
-          const tagName = typeof tag === "string" ? tag : tag?.name;
-          if (!tagName) {
-            return null;
-          }
-          const tagColor = typeof tag === "string" ? undefined : tag?.color;
-          return (
-            <Tag key={`${tagName}-${index}`} color={tagColor}>
-              {tagName}
-            </Tag>
-          );
-        })}
-        {hiddenCount > 0 && <Tag>+{hiddenCount}</Tag>}
-      </div>
-    );
-  };
-  const similarColumns = [
-    {
-      title: "名称",
-      dataIndex: "name",
-      key: "name",
-      render: (_: string, record: Dataset) => (
-        <Link to={`/data/management/detail/${record.id}`}>{record.name}</Link>
-      ),
-    },
-    {
-      title: "标签",
-      dataIndex: "tags",
-      key: "tags",
-      render: (tags: Array<string | { name?: string; color?: string }>) =>
-        renderDatasetTags(tags),
-    },
-    {
-      title: "类型",
-      dataIndex: "datasetType",
-      key: "datasetType",
-      width: 120,
-      render: (_: string, record: Dataset) =>
-        datasetTypeMap[record.datasetType as keyof typeof datasetTypeMap]?.label ||
-        "未知",
-    },
-    {
-      title: "文件数",
-      dataIndex: "fileCount",
-      key: "fileCount",
-      width: 120,
-      render: (value?: number) => value ?? 0,
-    },
-    {
-      title: "更新时间",
-      dataIndex: "updatedAt",
-      key: "updatedAt",
-      width: 180,
-    },
-  ];
+    handleDeleteFile,
+    handleDownloadFile,
+    handleBatchDeleteFiles,
+    handleBatchExport,
+    handleCreateDirectory,
+    handleDownloadDirectory,
+    handleDeleteDirectory,
+    handlePreviewFile,
+  } = filesOperation;
 
-  // 基本信息
+  // 基本信息
   const items: DescriptionsProps["items"] = [
     {
       key: "id",
@@ -211,7 +128,7 @@ export default function Overview({
       dataIndex: "fileName",
       key: "fileName",
       fixed: "left",
-      render: (text: string, record: DatasetFileRow) => {
+      render: (text: string, record: DatasetFileRow) => {
         const isDirectory = record.id.startsWith('directory-');
         const iconSize = 16;
 
@@ -230,35 +147,35 @@ export default function Overview({
           return (
             <Button
               type="link"
-              onClick={() => {
-                const currentPath = filesOperation.pagination.prefix || '';
-                // 文件夹路径必须以斜杠结尾
-                const newPath = `${currentPath}${record.fileName}/`;
-                filesOperation.fetchFiles(newPath, 1, filesOperation.pagination.pageSize);
-              }}
-            >
+              onClick={() => {
+                const currentPath = filesOperation.pagination.prefix || '';
+                // 文件夹路径必须以斜杠结尾
+                const newPath = `${currentPath}${record.fileName}/`;
+                filesOperation.fetchFiles(newPath, 1, filesOperation.pagination.pageSize);
+              }}
+            >
               {content}
             </Button>
           );
         }
 
-        return (
-            <Button
-              type="link"
-              loading={previewLoading && previewFileName === record.fileName}
-              onClick={() => handlePreviewFile(record)}
-            >
-              {content}
-            </Button>
-          );
-      },
+        return (
+            <Button
+              type="link"
+              loading={previewLoading && previewFileName === record.fileName}
+              onClick={() => handlePreviewFile(record)}
+            >
+              {content}
+            </Button>
+          );
+      },
     },
     {
       title: "大小",
       dataIndex: "fileSize",
       key: "fileSize",
       width: 150,
-      render: (text: number, record: DatasetFileRow) => {
+      render: (text: number, record: DatasetFileRow) => {
         const isDirectory = record.id.startsWith('directory-');
         if (isDirectory) {
           return formatBytes(record.fileSize || 0);
@@ -271,7 +188,7 @@ export default function Overview({
       dataIndex: "fileCount",
       key: "fileCount",
       width: 120,
-      render: (text: number, record: DatasetFileRow) => {
+      render: (text: number, record: DatasetFileRow) => {
         const isDirectory = record.id.startsWith('directory-');
         if (!isDirectory) {
           return "-";
@@ -291,7 +208,7 @@ export default function Overview({
       key: "action",
       width: 180,
       fixed: "right",
-      render: (_, record: DatasetFileRow) => {
+      render: (_, record: DatasetFileRow) => {
         const isDirectory = record.id.startsWith('directory-');
 
         if (isDirectory) {
@@ -332,6 +249,14 @@ export default function Overview({
 
         return (
         <div className="flex">
+          <Button
+            size="small"
+            type="link"
+            loading={previewLoading && previewFileName === record.fileName}
+            onClick={() => handlePreviewFile(record)}
+          >
+            预览
+          </Button>
           <Button
             size="small"
             type="link"
@@ -367,70 +292,45 @@ export default function Overview({
           column={5}
         />
 
-        {/* 相似数据集 */}
-        <div className="mt-8">
-          <div className="flex items-center justify-between mb-3">
-            <h2 className="text-base font-semibold">相似数据集</h2>
-            {similarTagsSummary && (
-              <span className="text-xs text-gray-500">
-                匹配标签：{similarTagsSummary}
-              </span>
-            )}
-          </div>
-          <Table
-            size="small"
-            rowKey="id"
-            columns={similarColumns}
-            dataSource={similarDatasets}
-            loading={similarDatasetsLoading}
-            pagination={false}
-            locale={{
-              emptyText: similarTags?.length
-                ? "暂无相似数据集"
-                : "当前数据集未设置标签",
-            }}
-          />
-        </div>
-
-        {/* 文件列表 */}
-        <div className="flex items-center justify-between mt-8 mb-2">
-          <h2 className="text-base font-semibold">文件列表</h2>
-          <div className="flex items-center gap-2">
-            <Button size="small" onClick={() => onUpload?.()}>
-              文件上传
-            </Button>
-            <Button
-              type="primary"
-              size="small"
-              onClick={() => {
-                let dirName = "";
-                modal.confirm({
-                  title: "新建文件夹",
-                  content: (
-                    <Input
-                      autoFocus
-                      placeholder="请输入文件夹名称"
-                      onChange={(e) => {
-                        dirName = e.target.value?.trim();
-                      }}
-                    />
-                  ),
-                  okText: "确定",
-                  cancelText: "取消",
-                  onOk: async () => {
-                    if (!dirName) {
-                      message.warning("请输入文件夹名称");
-                      return Promise.reject();
-                    }
-                    await handleCreateDirectory(dirName);
-                  },
-                });
-              }}
-            >
-              新建文件夹
-            </Button>
-          </div>
-        </div>
+        {/* 文件列表 */}
+        <div className="flex items-center justify-between mt-8 mb-2">
+          <h2 className="text-base font-semibold">文件列表</h2>
+          <div className="flex items-center gap-2">
+            <Button size="small" onClick={() => onUpload?.()}>
+              文件上传
+            </Button>
+            <Button
+              type="primary"
+              size="small"
+              onClick={() => {
+                let dirName = "";
+                modal.confirm({
+                  title: "新建文件夹",
+                  content: (
+                    <Input
+                      autoFocus
+                      placeholder="请输入文件夹名称"
+                      onChange={(e) => {
+                        dirName = e.target.value?.trim();
+                      }}
+                    />
+                  ),
+                  okText: "确定",
+                  cancelText: "取消",
+                  onOk: async () => {
+                    if (!dirName) {
+                      message.warning("请输入文件夹名称");
+                      return Promise.reject();
+                    }
+                    await handleCreateDirectory(dirName);
+                  },
+                });
+              }}
+            >
+              新建文件夹
+            </Button>
+          </div>
+        </div>
         {selectedFiles.length > 0 && (
           <div className="flex items-center gap-2 p-3 bg-blue-50 rounded-lg border border-blue-200">
             <span className="text-sm text-blue-700 font-medium">
@@ -511,63 +411,98 @@ export default function Overview({
           />
         </div>
       </div>
-      {/* 文件预览弹窗 */}
-      <Modal
-        title={`文件预览：${previewFileName}`}
-        open={previewVisible}
-        onCancel={closePreview}
-        footer={[
-          <Button key="close" onClick={closePreview}>
-            关闭
-          </Button>,
-        ]}
-        width={previewFileType === "text" ? PREVIEW_MODAL_WIDTH.text : PREVIEW_MODAL_WIDTH.media}
-      >
-        {previewFileType === "text" && (
-          <pre
-            style={{
-              maxHeight: `${PREVIEW_MAX_HEIGHT}px`,
-              overflow: "auto",
-              whiteSpace: "pre-wrap",
-              wordBreak: "break-all",
-              fontSize: PREVIEW_TEXT_FONT_SIZE,
-              color: "#222",
-              backgroundColor: "#f5f5f5",
-              padding: `${PREVIEW_TEXT_PADDING}px`,
-              borderRadius: "4px",
-            }}
-          >
-            {previewContent}
-          </pre>
+      {/* 文件预览弹窗 */}
+      <Modal
+        title={`文件预览：${previewFileName}`}
+        open={previewVisible}
+        onCancel={closePreview}
+        footer={[
+          <Button key="close" onClick={closePreview}>
+            关闭
+          </Button>,
+        ]}
+        width={previewFileType === "text" ? PREVIEW_MODAL_WIDTH.text : PREVIEW_MODAL_WIDTH.media}
+      >
+        {previewFileType === "text" && (
+          <pre
+            style={{
+              maxHeight: `${PREVIEW_MAX_HEIGHT}px`,
+              overflow: "auto",
+              whiteSpace: "pre-wrap",
+              wordBreak: "break-all",
+              fontSize: PREVIEW_TEXT_FONT_SIZE,
+              color: "#222",
+              backgroundColor: "#f5f5f5",
+              padding: `${PREVIEW_TEXT_PADDING}px`,
+              borderRadius: "4px",
+            }}
+          >
+            {previewContent}
+          </pre>
+        )}
+        {previewFileType === "image" && (
+          <div style={{ textAlign: "center" }}>
+            <img
+              src={previewMediaUrl}
+              alt={previewFileName}
+              style={{ maxWidth: "100%", maxHeight: `${PREVIEW_MAX_HEIGHT}px`, objectFit: "contain" }}
+            />
+          </div>
+        )}
+        {previewFileType === "pdf" && (
+          <>
+            {previewMediaUrl ? (
+              <iframe
+                src={previewMediaUrl}
+                title={previewFileName || "PDF 预览"}
+                style={{ width: "100%", height: `${PREVIEW_MAX_HEIGHT}px`, border: "none" }}
+              />
+            ) : (
+              <div
+                style={{
+                  height: `${PREVIEW_MAX_HEIGHT}px`,
+                  display: "flex",
+                  flexDirection: "column",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  gap: 12,
+                  color: "#666",
+                }}
+              >
+                {officePreviewStatus === "FAILED" ? (
+                  <>
+                    <div>转换失败</div>
+                    <div>{officePreviewError || "请稍后重试"}</div>
+                  </>
+                ) : (
+                  <>
+                    <Spin />
+                    <div>正在转换，请稍候...</div>
+                  </>
+                )}
+              </div>
+            )}
+          </>
         )}
-        {previewFileType === "image" && (
-          <div style={{ textAlign: "center" }}>
-            <img
-              src={previewMediaUrl}
-              alt={previewFileName}
-              style={{ maxWidth: "100%", maxHeight: `${PREVIEW_MAX_HEIGHT}px`, objectFit: "contain" }}
-            />
-          </div>
-        )}
-        {previewFileType === "video" && (
-          <div style={{ textAlign: "center" }}>
-            <video
-              src={previewMediaUrl}
-              controls
-              style={{ maxWidth: "100%", maxHeight: `${PREVIEW_MAX_HEIGHT}px` }}
-            >
-              您的浏览器不支持视频播放
-            </video>
-          </div>
-        )}
-        {previewFileType === "audio" && (
-          <div style={{ textAlign: "center", padding: `${PREVIEW_AUDIO_PADDING}px 0` }}>
-            <audio src={previewMediaUrl} controls style={{ width: "100%" }}>
-              您的浏览器不支持音频播放
-            </audio>
-          </div>
-        )}
-      </Modal>
-    </>
-  );
-}
+        {previewFileType === "video" && (
+          <div style={{ textAlign: "center" }}>
+            <video
+              src={previewMediaUrl}
+              controls
+              style={{ maxWidth: "100%", maxHeight: `${PREVIEW_MAX_HEIGHT}px` }}
+            >
+              您的浏览器不支持视频播放
+            </video>
+          </div>
+        )}
+        {previewFileType === "audio" && (
+          <div style={{ textAlign: "center", padding: `${PREVIEW_AUDIO_PADDING}px 0` }}>
+            <audio src={previewMediaUrl} controls style={{ width: "100%" }}>
+              您的浏览器不支持音频播放
+            </audio>
+          </div>
+        )}
+      </Modal>
+    </>
+  );
+}

frontend/src/pages/DataManagement/Detail/useFilesOperation.ts

@@ -1,22 +1,51 @@
-import type {
-  Dataset,
-  DatasetFile,
-} from "@/pages/DataManagement/dataset.model";
+import type {
+  Dataset,
+  DatasetFile,
+} from "@/pages/DataManagement/dataset.model";
 import { App } from "antd";
-import { useState } from "react";
-import { PREVIEW_TEXT_MAX_LENGTH, resolvePreviewFileType, truncatePreviewText } from "@/utils/filePreview";
-import {
-  deleteDatasetFileUsingDelete,
-  downloadFileByIdUsingGet,
-  exportDatasetUsingPost,
-  queryDatasetFilesUsingGet,
-  createDatasetDirectoryUsingPost,
-  downloadDirectoryUsingGet,
-  deleteDirectoryUsingDelete,
-} from "../dataset.api";
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  PREVIEW_TEXT_MAX_LENGTH,
+  resolvePreviewFileType,
+  truncatePreviewText,
+  type PreviewFileType,
+} from "@/utils/filePreview";
+import {
+  deleteDatasetFileUsingDelete,
+  downloadFileByIdUsingGet,
+  exportDatasetUsingPost,
+  queryDatasetFilesUsingGet,
+  createDatasetDirectoryUsingPost,
+  downloadDirectoryUsingGet,
+  deleteDirectoryUsingDelete,
+  queryDatasetFilePreviewStatusUsingGet,
+  convertDatasetFilePreviewUsingPost,
+} from "../dataset.api";
 import { useParams } from "react-router";
 
-
+const OFFICE_FILE_EXTENSIONS = [".doc", ".docx"];
+const OFFICE_PREVIEW_POLL_INTERVAL = 2000;
+const OFFICE_PREVIEW_POLL_MAX_TIMES = 60;
+
+type OfficePreviewStatus = "UNSET" | "PENDING" | "PROCESSING" | "READY" | "FAILED";
+
+const isOfficeFileName = (fileName?: string) => {
+  const lowerName = (fileName || "").toLowerCase();
+  return OFFICE_FILE_EXTENSIONS.some((ext) => lowerName.endsWith(ext));
+};
+
+const normalizeOfficePreviewStatus = (status?: string): OfficePreviewStatus => {
+  if (!status) {
+    return "UNSET";
+  }
+  const upper = status.toUpperCase();
+  if (upper === "PENDING" || upper === "PROCESSING" || upper === "READY" || upper === "FAILED") {
+    return upper as OfficePreviewStatus;
+  }
+  return "UNSET";
+};
+
+
 export function useFilesOperation(dataset: Dataset) {
   const { message } = App.useApp();
   const { id } = useParams(); // 获取动态路由参数
@@ -35,9 +64,26 @@ export function useFilesOperation(dataset: Dataset) {
   const [previewVisible, setPreviewVisible] = useState(false);
   const [previewContent, setPreviewContent] = useState("");
   const [previewFileName, setPreviewFileName] = useState("");
-  const [previewFileType, setPreviewFileType] = useState<"text" | "image" | "video" | "audio">("text");
+  const [previewFileType, setPreviewFileType] = useState<PreviewFileType>("text");
   const [previewMediaUrl, setPreviewMediaUrl] = useState("");
   const [previewLoading, setPreviewLoading] = useState(false);
+  const [officePreviewStatus, setOfficePreviewStatus] = useState<OfficePreviewStatus | null>(null);
+  const [officePreviewError, setOfficePreviewError] = useState("");
+  const officePreviewPollingRef = useRef<number | null>(null);
+  const officePreviewFileRef = useRef<string | null>(null);
+
+  const clearOfficePreviewPolling = useCallback(() => {
+    if (officePreviewPollingRef.current) {
+      window.clearTimeout(officePreviewPollingRef.current);
+      officePreviewPollingRef.current = null;
+    }
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      clearOfficePreviewPolling();
+    };
+  }, [clearOfficePreviewPolling]);
 
   const fetchFiles = async (
     prefix?: string,
@@ -52,6 +98,7 @@ export function useFilesOperation(dataset: Dataset) {
       size: pageSize !== undefined ? pageSize : pagination.pageSize,
       isWithDirectory: true,
       prefix: targetPrefix,
+      excludeDerivedFiles: true,
     };
 
     const { data } = await queryDatasetFilesUsingGet(id!, params);
@@ -105,22 +152,66 @@ export function useFilesOperation(dataset: Dataset) {
       return;
     }
 
+    const previewUrl = `/api/data-management/datasets/${datasetId}/files/${file.id}/preview`;
+    setPreviewFileName(file.fileName);
+    setPreviewContent("");
+    setPreviewMediaUrl("");
+
+    if (isOfficeFileName(file?.fileName)) {
+      setPreviewFileType("pdf");
+      setPreviewVisible(true);
+      setPreviewLoading(true);
+      setOfficePreviewStatus("PROCESSING");
+      setOfficePreviewError("");
+      officePreviewFileRef.current = file.id;
+      try {
+        const { data: statusData } = await queryDatasetFilePreviewStatusUsingGet(datasetId, file.id);
+        const currentStatus = normalizeOfficePreviewStatus(statusData?.status);
+        if (currentStatus === "READY") {
+          setPreviewMediaUrl(previewUrl);
+          setOfficePreviewStatus("READY");
+          setPreviewLoading(false);
+          return;
+        }
+        if (currentStatus === "PROCESSING") {
+          pollOfficePreviewStatus(datasetId, file.id, 0);
+          return;
+        }
+        const { data } = await convertDatasetFilePreviewUsingPost(datasetId, file.id);
+        const status = normalizeOfficePreviewStatus(data?.status);
+        if (status === "READY") {
+          setPreviewMediaUrl(previewUrl);
+          setOfficePreviewStatus("READY");
+        } else if (status === "FAILED") {
+          setOfficePreviewStatus("FAILED");
+          setOfficePreviewError(data?.previewError || "转换失败，请稍后重试");
+        } else {
+          setOfficePreviewStatus("PROCESSING");
+          pollOfficePreviewStatus(datasetId, file.id, 0);
+          return;
+        }
+      } catch (error) {
+        console.error("触发预览转换失败", error);
+        message.error({ content: "触发预览转换失败" });
+        setOfficePreviewStatus("FAILED");
+        setOfficePreviewError("触发预览转换失败");
+      } finally {
+        setPreviewLoading(false);
+      }
+      return;
+    }
+
     const fileType = resolvePreviewFileType(file?.fileName);
     if (!fileType) {
       message.warning({ content: "不支持预览该文件类型" });
       return;
     }
-
-    const fileUrl = `/api/data-management/datasets/${datasetId}/files/${file.id}/download`;
-    setPreviewFileName(file.fileName);
     setPreviewFileType(fileType);
-    setPreviewContent("");
-    setPreviewMediaUrl("");
 
     if (fileType === "text") {
       setPreviewLoading(true);
       try {
-        const response = await fetch(fileUrl);
+        const response = await fetch(previewUrl);
         if (!response.ok) {
           throw new Error("下载失败");
         }
@@ -136,18 +227,67 @@ export function useFilesOperation(dataset: Dataset) {
       return;
     }
 
-    setPreviewMediaUrl(fileUrl);
+    setPreviewMediaUrl(previewUrl);
     setPreviewVisible(true);
   };
 
   const closePreview = () => {
+    clearOfficePreviewPolling();
+    officePreviewFileRef.current = null;
     setPreviewVisible(false);
     setPreviewContent("");
     setPreviewMediaUrl("");
     setPreviewFileName("");
     setPreviewFileType("text");
+    setOfficePreviewStatus(null);
+    setOfficePreviewError("");
   };
 
+  const pollOfficePreviewStatus = useCallback(
+    async (datasetId: string, fileId: string, attempt: number) => {
+      clearOfficePreviewPolling();
+      officePreviewPollingRef.current = window.setTimeout(async () => {
+        if (officePreviewFileRef.current !== fileId) {
+          return;
+        }
+        try {
+          const { data } = await queryDatasetFilePreviewStatusUsingGet(datasetId, fileId);
+          const status = normalizeOfficePreviewStatus(data?.status);
+          if (status === "READY") {
+            setPreviewMediaUrl(`/api/data-management/datasets/${datasetId}/files/${fileId}/preview`);
+            setOfficePreviewStatus("READY");
+            setOfficePreviewError("");
+            setPreviewLoading(false);
+            return;
+          }
+          if (status === "FAILED") {
+            setOfficePreviewStatus("FAILED");
+            setOfficePreviewError(data?.previewError || "转换失败，请稍后重试");
+            setPreviewLoading(false);
+            return;
+          }
+          if (attempt >= OFFICE_PREVIEW_POLL_MAX_TIMES - 1) {
+            setOfficePreviewStatus("FAILED");
+            setOfficePreviewError("转换超时，请稍后重试");
+            setPreviewLoading(false);
+            return;
+          }
+          pollOfficePreviewStatus(datasetId, fileId, attempt + 1);
+        } catch (error) {
+          console.error("轮询预览状态失败", error);
+          if (attempt >= OFFICE_PREVIEW_POLL_MAX_TIMES - 1) {
+            setOfficePreviewStatus("FAILED");
+            setOfficePreviewError("转换超时，请稍后重试");
+            setPreviewLoading(false);
+            return;
+          }
+          pollOfficePreviewStatus(datasetId, fileId, attempt + 1);
+        }
+      }, OFFICE_PREVIEW_POLL_INTERVAL);
+    },
+    [clearOfficePreviewPolling]
+  );
+
   const handleDeleteFile = async (file: DatasetFile) => {
     try {
       await deleteDatasetFileUsingDelete(dataset.id, file.id);
@@ -190,6 +330,8 @@ export function useFilesOperation(dataset: Dataset) {
     previewFileType,
     previewMediaUrl,
     previewLoading,
+    officePreviewStatus,
+    officePreviewError,
     closePreview,
     fetchFiles,
     setFileList,
@@ -240,4 +382,5 @@ interface DatasetFilesQueryParams {
   size: number;
   isWithDirectory: boolean;
   prefix: string;
+  excludeDerivedFiles?: boolean;
 }

frontend/src/pages/DataManagement/Home/DataManagement.tsx

@@ -8,8 +8,8 @@ import {
 } from "@ant-design/icons";
 import TagManager from "@/components/business/TagManagement";
 import { Link, useNavigate } from "react-router";
-import { useEffect, useMemo, useState } from "react";
-import type { ReactNode } from "react";
+import { useEffect, useMemo, useState } from "react";
+import type { ReactNode } from "react";
 import { SearchControls } from "@/components/SearchControls";
 import CardView from "@/components/CardView";
 import type { Dataset } from "@/pages/DataManagement/dataset.model";
@@ -36,19 +36,19 @@ export default function DatasetManagementPage() {
   const [editDatasetOpen, setEditDatasetOpen] = useState(false);
   const [currentDataset, setCurrentDataset] = useState<Dataset | null>(null);
   const [showUploadDialog, setShowUploadDialog] = useState(false);
-  const [statisticsData, setStatisticsData] = useState<StatisticsData>({
-    count: [],
-    size: [],
-  });
+  const [statisticsData, setStatisticsData] = useState<StatisticsData>({
+    count: [],
+    size: [],
+  });
 
   async function fetchStatistics() {
     const { data } = await getDatasetStatisticsUsingGet();
 
-    const statistics: StatisticsData = {
-      size: [
-        {
-          title: "数据集总数",
-          value: data?.totalDatasets || 0,
+    const statistics: StatisticsData = {
+      size: [
+        {
+          title: "数据集总数",
+          value: data?.totalDatasets || 0,
         },
         {
           title: "文件总数",
@@ -76,10 +76,10 @@ export default function DatasetManagementPage() {
           title: "视频",
           value: data?.count?.video || 0,
         },
-      ],
-    };
-    setStatisticsData(statistics);
-  }
+      ],
+    };
+    setStatisticsData(statistics);
+  }
 
   const [tags, setTags] = useState<string[]>([]);
 
@@ -136,9 +136,9 @@ export default function DatasetManagementPage() {
     message.success("数据集下载成功");
   };
 
-  const handleDeleteDataset = async (id: string) => {
-    if (!id) return;
-    await deleteDatasetByIdUsingDelete(id);
+  const handleDeleteDataset = async (id: string) => {
+    if (!id) return;
+    await deleteDatasetByIdUsingDelete(id);
     fetchData({ pageOffset: 0 });
     message.success("数据删除成功");
   };
@@ -223,12 +223,12 @@ export default function DatasetManagementPage() {
       title: "状态",
       dataIndex: "status",
       key: "status",
-      render: (status: DatasetStatusMeta) => {
-        return (
-          <Tag icon={status?.icon} color={status?.color}>
-            {status?.label}
-          </Tag>
-        );
+      render: (status: DatasetStatusMeta) => {
+        return (
+          <Tag icon={status?.icon} color={status?.color}>
+            {status?.label}
+          </Tag>
+        );
       },
       width: 120,
     },
@@ -274,10 +274,10 @@ export default function DatasetManagementPage() {
       key: "actions",
       width: 200,
       fixed: "right",
-      render: (_: unknown, record: Dataset) => (
-        <div className="flex items-center gap-2">
-          {operations.map((op) => (
-            <Tooltip key={op.key} title={op.label}>
+      render: (_: unknown, record: Dataset) => (
+        <div className="flex items-center gap-2">
+          {operations.map((op) => (
+            <Tooltip key={op.key} title={op.label}>
               <Button
                 type="text"
                 icon={op.icon}
@@ -329,7 +329,7 @@ export default function DatasetManagementPage() {
     <div className="gap-4 h-full flex flex-col">
       {/* Header */}
       <div className="flex items-center justify-between">
-        <h1 className="text-xl font-bold">数据管理</h1>
+        <h1 className="text-xl font-bold">数据集统计</h1>
         <div className="flex gap-2 items-center">
           {/* tasks */}
           <TagManager
@@ -353,13 +353,13 @@ export default function DatasetManagementPage() {
       <div className="grid grid-cols-1 gap-4">
         <Card>
           <div className="grid grid-cols-3">
-            {statisticsData.size.map((item) => (
-              <Statistic
-                title={item.title}
-                key={item.title}
-                value={`${item.value}`}
-              />
-            ))}
+            {statisticsData.size.map((item) => (
+              <Statistic
+                title={item.title}
+                key={item.title}
+                value={`${item.value}`}
+              />
+            ))}
           </div>
         </Card>
       </div>
@@ -396,22 +396,22 @@ export default function DatasetManagementPage() {
         updateEvent="update:datasets"
       />
     </div>
-  );
-}
-
-type StatisticsItem = {
-  title: string;
-  value: number | string;
-};
-
-type StatisticsData = {
-  count: StatisticsItem[];
-  size: StatisticsItem[];
-};
-
-type DatasetStatusMeta = {
-  label: string;
-  value: string;
-  color: string;
-  icon: ReactNode;
-};
+  );
+}
+
+type StatisticsItem = {
+  title: string;
+  value: number | string;
+};
+
+type StatisticsData = {
+  count: StatisticsItem[];
+  size: StatisticsItem[];
+};
+
+type DatasetStatusMeta = {
+  label: string;
+  value: string;
+  color: string;
+  icon: ReactNode;
+};

frontend/src/pages/DataManagement/dataset.api.ts

@@ -107,17 +107,33 @@ export function deleteDirectoryUsingDelete(
   return del(`/api/data-management/datasets/${id}/files/directories?prefix=${encodeURIComponent(directoryPath)}`);
 }
 
-export function downloadFileByIdUsingGet(
-  id: string | number,
-  fileId: string | number,
-  fileName: string
-) {
-  return download(
-    `/api/data-management/datasets/${id}/files/${fileId}/download`,
-    null,
-    fileName
-  );
-}
+export function downloadFileByIdUsingGet(
+  id: string | number,
+  fileId: string | number,
+  fileName: string
+) {
+  return download(
+    `/api/data-management/datasets/${id}/files/${fileId}/download`,
+    null,
+    fileName
+  );
+}
+
+// 数据集文件预览状态
+export function queryDatasetFilePreviewStatusUsingGet(
+  datasetId: string | number,
+  fileId: string | number
+) {
+  return get(`/api/data-management/datasets/${datasetId}/files/${fileId}/preview/status`);
+}
+
+// 触发数据集文件预览转换
+export function convertDatasetFilePreviewUsingPost(
+  datasetId: string | number,
+  fileId: string | number
+) {
+  return post(`/api/data-management/datasets/${datasetId}/files/${fileId}/preview/convert`, {});
+}
 
 // 删除数据集文件
 export function deleteDatasetFileUsingDelete(

frontend/src/pages/DataManagement/dataset.model.ts

@@ -34,10 +34,12 @@ export enum DataSource {
 
 export interface DatasetFile {
   id: string;
+  datasetId?: string;
   fileName: string;
   size: string;
   uploadDate: string;
   path: string;
+  filePath?: string;
 }
 
 export interface Dataset {
@@ -100,6 +102,13 @@ export interface DatasetTask {
   executionHistory?: { time: string; status: string }[];
 }
 
+export interface StreamUploadInfo {
+  currentFile: string;
+  fileIndex: number;
+  totalFiles: number;
+  uploadedLines: number;
+}
+
 export interface TaskItem {
   key: string;
   title: string;
@@ -111,4 +120,6 @@ export interface TaskItem {
   updateEvent?: string;
   size?: number;
   hasArchive?: boolean;
+  prefix?: string;
+  streamUploadInfo?: StreamUploadInfo;
 }

frontend/src/pages/KnowledgeBase/Detail/KnowledgeBaseDetail.tsx

@@ -1,12 +1,23 @@
 import type React from "react";
-import { useEffect, useState } from "react";
-import { Table, Badge, Button, Breadcrumb, Tooltip, App, Card, Input, Empty, Spin } from "antd";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+  Table,
+  Badge,
+  Button,
+  Breadcrumb,
+  Tooltip,
+  App,
+  Card,
+  Input,
+  Empty,
+  Spin,
+} from "antd";
 import {
   DeleteOutlined,
   EditOutlined,
   ReloadOutlined,
 } from "@ant-design/icons";
-import { useNavigate, useParams } from "react-router";
+import { useNavigate, useParams, useSearchParams } from "react-router";
 import DetailHeader from "@/components/DetailHeader";
 import { SearchControls } from "@/components/SearchControls";
 import { KBFile, KnowledgeBaseItem } from "../knowledge-base.model";
@@ -18,9 +29,9 @@ import {
   queryKnowledgeBaseFilesUsingGet,
   retrieveKnowledgeBaseContent,
 } from "../knowledge-base.api";
-import useFetchData from "@/hooks/useFetchData";
 import AddDataDialog from "../components/AddDataDialog";
 import CreateKnowledgeBase from "../components/CreateKnowledgeBase";
+import { File, Folder } from "lucide-react";
 
 interface StatisticItem {
   icon?: React.ReactNode;
@@ -39,44 +50,127 @@ interface RecallResult {
   primaryKey?: string;
 }
 
+type KBFileRow = KBFile & {
+  isDirectory?: boolean;
+  displayName?: string;
+  fullPath?: string;
+  fileCount?: number;
+};
+
+const PATH_SEPARATOR = "/";
+const normalizePath = (value?: string) =>
+  (value ?? "").replace(/\\/g, PATH_SEPARATOR);
+
+const normalizePrefix = (value?: string) => {
+  const trimmed = normalizePath(value).replace(/^\/+/, "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.endsWith(PATH_SEPARATOR)
+    ? trimmed
+    : `${trimmed}${PATH_SEPARATOR}`;
+};
+
+const splitRelativePath = (fullPath: string, prefix: string) => {
+  if (prefix && !fullPath.startsWith(prefix)) {
+    return [];
+  }
+  const remainder = fullPath.slice(prefix.length);
+  return remainder.split(PATH_SEPARATOR).filter(Boolean);
+};
+
+const resolveFileRelativePath = (file: KBFile) => {
+  const rawPath = file.relativePath || file.fileName || file.name || "";
+  return normalizePath(rawPath).replace(/^\/+/, "");
+};
+
 const KnowledgeBaseDetailPage: React.FC = () => {
   const navigate = useNavigate();
+  const [searchParams] = useSearchParams();
   const { message } = App.useApp();
   const { id } = useParams<{ id: string }>();
   const [knowledgeBase, setKnowledgeBase] = useState<KnowledgeBaseItem | undefined>(undefined);
   const [showEdit, setShowEdit] = useState(false);
   const [activeTab, setActiveTab] = useState<'fileList' | 'recallTest'>('fileList');
+  const [filePrefix, setFilePrefix] = useState("");
+  const [fileKeyword, setFileKeyword] = useState("");
+  const [filesLoading, setFilesLoading] = useState(false);
+  const [allFiles, setAllFiles] = useState<KBFile[]>([]);
+  const [filePagination, setFilePagination] = useState({
+    current: 1,
+    pageSize: 10,
+  });
   const [recallLoading, setRecallLoading] = useState(false);
   const [recallResults, setRecallResults] = useState<RecallResult[]>([]);
   const [recallQuery, setRecallQuery] = useState("");
 
-  const fetchKnowledgeBaseDetails = async (id: string) => {
-    const { data } = await queryKnowledgeBaseByIdUsingGet(id);
+  const fetchKnowledgeBaseDetails = useCallback(async (baseId: string) => {
+    const { data } = await queryKnowledgeBaseByIdUsingGet(baseId);
     setKnowledgeBase(mapKnowledgeBase(data));
-  };
+  }, []);
+
+  const fetchFiles = useCallback(async () => {
+    if (!id) {
+      setAllFiles([]);
+      return;
+    }
+    setFilesLoading(true);
+    try {
+      const pageSize = 200;
+      let page = 0;
+      let combined: KBFile[] = [];
+      const currentPrefix = normalizePrefix(filePrefix);
+      const keyword = fileKeyword.trim();
+      while (true) {
+        const { data } = await queryKnowledgeBaseFilesUsingGet(id, {
+          page,
+          size: pageSize,
+          ...(currentPrefix ? { relativePath: currentPrefix } : {}),
+          ...(keyword ? { fileName: keyword } : {}),
+        });
+        const content = Array.isArray(data?.content) ? data.content : [];
+        combined = combined.concat(content.map(mapFileData));
+        if (content.length < pageSize) {
+          break;
+        }
+        if (typeof data?.totalElements === "number" && combined.length >= data.totalElements) {
+          break;
+        }
+        page += 1;
+      }
+      setAllFiles(combined);
+    } catch (error) {
+      console.error("Failed to fetch knowledge base files:", error);
+      message.error("文件列表加载失败");
+    } finally {
+      setFilesLoading(false);
+    }
+  }, [id, filePrefix, fileKeyword, message]);
 
   useEffect(() => {
     if (id) {
       fetchKnowledgeBaseDetails(id);
     }
-  }, [id]);
+  }, [id, fetchKnowledgeBaseDetails]);
 
-  const {
-    loading,
-    tableData: files,
-    searchParams,
-    pagination,
-    fetchData: fetchFiles,
-    setSearchParams,
-    handleFiltersChange,
-    handleKeywordChange,
-  } = useFetchData<KBFile>(
-    (params) => id ? queryKnowledgeBaseFilesUsingGet(id, params) : Promise.resolve({ data: [] }),
-    mapFileData
-  );
+  useEffect(() => {
+    if (!id) {
+      return;
+    }
+    const prefixParam = searchParams.get("prefix");
+    const fileNameParam = searchParams.get("fileName");
+    setFilePrefix(prefixParam ? normalizePrefix(prefixParam) : "");
+    setFileKeyword(fileNameParam ? fileNameParam : "");
+  }, [id, searchParams]);
+
+  useEffect(() => {
+    if (id) {
+      fetchFiles();
+    }
+  }, [id, fetchFiles]);
 
   // File table logic
-  const handleDeleteFile = async (file: KBFile) => {
+  const handleDeleteFile = async (file: KBFileRow) => {
     try {
       await deleteKnowledgeBaseFileByIdUsingDelete(knowledgeBase!.id, {
         ids: [file.id]
@@ -119,6 +213,152 @@ const KnowledgeBaseDetailPage: React.FC = () => {
     setRecallLoading(false);
   };
 
+  const handleOpenDirectory = (directoryName: string) => {
+    const currentPrefix = normalizePrefix(filePrefix);
+    const nextPrefix = normalizePrefix(`${currentPrefix}${directoryName}`);
+    setFilePrefix(nextPrefix);
+  };
+
+  const handleBackToParent = () => {
+    const currentPrefix = normalizePrefix(filePrefix);
+    if (!currentPrefix) {
+      return;
+    }
+    const trimmed = currentPrefix.replace(/\/$/, "");
+    const parts = trimmed.split(PATH_SEPARATOR).filter(Boolean);
+    parts.pop();
+    const parentPrefix = parts.length
+      ? `${parts.join(PATH_SEPARATOR)}${PATH_SEPARATOR}`
+      : "";
+    setFilePrefix(parentPrefix);
+  };
+
+  const handleDeleteDirectory = async (directoryName: string) => {
+    if (!knowledgeBase?.id) {
+      return;
+    }
+    const currentPrefix = normalizePrefix(filePrefix);
+    const directoryPrefix = normalizePrefix(`${currentPrefix}${directoryName}`);
+    const targetIds = allFiles
+      .filter((file) => {
+        const fullPath = resolveFileRelativePath(file);
+        return fullPath.startsWith(directoryPrefix);
+      })
+      .map((file) => file.id);
+    if (targetIds.length === 0) {
+      message.info("该文件夹为空");
+      return;
+    }
+    try {
+      await deleteKnowledgeBaseFileByIdUsingDelete(knowledgeBase.id, {
+        ids: targetIds,
+      });
+      message.success(`已删除 ${targetIds.length} 个文件`);
+      fetchFiles();
+    } catch {
+      message.error("文件夹删除失败");
+    }
+  };
+
+  const handleKeywordChange = (keyword: string) => {
+    setFileKeyword(keyword);
+  };
+
+  useEffect(() => {
+    setFilePagination((prev) => ({ ...prev, current: 1 }));
+  }, [filePrefix, fileKeyword]);
+
+  const normalizedPrefix = useMemo(() => normalizePrefix(filePrefix), [filePrefix]);
+
+  const { rows: fileRows, total: fileTotal } = useMemo(() => {
+    const folderMap = new Map<string, { name: string; fileCount: number }>();
+    const fileItems: KBFileRow[] = [];
+
+    allFiles.forEach((file) => {
+      const fullPath = resolveFileRelativePath(file);
+      if (!fullPath) {
+        return;
+      }
+      const segments = splitRelativePath(fullPath, normalizedPrefix);
+      if (segments.length === 0) {
+        return;
+      }
+      const leafName = segments[0];
+
+      if (segments.length > 1) {
+        const folderName = leafName;
+        const entry = folderMap.get(folderName) || {
+          name: folderName,
+          fileCount: 0,
+        };
+        entry.fileCount += 1;
+        folderMap.set(folderName, entry);
+        return;
+      }
+
+      const normalizedFileName = normalizePath(file.fileName);
+      const displayName = normalizedFileName.includes(PATH_SEPARATOR)
+        ? leafName
+        : file.fileName || leafName;
+      fileItems.push({
+        ...file,
+        name: displayName,
+        displayName,
+        fullPath,
+      });
+    });
+
+    const folderItems: KBFileRow[] = Array.from(folderMap.values()).map(
+      (entry) =>
+        ({
+          id: `directory-${normalizedPrefix}${entry.name}`,
+          fileName: entry.name,
+          name: entry.name,
+          status: null,
+          chunkCount: 0,
+          createdAt: "",
+          updatedAt: "",
+          metadata: {},
+          knowledgeBaseId: knowledgeBase?.id || "",
+          fileId: "",
+          updatedBy: "",
+          createdBy: "",
+          isDirectory: true,
+          displayName: entry.name,
+          fullPath: `${normalizedPrefix}${entry.name}/`,
+          fileCount: entry.fileCount,
+        }) as KBFileRow
+    );
+
+    const sortByName = (a: KBFileRow, b: KBFileRow) =>
+      (a.displayName || a.name || "").localeCompare(
+        b.displayName || b.name || "",
+        "zh-Hans-CN"
+      );
+
+    folderItems.sort(sortByName);
+    fileItems.sort(sortByName);
+
+    const combined = [...folderItems, ...fileItems];
+    return { rows: combined, total: combined.length };
+  }, [allFiles, knowledgeBase?.id, normalizedPrefix]);
+
+  const filePageCurrent = filePagination.current;
+  const filePageSize = filePagination.pageSize;
+
+  const pagedFileRows = useMemo(() => {
+    const startIndex = (filePageCurrent - 1) * filePageSize;
+    const endIndex = startIndex + filePageSize;
+    return fileRows.slice(startIndex, endIndex);
+  }, [filePageCurrent, filePageSize, fileRows]);
+
+  useEffect(() => {
+    const maxPage = Math.max(1, Math.ceil(fileTotal / filePageSize));
+    if (filePageCurrent > maxPage) {
+      setFilePagination((prev) => ({ ...prev, current: maxPage }));
+    }
+  }, [filePageCurrent, filePageSize, fileTotal]);
+
   const operations = [
     {
       key: "edit",
@@ -170,14 +410,38 @@ const KnowledgeBaseDetailPage: React.FC = () => {
       width: 200,
       ellipsis: true,
       fixed: "left" as const,
+      render: (name: string, record: KBFileRow) => {
+        const displayName = record.displayName || name;
+        if (record.isDirectory) {
+          return (
+            <Button
+              type="link"
+              onClick={() => handleOpenDirectory(displayName)}
+              className="flex items-center gap-2 p-0"
+            >
+              <Folder className="w-4 h-4 text-blue-500" />
+              <span className="truncate">{displayName}</span>
+            </Button>
+          );
+        }
+        return (
+          <div className="flex items-center gap-2">
+            <File className="w-4 h-4 text-gray-800" />
+            <span className="truncate">{displayName}</span>
+          </div>
+        );
+      },
     },
     {
       title: "状态",
       dataIndex: "status",
       key: "vectorizationStatus",
       width: 120,
-      render: (status: unknown) => {
-        if (typeof status === 'object' && status !== null) {
+      render: (status: unknown, record: KBFileRow) => {
+        if (record.isDirectory) {
+          return <Badge color="default" text="文件夹" />;
+        }
+        if (typeof status === "object" && status !== null) {
           const s = status as { color?: string; label?: string };
           return <Badge color={s.color} text={s.label} />;
         }
@@ -190,6 +454,8 @@ const KnowledgeBaseDetailPage: React.FC = () => {
       key: "chunkCount",
       width: 100,
       ellipsis: true,
+      render: (value: number, record: KBFileRow) =>
+        record.isDirectory ? "-" : value ?? 0,
     },
     {
       title: "创建时间",
@@ -197,6 +463,8 @@ const KnowledgeBaseDetailPage: React.FC = () => {
       key: "createdAt",
       ellipsis: true,
       width: 180,
+      render: (value: string, record: KBFileRow) =>
+        record.isDirectory ? "-" : value || "-",
     },
     {
       title: "更新时间",
@@ -204,26 +472,51 @@ const KnowledgeBaseDetailPage: React.FC = () => {
       key: "updatedAt",
       ellipsis: true,
       width: 180,
+      render: (value: string, record: KBFileRow) =>
+        record.isDirectory ? "-" : value || "-",
     },
     {
       title: "操作",
       key: "actions",
       align: "right" as const,
       width: 100,
-      render: (_: unknown, file: KBFile) => (
-        <div>
-          {fileOps.map((op) => (
-            <Tooltip key={op.key} title={op.label}>
+      render: (_: unknown, file: KBFileRow) => {
+        if (file.isDirectory) {
+          return (
+            <Tooltip title="删除文件夹">
               <Button
                 type="text"
-                icon={op.icon}
-                danger={op?.danger}
-                onClick={() => op.onClick(file)}
+                icon={<DeleteOutlined className="w-4 h-4" />}
+                danger
+                onClick={() => {
+                  modal.confirm({
+                    title: "确认删除该文件夹吗？",
+                    content: `删除后将移除文件夹 “${file.displayName || file.name}” 下的全部文件，且无法恢复。`,
+                    okText: "删除",
+                    okType: "danger",
+                    cancelText: "取消",
+                    onOk: () => handleDeleteDirectory(file.displayName || file.name),
+                  });
+                }}
               />
             </Tooltip>
-          ))}
-        </div>
-      ),
+          );
+        }
+        return (
+          <div>
+            {fileOps.map((op) => (
+              <Tooltip key={op.key} title={op.label}>
+                <Button
+                  type="text"
+                  icon={op.icon}
+                  danger={op?.danger}
+                  onClick={() => op.onClick(file)}
+                />
+              </Tooltip>
+            ))}
+          </div>
+        );
+      },
     },
   ];
 
@@ -265,12 +558,12 @@ const KnowledgeBaseDetailPage: React.FC = () => {
             <>
               <div className="flex-1">
                 <SearchControls
-                  searchTerm={searchParams.keyword}
+                  searchTerm={fileKeyword}
                   onSearchChange={handleKeywordChange}
                   searchPlaceholder="搜索文件名..."
                   filters={[]}
-                  onFiltersChange={handleFiltersChange}
-                  onClearFilters={() => setSearchParams({ ...searchParams, filter: { type: [], status: [], tags: [] } })}
+                  onFiltersChange={() => {}}
+                  onClearFilters={() => setFileKeyword("")}
                   showViewToggle={false}
                   showReload={false}
                 />
@@ -281,14 +574,54 @@ const KnowledgeBaseDetailPage: React.FC = () => {
         </div>
 
         {activeTab === 'fileList' ? (
-          <Table
-            loading={loading}
-            columns={fileColumns}
-            dataSource={files}
-            rowKey="id"
-            pagination={pagination}
-            scroll={{ y: "calc(100vh - 30rem)" }}
-          />
+          <>
+            <div className="mb-2">
+              {normalizedPrefix && (
+                <Button type="link" onClick={handleBackToParent} className="p-0">
+                  <span className="flex items-center text-blue-500">
+                    <svg
+                      className="w-4 h-4 mr-1"
+                      fill="none"
+                      stroke="currentColor"
+                      viewBox="0 0 24 24"
+                      xmlns="http://www.w3.org/2000/svg"
+                    >
+                      <path
+                        strokeLinecap="round"
+                        strokeLinejoin="round"
+                        strokeWidth={2}
+                        d="M10 19l-7-7m0 0l7-7m-7 7h18"
+                      />
+                    </svg>
+                    返回上一级
+                  </span>
+                </Button>
+              )}
+              {normalizedPrefix && (
+                <span className="ml-2 text-gray-600">
+                  当前路径: {normalizedPrefix}
+                </span>
+              )}
+            </div>
+            <Table
+              loading={filesLoading}
+              columns={fileColumns}
+              dataSource={pagedFileRows}
+              rowKey="id"
+              pagination={{
+                current: filePagination.current,
+                pageSize: filePagination.pageSize,
+                total: fileTotal,
+                showTotal: (total) => `共 ${total} 条`,
+                onChange: (page, pageSize) =>
+                  setFilePagination({
+                    current: page,
+                    pageSize: pageSize || filePagination.pageSize,
+                  }),
+              }}
+              scroll={{ y: "calc(100vh - 30rem)" }}
+            />
+          </>
         ) : (
           <div className="p-2">
             <div style={{ fontSize: 14, fontWeight: 300, marginBottom: 8 }}>基于语义文本检索和全文检索后的加权平均结果</div>