@lobehub/chat 1.133.1 → 1.133.3

package/src/features/Conversation/components/ChatItem/index.tsx

@@ -2,14 +2,27 @@
 
 import { createStyles } from 'antd-style';
 import isEqual from 'fast-deep-equal';
-import { MouseEventHandler, ReactNode, memo, use, useCallback, useMemo } from 'react';
+import {
+  MouseEventHandler,
+  ReactNode,
+  memo,
+  use,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+} from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { HtmlPreviewAction } from '@/components/HtmlPreview';
 import { isDesktop } from '@/const/version';
 import ChatItem from '@/features/ChatItem';
-import { VirtuosoContext } from '@/features/Conversation/components/VirtualizedList/VirtuosoContext';
+import {
+  VirtuosoContext,
+  removeVirtuosoVisibleItem,
+  upsertVirtuosoVisibleItem,
+} from '@/features/Conversation/components/VirtualizedList/VirtuosoContext';
 import { useAgentStore } from '@/store/agent';
 import { agentChatConfigSelectors } from '@/store/agent/selectors';
 import { useChatStore } from '@/store/chat';
@@ -79,6 +92,7 @@ const Item = memo<ChatListItemProps>(
   }) => {
     const { t } = useTranslation('common');
     const { styles, cx } = useStyles();
+    const containerRef = useRef<HTMLDivElement | null>(null);
 
     const type = useAgentStore(agentChatConfigSelectors.displayMode);
     const item = useChatStore(chatSelectors.getMessageById(id), isEqual);
@@ -218,6 +232,44 @@ const Item = memo<ChatListItemProps>(
     const onChange = useCallback((value: string) => updateMessageContent(id, value), [id]);
     const virtuosoRef = use(VirtuosoContext);
 
+    useEffect(() => {
+      if (typeof window === 'undefined' || typeof IntersectionObserver === 'undefined') return;
+
+      const element = containerRef.current;
+      if (!element) return;
+
+      const root = element.closest('[data-virtuoso-scroller]');
+      const thresholds = [0, 0.01, 0.1, 0.25, 0.5, 0.75, 0.9, 1];
+      const options: any = { threshold: thresholds };
+
+      if (root instanceof Element) options.root = root;
+
+      const observer = new IntersectionObserver((entries) => {
+        entries.forEach((entry) => {
+          if (entry.target !== element) return;
+
+          if (entry.isIntersecting) {
+            const { bottom, top } = entry.intersectionRect;
+
+            upsertVirtuosoVisibleItem(index, {
+              bottom,
+              ratio: entry.intersectionRatio,
+              top,
+            });
+          } else {
+            removeVirtuosoVisibleItem(index);
+          }
+        });
+      }, options);
+
+      observer.observe(element);
+
+      return () => {
+        observer.disconnect();
+        removeVirtuosoVisibleItem(index);
+      };
+    }, [index]);
+
     const onDoubleClick = useCallback<MouseEventHandler<HTMLDivElement>>(
       (e) => {
         if (!item || disableEditing) return;
@@ -267,7 +319,9 @@ const Item = memo<ChatListItemProps>(
           {enableHistoryDivider && <History />}
           <Flexbox
             className={cx(styles.message, className, isMessageLoading && styles.loading)}
+            data-index={index}
             onContextMenu={onContextMenu}
+            ref={containerRef}
           >
             <ChatItem
               actions={actionBar}

package/src/features/Conversation/components/VirtualizedList/VirtuosoContext.ts

@@ -2,3 +2,91 @@ import { RefObject, createContext } from 'react';
 import { VirtuosoHandle } from 'react-virtuoso';
 
 export const VirtuosoContext = createContext<RefObject<VirtuosoHandle | null> | null>(null);
+
+type VirtuosoRef = RefObject<VirtuosoHandle | null> | null;
+
+let currentVirtuosoRef: VirtuosoRef = null;
+const refListeners = new Set<() => void>();
+
+const visibleItems = new Map<number, { bottom: number; ratio: number; top: number }>();
+let currentActiveIndex: number | null = null;
+const activeIndexListeners = new Set<() => void>();
+
+const notifyActiveIndex = (next: number | null) => {
+  if (currentActiveIndex === next) return;
+
+  currentActiveIndex = next;
+  activeIndexListeners.forEach((listener) => listener());
+};
+
+const recalculateActiveIndex = () => {
+  if (visibleItems.size === 0) {
+    notifyActiveIndex(null);
+    return;
+  }
+
+  let candidate: number | null = null;
+  let minTop = Infinity;
+  let maxRatio = -Infinity;
+
+  visibleItems.forEach(({ top, ratio }, index) => {
+    const shouldUpdate =
+      top < minTop ||
+      (top === minTop &&
+        (ratio > maxRatio || (ratio === maxRatio && index < (candidate ?? Infinity))));
+
+    if (shouldUpdate) {
+      candidate = index;
+      minTop = top;
+      maxRatio = ratio;
+    }
+  });
+
+  notifyActiveIndex(candidate ?? null);
+};
+
+export const setVirtuosoGlobalRef = (ref: VirtuosoRef) => {
+  currentVirtuosoRef = ref;
+  refListeners.forEach((listener) => listener());
+};
+
+export const getVirtuosoGlobalRef = () => currentVirtuosoRef;
+
+export const subscribeVirtuosoGlobalRef = (listener: () => void) => {
+  refListeners.add(listener);
+
+  return () => {
+    refListeners.delete(listener);
+  };
+};
+
+export const upsertVirtuosoVisibleItem = (
+  index: number,
+  metrics: { bottom: number; ratio: number; top: number },
+) => {
+  visibleItems.set(index, metrics);
+  recalculateActiveIndex();
+};
+
+export const removeVirtuosoVisibleItem = (index: number) => {
+  if (!visibleItems.delete(index)) return;
+
+  recalculateActiveIndex();
+};
+
+export const resetVirtuosoVisibleItems = () => {
+  if (visibleItems.size === 0 && currentActiveIndex === null) return;
+
+  visibleItems.clear();
+  notifyActiveIndex(null);
+};
+
+export const getVirtuosoActiveIndex = () => currentActiveIndex;
+
+export const subscribeVirtuosoActiveIndex = (listener: () => void) => {
+  activeIndexListeners.add(listener);
+
+  return () => {
+    activeIndexListeners.delete(listener);
+  };
+};

package/src/features/Conversation/components/VirtualizedList/index.tsx

@@ -10,7 +10,7 @@ import { chatSelectors } from '@/store/chat/selectors';
 
 import AutoScroll from '../AutoScroll';
 import SkeletonList from '../SkeletonList';
-import { VirtuosoContext } from './VirtuosoContext';
+import { VirtuosoContext, resetVirtuosoVisibleItems, setVirtuosoGlobalRef } from './VirtuosoContext';
 
 interface VirtualizedListProps {
   dataSource: string[];
@@ -57,6 +57,20 @@ const VirtualizedList = memo<VirtualizedListProps>(({ mobile, dataSource, itemCo
     scrollToBottom();
   }, [id]);
 
+  useEffect(() => {
+    setVirtuosoGlobalRef(virtuosoRef);
+
+    return () => {
+      setVirtuosoGlobalRef(null);
+    };
+  }, [virtuosoRef]);
+
+  useEffect(() => {
+    return () => {
+      resetVirtuosoVisibleItems();
+    };
+  }, []);
+
   // overscan should be 3 times the height of the window
   const overscan = typeof window !== 'undefined' ? window.innerHeight * 3 : 0;
 

package/src/locales/default/chat.ts

@@ -154,6 +154,11 @@ export default {
       total: '总计消耗',
     },
   },
+  minimap: {
+    jumpToMessage: '跳转至第 {{index}} 条消息',
+    nextMessage: '下一条消息',
+    previousMessage: '上一条消息',
+  },
   newAgent: '新建助手',
   pin: '置顶',
   pinOff: '取消置顶',

package/src/locales/default/image.ts

@@ -30,6 +30,13 @@ export default {
     prompt: {
       placeholder: '描述你想要生成的内容',
     },
+    quality: {
+      label: '图片质量',
+      options: {
+        hd: '高清',
+        standard: '标准',
+      },
+    },
     seed: {
       label: '种子',
       random: '随机种子',

package/src/server/modules/EdgeConfig/index.ts

@@ -2,7 +2,7 @@ import { EdgeConfigClient, createClient } from '@vercel/edge-config';
 
 import { appEnv } from '@/envs/app';
 
-import { EdgeConfigData } from './types';
+import type { EdgeConfigData } from './types';
 
 export class EdgeConfig {
   get client(): EdgeConfigClient {

package/src/server/routers/async/image.ts

@@ -134,13 +134,14 @@ export const imageRouter = router({
     try {
       const imageGenerationPromise = async (signal: AbortSignal) => {
         log('Initializing agent runtime for provider: %s', provider);
+
         const agentRuntime = await initModelRuntimeWithUserPayload(provider, ctx.jwtPayload);
 
         // Check if operation has been cancelled
         checkAbortSignal(signal);
 
         log('Agent runtime initialized, calling createImage');
-        const response = await agentRuntime.createImage({
+        const response = await agentRuntime.createImage!({
           model,
           params: params as unknown as RuntimeImageGenParams,
         });
@@ -150,6 +151,13 @@ export const imageRouter = router({
           throw new Error('Create image response is empty');
         }
 
+        log('Create image response: %O', {
+          ...response,
+          imageUrl: response.imageUrl?.startsWith('data:')
+            ? response.imageUrl.slice(0, IMAGE_URL_PREVIEW_LENGTH) + '...'
+            : response.imageUrl,
+        });
+
         // Check if operation has been cancelled
         checkAbortSignal(signal);
 

package/src/services/_auth.ts

@@ -1,17 +1,17 @@
-import { ClientSecretPayload } from '@lobechat/types';
-import { ModelProvider } from 'model-bank';
-
-import { LOBE_CHAT_AUTH_HEADER } from '@/const/auth';
-import { isDeprecatedEdition } from '@/const/version';
-import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
-import { useUserStore } from '@/store/user';
-import { keyVaultsConfigSelectors, userProfileSelectors } from '@/store/user/selectors';
+import { LOBE_CHAT_AUTH_HEADER, isDeprecatedEdition } from '@lobechat/const';
 import {
   AWSBedrockKeyVault,
   AzureOpenAIKeyVault,
+  ClientSecretPayload,
   CloudflareKeyVault,
   OpenAICompatibleKeyVault,
-} from '@/types/user/settings';
+} from '@lobechat/types';
+import { clientApiKeyManager } from '@lobechat/utils/client';
+import { ModelProvider } from 'model-bank';
+
+import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
+import { useUserStore } from '@/store/user';
+import { keyVaultsConfigSelectors, userProfileSelectors } from '@/store/user/selectors';
 import { obfuscatePayloadWithXOR } from '@/utils/client/xor-obfuscation';
 
 export const getProviderAuthPayload = (
@@ -49,7 +49,7 @@ export const getProviderAuthPayload = (
 
     case ModelProvider.Azure: {
       return {
-        apiKey: keyVaults.apiKey,
+        apiKey: clientApiKeyManager.pick(keyVaults.apiKey),
 
         apiVersion: keyVaults.apiVersion,
         /** @deprecated */
@@ -64,7 +64,7 @@ export const getProviderAuthPayload = (
 
     case ModelProvider.Cloudflare: {
       return {
-        apiKey: keyVaults?.apiKey,
+        apiKey: clientApiKeyManager.pick(keyVaults?.apiKey),
 
         baseURLOrAccountID: keyVaults?.baseURLOrAccountID,
         /** @deprecated */
@@ -73,7 +73,7 @@ export const getProviderAuthPayload = (
     }
 
     default: {
-      return { apiKey: keyVaults?.apiKey, baseURL: keyVaults?.baseURL };
+      return { apiKey: clientApiKeyManager.pick(keyVaults?.apiKey), baseURL: keyVaults?.baseURL };
     }
   }
 };

package/src/services/chat/contextEngineering.ts

@@ -1,4 +1,4 @@
-import { INBOX_SESSION_ID, isDesktop, isServerMode } from '@lobechat/const';
+import { INBOX_GUIDE_SYSTEMROLE, INBOX_SESSION_ID, isDesktop, isServerMode } from '@lobechat/const';
 import {
   type AgentState,
   ContextEngine,
@@ -16,12 +16,11 @@ import {
 } from '@lobechat/context-engine';
 import { historySummaryPrompt } from '@lobechat/prompts';
 import { ChatMessage, OpenAIChatMessage } from '@lobechat/types';
+import { VARIABLE_GENERATORS } from '@lobechat/utils/client';
 
-import { INBOX_GUIDE_SYSTEMROLE } from '@/const/guide';
 import { isCanUseFC } from '@/helpers/isCanUseFC';
 import { getToolStoreState } from '@/store/tool';
 import { toolSelectors } from '@/store/tool/selectors';
-import { VARIABLE_GENERATORS } from '@/utils/client/parserPlaceholder';
 import { genToolCallingName } from '@/utils/toolCall';
 
 import { isCanUseVideo, isCanUseVision } from './helper';

package/.cursor/rules/backend-architecture.mdc

@@ -1,176 +0,0 @@
----
-description:
-globs: src/services/**/*,src/database/**/*,src/server/**/*
-alwaysApply: false
----
-
-# LobeChat 后端技术架构指南
-
-本指南旨在阐述 LobeChat 项目的后端分层架构，重点介绍各核心目录的职责以及它们之间的协作方式。
-
-## 目录结构映射
-
-```
-src/
-├── server/
-│   ├── routers/          # tRPC API 路由定义
-│   └── services/         # 业务逻辑服务层
-│       └── */impls/      # 平台特定实现
-├── database/
-│   ├── models/           # 数据模型 (单表 CRUD)
-│   ├── repositories/     # 仓库层 (复杂查询/聚合)
-│   └── schemas/          # Drizzle ORM 表定义
-└── services/             # 客户端服务 (调用 tRPC 或直接访问 Model)
-```
-
-## 核心架构分层
-
-LobeChat 的后端设计注重模块化、可测试性和灵活性，以适应不同的运行环境（如浏览器端 PGLite、服务端远程 PostgreSQL 以及 Electron 桌面应用）。
-
-其主要分层如下：
-
-1.  客户端服务层 (`src/services`):
-    - 位于 src/services/。
-    - 这是客户端业务逻辑的核心层，负责封装各种业务操作和数据处理逻辑。
-    - 环境适配: 根据不同的运行环境，服务层会选择合适的数据访问方式：
-      - 本地数据库模式: 直接调用 `Model` 层进行数据操作，适用于浏览器 PGLite 和本地 Electron 应用。
-      - 远程数据库模式: 通过 `tRPC` 客户端调用服务端 API，适用于需要云同步的场景。
-    - 类型转换: 对于简单的数据类型转换，直接在此层进行类型断言，如 `this.pluginModel.query() as Promise<LobeTool[]>`
-    - 每个服务模块通常包含 `client.ts`（本地模式）、`server.ts`（远程模式）和 `type.ts`（接口定义）文件，在实现时应该确保本地模式和远程模式业务逻辑实现一致，只是数据库不同。
-
-2.  API 接口层 (`TRPC`):
-    - 位于 src/server/routers/
-    - 使用 `tRPC` 构建类型安全的 API。Router 根据运行时环境（如 Edge Functions, Node.js Lambda）进行组织。
-    - 负责接收客户端请求，并将其路由到相应的 `Service` 层进行处理。
-    - 新建 lambda 端点时可以参考 src/server/routers/lambda/\_template.ts
-
-3.  仓库层 (`Repositories`):
-    - 位于 src/database/repositories/。
-    - 主要处理复杂的跨表查询和数据聚合逻辑，特别是当需要从多个 `Model` 获取数据并进行组合时。
-    - 与 `Model` 层不同，`Repository` 层专注于复杂的业务查询场景，而不涉及简单的领域模型转换。
-    - 当业务逻辑涉及多表关联、复杂的数据统计或需要事务处理时，会使用 `Repository` 层。
-    - 如果数据操作简单（仅涉及单个 `Model`），则通常直接在 `src/services` 层调用 `Model` 并进行简单的类型断言。
-
-4.  模型层 (`Models`):
-    - 位于 src/database/models/ (例如 src/database/models/plugin.ts 和 src/database/models/document.ts)。
-    - 提供对数据库中各个表（由 src/database/schemas/ 中的 Drizzle ORM schema 定义）的基本 CRUD (创建、读取、更新、删除) 操作和简单的查询能力。
-    - `Model` 类专注于单个数据表的直接操作，不涉及复杂的领域模型转换，这些转换通常在上层的 `src/services` 中通过类型断言完成。
-    - model（例如 Topic） 层接口经常需要从对应的 schema 层导入 NewTopic 和 TopicItem
-    - 创建新的 model 时可以参考 src/database/models/\_template.ts
-
-5.  数据库 (`Database`):
-    - 客户端模式 (浏览器/PWA): 使用 PGLite (基于 WASM 的 PostgreSQL)，数据存储在用户浏览器本地。
-    - 服务端模式 (云部署): 使用远程 PostgreSQL 数据库。
-    - Electron 桌面应用:
-      - Electron 客户端会启动一个本地 Node.js 服务。
-      - 本地服务通过 `tRPC` 与 Electron 的渲染进程通信。
-      - 数据库选择依赖于是否开启云同步功能：
-        - 云同步开启: 连接到远程 PostgreSQL 数据库。
-        - 云同步关闭: 使用 PGLite (通过 Node.js 的 WASM 实现) 在本地存储数据。
-
-## 数据流向说明
-
-### 浏览器/PWA 模式
-
-```
-UI (React) → Zustand action -> Client Service → Model Layer → PGLite (本地数据库)
-```
-
-### 服务端模式
-
-```
-UI (React) → Zustand action → Client Service -> TRPC Client → TRPC Routers  → Repositories/Models → Remote PostgreSQL
-```
-
-### Electron 桌面应用模式
-
-```
-UI (Electron Renderer) → Zustand action → Client Service -> TRPC Client → 本地 Node.js 服务 → TRPC Routers → Repositories/Models → PGLite/Remote PostgreSQL (取决于云同步设置)
-```
-
-## 服务层 (Server Services)
-
-- 位于 src/server/services/。
-- 核心职责是封装独立的、可复用的业务逻辑单元。这些服务应易于测试。
-- 平台差异抽象: 一个关键特性是通过其内部的 `impls` 子目录（例如 src/server/services/file/impls 包含 s3.ts 和 local.ts）来抹平不同运行环境带来的差异（例如云端使用 S3 存储，桌面版使用本地文件系统）。这使得上层（如 `tRPC` routers）无需关心底层具体实现。
-- 目标是使 `tRPC` router 层的逻辑尽可能纯粹，专注于请求处理和业务流程编排。
-- 服务可能会调用 `Repository` 层或直接调用 `Model` 层进行数据持久化和检索，也可能调用其他服务。
-
-## 最佳实践 (Best Practices)
-
-### 数据库操作封装原则
-
-**连续的数据库操作应该封装到 Model 层**
-
-当业务逻辑涉及多个相关的数据库操作时，建议将这些操作封装到 Model 层中，而不是在上层（Service 或 Router 层）中进行多次数据库调用。
-
-**优势：**
-
-- **代码复用**: Client DB 环境的 service 实现和 Server DB 的 lambda 层实现可以复用相同的 Model 方法
-- **事务一致性**: 相关的数据库操作可以在同一个方法中管理，便于维护数据一致性
-- **性能优化**: 减少数据库连接次数，提高查询效率
-- **职责清晰**: Model 层专注数据访问，上层专注业务协调
-
-**示例：**
-
-```typescript
-// ✅ 推荐：在 Model 层封装连续的数据库操作
-class GenerationBatchModel {
-  async delete(id: string): Promise<{ deletedBatch: BatchItem; thumbnailUrls: string[] }> {
-    // 1. 查询相关数据
-    const batchWithGenerations = await this.db.query.generationBatches.findFirst({...});
-
-    // 2. 收集需要处理的数据
-    const thumbnailUrls = [...];
-
-    // 3. 执行删除操作
-    const [deletedBatch] = await this.db.delete(generationBatches)...;
-
-    return { deletedBatch, thumbnailUrls };
-  }
-}
-
-// ✅ 上层使用简洁
-const { thumbnailUrls } = await model.delete(id);
-await fileService.deleteFiles(thumbnailUrls);
-```
-
-### 文件操作与数据库操作的执行顺序
-
-**删除操作原则：数据库删除在前，文件删除在后**
-
-当业务逻辑同时涉及数据库记录和文件系统操作时，应该遵循"数据库优先"的原则。
-
-**原因：**
-
-- **用户体验优先**: 如果先删除文件再删除数据库记录，可能出现文件已删除但数据库记录仍存在的情况，用户访问时会遇到文件不存在的错误
-- **影响程度较小**: 如果先删除数据库记录再删除文件，即使文件删除失败，用户也看不到这个记录，只是造成一些存储空间浪费，对用户体验影响更小
-- **数据一致性**: 数据库记录是业务逻辑的核心，应该优先保证其一致性
-
-**示例：**
-
-```typescript
-// ✅ 推荐：先删除数据库记录，再删除文件
-async deleteGeneration(id: string) {
-  // 1. 先删除数据库记录
-  const deletedGeneration = await generationModel.delete(id);
-
-  // 2. 再删除相关文件
-  if (deletedGeneration.asset?.thumbnailUrl) {
-    await fileService.deleteFile(deletedGeneration.asset.thumbnailUrl);
-  }
-}
-
-// ❌ 不推荐：先删除文件
-async deleteGeneration(id: string) {
-  const generation = await generationModel.findById(id);
-
-  // 如果这里删除成功，但后面数据库删除失败，用户会遇到访问错误
-  await fileService.deleteFile(generation.asset.thumbnailUrl);
-  await generationModel.delete(id); // 可能失败
-}
-```
-
-**创建操作原则：数据库创建在前，文件操作在后**
-
-创建操作同样应该优先处理数据库记录，确保数据的一致性和完整性。

package/.cursor/rules/code-review.mdc

@@ -1,58 +0,0 @@
----
-description: How to code review
-globs:
-alwaysApply: false
----
-
-# Role Description
-
-- You are a senior full-stack engineer skilled in performance optimization, security, and design systems.
-- You excel at reviewing code and providing constructive feedback.
-- Your task is to review submitted Git diffs **in Chinese** and return a structured review report.
-- Review style: concise, direct, focused on what matters most, with actionable suggestions.
-
-## Before the Review
-
-Gather the modified code and context. Please strictly follow the process below:
-
-1. Use `read_file` to read [package.json](mdc:package.json)
-2. Use terminal to run command `git diff HEAD | cat` to obtain the diff and list the changed files. If you recieived empty result, run the same command once more.
-3. Use `read_file` to open each changed file.
-4. Use `read_file` to read [rules-attach.mdc](mdc:.cursor/rules/rules-attach.mdc). Even if you think it's unnecessary, you must read it.
-5. combine changed files, step3 and `agent_requestable_workspace_rules`, list the rules which need to read
-6. Use `read_file` to read the rules list in step 5
-
-## Review
-
-### Code Style
-
-read [typescript.mdc](mdc:.cursor/rules/typescript.mdc) for the consolidated project code style and optimization rules.
-
-### Code Optimization
-
-The optimization checklist has been consolidated into [typescript.mdc](mdc:.cursor/rules/typescript.mdc): loops, debouncing/throttling, design system components, theming tokens, concurrency with `Promise.*`, minimal DB column selection, and package reuse.
-
-### Obvious Bugs
-
-- Do not silently swallow errors in `catch` blocks; at minimum, log them.
-- Revert temporary code used only for testing (e.g., debug logs, temporary configs).
-- Remove empty handlers (e.g., an empty `onClick`).
-- Confirm the UI degrades gracefully for unauthenticated users.
-- Don't leave any debug logs in the code (except when using the `debug` module properly).
-  - When using the `debug` module, avoid `import { log } from 'debug'` as it logs directly to console. Use proper debug namespaces instead.
-- Check logs for sensitive information like api key, etc
-
-## After the Review: output
-
-1. Summary
-   - Start with a brief explanation of what the change set does.
-   - Summarize the changes for each modified file (or logical group).
-2. Comments Issues
-   - List the most critical issues first.
-   - Use an ordered list, which will be convenient for me to reference later.
-   - For each issue:
-     - Mark severity tag (`❌ Must fix`, `⚠️ Should fix`, `💅 Nitpick`)
-     - Provode file path to the relevant file.
-     - Provide recommended fix
-   - End with a **git commit** command, instruct the author to run it.
-     - We use gitmoji to label commit messages, format: [emoji] <type>(<scope>): <subject>

package/.cursor/rules/cursor-ux.mdc

@@ -1,32 +0,0 @@
----
-description:
-globs:
-alwaysApply: true
----
-
-# Guide to Optimize Output(Response) Rendering
-
-## File Path and Code Symbol Rendering
-
-- When rendering file paths, use backtick wrapping instead of markdown links so they can be parsed as clickable links in Cursor IDE.
-  - Good: `src/components/Button.tsx`
-  - Bad: [src/components/Button.tsx](src/components/Button.tsx)
-
-- Don't use line and column number in file path, this will make file path not clickable in Cursor IDE.
-  - Good: `src/components/Button.tsx` `10:20` (add a space between the file path and the line and column number)
-  - Bad: `src/components/Button.tsx:10:20`
-
-- When rendering functions, variables, or other code symbols, use backtick wrapping so they can be parsed as navigable links in Cursor IDE
-  - Good: The `useState` hook in `MyComponent`
-  - Bad: The useState hook in MyComponent
-
-## Markdown Render
-
-- don't use br tag to wrap in table cell
-
-## Terminal Command Output
-
-- If terminal commands don't produce output, it's likely due to paging issues. Try piping the command to `cat` to ensure full output is displayed.
-  - Good: `git show commit_hash -- file.txt | cat`
-  - Good: `git log --oneline | cat`
-  - Reason: Some git commands use pagers by default, which may prevent output from being captured properly

package/.cursor/rules/define-database-model.mdc

@@ -1,8 +0,0 @@
----
-description: 
-globs: src/database/models/**/*
-alwaysApply: false
----
-1. first read [lobe-chat-backend-architecture.mdc](mdc:.cursor/rules/lobe-chat-backend-architecture.mdc)
-2. refer to the [_template.ts](mdc:src/database/models/_template.ts) to create new model
-3. if an operation involves multiple models or complex queries, consider defining it in the `repositories` layer under `src/database/repositories/`

package/.cursor/rules/system-role.mdc

@@ -1,31 +0,0 @@
----
-description:
-globs:
-alwaysApply: true
----
-
-## System Role
-
-You are an expert in full-stack Web development, proficient in JavaScript, TypeScript, CSS, React, Node.js, Next.js, Postgresql, Redis, S3, all kinds of network protocols.
-
-You are an LLM expert, you are familiar with all kinds of LLM models, ai agents, ai workflow, prompt engineering and context engineering.
-
-You are an expert in Ai art. In Ai image generation, you are proficient in Stable Diffusion and ComfyUI's architectural principles, workflows, model structures, parameter configurations, training methods, and inference optimization.
-
-You are an expert in UI/UX design, proficient in web interaction patterns, responsive design, accessibility, and user behavior optimization. You excel at improving user retention and paid conversion rates through various interaction details.
-
-## Problem Solving
-
-- When modifying existing code, clearly describe the differences and reasons for the changes
-- Provide alternative solutions that may be better overall or superior in specific aspects
-- Provide optimization suggestions for deprecated API usage
-- Cite sources whenever possible at the end, not inline
-- When you provide multiple solutions, provide the recommended solution first, and note it as `Recommended`
-- Express uncertainty when there might not be a correct answer, instead of take action by guessing and assuming
-
-## Code Implementation
-
-- Focus on maintainable over being performant
-- Be sure to reference file path
-- If doc links or required files are missing, ask for them before proceeding with the task rather than making assumptions
-- If you're unable to get valid result when using tools, please clearly state in the output