@lobehub/lobehub 2.0.0-next.54 → 2.0.0-next.56

package/src/locales/default/file.ts

@@ -1,5 +1,8 @@
 export default {
-  desc: '管理你的知识',
+  addFolder: '创建文件夹',
+  addKnowledge: '添加知识',
+  addPage: '创建文稿',
+  desc: '管理你的工作、学习与生活知识。',
   detail: {
     basic: {
       createdAt: '创建时间',
@@ -21,15 +24,89 @@ export default {
       embeddingStatus: '向量化',
     },
   },
+  documentEditor: {
+    addIcon: '添加图标',
+    autoSaveMessage: '文档会自动保存，无需手动保存',
+    chooseIcon: '选择图标',
+    deleteConfirm: {
+      content: '即将删除该文档，删除后将不可恢复，请谨慎操作。',
+      title: '删除文档',
+    },
+    deleteError: '删除文档失败',
+    deleteSuccess: '文档删除成功',
+    editedAt: '最后编辑于 {{time}}',
+    editedBy: '最后编辑者 {{name}}',
+    editorPlaceholder: '输入文档内容，按 / 打开命令菜单',
+    empty: {
+      createNewDocument: '创建新文档',
+      title: '选择一个文档以开始',
+      uploadMarkdown: '上传 Markdown 文件',
+    },
+    linkCopied: '链接已复制',
+    menu: {
+      copyLink: '复制链接',
+      exportDocument: '导出文档',
+      importDocument: '导入文档',
+      pin: '置顶文档',
+    },
+    saving: '保存中...',
+    titlePlaceholder: '无标题',
+    wordCount: '{{wordCount}} 字',
+  },
+  documentList: {
+    copyContent: '复制全文',
+    documentCount: '共 {{count}} 个文档',
+    duplicate: '创建副本',
+    empty: '暂无文档，点击上方按钮创建你的第一篇文档',
+    noResults: '未找到匹配的文档',
+    selectNote: '选择一个文档开始编辑',
+    untitled: '无标题',
+  },
   empty: '暂无已上传文件/文件夹',
   header: {
     actions: {
       newFolder: '新建文件夹',
+      newPage: '新建文稿',
       uploadFile: '上传文件',
       uploadFolder: '上传文件夹',
     },
+    newDocumentButton: '新建文档',
+    newNoteDialog: {
+      cancel: '取消',
+      editTitle: '编辑文档',
+      emptyContent: '文档内容不能为空',
+      loadError: '加载文档失败,请重试',
+      loading: '加载中...',
+      save: '保存',
+      saveError: '保存文档失败,请重试',
+      saveSuccess: '文档保存成功',
+      title: '新建文档',
+      updateSuccess: '文档更新成功',
+    },
     uploadButton: '上传',
   },
+  home: {
+    getStarted: '开始使用',
+    greeting: '开始',
+    quickActions: '快捷操作',
+    recentDocuments: '最近文档',
+    recentFiles: '最近文件',
+    subtitle: '欢迎使用知识库，从这里开始管理你的文档和文档',
+    uploadEntries: {
+      files: {
+        title: '上传文件',
+      },
+      folder: {
+        title: '上传文件夹',
+      },
+      knowledgeBase: {
+        title: '新建知识库',
+      },
+      newDocument: {
+        title: '新建文档',
+      },
+    },
+  },
   knowledgeBase: {
     list: {
       confirmRemoveKnowledgeBase:
@@ -39,6 +116,10 @@ export default {
     new: '新建知识库',
     title: '知识库',
   },
+  menu: {
+    allDocuments: '全部文档',
+    allFiles: '全部文件',
+  },
   networkError: '获取知识库失败，请检测网络连接后重试',
   notSupportGuide: {
     desc: '当前部署实例为客户端数据库模式，无法使用文件管理功能。请切换到<1>服务端数据库部署模式</1>，或直接使用 <3>LobeChat Cloud</3>',
@@ -62,12 +143,16 @@ export default {
     downloadFile: '下载文件',
     unsupportedFileAndContact: '此文件格式暂不支持在线预览，如有预览诉求，欢迎<1>反馈给我们</1>',
   },
+  searchDocumentPlaceholder: '搜索文档',
   searchFilePlaceholder: '搜索文件',
   tab: {
-    all: '全部文件',
+    all: '全部',
     audios: '语音',
     documents: '文档',
+    home: '首页',
     images: '图片',
+    moreTypes: '更多类型',
+    pages: '文稿',
     videos: '视频',
     websites: '网页',
   },

package/src/server/routers/lambda/__tests__/file.test.ts

@@ -39,13 +39,21 @@ function createCallerWithCtx(partialCtx: any = {}) {
     delete: vi.fn(),
   };
 
+  const knowledgeRepo = {
+    query: vi.fn().mockResolvedValue([]),
+  };
+
+  const documentModel = {};
+
   const ctx = {
     serverDB: {} as any,
     userId: 'test-user',
     asyncTaskModel,
     chunkModel,
+    documentModel,
     fileModel,
     fileService,
+    knowledgeRepo,
     ...partialCtx,
   };
 
@@ -58,18 +66,24 @@ vi.mock('@/config/db', () => ({
   },
 }));
 
+const mockAsyncTaskFindByIds = vi.fn();
+const mockAsyncTaskFindById = vi.fn();
+const mockAsyncTaskDelete = vi.fn();
+const mockChunkCountByFileIds = vi.fn();
+const mockChunkCountByFileId = vi.fn();
+
 vi.mock('@/database/models/asyncTask', () => ({
   AsyncTaskModel: vi.fn(() => ({
-    findById: vi.fn(),
-    findByIds: vi.fn(),
-    delete: vi.fn(),
+    delete: mockAsyncTaskDelete,
+    findById: mockAsyncTaskFindById,
+    findByIds: mockAsyncTaskFindByIds,
   })),
 }));
 
 vi.mock('@/database/models/chunk', () => ({
   ChunkModel: vi.fn(() => ({
-    countByFileId: vi.fn(),
-    countByFileIds: vi.fn(),
+    countByFileId: mockChunkCountByFileId,
+    countByFileIds: mockChunkCountByFileIds,
   })),
 }));
 
@@ -85,14 +99,28 @@ vi.mock('@/database/models/file', () => ({
   })),
 }));
 
+const mockFileServiceGetFullFileUrl = vi.fn();
+
 vi.mock('@/server/services/file', () => ({
   FileService: vi.fn(() => ({
-    getFullFileUrl: vi.fn(),
     deleteFile: vi.fn(),
     deleteFiles: vi.fn(),
+    getFullFileUrl: mockFileServiceGetFullFileUrl,
   })),
 }));
 
+const mockKnowledgeRepoQuery = vi.fn().mockResolvedValue([]);
+
+vi.mock('@/database/repositories/knowledge', () => ({
+  KnowledgeRepo: vi.fn(() => ({
+    query: mockKnowledgeRepoQuery,
+  })),
+}));
+
+vi.mock('@/database/models/document', () => ({
+  DocumentModel: vi.fn(() => ({})),
+}));
+
 describe('fileRouter', () => {
   let ctx: any;
   let caller: any;
@@ -169,6 +197,57 @@ describe('fileRouter', () => {
     });
   });
 
+  describe('getKnowledgeItems', () => {
+    it('should return knowledge items with files and documents', async () => {
+      const knowledgeItems = [
+        {
+          ...mockFile,
+          chunkTaskId: 'chunk-1',
+          embeddingTaskId: 'emb-1',
+          id: 'file-1',
+          sourceType: 'file' as const,
+        },
+        {
+          editorData: { content: 'test' },
+          id: 'doc-1',
+          name: 'Document 1',
+          sourceType: 'document' as const,
+        },
+      ];
+
+      mockKnowledgeRepoQuery.mockResolvedValue(knowledgeItems);
+      mockChunkCountByFileIds.mockResolvedValue([{ count: 10, id: 'file-1' }]);
+      mockAsyncTaskFindByIds
+        .mockResolvedValueOnce([{ error: null, id: 'chunk-1', status: AsyncTaskStatus.Success }])
+        .mockResolvedValueOnce([{ error: null, id: 'emb-1', status: AsyncTaskStatus.Success }]);
+      mockFileServiceGetFullFileUrl.mockResolvedValue('https://example.com/test-url');
+
+      const result = await caller.getKnowledgeItems({});
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toMatchObject({
+        chunkCount: 10,
+        chunkingStatus: AsyncTaskStatus.Success,
+        embeddingStatus: AsyncTaskStatus.Success,
+        finishEmbedding: true,
+        id: 'file-1',
+        sourceType: 'file',
+        url: 'https://example.com/test-url',
+      });
+      expect(result[1]).toMatchObject({
+        chunkCount: null,
+        chunkingError: null,
+        chunkingStatus: null,
+        editorData: { content: 'test' },
+        embeddingError: null,
+        embeddingStatus: null,
+        finishEmbedding: false,
+        id: 'doc-1',
+        name: 'Document 1',
+      });
+    });
+  });
+
   describe('removeFile', () => {
     it('should do nothing when file not found', async () => {
       ctx.fileModel.delete.mockResolvedValue(null);

package/src/server/routers/lambda/document.ts

@@ -21,6 +21,38 @@ const documentProcedure = authedProcedure.use(serverDatabase).use(async (opts) =
 });
 
 export const documentRouter = router({
+  createDocument: documentProcedure
+    .input(
+      z.object({
+        content: z.string().optional(),
+        editorData: z.string(),
+        fileType: z.string().optional(),
+        knowledgeBaseId: z.string().optional(),
+        metadata: z.record(z.any()).optional(),
+        title: z.string(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      // Parse editorData from JSON string to object
+      const editorData = JSON.parse(input.editorData);
+      return ctx.documentService.createDocument({
+        ...input,
+        editorData,
+      });
+    }),
+
+  deleteDocument: documentProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      return ctx.documentService.deleteDocument(input.id);
+    }),
+
+  getDocumentById: documentProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ ctx, input }) => {
+      return ctx.documentService.getDocumentById(input.id);
+    }),
+
   parseFileContent: documentProcedure
     .input(
       z.object({
@@ -33,4 +65,29 @@ export const documentRouter = router({
 
       return lobeDocument;
     }),
+
+  queryDocuments: documentProcedure.query(async ({ ctx }) => {
+    return ctx.documentService.queryDocuments();
+  }),
+
+  updateDocument: documentProcedure
+    .input(
+      z.object({
+        content: z.string().optional(),
+        editorData: z.string().optional(),
+        id: z.string(),
+        metadata: z.record(z.any()).optional(),
+        rawData: z.string().optional(),
+        title: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { id, editorData: editorDataString, ...params } = input;
+      // Parse editorData from JSON string to object if present
+      const editorData = editorDataString ? JSON.parse(editorDataString) : undefined;
+      return ctx.documentService.updateDocument(id, {
+        ...params,
+        editorData,
+      });
+    }),
 });

package/src/server/routers/lambda/file.ts

@@ -4,7 +4,9 @@ import { z } from 'zod';
 import { serverDBEnv } from '@/config/db';
 import { AsyncTaskModel } from '@/database/models/asyncTask';
 import { ChunkModel } from '@/database/models/chunk';
+import { DocumentModel } from '@/database/models/document';
 import { FileModel } from '@/database/models/file';
+import { KnowledgeRepo } from '@/database/repositories/knowledge';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { serverDatabase } from '@/libs/trpc/lambda/middleware';
 import { FileService } from '@/server/services/file';
@@ -18,8 +20,10 @@ const fileProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
     ctx: {
       asyncTaskModel: new AsyncTaskModel(ctx.serverDB, ctx.userId),
       chunkModel: new ChunkModel(ctx.serverDB, ctx.userId),
+      documentModel: new DocumentModel(ctx.serverDB, ctx.userId),
       fileModel: new FileModel(ctx.serverDB, ctx.userId),
       fileService: new FileService(ctx.serverDB, ctx.userId),
+      knowledgeRepo: new KnowledgeRepo(ctx.serverDB, ctx.userId),
     },
   });
 });
@@ -95,6 +99,8 @@ export const fileRouter = router({
         embeddingError: embeddingTask?.error,
         embeddingStatus: embeddingTask?.status as AsyncTaskStatus,
         finishEmbedding: embeddingTask?.status === AsyncTaskStatus.Success,
+        metadata: item.metadata as Record<string, any> | null | undefined,
+        sourceType: 'file' as const,
         url: await ctx.fileService.getFullFileUrl(item.url!),
       };
     }),
@@ -132,6 +138,7 @@ export const fileRouter = router({
         embeddingError: embeddingTask?.error ?? null,
         embeddingStatus: embeddingTask?.status as AsyncTaskStatus,
         finishEmbedding: embeddingTask?.status === AsyncTaskStatus.Success,
+        sourceType: 'file' as const,
         url: await ctx.fileService.getFullFileUrl(item.url!),
       } as FileListItem;
       resultFiles.push(fileItem);
@@ -140,6 +147,71 @@ export const fileRouter = router({
     return resultFiles;
   }),
 
+  getKnowledgeItems: fileProcedure.input(QueryFileListSchema).query(async ({ ctx, input }) => {
+    const knowledgeItems = await ctx.knowledgeRepo.query(input);
+
+    // Process files (add chunk info and async task status)
+    const fileItems = knowledgeItems.filter((item) => item.sourceType === 'file');
+    const fileIds = fileItems.map((item) => item.id);
+    const chunks = await ctx.chunkModel.countByFileIds(fileIds);
+
+    const chunkTaskIds = fileItems.map((item) => item.chunkTaskId).filter(Boolean) as string[];
+    const chunkTasks = await ctx.asyncTaskModel.findByIds(chunkTaskIds, AsyncTaskType.Chunking);
+
+    const embeddingTaskIds = fileItems
+      .map((item) => item.embeddingTaskId)
+      .filter(Boolean) as string[];
+    const embeddingTasks = await ctx.asyncTaskModel.findByIds(
+      embeddingTaskIds,
+      AsyncTaskType.Embedding,
+    );
+
+    // Combine all items with their metadata
+    const resultItems = [] as any[];
+    for (const item of knowledgeItems) {
+      if (item.sourceType === 'file') {
+        const chunkTask = item.chunkTaskId
+          ? chunkTasks.find((task) => task.id === item.chunkTaskId)
+          : null;
+        const embeddingTask = item.embeddingTaskId
+          ? embeddingTasks.find((task) => task.id === item.embeddingTaskId)
+          : null;
+
+        resultItems.push({
+          ...item,
+          chunkCount: chunks.find((chunk) => chunk.id === item.id)?.count ?? null,
+          chunkingError: chunkTask?.error ?? null,
+          chunkingStatus: chunkTask?.status as AsyncTaskStatus,
+          editorData: null,
+          embeddingError: embeddingTask?.error ?? null,
+          embeddingStatus: embeddingTask?.status as AsyncTaskStatus,
+          finishEmbedding: embeddingTask?.status === AsyncTaskStatus.Success,
+          url: await ctx.fileService.getFullFileUrl(item.url!),
+        } as FileListItem);
+      } else {
+        // Document item - no chunk processing needed, includes editorData
+        const documentItem = {
+          ...item,
+          chunkCount: null,
+          chunkingError: null,
+          chunkingStatus: null,
+          embeddingError: null,
+          embeddingStatus: null,
+          finishEmbedding: false,
+        } as FileListItem;
+        console.log('[API getKnowledgeItems] Processing document:', {
+          editorDataPreview: item.editorData ? JSON.stringify(item.editorData).slice(0, 100) : null,
+          hasEditorData: !!item.editorData,
+          id: item.id,
+          name: item.name,
+        });
+        resultItems.push(documentItem);
+      }
+    }
+
+    return resultItems;
+  }),
+
   removeAllFiles: fileProcedure.mutation(async ({ ctx }) => {
     return ctx.fileModel.clear();
   }),

package/src/server/routers/lambda/knowledge.ts

@@ -0,0 +1,94 @@
+import { AsyncTaskModel } from '@/database/models/asyncTask';
+import { ChunkModel } from '@/database/models/chunk';
+import { DocumentModel } from '@/database/models/document';
+import { FileModel } from '@/database/models/file';
+import { KnowledgeRepo } from '@/database/repositories/knowledge';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { serverDatabase } from '@/libs/trpc/lambda/middleware';
+import { FileService } from '@/server/services/file';
+import { AsyncTaskStatus, AsyncTaskType } from '@/types/asyncTask';
+import { FileListItem, QueryFileListSchema } from '@/types/files';
+
+const knowledgeProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: {
+      asyncTaskModel: new AsyncTaskModel(ctx.serverDB, ctx.userId),
+      chunkModel: new ChunkModel(ctx.serverDB, ctx.userId),
+      documentModel: new DocumentModel(ctx.serverDB, ctx.userId),
+      fileModel: new FileModel(ctx.serverDB, ctx.userId),
+      fileService: new FileService(ctx.serverDB, ctx.userId),
+      knowledgeRepo: new KnowledgeRepo(ctx.serverDB, ctx.userId),
+    },
+  });
+});
+
+export const knowledgeRouter = router({
+  getKnowledgeItems: knowledgeProcedure.input(QueryFileListSchema).query(async ({ ctx, input }) => {
+    const knowledgeItems = await ctx.knowledgeRepo.query(input);
+
+    // Process files (add chunk info and async task status)
+    const fileItems = knowledgeItems.filter((item) => item.sourceType === 'file');
+    const fileIds = fileItems.map((item) => item.id);
+    const chunks = await ctx.chunkModel.countByFileIds(fileIds);
+
+    const chunkTaskIds = fileItems.map((item) => item.chunkTaskId).filter(Boolean) as string[];
+    const chunkTasks = await ctx.asyncTaskModel.findByIds(chunkTaskIds, AsyncTaskType.Chunking);
+
+    const embeddingTaskIds = fileItems
+      .map((item) => item.embeddingTaskId)
+      .filter(Boolean) as string[];
+    const embeddingTasks = await ctx.asyncTaskModel.findByIds(
+      embeddingTaskIds,
+      AsyncTaskType.Embedding,
+    );
+
+    // Combine all items with their metadata
+    const resultItems = [] as any[];
+    for (const item of knowledgeItems) {
+      if (item.sourceType === 'file') {
+        const chunkTask = item.chunkTaskId
+          ? chunkTasks.find((task) => task.id === item.chunkTaskId)
+          : null;
+        const embeddingTask = item.embeddingTaskId
+          ? embeddingTasks.find((task) => task.id === item.embeddingTaskId)
+          : null;
+
+        resultItems.push({
+          ...item,
+          chunkCount: chunks.find((chunk) => chunk.id === item.id)?.count ?? null,
+          chunkingError: chunkTask?.error ?? null,
+          chunkingStatus: chunkTask?.status as AsyncTaskStatus,
+          editorData: null,
+          embeddingError: embeddingTask?.error ?? null,
+          embeddingStatus: embeddingTask?.status as AsyncTaskStatus,
+          finishEmbedding: embeddingTask?.status === AsyncTaskStatus.Success,
+          url: await ctx.fileService.getFullFileUrl(item.url!),
+        } as FileListItem);
+      } else {
+        // Document item - no chunk processing needed, includes editorData
+        const documentItem = {
+          ...item,
+          chunkCount: null,
+          chunkingError: null,
+          chunkingStatus: null,
+          embeddingError: null,
+          embeddingStatus: null,
+          finishEmbedding: false,
+        } as FileListItem;
+        console.log('[API getKnowledgeItems] Processing document:', {
+          editorDataPreview: item.editorData ? JSON.stringify(item.editorData).slice(0, 100) : null,
+          hasEditorData: !!item.editorData,
+          id: item.id,
+          name: item.name,
+        });
+        resultItems.push(documentItem);
+      }
+    }
+
+    return resultItems;
+  }),
+});
+
+export type KnowledgeRouter = typeof knowledgeRouter;

package/src/server/services/document/index.ts

@@ -1,4 +1,5 @@
 import { LobeChatDatabase } from '@lobechat/database';
+import { DocumentItem } from '@lobechat/database/schemas';
 import { loadFile } from '@lobechat/file-loaders';
 import debug from 'debug';
 
@@ -15,14 +16,116 @@ export class DocumentService {
   private fileModel: FileModel;
   private documentModel: DocumentModel;
   private fileService: FileService;
+  private db: LobeChatDatabase;
 
   constructor(db: LobeChatDatabase, userId: string) {
     this.userId = userId;
+    this.db = db;
     this.fileModel = new FileModel(db, userId);
     this.fileService = new FileService(db, userId);
     this.documentModel = new DocumentModel(db, userId);
   }
 
+  /**
+   * Create a document
+   */
+  async createDocument(params: {
+    content?: string;
+    editorData: Record<string, any>;
+    fileType?: string;
+    knowledgeBaseId?: string;
+    metadata?: Record<string, any>;
+    rawData?: string;
+    title: string;
+  }): Promise<DocumentItem> {
+    const {
+      content,
+      editorData,
+      title,
+      fileType = 'custom/document',
+      metadata,
+      knowledgeBaseId,
+    } = params;
+
+    // Calculate character and line counts
+    const totalCharCount = content?.length || 0;
+    const totalLineCount = content?.split('\n').length || 0;
+
+    const document = await this.documentModel.create({
+      content,
+      editorData,
+      fileId: knowledgeBaseId ? null : undefined,
+      fileType,
+      filename: title,
+      metadata,
+      pages: undefined,
+      source: 'document',
+      sourceType: 'api',
+      title,
+      totalCharCount,
+      totalLineCount,
+    });
+
+    return document;
+  }
+
+  /**
+   * Query all documents
+   */
+  async queryDocuments() {
+    return this.documentModel.query();
+  }
+
+  /**
+   * Get document by ID
+   */
+  async getDocumentById(id: string) {
+    return this.documentModel.findById(id);
+  }
+
+  /**
+   * Delete document
+   */
+  async deleteDocument(id: string) {
+    return this.documentModel.delete(id);
+  }
+
+  /**
+   * Update document
+   */
+  async updateDocument(
+    id: string,
+    params: {
+      content?: string;
+      editorData?: Record<string, any>;
+      metadata?: Record<string, any>;
+      title?: string;
+    },
+  ) {
+    const updates: any = {};
+
+    if (params.content !== undefined) {
+      updates.content = params.content;
+      updates.totalCharCount = params.content.length;
+      updates.totalLineCount = params.content.split('\n').length;
+    }
+
+    if (params.editorData !== undefined) {
+      updates.editorData = params.editorData;
+    }
+
+    if (params.title !== undefined) {
+      updates.title = params.title;
+      updates.filename = params.title;
+    }
+
+    if (params.metadata !== undefined) {
+      updates.metadata = params.metadata;
+    }
+
+    return this.documentModel.update(id, updates);
+  }
+
   /**
    * 解析文件内容
    *