STDIN

1 fix: 修复Vue模板语法错误和优化项目配置
   2
   3 - 修复MainDashboard.vue中多余的template结束标签导致的Vue编译错误
   4 - 更新项目文档QWEN.md，完善项目说明和部署指南
   5 - 优化create_admin.py脚本，从main.py导入统一配置
   6 - 增强PDF解析器错误处理和兼容性
   7 - 改进登录页面UI设计和用户体验
   8
   9 🤖 Generated with [Claude Code](https://claude.com/claude-code)
  10
  11 Co-Authored-By: Claude <noreply@anthropic.com>

QWEN.md

@@ -1,117 +1,192 @@
-# 学习助手 Pro (WordMaster Pro) 项目指南
+# 学习助手 Pro - 项目说明
 
 ## 项目概述
 
-这是一个基于 FastAPI + Vue3 的智能试卷管理与学习跟踪系统，支持PDF试卷智能解析、题目自动提取、错题管理和学习统计等功能。
+这是一个基于 FastAPI + Vue3 的智能试卷管理与学习跟踪系统，支持PDF试卷智能解析、题目自动提取、错题管理和学习统计等功能。项目采用前后端分离架构，旨在帮助学生高效管理试卷、跟踪错题并进行个性化学习。
 
-### 核心功能
+## 核心功能
 
-1. **智能试卷管理**
-   - PDF试卷上传和预览
-   - 多学科试卷分类管理（数学、语文、英语等）
-   - 试卷信息自动识别和标注
+### 智能试卷管理
+- PDF试卷上传和预览
+- 多学科试卷分类管理（数学、语文、英语等）
+- 试卷信息自动识别和标注
 
-2. **题目智能提取**
-   - AI驱动的PDF文本层解析，速度快准确率高（95%+）
-   - OCR备份解析，处理扫描版PDF
-   - 自动识别题目类型（选择题、填空题、解答题等）
-   - 智能提取题目图片（几何图形、函数图像等）
-   - 数学符号自动修复和优化
+### 题目智能提取
+- AI驱动的PDF文本层解析，速度快准确率高（95%+）
+- OCR备份解析，处理扫描版PDF
+- 自动识别题目类型（选择题、填空题、解答题等）
+- 智能提取题目图片（几何图形、函数图像等）
+- 数学符号自动修复和优化
 
-3. **错题管理系统**
-   - 智能错题收集和分类
-   - 艾宾浩斯遗忘曲线复习提醒
-   - 个性化学习计划生成
-   - 错题复习统计和进度跟踪
+### 错题管理系统
+- 智能错题收集和分类
+- 艾宾浩斯遗忘曲线复习提醒
+- 个性化学习计划生成
+- 错题复习统计和进度跟踪
 
-4. **学习数据分析**
-   - 详细的学习进度统计
-   - 多维度数据可视化
-   - 学科强弱项分析
-   - 学习效率评估
+### 学习数据分析
+- 详细的学习进度统计
+- 多维度数据可视化
+- 学科强弱项分析
+- 学习效率评估
 
-### 技术栈
+## 技术栈
 
-- **后端**: FastAPI, SQLAlchemy, JWT, Pydantic
-- **前端**: Vue 3, Element Plus, Pinia, Vite
-- **数据库**: SQLite (可升级到 PostgreSQL/MySQL)
-- **PDF处理**: PyMuPDF (fitz), OCR技术
+### 后端 (FastAPI)
+- **FastAPI**: 高性能 Python Web 框架
+- **SQLAlchemy**: ORM 数据库操作
+- **JWT**: 用户认证
+- **Pydantic**: 数据验证
+- **pdfplumber**: PDF解析
+- **PyMuPDF**: PDF处理
+- **BCrypt**: 密码加密
+- **SQLAlchemy**: 数据库ORM
+
+### 前端 (Vue3)
+- **Vue 3**: 组合式 API
+- **Element Plus**: UI 组件库
+- **Pinia**: 状态管理
+- **Axios**: HTTP客户端
+- **Chart.js**: 数据可视化
+- **Vite**: 构建工具
+
+### 数据库
+- **SQLite**: 轻量级数据库（可升级到 PostgreSQL/MySQL）
 
 ## 项目结构
 
 ```
 pager/
-├── backend/                 # 后端服务
-│   ├── main.py             # 主应用文件
-│   ├── requirements.txt    # Python依赖
-│   ├── pdf_splitter_hybrid.py  # PDF拆分器
-│   ├── pdf_exam_parser_enhanced.py  # PDF解析器
-│   ├── pdf_image_extractor.py  # PDF图片提取器
-│   ├── create_admin.py     # 管理员创建脚本
-│   ├── migrate_db.py       # 数据库迁移脚本
-│   └── initial_words.csv   # 初始词汇
-├── frontend/                # 前端应用
-│   ├── package.json        # 前端依赖
-│   ├── src/                # 源代码
-│   ├── vite.config.js      # Vite构建配置
-│   └── index.html          # 构建入口
-├── start.sh               # 启动脚本
-├── stop.sh                # 停止脚本
-├── status.sh              # 状态检查脚本
-└── README.md              # 项目说明
+├── backend/
+│   ├── main.py                 # 后端主应用
+│   ├── api_images.py           # 图片API路由
+│   ├── create_admin.py         # 创建管理员脚本
+│   ├── migrate_db.py           # 数据库迁移脚本
+│   ├── pdf_*.py               # PDF解析相关工具
+│   ├── requirements.txt        # Python依赖
+│   ├── initial_words.csv      # 初始单词数据
+│   └── utils/                 # 工具函数
+├── frontend/
+│   ├── src/                   # 源代码
+│   ├── package.json           # Node.js依赖
+│   ├── vite.config.js         # Vite配置
+│   └── index.html             # 主HTML文件
+├── README.md                  # 项目说明
+├── start.sh/start_app.sh      # 启动脚本
+├── status.sh/status_app.sh    # 状态检查脚本
+├── stop.sh/stop_app.sh        # 停止脚本
+└── index.html                 # 根目录HTML文件
 ```
 
-## 数据库模型
+## 构建和运行
 
-### 主要实体
-- **User**: 用户信息
-- **Word**: 词汇表
-- **UserWordProgress**: 用户词汇学习进度 (使用SM-2算法)
-- **Paper**: 试卷信息
-- **Mistake**: 错题信息
-- **ReviewLog**: 复习记录
-- **Question**: 题目信息
-- **QuestionCollection**: 题集
+### 后端启动
 
-### 学习算法
-- **SM-2 间隔重复算法**: 个性化复习间隔
-- **Leitner系统**: 用于错题复习提醒
-
-## 运行和部署
-
-### 开发环境启动
-
-**后端启动:**
+1. 进入后端目录：
 ```bash
 cd backend
+```
+
+2. 安装依赖：
+```bash
 pip install -r requirements.txt
+```
+
+3. 启动后端服务：
+```bash
 python main.py
 ```
+
 后端将在 `http://0.0.0.0:8888` 启动
 
-**前端启动:**
+### 前端启动
+
+1. 进入前端目录：
 ```bash
 cd frontend
+```
+
+2. 安装依赖：
+```bash
 npm install
+```
+
+3. 启动开发服务器：
+```bash
 npm run dev
 ```
-前端将在 `http://localhost:3000` 启动
 
-### 使用启动脚本
-```bash
-# 启动服务
-./start.sh
+前端将在 `http://localhost:3000` 启动 (如端口被占用会自动选择其他端口)
 
-# 停止服务
-./stop.sh
+## 环境变量配置
 
-# 检查状态
-./status.sh
+### 后端配置
+
+在后端目录创建 `.env` 文件：
+```
+SECRET_KEY=your-super-secret-key-here
+DATABASE_URL=sqlite:///./wordmaster.db
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+ALGORITHM=HS256
 ```
 
-### 生产环境部署
+### 前端配置
 
-**Docker部署:**
+在前端目录创建 `.env.development` 文件：
+```
+VITE_BACKEND_HOST=localhost
+VITE_BACKEND_PORT=8888
+VITE_APP_VERSION=1.0.0
+```
+
+## 主要API端点
+
+### 认证
+- `POST /api/auth/register` - 用户注册
+- `POST /api/auth/login` - 用户登录
+
+### 词汇管理
+- `GET /api/words` - 获取词汇列表
+- `POST /api/words` - 创建词汇
+- `POST /api/words/import` - 批量导入词汇
+
+### 学习管理
+- `GET /api/study/due` - 获取待学习词汇
+- `POST /api/study/submit` - 提交学习结果
+
+### 试卷管理
+- `POST /api/papers` - 创建试卷
+- `GET /api/papers` - 获取试卷列表
+- `POST /api/papers/{paper_id}/split` - 拆解试卷为题目
+
+### 题目管理
+- `POST /api/questions` - 创建题目
+- `GET /api/questions` - 获取题目列表
+- `GET /api/questions/{question_id}/format` - 获取格式化题目
+
+### 错题管理
+- `POST /api/mistakes` - 创建错题
+- `GET /api/mistakes` - 获取错题列表
+- `POST /api/mistakes/{mistake_id}/review` - 提交复习结果
+
+### 仪表盘
+- `GET /api/dashboard` - 获取仪表盘统计
+
+## 开发规范
+
+### 代码风格
+- Python: 遵循 PEP 8 标准
+- JavaScript/TypeScript: 使用 ESLint 和 Prettier
+- HTML/CSS: 使用语义化标签和 BEM 命名规范
+
+### 提交规范
+- 使用 Git 提交信息规范，如 "feat: 添加新功能"、"fix: 修复问题" 等
+
+## 部署选项
+
+### Docker 部署 (推荐)
+
+创建 `docker-compose.yml`：
 ```yaml
 version: '3.8'
 services:
@@ -132,102 +207,52 @@ services:
       - backend
 ```
 
-## API 接口
+启动：
+```bash
+docker-compose up -d
+```
 
-### 认证接口
-- `POST /api/auth/register` - 用户注册
-- `POST /api/auth/login` - 用户登录
+### PM2 部署
 
-### 词汇接口
-- `GET /api/words` - 获取词汇列表
-- `POST /api/words` - 创建词汇
-- `POST /api/words/import` - 导入词汇 (CSV/JSON)
+1. 安装 PM2：
+```bash
+npm install -g pm2
+```
 
-### 学习接口
-- `GET /api/study/due` - 获取今日待学习词汇
-- `POST /api/study/submit` - 提交学习结果
+2. 启动后端：
+```bash
+pm2 start "uvicorn main:app --host 0.0.0.0 --port 8000" --name wordmaster-backend
+```
 
-### 试卷接口
-- `POST /api/papers` - 创建试卷
-- `GET /api/papers` - 获取试卷列表
-- `POST /api/papers/{paper_id}/split` - 拆分试卷PDF，提取题目
-
-### 错题接口
-- `POST /api/mistakes` - 创建错题
-- `GET /api/mistakes` - 获取错题列表
-- `POST /api/mistakes/{mistake_id}/review` - 提交错题复习结果
-
-### 题目接口
-- `POST /api/questions` - 创建题目
-- `GET /api/questions` - 获取题目列表
-- `DELETE /api/questions/{question_id}` - 删除题目
-
-## PDF处理流程
-
-系统使用混合PDF处理策略：
-
-1. **文本层解析**: 优先使用增强文本解析（速度快，准确率高）
-2. **OCR备份**: 用于扫描版PDF或文本层质量差的情况
-3. **智能图片提取**: 自动关联题目与图片
-
-## 开发惯例
-
-### 后端开发
-- 使用Pydantic进行数据验证
-- 使用SQLAlchemy进行数据库操作
-- JWT认证
-- 遵循FastAPI异步编程模式
-
-### 前端开发
-- Vue 3 Composition API
-- Element Plus UI组件库
-- Pinia状态管理
-- Vite构建工具
-
-### 代码规范
-- Python: 遵循PEP 8规范
-- JavaScript: 使用ES6+语法
-- 代码注释: 关键函数和类需添加注释
-
-## 性能优化
-
-- **超快解析速度**: 0.01秒完成一页试卷解析
-- **高准确率**: 文本识别准确率95%+
-- **智能缓存**: 词汇学习状态缓存
-- **数据库索引**: 优化查询性能
+3. 构建并启动前端：
+```bash
+cd frontend
+npm run build
+pm2 serve dist 3000 --name wordmaster-frontend
+```
 
 ## 安全建议
 
-1. **修改默认密钥**: 将 `SECRET_KEY` 改为生产环境强密钥
-2. **CORS配置**: 限制具体域名而非允许所有域名
-3. **HTTPS部署**: 使用SSL证书
-4. **数据库安全**: 定期备份，访问控制
+1. 修改默认密钥：
+   ```python
+   SECRET_KEY = "your-production-secret-key-very-long-and-random"
+   ```
 
-## 扩展功能
+2. CORS 配置：
+   ```python
+   allow_origins=["https://your-domain.com"]  # 限制具体域名
+   ```
 
-### 已实现功能
-- 响应式设计支持移动端
-- 语音朗读 (TTS) 功能
-- 快捷键支持
-- 离线缓存 (PWA)
+3. HTTPS 部署：使用 SSL 证书
 
-### 可扩展方向
-- 多语言支持
-- AI题目解析和难度评估
-- 社交学习功能
-- 更多学习模式
+4. 数据库安全：定期备份，访问控制
 
-## 故障排除
+## 系统特点
 
-常见问题:
-- 端口被占用: 检查并关闭占用端口的进程
-- 依赖安装失败: 确认Python/Node.js版本兼容性
-- PDF解析失败: 检查PDF文件格式和权限
-- 数据库连接错误: 检查数据库路径和权限
-
-## 版本控制
-
-- 主分支: `main` - 稳定版本
-- 开发分支: `develop` - 开发中功能
-- 功能分支: `feature/xxx` - 新功能开发
-- 修复分支: `hotfix/xxx` - 紧急修复
+- **超快解析速度**: 0.01秒完成一页试卷解析
+- **高准确率**: 文本识别准确率95%+，性能提升2900倍
+- **智能图片提取**: 自动关联题目与图片，完美显示数学图形
+- **热加载开发**: 前后端完整热加载支持
+- **响应式设计**: 支持电脑、平板、手机
+- **离线缓存**: 渐进式 Web 应用
+- **学习算法**: SM-2 间隔重复算法实现个性化复习

backend/create_admin.py

@@ -5,11 +5,8 @@
 """
 import sys
 import os
-import bcrypt
 from datetime import datetime
-from sqlalchemy import create_engine, Column, Integer, String, DateTime
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+import bcrypt
 
 # 添加环境变量加载
 import dotenv
@@ -17,29 +14,29 @@ dotenv.load_dotenv()
 
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-# 数据库配置 - 使用与 main.py 相同的配置
-DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:postgres@localhost:5432/wordmaster")
-engine = create_engine(DATABASE_URL)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+# 从 main.py 导入所有模型和配置
+from main import (
+    engine, 
+    SessionLocal, 
+    Base,
+    User,
+    get_password_hash
+)
 
-# 导入模型（这里直接定义，避免循环导入）
-Base = declarative_base()
-
-class User(Base):
-    __tablename__ = "users"
-
-    id = Column(Integer, primary_key=True, index=True)
-    username = Column(String, unique=True, index=True)
-    email = Column(String, unique=True, index=True)
-    hashed_password = Column(String)
-    created_at = Column(DateTime, default=datetime.utcnow)
-
-def get_password_hash(password: str) -> str:
-    """生成密码哈希"""
-    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+def create_tables():
+    """创建所有数据库表"""
+    try:
+        Base.metadata.create_all(bind=engine)
+        print("✅ 所有数据库表创建成功！")
+    except Exception as e:
+        print(f"❌ 创建数据库表失败: {e}")
+        raise
 
 def create_admin_user():
     """创建管理员用户"""
+    # 先创建所有表
+    create_tables()
+    
     # 创建数据库会话
     db = SessionLocal()
 

backend/pdf_exam_parser_enhanced_v2.py

@@ -110,7 +110,12 @@ class PDFExamParserEnhancedV2:
 
     def extract_lines_smart(self, pdf_path: str) -> List[Dict]:
         """智能文本行提取 - 改进页眉页脚过滤"""
-        doc = fitz.open(pdf_path)
+        try:
+            doc = fitz.open(pdf_path)
+        except Exception as e:
+            self.log(f"无法打开PDF文件: {pdf_path}, 错误: {str(e)}", "ERROR")
+            return []
+
         lines = []
         all_headers = []
         all_footers = []
@@ -118,67 +123,110 @@ class PDFExamParserEnhancedV2:
         self.log(f"开始处理PDF: {pdf_path}")
         self.log(f"总页数: {len(doc)}")
 
-        # 第一轮：收集页眉页脚候选
-        for page_num, page in enumerate(doc):
-            blocks = page.get_text("blocks")
-            page_height = page.rect.height
+        # First, try the original method with blocks
+        try:
+            # 第一轮：收集页眉页脚候选
+            for page_num in range(len(doc)):
+                page = doc[page_num]
+                blocks = page.get_text("blocks")
+                page_height = page.rect.height
 
-            for block in blocks:
-                x0, y0, x1, y1, text = block[0], block[1], block[2], block[3], block[4]
-                text = self.normalize_text(text)
+                for block in blocks:
+                    # PyMuPDF blocks format: (x0, y0, x1, y1, text, block_no, block_type)
+                    # The text is at index 4
+                    if len(block) >= 5:
+                        x0, y0, x1, y1 = block[0], block[1], block[2], block[3]
+                        text = block[4]
+                        
+                        # Skip non-text blocks
+                        if not isinstance(text, str) or not text.strip():
+                            continue
+                            
+                        text = self.normalize_text(text)
 
-                if not text or len(text) < 3:
+                        if not text or len(text) < 3:
+                            continue
+
+                        # 收集页眉候选（顶部15%）
+                        if y0 <= page_height * 0.15:
+                            all_headers.append(text)
+
+                        # 收集页脚候选（底部10%）
+                        if y1 >= page_height * 0.90:
+                            all_footers.append(text)
+
+            # 分析页眉页脚
+            header_candidates = {text for text, count in Counter(all_headers).items() if count >= 2}
+            footer_candidates = {text for text, count in Counter(all_footers).items() if count >= 2}
+
+            self.log(f"识别页眉: {list(header_candidates)[:5]}")  # Show first 5 only
+            self.log(f"识别页脚: {list(footer_candidates)[:5]}")  # Show first 5 only
+
+            # 第二轮：提取有效文本行
+            for page_num in range(len(doc)):
+                page = doc[page_num]
+                blocks = page.get_text("blocks")
+                page_height = page.rect.height
+
+                for block in blocks:
+                    # PyMuPDF blocks format: (x0, y0, x1, y1, text, block_no, block_type)
+                    if len(block) >= 5:
+                        x0, y0, x1, y1 = block[0], block[1], block[2], block[3]
+                        text = block[4]
+                        
+                        # Skip non-text blocks
+                        if not isinstance(text, str) or not text.strip():
+                            continue
+                            
+                        text = self.normalize_text(text)
+
+                        if not text:
+                            continue
+
+                        # 过滤页眉页脚
+                        is_header = (y0 <= page_height * 0.15 and text in header_candidates)
+                        is_footer = (y1 >= page_height * 0.90 and text in footer_candidates)
+
+                        if is_header:
+                            self.log(f"过滤页眉: {text[:30]}...")
+                            continue
+                        if is_footer:
+                            self.log(f"过滤页脚: {text[:30]}...")
+                            continue
+
+                        # 按行处理 - split the block text into individual lines
+                        for line in text.split('\n'):
+                            line = line.strip()
+                            if line and len(line) > 1:
+                                lines.append({
+                                    "page": page_num + 1,
+                                    "y": y0,
+                                    "x": x0,
+                                    "text": line
+                                })
+
+        except Exception as e:
+            self.log(f"按blocks提取失败: {str(e)}, 尝试按页面提取", "WARNING")
+            # If blocks method fails, try alternative method
+            for page_num in range(len(doc)):
+                page = doc[page_num]
+                try:
+                    # Extract text for the page
+                    text = page.get_text()
+                    if text:
+                        for line_num, line in enumerate(text.split('\n')):
+                            line = self.normalize_text(line)
+                            if line and len(line) > 1:
+                                lines.append({
+                                    "page": page_num + 1,
+                                    "y": line_num * 10,  # Approximate y position
+                                    "x": 0,  # Approximate x position
+                                    "text": line
+                                })
+                except Exception as page_error:
+                    self.log(f"页面 {page_num + 1} 提取失败: {str(page_error)}", "WARNING")
                     continue
 
-                # 收集页眉候选（顶部15%）
-                if y0 <= page_height * 0.15:
-                    all_headers.append(text)
-
-                # 收集页脚候选（底部10%）
-                if y1 >= page_height * 0.90:
-                    all_footers.append(text)
-
-        # 分析页眉页脚
-        header_candidates = {text for text, count in Counter(all_headers).items() if count >= 2}
-        footer_candidates = {text for text, count in Counter(all_footers).items() if count >= 2}
-
-        self.log(f"识别页眉: {header_candidates}")
-        self.log(f"识别页脚: {footer_candidates}")
-
-        # 第二轮：提取有效文本行
-        for page_num, page in enumerate(doc):
-            blocks = page.get_text("blocks")
-            page_height = page.rect.height
-
-            for block in blocks:
-                x0, y0, x1, y1, text = block[0], block[1], block[2], block[3], block[4]
-                text = self.normalize_text(text)
-
-                if not text:
-                    continue
-
-                # 过滤页眉页脚
-                is_header = (y0 <= page_height * 0.15 and text in header_candidates)
-                is_footer = (y1 >= page_height * 0.90 and text in footer_candidates)
-
-                if is_header:
-                    self.log(f"过滤页眉: {text}")
-                    continue
-                if is_footer:
-                    self.log(f"过滤页脚: {text}")
-                    continue
-
-                # 按行处理
-                for line in text.split('\n'):
-                    line = line.strip()
-                    if line and len(line) > 1:
-                        lines.append({
-                            "page": page_num + 1,
-                            "y": y0,
-                            "x": x0,
-                            "text": line
-                        })
-
         doc.close()
 
         # 按阅读顺序排序
@@ -330,12 +378,48 @@ class PDFExamParserEnhancedV2:
         self.log("=" * 50)
         self.log("开始增强版PDF解析")
 
+        # Check if PDF file exists and is accessible
+        if not pdf_path:
+            return {"success": False, "error": "PDF路径为空"}
+
+        if not os.path.exists(pdf_path):
+            return {"success": False, "error": f"PDF文件不存在: {pdf_path}"}
+
+        if not os.path.isfile(pdf_path):
+            return {"success": False, "error": f"路径不是文件: {pdf_path}"}
+
         try:
             # 1. 提取文本行
             lines = self.extract_lines_smart(pdf_path)
 
             if not lines:
-                return {"success": False, "error": "无法提取PDF文本"}
+                # Try one more method - extracting as plain text
+                self.log("尝试备用提取方法...")
+                try:
+                    doc = fitz.open(pdf_path)
+                    for page_num in range(len(doc)):
+                        page = doc[page_num]
+                        page_text = page.get_text()
+                        if page_text.strip():
+                            # Split page text into lines
+                            for line_num, line_text in enumerate(page_text.split('\n')):
+                                line_text = self.normalize_text(line_text.strip())
+                                if line_text and len(line_text) > 1:
+                                    lines.append({
+                                        "page": page_num + 1,
+                                        "y": line_num * 10,  # Approximate position
+                                        "x": 0,
+                                        "text": line_text
+                                    })
+                    doc.close()
+                    
+                    if lines:
+                        self.log(f"备用方法成功提取 {len(lines)} 行文本")
+                    else:
+                        return {"success": False, "error": "PDF内容为空或无法读取文本"}
+                except Exception as backup_error:
+                    self.log(f"备用方法失败: {str(backup_error)}", "ERROR")
+                    return {"success": False, "error": "无法提取PDF文本"}
 
             # 2. 提取原始文本用于题号补全
             original_text = "\n".join([line["text"] for line in lines])

frontend/src/views/Login.vue

@@ -1,15 +1,19 @@
 <template>
-  <div class="gradient-bg">
+  <div class="login-bg">
     <div class="login-container">
       <el-card class="login-card glass-effect">
         <template #header>
           <div class="card-header">
-            <h1>🧠 WordMaster Pro</h1>
-            <p>智能单词记忆大师</p>
+            <div class="logo-section">
+              <h1 class="app-title">
+                <span class="brain-emoji">🧠</span> WordMaster Pro
+              </h1>
+              <p class="app-subtitle">智能单词记忆大师</p>
+            </div>
           </div>
         </template>
         
-        <el-tabs v-model="activeTab" class="login-tabs">
+        <el-tabs v-model="activeTab" class="login-tabs" @tab-change="onTabChange">
           <el-tab-pane label="登录" name="login">
             <el-form 
               ref="loginFormRef" 
@@ -23,6 +27,8 @@
                   v-model="loginForm.username" 
                   placeholder="请输入用户名"
                   size="large"
+                  :prefix-icon="User"
+                  clearable
                 />
               </el-form-item>
               <el-form-item label="密码" prop="password">
@@ -31,9 +37,17 @@
                   type="password" 
                   placeholder="请输入密码"
                   size="large"
+                  :prefix-icon="Lock"
                   show-password
+                  @keyup.enter="handleLogin"
                 />
               </el-form-item>
+              <el-form-item>
+                <div class="remember-forgot">
+                  <el-checkbox v-model="loginForm.rememberMe">记住密码</el-checkbox>
+                  <el-link type="primary" :underline="false" @click="handleForgotPassword">忘记密码？</el-link>
+                </div>
+              </el-form-item>
               <el-form-item>
                 <el-button 
                   type="primary" 
@@ -41,9 +55,11 @@
                   style="width: 100%" 
                   :loading="loading"
                   @click="handleLogin"
-                  class="btn-gradient"
+                  class="login-button"
+                  :disabled="!loginForm.username || !loginForm.password"
                 >
-                  登录
+                  <span v-if="!loading">登录</span>
+                  <span v-else>登录中...</span>
                 </el-button>
               </el-form-item>
             </el-form>
@@ -62,6 +78,8 @@
                   v-model="registerForm.username" 
                   placeholder="请输入用户名"
                   size="large"
+                  :prefix-icon="User"
+                  clearable
                 />
               </el-form-item>
               <el-form-item label="邮箱" prop="email">
@@ -69,6 +87,8 @@
                   v-model="registerForm.email" 
                   placeholder="请输入邮箱"
                   size="large"
+                  :prefix-icon="Message"
+                  clearable
                 />
               </el-form-item>
               <el-form-item label="密码" prop="password">
@@ -77,6 +97,7 @@
                   type="password" 
                   placeholder="请输入密码"
                   size="large"
+                  :prefix-icon="Lock"
                   show-password
                 />
               </el-form-item>
@@ -86,6 +107,7 @@
                   type="password" 
                   placeholder="请确认密码"
                   size="large"
+                  :prefix-icon="Lock"
                   show-password
                 />
               </el-form-item>
@@ -96,24 +118,39 @@
                   style="width: 100%" 
                   :loading="loading"
                   @click="handleRegister"
-                  class="btn-gradient"
+                  class="register-button"
+                  :disabled="!registerForm.username || !registerForm.email || !registerForm.password || !registerForm.confirmPassword"
                 >
-                  注册
+                  <span v-if="!loading">注册</span>
+                  <span v-else>注册中...</span>
                 </el-button>
               </el-form-item>
             </el-form>
           </el-tab-pane>
         </el-tabs>
+        
+        <div class="social-login">
+          <p class="divider">或使用其他方式登录</p>
+          <div class="social-icons">
+            <el-button class="social-btn wechat" circle>
+              <span>WeChat</span>
+            </el-button>
+            <el-button class="social-btn qq" circle>
+              <span>QQ</span>
+            </el-button>
+          </div>
+        </div>
       </el-card>
     </div>
   </div>
 </template>
 
 <script setup>
-import { ref, reactive } from 'vue'
+import { ref, reactive, nextTick } from 'vue'
 import { useRouter } from 'vue-router'
-import { ElMessage } from 'element-plus'
+import { ElMessage, ElNotification } from 'element-plus'
 import { useAuthStore } from '../stores/auth'
+import { User, Lock, Message } from '@element-plus/icons-vue'
 
 const router = useRouter()
 const authStore = useAuthStore()
@@ -125,7 +162,8 @@ const registerFormRef = ref()
 
 const loginForm = reactive({
   username: '',
-  password: ''
+  password: '',
+  rememberMe: false
 })
 
 const registerForm = reactive({
@@ -174,129 +212,505 @@ const registerRules = {
 
 const handleLogin = async () => {
   if (!loginFormRef.value) return
-  
-  await loginFormRef.value.validate(async (valid) => {
-    if (valid) {
-      loading.value = true
-      try {
-        await authStore.login(loginForm)
-        ElMessage.success('登录成功')
-        router.push('/dashboard')
-      } catch (error) {
-        ElMessage.error(error.message)
-      } finally {
-        loading.value = false
-      }
+
+  try {
+    await loginFormRef.value.validate()
+
+    loading.value = true
+
+    await authStore.login(loginForm)
+    ElNotification({
+      title: '登录成功',
+      message: `欢迎回来，${loginForm.username}！准备好挑战今日新单词了吗？`,
+      type: 'success',
+      duration: 3000
+    })
+
+    // Small delay to ensure authentication state is fully set
+    await new Promise(resolve => setTimeout(resolve, 50))
+
+    // Force navigation to main dashboard with error handling
+    try {
+      await router.replace('/')
+      console.log('Navigation to / successful after login')
+    } catch (navError) {
+      console.error('Navigation error:', navError)
+      // Fallback: force window redirect if router fails
+      window.location.href = '/'
     }
-  })
+  } catch (error) {
+    // Handle validation errors (these come from element-plus validation)
+    if (error.message && error.message.includes('validate')) {
+      return
+    }
+
+    // Handle API errors (these come from authStore.login)
+    if (error.response) {
+      // Server responded with error status
+      const errorMessage = error.response.data?.detail || `登录失败: ${error.response.status}`
+      ElMessage.error(errorMessage)
+    } else if (error.request) {
+      // Request was made but no response received
+      ElMessage.error('网络连接错误，请检查网络')
+    } else {
+      // Other errors
+      ElMessage.error(error.message || '登录失败')
+    }
+  } finally {
+    loading.value = false
+  }
 }
 
 const handleRegister = async () => {
   if (!registerFormRef.value) return
-  
-  await registerFormRef.value.validate(async (valid) => {
-    if (valid) {
-      loading.value = true
-      try {
-        await authStore.register({
-          username: registerForm.username,
-          email: registerForm.email,
-          password: registerForm.password
-        })
-        ElMessage.success('注册成功')
-        router.push('/dashboard')
-      } catch (error) {
-        ElMessage.error(error.message)
-      } finally {
-        loading.value = false
-      }
+
+  try {
+    await registerFormRef.value.validate()
+
+    loading.value = true
+
+    await authStore.register({
+      username: registerForm.username,
+      email: registerForm.email,
+      password: registerForm.password
+    })
+    ElNotification({
+      title: '注册成功',
+      message: '账户创建成功，请登录开始学习！',
+      type: 'success',
+      duration: 3000
+    })
+
+    // Small delay to ensure authentication state is fully set
+    await new Promise(resolve => setTimeout(resolve, 50))
+
+    // Force navigation to main dashboard with error handling
+    try {
+      await router.replace('/')
+      console.log('Navigation to / successful after registration')
+    } catch (navError) {
+      console.error('Navigation error:', navError)
+      // Fallback: force window redirect if router fails
+      window.location.href = '/'
     }
-  })
+  } catch (error) {
+    // Handle validation errors (these come from element-plus validation)
+    if (error.message && error.message.includes('validate')) {
+      return
+    }
+
+    // Handle API errors (these come from authStore.register)
+    if (error.response) {
+      // Server responded with error status
+      const errorMessage = error.response.data?.detail || `注册失败: ${error.response.status}`
+      ElMessage.error(errorMessage)
+    } else if (error.request) {
+      // Request was made but no response received
+      ElMessage.error('网络连接错误，请检查网络')
+    } else {
+      // Other errors
+      ElMessage.error(error.message || '注册失败')
+    }
+  } finally {
+    loading.value = false
+  }
 }
+
+const handleForgotPassword = () => {
+  ElMessage.info('忘记密码功能开发中...')
+}
+
+const onTabChange = (tabName) => {
+  // Add animation or other effects when switching tabs
+  console.log('Tab changed to:', tabName)
+}
+
+// Add animation when component mounts
+const animateOnMount = () => {
+  // Add a slight delay to allow the component to render first
+  setTimeout(() => {
+    const card = document.querySelector('.login-card')
+    if (card) {
+      card.style.opacity = '0'
+      card.style.transform = 'translateY(20px)'
+      
+      // Animate in
+      setTimeout(() => {
+        card.style.transition = 'all 0.5s ease'
+        card.style.opacity = '1'
+        card.style.transform = 'translateY(0)'
+      }, 50)
+    }
+  }, 100)
+}
+
+// Call animation when component mounts
+import { onMounted } from 'vue'
+onMounted(() => {
+  animateOnMount()
+})
 </script>
 
 <style scoped>
-.login-container {
-  display: flex;
-  justify-content: center;
-  align-items: center;
+.login-bg {
   min-height: 100vh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
   padding: 20px;
+  position: relative;
+  overflow: hidden;
+}
+
+.login-bg::before {
+  content: '';
+  position: absolute;
+  top: -50%;
+  left: -50%;
+  width: 200%;
+  height: 200%;
+  background: radial-gradient(circle, rgba(255,255,255,0.1) 0%, rgba(255,255,255,0) 70%);
+  transform: rotate(30deg);
+  z-index: 0;
+}
+
+.login-container {
+  position: relative;
+  z-index: 1;
+  width: 100%;
+  max-width: 450px;
 }
 
 .login-card {
-  width: 100%;
-  max-width: 400px;
   border: none;
-  box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+  border-radius: 20px;
+  overflow: hidden;
+  position: relative;
+  box-shadow: 0 25px 45px rgba(0, 0, 0, 0.2);
+}
+
+.login-card.glass-effect {
+  background: rgba(255, 255, 255, 0.15);
+  backdrop-filter: blur(12px);
+  -webkit-backdrop-filter: blur(12px);
+  border: 1px solid rgba(255, 255, 255, 0.18);
 }
 
 .card-header {
   text-align: center;
+  padding: 30px 20px 20px;
+  background: rgba(255, 255, 255, 0.1);
+  border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.logo-section {
   color: white;
   text-shadow: 0 2px 10px rgba(0,0,0,0.3);
 }
 
-.card-header h1 {
-  margin: 0 0 10px 0;
-  font-size: 2.5em;
+.app-title {
+  margin: 0 0 8px 0;
+  font-size: 2.2em;
   font-weight: 700;
+  background: linear-gradient(45deg, #fff, #e0e0ff);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
 }
 
-.card-header p {
+.brain-emoji {
+  display: inline-block;
+  transition: transform 0.3s ease;
+}
+
+.app-title:hover .brain-emoji {
+  transform: scale(1.2) rotate(10deg);
+}
+
+.app-subtitle {
   margin: 0;
   font-size: 1.2em;
   opacity: 0.9;
+  font-weight: 300;
 }
 
 .login-tabs {
   margin-top: 20px;
+  padding: 0 25px 25px;
 }
 
 :deep(.el-tabs__header) {
-  margin: 0 0 20px 0;
+  margin: 0 0 25px 0;
+  padding: 0 10px;
+}
+
+:deep(.el-tabs__nav-wrap)::after {
+  background-color: rgba(255, 255, 255, 0.2);
 }
 
 :deep(.el-tabs__item) {
-  color: white;
+  color: rgba(255, 255, 255, 0.85);
   font-weight: 500;
+  font-size: 1.1em;
+  padding: 0 20px;
 }
 
 :deep(.el-tabs__item.is-active) {
-  color: #409eff;
+  color: white;
+  font-weight: 600;
 }
 
 :deep(.el-tabs__active-bar) {
-  background-color: #409eff;
+  background-color: white;
+  height: 3px;
+  border-radius: 2px;
+}
+
+:deep(.el-tabs__content) {
+  min-height: 280px;
 }
 
 :deep(.el-form-item__label) {
   color: white !important;
   font-weight: 500;
+  padding-bottom: 8px;
 }
 
 :deep(.el-input__wrapper) {
-  background-color: rgba(255, 255, 255, 0.1);
-  border: 1px solid rgba(255, 255, 255, 0.3);
-  border-radius: 8px;
+  background-color: rgba(255, 255, 255, 0.2) !important;
+  border: 1px solid rgba(255, 255, 255, 0.3) !important;
+  border-radius: 12px !important;
+  backdrop-filter: blur(10px);
+  transition: all 0.3s ease;
+}
+
+:deep(.el-input__wrapper):hover {
+  background-color: rgba(255, 255, 255, 0.25) !important;
+  border-color: rgba(255, 255, 255, 0.5) !important;
+}
+
+:deep(.el-input__wrapper.is-focus) {
+  background-color: rgba(255, 255, 255, 0.25) !important;
+  border-color: #409eff !important;
+  box-shadow: 0 0 0 2px rgba(64, 158, 255, 0.3) !important;
 }
 
 :deep(.el-input__inner) {
   color: white;
+  font-size: 1em;
 }
 
 :deep(.el-input__inner::placeholder) {
   color: rgba(255, 255, 255, 0.7);
 }
 
-.btn-gradient {
+:deep(.el-input__prefix) {
+  color: rgba(255, 255, 255, 0.7) !important;
+}
+
+:deep(.el-checkbox__label) {
+  color: white !important;
+}
+
+:deep(.el-link) {
+  color: rgba(255, 255, 255, 0.9) !important;
+}
+
+:deep(.el-link):hover {
+  color: white !important;
+}
+
+.remember-forgot {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 10px;
+}
+
+.login-button, .register-button {
   background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%) !important;
   border: none !important;
+  border-radius: 12px !important;
+  height: 48px !important;
+  font-size: 1.1em !important;
+  font-weight: 600 !important;
+  letter-spacing: 1px;
+  transition: all 0.3s ease;
+  position: relative;
+  overflow: hidden;
+}
+
+.login-button::after, .register-button::after {
+  content: '';
+  position: absolute;
+  top: -50%;
+  left: -50%;
+  width: 200%;
+  height: 200%;
+  background: rgba(255, 255, 255, 0.1);
+  transform: rotate(30deg);
+  transition: all 0.6s ease;
+  opacity: 0;
+}
+
+.login-button:hover, .register-button:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 10px 25px rgba(0, 0, 0, 0.3) !important;
+}
+
+.login-button:hover::after, .register-button:hover::after {
+  opacity: 1;
+  transform: rotate(30deg) translate(20%, 20%);
+}
+
+.login-button:active, .register-button:active {
+  transform: translateY(0);
+}
+
+.login-button:disabled, .register-button:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.social-login {
+  text-align: center;
+  margin-top: 25px;
+  padding-top: 20px;
+  border-top: 1px solid rgba(255, 255, 255, 0.2);
+}
+
+.divider {
+  color: rgba(255, 255, 255, 0.7);
+  margin-bottom: 20px;
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 0.9em;
+}
+
+.divider::before,
+.divider::after {
+  content: '';
+  flex: 1;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.2);
+}
+
+.divider::before {
+  margin-right: 15px;
+}
+
+.divider::after {
+  margin-left: 15px;
+}
+
+.social-icons {
+  display: flex;
+  justify-content: center;
+  gap: 20px;
+}
+
+.social-btn {
+  width: 50px;
+  height: 50px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(255, 255, 255, 0.2) !important;
+  border: 1px solid rgba(255, 255, 255, 0.3) !important;
+  color: white !important;
   transition: all 0.3s ease;
 }
 
-.btn-gradient:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 8px 25px rgba(0,0,0,0.3);
+.social-btn:hover {
+  background: rgba(255, 255, 255, 0.3) !important;
+  transform: translateY(-3px);
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.2);
+}
+
+.social-btn.wechat {
+  background: linear-gradient(135deg, #07c160 0%, #06a95c 100%) !important;
+}
+
+.social-btn.qq {
+  background: linear-gradient(135deg, #4c9beb 0%, #4489d3 100%) !important;
+}
+
+/* Animation for form validation errors */
+:deep(.el-form-item.is-error .el-input__wrapper) {
+  background-color: rgba(255, 0, 0, 0.1) !important;
+  border-color: #ff4d4d !important;
+  box-shadow: 0 0 0 2px rgba(255, 77, 77, 0.3) !important;
+}
+
+/* Loading animation enhancement */
+@keyframes pulse {
+  0% { box-shadow: 0 0 0 0 rgba(64, 158, 255, 0.7); }
+  70% { box-shadow: 0 0 0 12px rgba(64, 158, 255, 0); }
+  100% { box-shadow: 0 0 0 0 rgba(64, 158, 255, 0); }
+}
+
+:deep(.el-button.is-loading) {
+  position: relative;
+}
+
+:deep(.el-button.is-loading::after) {
+  content: '';
+  position: absolute;
+  top: -1px;
+  left: -1px;
+  right: -1px;
+  bottom: -1px;
+  border-radius: inherit;
+  animation: pulse 1.5s infinite;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+  .login-container {
+    max-width: 95%;
+    margin: 10px;
+  }
+  
+  .app-title {
+    font-size: 1.8em;
+  }
+  
+  .app-subtitle {
+    font-size: 1em;
+  }
+  
+  :deep(.el-tabs__item) {
+    font-size: 1em;
+    padding: 0 15px;
+  }
+  
+  .social-icons {
+    gap: 15px;
+  }
+  
+  .social-btn {
+    width: 45px;
+    height: 45px;
+  }
+}
+
+/* Additional visual enhancements */
+.glass-effect::before {
+  content: '';
+  position: absolute;
+  top: -10px;
+  right: -10px;
+  bottom: -10px;
+  left: -10px;
+  background: linear-gradient(135deg, rgba(255,255,255,0.1), rgba(255,255,255,0.05));
+  z-index: -1;
+  border-radius: 25px; /* Slightly larger than card for effect */
+  filter: blur(10px);
 }
 </style>

start.sh

@@ -1,48 +1,46 @@
-# 启动脚本
 #!/bin/bash
 
-echo "🚀 启动 WordMaster Pro 系统..."
+# 简化启动脚本 - 快速启动前后端应用
+# 作者: Qwen Assistant
+# 功能: 快速启动系统，带基本检查
 
-# 检查 Python 和 Node.js
+set -e  # 遇到错误立即退出
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# 打印带颜色的消息
+print_message() {
+    local color=$1
+    local message=$2
+    echo -e "${color}${message}${NC}"
+}
+
+print_message $BLUE "🚀 启动 WordMaster Pro 系统..."
+
+# 检查基本环境
 if ! command -v python3 &> /dev/null; then
-    echo "❌ Python3 未安装，请先安装 Python 3.7+"
+    print_message $RED "❌ Python3 未安装，请先安装 Python 3.8+"
     exit 1
 fi
 
 if ! command -v node &> /dev/null; then
-    echo "❌ Node.js 未安装，请先安装 Node.js 16+"
+    print_message $RED "❌ Node.js 未安装，请先安装 Node.js 16+"
     exit 1
 fi
 
-# 启动后端
-echo "📡 启动后端服务..."
-cd backend
-source venv/bin/activate
-uvicorn main:app --host 0.0.0.0 --port 8888 &
-BACKEND_PID=$!
-echo "✅ 后端已启动 (PID: $BACKEND_PID) - http://0.0.0.0:8888"
+print_message $GREEN "✅ 环境检查通过"
 
-# 等待后端启动
-sleep 3
+# 获取脚本目录
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
 
-# 启动前端
-echo "🎨 启动前端服务..."
-cd ../frontend
-npm run dev &
-FRONTEND_PID=$!
-echo "✅ 前端已启动 (PID: $FRONTEND_PID) - 端口将自动选择"
+# 建议使用优化版启动脚本
+print_message $YELLOW "💡 提示: 使用 ./start_app.sh 启动脚本可获得更好的稳定性、依赖检查和错误处理"
 
-echo ""
-echo "🎉 WordMaster Pro 启动成功！"
-echo "📖 前端访问地址: 请查看上方显示的实际端口 (支持远程访问)"
-echo "🔧 后端 API 地址: http://0.0.0.0:8888 (支持远程访问)"
-echo "📚 API 文档: http://localhost:8888/docs 或 http://[你的IP]:8888/docs"
-echo ""
-echo "按 Ctrl+C 停止服务"
-
-# 保存进程ID以便停止
-echo $BACKEND_PID > .backend.pid
-echo $FRONTEND_PID > .frontend.pid
-
-# 等待用户中断
-wait
+# 直接调用优化版启动脚本
+exec ./start_app.sh

start_app.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
 
-# 统一启动脚本 - 一键启动前后端应用
+# 统一启动脚本 - 一键启动前后端应用（优化版）
 # 作者: Qwen Assistant
-# 功能: 自动设置环境、启动后端和前端、管理进程
+# 功能: 自动设置环境、启动后端和前端、管理进程、处理依赖和端口冲突
 
 set -e  # 遇到错误立即退出
 
@@ -11,6 +11,8 @@ RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+CYAN='\033[0;36m'
 NC='\033[0m' # No Color
 
 # 打印带颜色的消息
@@ -20,61 +22,178 @@ print_message() {
     echo -e "${color}${message}${NC}"
 }
 
+# 日志记录函数
+log_message() {
+    local level=$1
+    local message=$2
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    echo "[$timestamp] [$level] $message" | tee -a "startup.log"
+}
+
 # 检查端口是否被占用
 check_port() {
     local port=$1
     if lsof -i :$port > /dev/null 2>&1; then
-        print_message $YELLOW "⚠️  端口 $port 已被占用"
-        return 0
+        return 0  # 端口被占用
     else
-        return 1
+        return 1  # 端口未被占用
     fi
 }
 
 # 生成随机可用端口
 get_available_port() {
     local start_port=$1
+    local max_attempts=50
     local port=$start_port
-    while lsof -i :$port > /dev/null 2>&1; do
+    local attempts=0
+    
+    while check_port $port && [ $attempts -lt $max_attempts ]; do
         port=$((port + 1))
+        attempts=$((attempts + 1))
     done
+    
+    if [ $attempts -eq $max_attempts ]; then
+        print_message $RED "❌ 无法找到可用端口，请手动释放相关端口"
+        exit 1
+    fi
+    
     echo $port
 }
 
-print_message $BLUE "🚀 开始启动 WordMaster Pro 系统..."
+# 检查依赖安装状态
+check_dependencies() {
+    local missing_deps=()
+    
+    # 检查 Python 依赖
+    if ! command -v python3 &> /dev/null; then
+        missing_deps+=("python3")
+    else
+        if ! python3 -c "import fastapi, uvicorn, sqlalchemy, pydantic, jwt, bcrypt, pandas, fitz, dotenv" > /dev/null 2>&1; then
+            missing_deps+=("python_backend_deps")
+        fi
+    fi
+    
+    # 检查 Node.js 依赖
+    if ! command -v node &> /dev/null; then
+        missing_deps+=("nodejs")
+    fi
+    
+    if ! command -v npm &> /dev/null; then
+        missing_deps+=("npm")
+    fi
+    
+    # 检查前端依赖
+    if [ -f "frontend/package.json" ] && [ ! -d "frontend/node_modules" ]; then
+        missing_deps+=("frontend_deps")
+    fi
+    
+    if [ ${#missing_deps[@]} -ne 0 ]; then
+        print_message $YELLOW "⚠️  检测到以下依赖缺失或未安装:"
+        for dep in "${missing_deps[@]}"; do
+            echo "   - $dep"
+        done
+        return 1
+    fi
+    
+    return 0
+}
 
-# 检查 Python 和 Node.js
+# 检查系统资源
+check_system_resources() {
+    print_message $BLUE "📊 系统资源检查:"
+    
+    if command -v free &> /dev/null; then
+        # Linux system
+        mem_available=$(free -m | awk 'NR==2{printf "%.1f", $7/1024}')
+        disk_available=$(df . | awk 'NR==2{printf "%d", $4/1024}')
+        
+        print_message $CYAN "   可用内存: ${mem_available}GB"
+        print_message $CYAN "   可用磁盘: ${disk_available}MB"
+        
+        if (( $(echo "$mem_available < 0.5" | bc -l 2>/dev/null || echo "0") )); then
+            print_message $YELLOW "⚠️  可用内存较少，可能影响启动性能"
+        fi
+        
+        if [ $disk_available -lt 500 ]; then
+            print_message $YELLOW "⚠️  可用磁盘空间较少，可能影响应用运行"
+        fi
+    else
+        # macOS system - use vm_stat for memory and df for disk
+        # Memory check for macOS using vm_stat
+        page_size=$(vm_stat | grep "page size" | awk '{print $6}' | sed 's/bytes//')
+        free_pages=$(vm_stat | grep free | awk '{print $3}' | sed 's/\.//')
+        inactive_pages=$(vm_stat | grep inactive | awk '{print $3}' | sed 's/\.//')
+        free_memory=$(( (free_pages + inactive_pages) * page_size / 1024 / 1024 / 1024 ))
+        
+        # Disk space check for macOS
+        disk_available=$(df . | awk 'NR==2{printf "%d", $4/1024}')  # Convert to MB
+        
+        print_message $CYAN "   可用内存估算: ${free_memory}GB"
+        print_message $CYAN "   可用磁盘: ${disk_available}MB"
+        
+        if [ $free_memory -lt 1 ]; then
+            print_message $YELLOW "⚠️  可用内存较少，可能影响启动性能"
+        fi
+        
+        if [ $disk_available -lt 500 ]; then
+            print_message $YELLOW "⚠️  可用磁盘空间较少，可能影响应用运行"
+        fi
+    fi
+}
+
+print_message $BLUE "🚀 开始启动 WordMaster Pro 系统 (优化版)..."
+
+# 记录启动过程
+log_message "INFO" "开始启动 WordMaster Pro 系统"
+
+# 获取脚本目录
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# 检查系统资源
+check_system_resources
+
+# 检查必要命令
+print_message $BLUE "🔍 检查系统环境..."
 if ! command -v python3 &> /dev/null; then
+    log_message "ERROR" "Python3 未安装，请先安装 Python 3.8+"
     print_message $RED "❌ Python3 未安装，请先安装 Python 3.8+"
     exit 1
 fi
 
 if ! command -v node &> /dev/null; then
+    log_message "ERROR" "Node.js 未安装，请先安装 Node.js 16+"
     print_message $RED "❌ Node.js 未安装，请先安装 Node.js 16+"
     exit 1
 fi
 
 if ! command -v npm &> /dev/null; then
+    log_message "ERROR" "npm 未安装，请先安装 Node.js 16+ (包含npm)"
     print_message $RED "❌ npm 未安装，请先安装 Node.js 16+ (包含npm)"
     exit 1
 fi
 
-# 准备工作目录
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR"
+if ! command -v lsof &> /dev/null; then
+    log_message "ERROR" "lsof 未安装，无法检查端口占用"
+    print_message $RED "❌ lsof 未安装，无法检查端口占用"
+    exit 1
+fi
+
+print_message $GREEN "✅ 系统环境检查通过"
 
 # 加载环境变量
-if [ -f ".env" ]; then
+ENV_FILE=".env"
+if [ -f "$ENV_FILE" ]; then
     print_message $BLUE "🔧 加载环境变量配置..."
-    export $(grep -v '^#' .env | xargs)
+    export $(grep -v '^#' "$ENV_FILE" | xargs)
     BACKEND_PORT=${BACKEND_PORT:-8888}
     FRONTEND_PORT=${FRONTEND_PORT:-3008}
-    DATABASE_URL=${DATABASE_URL:-"postgresql://postgres:postgres@localhost:5432/wordmaster"}
+    DATABASE_URL=${DATABASE_URL:-"sqlite:///./wordmaster.db"}
 else
-    print_message $YELLOW "⚠️  未找到 .env 文件，使用默认配置"
+    print_message $YELLOW "⚠️  未找到 $ENV_FILE 文件，使用默认配置"
     BACKEND_PORT=8888
     FRONTEND_PORT=3008
-    DATABASE_URL="postgresql://postgres:postgres@localhost:5432/wordmaster"
+    DATABASE_URL="sqlite:///./wordmaster.db"
 fi
 
 print_message $BLUE "🔧 使用配置信息:"
@@ -82,122 +201,178 @@ print_message $GREEN "   后端端口: $BACKEND_PORT"
 print_message $GREEN "   前端端口: $FRONTEND_PORT"
 print_message $GREEN "   数据库: $DATABASE_URL"
 
-# 检查并创建后端虚拟环境
-print_message $BLUE "🔧 检查后端环境..."
-if [ ! -d "backend/venv" ]; then
-    print_message $YELLOW "⚠️  检测到虚拟环境不存在，正在创建..."
-    python3 -m venv backend/venv
-    print_message $GREEN "✅ 虚拟环境创建成功"
-fi
-
-# 激活虚拟环境并检查依赖
-source backend/venv/bin/activate
-
-# 检查依赖是否已安装
-if ! python -c "import fastapi, uvicorn, sqlalchemy, pydantic, jwt, bcrypt, pandas, fitz, dotenv" > /dev/null 2>&1; then
-    print_message $YELLOW "⚠️  检测到依赖未完全安装，正在安装..."
-    cd backend
-    if [ ! -f "requirements.txt" ]; then
-        print_message $RED "❌ requirements.txt 不存在"
-        exit 1
-    fi
-    
-    pip install --upgrade pip
-    pip install -r requirements.txt
-    
-    # 确保安装了 PyMuPDF
-    pip install PyMuPDF
-    cd ..
-    print_message $GREEN "✅ 依赖安装完成"
-else
-    print_message $GREEN "✅ 后端依赖已安装"
-fi
-
 # 检查并清理之前的进程
 print_message $BLUE "🧹 检查并清理之前的进程..."
 if [ -f ".backend.pid" ]; then
     OLD_BACKEND_PID=$(cat .backend.pid)
     if ps -p $OLD_BACKEND_PID > /dev/null 2>&1; then
         print_message $YELLOW "⚠️  发现已存在的后端进程 $OLD_BACKEND_PID，正在停止..."
-        kill $OLD_BACKEND_PID
+        kill $OLD_BACKEND_PID 2>/dev/null || true
+        sleep 2
+        # 等待进程终止
+        attempts=0
+        while ps -p $OLD_BACKEND_PID > /dev/null 2>&1 && [ $attempts -lt 10 ]; do
+            sleep 1
+            attempts=$((attempts + 1))
+        done
+        # 如果仍未终止，强制杀死
+        if ps -p $OLD_BACKEND_PID > /dev/null 2>&1; then
+            print_message $YELLOW "⏳ 强制终止后端进程..."
+            kill -9 $OLD_BACKEND_PID 2>/dev/null || true
+        fi
     fi
-    rm .backend.pid
+    rm -f .backend.pid
 fi
 
 if [ -f ".frontend.pid" ]; then
     OLD_FRONTEND_PID=$(cat .frontend.pid)
     if ps -p $OLD_FRONTEND_PID > /dev/null 2>&1; then
         print_message $YELLOW "⚠️  发现已存在的前端进程 $OLD_FRONTEND_PID，正在停止..."
-        kill $OLD_FRONTEND_PID
+        kill $OLD_FRONTEND_PID 2>/dev/null || true
+        sleep 2
+        # 等待进程终止
+        attempts=0
+        while ps -p $OLD_FRONTEND_PID > /dev/null 2>&1 && [ $attempts -lt 10 ]; do
+            sleep 1
+            attempts=$((attempts + 1))
+        done
+        # 如果仍未终止，强制杀死
+        if ps -p $OLD_FRONTEND_PID > /dev/null 2>&1; then
+            print_message $YELLOW "⏳ 强制终止前端进程..."
+            kill -9 $OLD_FRONTEND_PID 2>/dev/null || true
+        fi
     fi
-    rm .frontend.pid
+    rm -f .frontend.pid
 fi
 
 # 检查端口占用情况
+print_message $BLUE "🔍 检查端口占用情况..."
 if check_port $BACKEND_PORT; then
-    print_message $YELLOW "⚠️  后端端口 $BACKEND_PORT 被占用，尝试寻找可用端口..."
+    print_message $YELLOW "⚠️  后端端口 $BACKEND_PORT 被占用，寻找可用端口..."
     BACKEND_PORT=$(get_available_port 8888)
-    print_message $YELLOW "ℹ️  使用后端端口: $BACKEND_PORT"
+    print_message $GREEN "ℹ️  使用后端端口: $BACKEND_PORT"
 fi
 
 if check_port $FRONTEND_PORT; then
-    print_message $YELLOW "⚠️  前端端口 $FRONTEND_PORT 被占用，尝试寻找可用端口..."
+    print_message $YELLOW "⚠️  前端端口 $FRONTEND_PORT 被占用，寻找可用端口..."
     FRONTEND_PORT=$(get_available_port 3008)
-    print_message $YELLOW "ℹ️  使用前端端口: $FRONTEND_PORT"
+    print_message $GREEN "ℹ️  使用前端端口: $FRONTEND_PORT"
 fi
 
-# 检查PostgreSQL数据库连接
-print_message $BLUE "🔍 检查PostgreSQL数据库连接..."
-if ! command -v psql &> /dev/null; then
-    print_message $YELLOW "⚠️  psql 未安装，跳过数据库连接检查"
-else
-    DB_HOST=$(echo $DATABASE_URL | sed -n 's/.*@//p' | cut -d':' -f1)
-    DB_PORT=$(echo $DATABASE_URL | sed -n 's/.*://p' | cut -d'/' -f1)
-    if [ "$DB_HOST" == "localhost" ] || [ "$DB_HOST" == "127.0.0.1" ]; then
-        if ! lsof -i :$DB_PORT | grep LISTEN > /dev/null 2>&1; then
-            print_message $YELLOW "⚠️  PostgreSQL 服务未在端口 $DB_PORT 上运行"
-        else
-            print_message $GREEN "✅ PostgreSQL 服务运行正常"
-        fi
+# 检查依赖状态
+print_message $BLUE "🔍 检查依赖安装状态..."
+if ! check_dependencies; then
+    print_message $YELLOW "⚠️  检测到依赖缺失，正在尝试自动安装..."
+    
+    # 检查并创建后端虚拟环境
+    if [ ! -d "backend/venv" ]; then
+        print_message $BLUE "🔧 创建后端虚拟环境..."
+        python3 -m venv backend/venv
+        print_message $GREEN "✅ 虚拟环境创建成功"
     fi
+
+    # 激活虚拟环境
+    source backend/venv/bin/activate
+    
+    # 检查并安装后端依赖
+    if ! python -c "import fastapi, uvicorn, sqlalchemy, pydantic, jwt, bcrypt, pandas, fitz, dotenv" > /dev/null 2>&1; then
+        print_message $BLUE "🔧 安装后端依赖..."
+        cd backend
+        if [ ! -f "requirements.txt" ]; then
+            print_message $RED "❌ requirements.txt 不存在"
+            exit 1
+        fi
+        
+        pip install --upgrade pip
+        if ! pip install -r requirements.txt; then
+            print_message $RED "❌ 后端依赖安装失败"
+            exit 1
+        fi
+        cd ..
+        print_message $GREEN "✅ 后端依赖安装完成"
+    fi
+    
+    # 检查并安装前端依赖
+    if [ -f "frontend/package.json" ] && [ ! -d "frontend/node_modules" ]; then
+        print_message $BLUE "🔧 安装前端依赖..."
+        cd frontend
+        if ! npm install; then
+            print_message $RED "❌ 前端依赖安装失败"
+            exit 1
+        fi
+        cd ..
+        print_message $GREEN "✅ 前端依赖安装完成"
+    fi
+else
+    print_message $GREEN "✅ 依赖检查通过"
 fi
 
+# 激活后端虚拟环境
+print_message $BLUE "🔧 激活后端虚拟环境..."
+source backend/venv/bin/activate
+
 # 启动后端
 print_message $BLUE "📡 启动后端服务 (端口: $BACKEND_PORT)..."
 cd backend
-nohup uvicorn main:app --host 0.0.0.0 --port $BACKEND_PORT > backend.log 2>&1 &
+
+# 清理旧日志文件（保留最近的）
+if [ -f "backend.log" ]; then
+    mv backend.log backend.log.prev 2>/dev/null || true
+fi
+
+# 启动后端服务
+nohup uvicorn main:app --host 0.0.0.0 --port $BACKEND_PORT --log-level info > backend.log 2>&1 &
 BACKEND_PID=$!
 echo $BACKEND_PID > ../.backend.pid
+
 print_message $GREEN "✅ 后端已启动 (PID: $BACKEND_PID, 端口: $BACKEND_PORT)"
+log_message "INFO" "后端服务启动成功 (PID: $BACKEND_PID, 端口: $BACKEND_PORT)"
 
-# 等待后端启动
-print_message $BLUE "⏳ 等待后端服务启动..."
-sleep 5
+# 等待后端启动并验证
+print_message $BLUE "⏳ 验证后端服务启动状态..."
+backend_attempts=0
+backend_ready=false
 
-# 验证后端是否成功启动
-if ! kill -0 $BACKEND_PID 2>/dev/null; then
-    print_message $RED "❌ 后端启动失败，请检查 backend.log 文件"
-    exit 1
-else
-    if curl -s "http://localhost:$BACKEND_PORT/docs" > /dev/null; then
-        print_message $GREEN "✅ 后端API服务运行正常"
+while [ $backend_attempts -lt 30 ]; do  # 最多等待30秒
+    if kill -0 $BACKEND_PID 2>/dev/null; then
+        if curl -s --max-time 5 "http://localhost:$BACKEND_PORT/docs" > /dev/null; then
+            print_message $GREEN "✅ 后端API服务运行正常"
+            backend_ready=true
+            break
+        else
+            print_message $CYAN "⏳ 等待后端服务完全启动... ($backend_attempts/30)"
+        fi
     else
-        print_message $YELLOW "⚠️  后端进程运行中，但API可能未完全就绪 (继续启动前端)"
+        print_message $RED "❌ 后端进程已终止"
+        break
     fi
+    sleep 1
+    backend_attempts=$((backend_attempts + 1))
+done
+
+if [ "$backend_ready" = false ]; then
+    print_message $RED "❌ 后端服务启动超时或无法访问"
+    log_message "ERROR" "后端服务启动失败"
+    
+    # 检查后端日志
+    if [ -f "backend.log" ]; then
+        print_message $RED "📋 后端错误日志最后10行:"
+        tail -10 backend.log
+    fi
+    
+    exit 1
 fi
 
 # 启动前端
-print_message $BLUE "🎨 启前端服务 (端口: $FRONTEND_PORT)..."
+print_message $BLUE "🎨 启动前端服务 (端口: $FRONTEND_PORT)..."
 cd ../frontend
 
-# 检查是否已安装前端依赖
-if [ ! -d "node_modules" ]; then
-    print_message $YELLOW "⚠️  检测到 node_modules 不存在，正在安装依赖..."
-    npm install
-    print_message $GREEN "✅ 前端依赖安装完成"
+# 清理旧日志文件（保留最近的）
+if [ -f "frontend.log" ]; then
+    mv frontend.log frontend.log.prev 2>/dev/null || true
 fi
 
-# 确保环境变量文件包含正确的端口 - 从.env.development读取并更新端口
+# 确保环境变量文件包含正确的端口
 if [ -f ".env.development" ]; then
     # 更新 .env.development with the correct backend port
     sed -i.bak "s|VITE_BACKEND_PORT=.*|VITE_BACKEND_PORT=$BACKEND_PORT|" .env.development 2>/dev/null || true
@@ -220,42 +395,67 @@ VITE_BACKEND_PORT=$BACKEND_PORT
 
 # 调试配置
 VITE_DEBUG=true
-VITE_LOG_LEVEL=debug
+VITE_LOG_LEVEL=info
 VITE_SERVER_PORT=$FRONTEND_PORT
 EOF
     print_message $GREEN "✅ 创建了前端环境配置文件"
 fi
 
-# 启动前端 - explicitly specify the port for Vite
-nohup npm run dev -- --port $FRONTEND_PORT > frontend.log 2>&1 &
+# 启动前端 - 使用指定端口
+if command -v timeout >/dev/null 2>&1; then
+    # timeout 命令可用
+    timeout 60s npm run dev -- --port $FRONTEND_PORT > ../frontend.log 2>&1 &
+else
+    # timeout 命令不可用，直接启动
+    npm run dev -- --port $FRONTEND_PORT > ../frontend.log 2>&1 &
+fi
+
 FRONTEND_PID=$!
 echo $FRONTEND_PID > ../.frontend.pid
+
 print_message $GREEN "✅ 前端已启动 (PID: $FRONTEND_PID, 端口: $FRONTEND_PORT)"
+log_message "INFO" "前端服务启动成功 (PID: $FRONTEND_PID, 端口: $FRONTEND_PORT)"
 
-# 等待前端启动
-print_message $BLUE "⏳ 等待前端服务启动..."
-sleep 8
+# 等待前端启动并验证
+print_message $BLUE "⏳ 验证前端服务启动状态..."
+frontend_attempts=0
+frontend_ready=false
 
-# 验证前端是否成功启动
-if ! kill -0 $FRONTEND_PID 2>/dev/null; then
-    print_message $RED "❌ 前端启动失败，请检查 frontend.log 文件"
-    exit 1
-else
-    if curl -s "http://localhost:$FRONTEND_PORT" > /dev/null; then
-        print_message $GREEN "✅ 前端服务运行正常"
+while [ $frontend_attempts -lt 45 ]; do  # 最多等待45秒，因为前端启动通常需要更多时间
+    if kill -0 $FRONTEND_PID 2>/dev/null; then
+        # 尝试访问前端服务
+        if curl -s --max-time 5 "http://localhost:$FRONTEND_PORT" > /dev/null; then
+            print_message $GREEN "✅ 前端服务运行正常"
+            frontend_ready=true
+            break
+        else
+            print_message $CYAN "⏳ 等待前端服务完全启动... ($frontend_attempts/45)"
+        fi
     else
-        print_message $YELLOW "⚠️  前端进程运行中，但可能需要更多时间启动"
+        print_message $YELLOW "⚠️  前端进程可能已重启或仍在启动中... ($frontend_attempts/45)"
     fi
+    sleep 1
+    frontend_attempts=$((frontend_attempts + 1))
+done
+
+if [ "$frontend_ready" = false ]; then
+    print_message $YELLOW "⚠️  前端服务可能需要更多时间启动（后台继续运行）"
+    log_message "WARNING" "前端服务启动时间较长"
+else
+    log_message "INFO" "前端服务启动完成"
 fi
 
 # 显示启动完成信息
+print_message $GREEN ""
 print_message $GREEN "🎉 WordMaster Pro 系统启动成功！"
+print_message $GREEN ""
 
 echo ""
 print_message $BLUE "📝 访问地址:"
 print_message $GREEN "📖 前端访问地址: http://localhost:$FRONTEND_PORT"
-print_message $GREEN "🔧 后端 API 地址: http://localhost:$BACKEND_PORT"
+print_message $GREEN "🔧 后端 API 地址: http://localhost:$BACKEND_PORT" 
 print_message $GREEN "📚 API 文档: http://localhost:$BACKEND_PORT/docs"
+print_message $GREEN "🌐 支持远程访问 (通过服务器IP:端口访问)"
 echo ""
 
 print_message $BLUE "📋 进程信息:"
@@ -263,8 +463,25 @@ print_message $GREEN "📡 后端进程 PID: $(cat .backend.pid)"
 print_message $GREEN "🎨 前端进程 PID: $(cat .frontend.pid)"
 echo ""
 
-print_message $YELLOW "💡 提示: 使用 ./stop_app.sh 停止应用程序"
-print_message $YELLOW "📋 日志文件: backend.log 和 frontend.log"
+print_message $BLUE "📁 日志文件:"
+print_message $CYAN "   后端日志: $(pwd)/backend/backend.log"
+print_message $CYAN "   前端日志: $(pwd)/frontend/frontend.log"
+print_message $CYAN "   启动日志: $(pwd)/startup.log"
+echo ""
 
-# 后台运行，不阻塞终端
-print_message $BLUE "✅ 应用程序已在后台运行"
+print_message $YELLOW "💡 提示:"
+print_message $YELLOW "   - 使用 ./stop_app.sh 停止应用程序"
+print_message $YELLOW "   - 使用 ./status_app.sh 检查应用程序状态"
+print_message $YELLOW "   - 实时查看后端日志: tail -f backend/backend.log"
+print_message $YELLOW "   - 实时查看前端日志: tail -f frontend/frontend.log"
+print_message $YELLOW "   - 如遇问题，请查看日志并重新启动"
+echo ""
+
+print_message $GREEN "📋 要实时监控日志，可使用以下命令："
+print_message $CYAN "   后端实时日志: tail -f backend/backend.log"
+print_message $CYAN "   前端实时日志: tail -f frontend/frontend.log"
+print_message $CYAN "   同时查看: tail -f backend/backend.log frontend/frontend.log"
+
+log_message "INFO" "WordMaster Pro 系统启动完成"
+
+print_message $GREEN "✅ 应用程序已在后台稳定运行！"

status_app.sh

@@ -1,13 +1,16 @@
 #!/bin/bash
 
-# 状态检查脚本 - 检查应用运行状态
+# 状态检查脚本 - 检查应用运行状态（优化版）
 # 作者: Qwen Assistant
+# 功能: 检查应用运行状态、系统资源使用情况、日志分析
 
 # 颜色定义
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+CYAN='\033[0;36m'
 NC='\033[0m' # No Color
 
 # 打印带颜色的消息
@@ -17,8 +20,19 @@ print_message() {
     echo -e "${color}${message}${NC}"
 }
 
-print_message $BLUE "🔍 WordMaster Pro 系统状态检查"
-echo "================================"
+# 日志记录函数
+log_message() {
+    local level=$1
+    local message=$2
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    echo "[$timestamp] [$level] $message" | tee -a "status.log"
+}
+
+print_message $BLUE "🔍 WordMaster Pro 系统状态检查 (优化版)"
+echo "=============================================="
+
+# 记录状态检查
+log_message "INFO" "开始系统状态检查"
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 cd "$SCRIPT_DIR"
@@ -33,23 +47,85 @@ else
     FRONTEND_PORT=3008
 fi
 
+# 显示系统信息
+print_message $BLUE "🖥️  系统信息:"
+print_message $CYAN "   操作系统: $(uname -s)"
+print_message $CYAN "   主机名: $(hostname)"
+print_message $CYAN "   当前时间: $(date)"
+echo ""
+
+# 检查系统资源
+print_message $BLUE "📊 系统资源状态:"
+if command -v free &> /dev/null; then
+    mem_total=$(free -m | awk 'NR==2{printf "%.1f", $2/1024}')
+    mem_used=$(free -m | awk 'NR==2{printf "%.1f", $3/1024}')
+    mem_available=$(free -m | awk 'NR==2{printf "%.1f", $7/1024}')
+    mem_percent=$(free | awk 'NR==2{printf "%.1f", $3*100/$2}')
+    print_message $CYAN "   内存: 已用 ${mem_total}GB / 总计 ${mem_total}GB (${mem_percent:-N/A}% 使用率)"
+    print_message $CYAN "   可用内存: ${mem_available:-N/A}GB"
+else
+    # 适用于 macOS 的内存检查
+    if command -v vm_stat &> /dev/null; then
+        page_size=$(vm_stat | grep "page size" | awk '{print $6}' | sed 's/bytes//')
+        free_pages=$(vm_stat | grep free | awk '{print $3}' | sed 's/\.//')
+        inactive_pages=$(vm_stat | grep inactive | awk '{print $3}' | sed 's/\.//')
+        free_memory=$(( (free_pages + inactive_pages) * page_size / 1024 / 1024 / 1024 ))
+        print_message $CYAN "   可用内存 (估算): ${free_memory}GB"
+    fi
+fi
+
+if command -v df &> /dev/null; then
+    disk_usage=$(df -h . | awk 'NR==2 {print $5}' | sed 's/%//')
+    disk_total=$(df -h . | awk 'NR==2 {print $2}')
+    disk_used=$(df -h . | awk 'NR==2 {print $3}')
+    disk_available=$(df -h . | awk 'NR==2 {print $4}')
+    print_message $CYAN "   磁盘: 已用 ${disk_used} / 总计 ${disk_total} (${disk_usage:-N/A}% 使用率)"
+    print_message $CYAN "   可用磁盘: ${disk_available}"
+fi
+
+# 适用于 macOS 的 CPU 检查
+if command -v top &> /dev/null; then
+    cpu_usage=$(top -l 1 | grep "CPU usage" | awk '{print $3}' | sed 's/%//' | cut -d'.' -f1)
+    print_message $CYAN "   CPU 使用率: ${cpu_usage:-N/A}%"
+fi
+echo ""
+
 # 检查后端状态
 print_message $BLUE "📡 后端服务状态 (端口: $BACKEND_PORT):"
 if [ -f ".backend.pid" ]; then
     BACKEND_PID=$(cat .backend.pid)
-    if ps -p $BACKEND_PID > /dev/null 2>&1; then
+    if [ ! -z "$BACKEND_PID" ] && ps -p $BACKEND_PID > /dev/null 2>&1; then
         print_message $GREEN "  ✅ 后端进程运行中 (PID: $BACKEND_PID)"
+        
+        # 检查进程详细信息
+        backend_cpu=$(ps -p $BACKEND_PID -o %cpu --no-headers 2>/dev/null | xargs || echo "N/A")
+        backend_mem=$(ps -p $BACKEND_PID -o %mem --no-headers 2>/dev/null | xargs || echo "N/A")
+        print_message $CYAN "     CPU使用率: ${backend_cpu}%, 内存使用率: ${backend_mem}%"
+        
         # 尝试访问API文档
-        if curl -s "http://localhost:$BACKEND_PORT/docs" > /dev/null 2>&1; then
+        if curl -s --max-time 10 "http://localhost:$BACKEND_PORT/docs" > /dev/null 2>&1; then
             print_message $GREEN "  ✅ API服务可访问"
         else
             print_message $YELLOW "  ⚠️  API服务可能未就绪"
         fi
+        
+        # 检查端口监听状态
+        if lsof -i :$BACKEND_PORT > /dev/null 2>&1; then
+            print_message $GREEN "  ✅ 端口 $BACKEND_PORT 正在监听"
+        else
+            print_message $RED "  ❌ 端口 $BACKEND_PORT 未监听"
+        fi
     else
         print_message $RED "  ❌ 后端进程未运行 (PID: $BACKEND_PID)"
     fi
 else
     print_message $RED "  ❌ 后端进程未启动"
+    
+    # 查找可能的后端进程
+    possible_pids=$(pgrep -f "uvicorn.*main:app" 2>/dev/null || echo "")
+    if [ ! -z "$possible_pids" ]; then
+        print_message $YELLOW "  ⚠️  检测到可能的后端进程: $possible_pids (但没有 PID 文件)"
+    fi
 fi
 
 echo ""
@@ -58,61 +134,190 @@ echo ""
 print_message $BLUE "🎨 前端服务状态 (端口: $FRONTEND_PORT):"
 if [ -f ".frontend.pid" ]; then
     FRONTEND_PID=$(cat .frontend.pid)
-    if ps -p $FRONTEND_PID > /dev/null 2>&1; then
+    if [ ! -z "$FRONTEND_PID" ] && ps -p $FRONTEND_PID > /dev/null 2>&1; then
         print_message $GREEN "  ✅ 前端进程运行中 (PID: $FRONTEND_PID)"
-        # 尝试访问 frontend
-        if curl -s "http://localhost:$FRONTEND_PORT" > /dev/null 2>&1; then
+        
+        # 检查进程详细信息
+        frontend_cpu=$(ps -p $FRONTEND_PID -o %cpu --no-headers 2>/dev/null | xargs || echo "N/A")
+        frontend_mem=$(ps -p $FRONTEND_PID -o %mem --no-headers 2>/dev/null | xargs || echo "N/A")
+        print_message $CYAN "     CPU使用率: ${frontend_cpu}%, 内存使用率: ${frontend_mem}%"
+        
+        # 尝试访问前端
+        if curl -s --max-time 10 "http://localhost:$FRONTEND_PORT" > /dev/null 2>&1; then
             print_message $GREEN "  ✅ 前端服务可访问"
         else
             print_message $YELLOW "  ⚠️  前端服务可能未就绪"
         fi
+        
+        # 检查端口监听状态
+        if lsof -i :$FRONTEND_PID > /dev/null 2>&1; then
+            print_message $GREEN "  ✅ 端口 $FRONTEND_PID 正在监听"
+        else
+            print_message $RED "  ❌ 端口 $FRONTEND_PID 未监听"
+        fi
     else
         print_message $RED "  ❌ 前端进程未运行 (PID: $FRONTEND_PID)"
     fi
 else
     print_message $RED "  ❌ 前端进程未启动"
+    
+    # 查找可能的前端进程
+    possible_pids=$(pgrep -f "vite" 2>/dev/null || echo "")
+    if [ ! -z "$possible_pids" ]; then
+        print_message $YELLOW "  ⚠️  检测到可能的前端进程: $possible_pids (但没有 PID 文件)"
+    fi
 fi
 
 echo ""
 
+# 检查所有相关进程
+print_message $BLUE "📋 系统中所有相关进程:"
+all_backend_pids=$(pgrep -f "uvicorn.*main:app" 2>/dev/null)
+all_frontend_pids=$(pgrep -f "vite" 2>/dev/null)
+
+if [ ! -z "$all_backend_pids" ]; then
+    print_message $CYAN "  后端相关进程 (uvicorn):"
+    for pid in $all_backend_pids; do
+        cmd=$(ps -p $pid -o args --no-headers 2>/dev/null || echo "Unknown")
+        print_message $CYAN "    PID $pid: $cmd"
+    done
+else
+    print_message $YELLOW "  未找到后端相关进程 (uvicorn)"
+fi
+
+if [ ! -z "$all_frontend_pids" ]; then
+    print_message $CYAN "  前端相关进程 (vite):"
+    for pid in $all_frontend_pids; do
+        cmd=$(ps -p $pid -o args --no-headers 2>/dev/null || echo "Unknown")
+        print_message $CYAN "    PID $pid: $cmd"
+    done
+else
+    print_message $YELLOW "  未找到前端相关进程 (vite)"
+fi
+echo ""
+
+# 检查网络端口状态
+print_message $BLUE "🌐 网络端口状态:"
+print_message $CYAN "  后端端口 $BACKEND_PORT: $(if lsof -i :$BACKEND_PORT > /dev/null 2>&1; then echo "✅ 监听中"; else echo "❌ 未监听"; fi)"
+print_message $CYAN "  前端端口 $FRONTEND_PORT: $(if lsof -i :$FRONTEND_PORT > /dev/null 2>&1; then echo "✅ 监听中"; else echo "❌ 未监听"; fi)"
+echo ""
+
 # 检查日志文件
 print_message $BLUE "📋 日志文件信息:"
-if [ -f "backend.log" ]; then
-    BACKEND_LOG_SIZE=$(du -h backend.log | cut -f1)
-    print_message $BLUE "  后端日志: $(pwd)/backend.log ($BACKEND_LOG_SIZE)"
-    print_message $BLUE "  最后5行日志:"
-    tail -5 backend.log | sed 's/^/    /'
-else
-    print_message $YELLOW "  后端日志: 不存在"
-fi
+log_files=("backend.log" "frontend.log" "startup.log" "stop.log" "status.log")
 
-if [ -f "frontend.log" ]; then
-    FRONTEND_LOG_SIZE=$(du -h frontend.log | cut -f1)
-    print_message $BLUE "  前端日志: $(pwd)/frontend.log ($FRONTEND_LOG_SIZE)"
-    print_message $BLUE "  最后5行日志:"
-    tail -5 frontend.log | sed 's/^/    /'
-else
-    print_message $YELLOW "  前端日志: 不存在"
-fi
+for log_file in "${log_files[@]}"; do
+    if [ -f "$log_file" ]; then
+        log_size=$(du -h "$log_file" 2>/dev/null | cut -f1 || echo "N/A")
+        log_lines=$(wc -l < "$log_file" 2>/dev/null || echo "0")
+        print_message $CYAN "  $log_file: $log_size ($log_lines 行)"
+        
+        # 显示最后5行日志
+        if [ $log_lines -gt 0 ]; then
+            print_message $CYAN "    最后5行日志:"
+            tail -5 "$log_file" | sed 's/^/      /'
+        fi
+    else
+        print_message $YELLOW "  $log_file: 不存在"
+    fi
+    echo ""
+done
 
-echo ""
-
-# 检查数据库连接 (if psql is available)
-if command -v psql &> /dev/null; then
-    DATABASE_URL=$(grep -v '^#' .env 2>/dev/null | grep DATABASE_URL | cut -d'=' -f2- 2>/dev/null || echo "postgresql://postgres:postgres@localhost:5432/wordmaster")
+# 检查数据库连接 (如果配置了PostgreSQL)
+if command -v psql &> /dev/null && [[ "$DATABASE_URL" == *"postgresql://"* ]]; then
     DB_HOST=$(echo $DATABASE_URL | sed -n 's/.*@//p' | cut -d':' -f1)
     DB_PORT=$(echo $DATABASE_URL | sed -n 's/.*://p' | cut -d'/' -f1)
-    print_message $BLUE "🗄️  数据库状态 (Host: $DB_HOST, Port: $DB_PORT):"
+    print_message $BLUE "🗄️  PostgreSQL 数据库状态 (Host: $DB_HOST, Port: $DB_PORT):"
     if [ "$DB_HOST" == "localhost" ] || [ "$DB_HOST" == "127.0.0.1" ]; then
         if lsof -i :$DB_PORT | grep LISTEN > /dev/null 2>&1; then
             print_message $GREEN "  ✅ PostgreSQL 服务运行正常"
+            
+            # 尝试连接数据库
+            if echo "SELECT 1;" | psql "$DATABASE_URL" -tA > /dev/null 2>&1; then
+                print_message $GREEN "  ✅ 数据库连接正常"
+            else
+                print_message $RED "  ❌ 数据库连接失败"
+            fi
         else
             print_message $YELLOW "  ⚠️  PostgreSQL 服务未运行"
         fi
     else
         print_message $GREEN "  ✅ 数据库配置: $DATABASE_URL"
     fi
+elif [[ "$DATABASE_URL" == *"sqlite://"* ]]; then
+    DB_PATH=$(echo $DATABASE_URL | sed 's/sqlite:\/\///')
+    print_message $BLUE "🗄️  SQLite 数据库状态:"
+    if [ -f "$DB_PATH" ]; then
+        db_size=$(du -h "$DB_PATH" 2>/dev/null | cut -f1 || echo "N/A")
+        print_message $GREEN "  ✅ SQLite 数据库文件存在: $DB_PATH ($db_size)"
+    else
+        print_message $YELLOW "  ⚠️  SQLite 数据库文件不存在: $DB_PATH"
+    fi
 fi
 
 echo ""
-print_message $GREEN "🎉 检查完成！"
+
+# 端口检查（检查是否其他应用占用预期端口）
+print_message $BLUE "🔍 检查端口占用情况:"
+occupied_ports=()
+if lsof -i :$BACKEND_PORT > /dev/null 2>&1; then
+    port_user=$(lsof -i :$BACKEND_PORT | tail -n +2 | head -n 1 | awk '{print $1}')
+    port_pid=$(lsof -i :$BACKEND_PORT | tail -n +2 | head -n 1 | awk '{print $2}')
+    print_message $YELLOW "  ⚠️  后端端口 $BACKEND_PORT 被进程 $port_pid ($port_user) 占用"
+    occupied_ports+=("$BACKEND_PORT")
+fi
+
+if lsof -i :$FRONTEND_PORT > /dev/null 2>&1; then
+    port_user=$(lsof -i :$FRONTEND_PORT | tail -n +2 | head -n 1 | awk '{print $1}')
+    port_pid=$(lsof -i :$FRONTEND_PORT | tail -n +2 | head -n 1 | awk '{print $2}')
+    print_message $YELLOW "  ⚠️  前端端口 $FRONTEND_PORT 被进程 $port_pid ($port_user) 占用"
+    occupied_ports+=("$FRONTEND_PORT")
+fi
+
+if [ ${#occupied_ports[@]} -eq 0 ]; then
+    print_message $GREEN "  ✅ 无端口冲突"
+else
+    print_message $YELLOW "  提示: 如需使用这些端口，请先停止占用进程"
+fi
+
+echo ""
+
+# 服务健康度评分
+print_message $BLUE "💯 服务健康度评估:"
+score=0
+total_checks=0
+
+# 检查后端
+total_checks=$((total_checks + 1))
+if [ -f ".backend.pid" ] && ps -p $(cat .backend.pid) > /dev/null 2>&1; then
+    if curl -s --max-time 5 "http://localhost:$BACKEND_PORT/docs" > /dev/null 2>&1; then
+        score=$((score + 1))
+    fi
+fi
+
+# 检查前端
+total_checks=$((total_checks + 1))
+if [ -f ".frontend.pid" ] && ps -p $(cat .frontend.pid) > /dev/null 2>&1; then
+    if curl -s --max-time 5 "http://localhost:$FRONTEND_PORT" > /dev/null 2>&1; then
+        score=$((score + 1))
+    fi
+fi
+
+# 计算健康度百分比
+health_percentage=$((score * 100 / total_checks))
+health_status=""
+
+if [ $health_percentage -ge 80 ]; then
+    health_status="✅ 健康"
+    print_message $GREEN "  $health_status: ${health_percentage}% ($score/$total_checks)"
+elif [ $health_percentage -ge 50 ]; then
+    health_status="⚠️  部分正常"
+    print_message $YELLOW "  $health_status: ${health_percentage}% ($score/$total_checks)"
+else
+    health_status="❌ 不健康"
+    print_message $RED "  $health_status: ${health_percentage}% ($score/$total_checks)"
+fi
+echo ""
+
+print_message $GREEN "🎉 状态检查完成！"
+log_message "INFO" "系统状态检查完成，健康度: ${health_percentage}%"

stop.sh

@@ -1,31 +1,33 @@
-# 停止脚本
 #!/bin/bash
 
-echo "🛑 停止 WordMaster Pro 系统..."
+# 简化停止脚本 - 快速停止前后端应用
+# 作者: Qwen Assistant
+# 功能: 快速停止系统
 
-# 停止后端
-if [ -f .backend.pid ]; then
-    BACKEND_PID=$(cat .backend.pid)
-    if ps -p $BACKEND_PID > /dev/null; then
-        kill $BACKEND_PID
-        echo "✅ 后端服务已停止"
-    fi
-    rm .backend.pid
-fi
+set -e  # 遇到错误立即退出
 
-# 停止前端
-if [ -f .frontend.pid ]; then
-    FRONTEND_PID=$(cat .frontend.pid)
-    if ps -p $FRONTEND_PID > /dev/null; then
-        kill $FRONTEND_PID
-        echo "✅ 前端服务已停止"
-    fi
-    rm .frontend.pid
-fi
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
 
-# 清理端口（可选）
-echo "🧹 清理端口..."
-lsof -ti:8888 | xargs kill -9 2>/dev/null || true
-lsof -ti:3000 | xargs kill -9 2>/dev/null || true
+# 打印带颜色的消息
+print_message() {
+    local color=$1
+    local message=$2
+    echo -e "${color}${message}${NC}"
+}
 
-echo "🎉 WordMaster Pro 已完全停止！"
+print_message $BLUE "🛑 停止 WordMaster Pro 系统..."
+
+# 获取脚本目录
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# 建议使用优化版停止脚本
+print_message $YELLOW "💡 提示: 使用 ./stop_app.sh 停止脚本可获得更好的进程管理和清理功能"
+
+# 直接调用优化版停止脚本
+exec ./stop_app.sh

stop_app.sh

@@ -1,7 +1,8 @@
 #!/bin/bash
 
-# 统一停止脚本 - 一键停止前后端应用
+# 统一停止脚本 - 一键停止前后端应用（优化版）
 # 作者: Qwen Assistant
+# 功能: 安全停止前后端应用，清理进程和临时文件
 
 set -e  # 遇到错误立即退出
 
@@ -19,56 +20,211 @@ print_message() {
     echo -e "${color}${message}${NC}"
 }
 
+# 日志记录函数
+log_message() {
+    local level=$1
+    local message=$2
+    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+    echo "[$timestamp] [$level] $message" | tee -a "stop.log"
+}
+
 print_message $BLUE "🛑 开始停止 WordMaster Pro 系统..."
 
+# 记录停止过程
+log_message "INFO" "开始停止 WordMaster Pro 系统"
+
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 cd "$SCRIPT_DIR"
 
+# 检查是否有进程文件
+has_process_files=false
+if [ -f ".backend.pid" ] || [ -f ".frontend.pid" ]; then
+    has_process_files=true
+fi
+
+if [ "$has_process_files" = false ]; then
+    print_message $YELLOW "⚠️  未找到进程ID文件，系统可能未运行"
+    log_message "WARNING" "未找到进程ID文件"
+    
+    # 尝试通过端口查找进程
+    if lsof -i :8888 > /dev/null 2>&1 || lsof -i :3000 > /dev/null 2>&1; then
+        print_message $YELLOW "🔍 检测到可能的运行进程，尝试查找并停止..."
+        BACKEND_PID=$(lsof -ti:8888 2>/dev/null)
+        FRONTEND_PID=$(lsof -ti:3000 2>/dev/null)
+        
+        if [ ! -z "$BACKEND_PID" ]; then
+            print_message $YELLOW "📡 发现后端进程 (PID: $BACKEND_PID)，正在停止..."
+            kill $BACKEND_PID 2>/dev/null || true
+            sleep 1
+            if kill -0 $BACKEND_PID 2>/dev/null; then
+                kill -9 $BACKEND_PID 2>/dev/null || true
+            fi
+            print_message $GREEN "✅ 后端进程已停止"
+        fi
+        
+        if [ ! -z "$FRONTEND_PID" ]; then
+            print_message $YELLOW "🎨 发现前端进程 (PID: $FRONTEND_PID)，正在停止..."
+            kill $FRONTEND_PID 2>/dev/null || true
+            sleep 1
+            if kill -0 $FRONTEND_PID 2>/dev/null; then
+                kill -9 $FRONTEND_PID 2>/dev/null || true
+            fi
+            print_message $GREEN "✅ 前端进程已停止"
+        fi
+    else
+        print_message $GREEN "ℹ️  系统未运行或已停止"
+        log_message "INFO" "系统未运行或已停止"
+    fi
+    
+    # 清理进程文件
+    rm -f .backend.pid .frontend.pid
+    exit 0
+fi
+
 # 停止后端
 if [ -f ".backend.pid" ]; then
     BACKEND_PID=$(cat .backend.pid)
-    if ps -p $BACKEND_PID > /dev/null 2>&1; then
+    if [ ! -z "$BACKEND_PID" ] && ps -p $BACKEND_PID > /dev/null 2>&1; then
         print_message $YELLOW "📡 正在停止后端服务 (PID: $BACKEND_PID)..."
-        kill $BACKEND_PID 2>/dev/null || true
-        sleep 2
-        # 确保进程已经终止
+        log_message "INFO" "停止后端服务 (PID: $BACKEND_PID)"
+        
+        # 发送SIGTERM信号，给进程优雅退出的机会
+        kill -TERM $BACKEND_PID 2>/dev/null || true
+        sleep 3
+        
+        # 检查进程是否仍然存在
         if ps -p $BACKEND_PID > /dev/null 2>&1; then
-            print_message $YELLOW "⏳ 强制终止后端进程..."
-            kill -9 $BACKEND_PID 2>/dev/null || true
+            print_message $YELLOW "⏳ 后端进程仍在运行，等待更多时间..."
+            sleep 5
+            
+            # 再次检查
+            if ps -p $BACKEND_PID > /dev/null 2>&1; then
+                print_message $YELLOW "⏳ 后端进程仍未退出，强制终止..."
+                kill -9 $BACKEND_PID 2>/dev/null || true
+            fi
+        fi
+        
+        # 确认进程已终止
+        if ! ps -p $BACKEND_PID > /dev/null 2>&1; then
+            print_message $GREEN "✅ 后端服务已停止"
+            log_message "INFO" "后端服务已停止"
+        else
+            print_message $RED "❌ 无法停止后端进程 $BACKEND_PID"
+            log_message "ERROR" "无法停止后端进程 $BACKEND_PID"
         fi
-        rm -f .backend.pid
-        print_message $GREEN "✅ 后端服务已停止"
     else
-        print_message $YELLOW "⚠️  后端进程 $BACKEND_PID 不存在"
-        rm -f .backend.pid
+        print_message $YELLOW "⚠️  后端进程 $BACKEND_PID 不存在或已终止"
+        log_message "WARNING" "后端进程 $BACKEND_PID 不存在"
     fi
+    
+    # 清理后端进程文件
+    rm -f .backend.pid
 else
     print_message $YELLOW "⚠️  未找到后端进程ID文件"
+    log_message "WARNING" "未找到后端进程ID文件"
 fi
 
 # 停止前端
 if [ -f ".frontend.pid" ]; then
     FRONTEND_PID=$(cat .frontend.pid)
-    if ps -p $FRONTEND_PID > /dev/null 2>&1; then
+    if [ ! -z "$FRONTEND_PID" ] && ps -p $FRONTEND_PID > /dev/null 2>&1; then
         print_message $YELLOW "🎨 正在停止前端服务 (PID: $FRONTEND_PID)..."
-        kill $FRONTEND_PID 2>/dev/null || true
+        log_message "INFO" "停止前端服务 (PID: $FRONTEND_PID)"
+        
+        # 发送SIGTERM信号，给进程优雅退出的机会
+        kill -TERM $FRONTEND_PID 2>/dev/null || true
         sleep 2
-        # 确保进程已经终止
+        
+        # 检查进程是否仍然存在
         if ps -p $FRONTEND_PID > /dev/null 2>&1; then
-            print_message $YELLOW "⏳ 强制终止前端进程..."
-            kill -9 $FRONTEND_PID 2>/dev/null || true
+            print_message $YELLOW "⏳ 前端进程仍在运行，等待更多时间..."
+            sleep 3
+            
+            # 再次检查
+            if ps -p $FRONTEND_PID > /dev/null 2>&1; then
+                print_message $YELLOW "⏳ 前端进程仍未退出，强制终止..."
+                kill -9 $FRONTEND_PID 2>/dev/null || true
+            fi
+        fi
+        
+        # 确认进程已终止
+        if ! ps -p $FRONTEND_PID > /dev/null 2>&1; then
+            print_message $GREEN "✅ 前端服务已停止"
+            log_message "INFO" "前端服务已停止"
+        else
+            print_message $RED "❌ 无法停止前端进程 $FRONTEND_PID"
+            log_message "ERROR" "无法停止前端进程 $FRONTEND_PID"
         fi
-        rm -f .frontend.pid
-        print_message $GREEN "✅ 前端服务已停止"
     else
-        print_message $YELLOW "⚠️  前端进程不存在"
-        rm -f .frontend.pid
+        print_message $YELLOW "⚠️  前端进程 $FRONTEND_PID 不存在或已终止"
+        log_message "WARNING" "前端进程 $FRONTEND_PID 不存在"
     fi
+    
+    # 清理前端进程文件
+    rm -f .frontend.pid
 else
     print_message $YELLOW "⚠️  未找到前端进程ID文件"
+    log_message "WARNING" "未找到前端进程ID文件"
 fi
 
-# 清理端口占用（可选，通常不需要，因为kill已经处理了）
-print_message $BLUE "🧹 清理工作完成！"
+# 额外清理：尝试停止任何可能的 uvicorn 或 vite 进程
+print_message $BLUE "🧹 清理可能残留的进程..."
+ALL_UVICORN_PIDS=$(pgrep -f "uvicorn.*main:app" 2>/dev/null)
+ALL_VITE_PIDS=$(pgrep -f "vite" 2>/dev/null)
 
-print_message $GREEN "🎉 WordMaster Pro 系统已完全停止！"
+if [ ! -z "$ALL_UVICORN_PIDS" ]; then
+    print_message $YELLOW "🔍 发现可能的 uvicorn 进程: $ALL_UVICORN_PIDS"
+    for pid in $ALL_UVICORN_PIDS; do
+        if [ "$pid" != "$BACKEND_PID" ]; then  # 避免重复停止
+            kill -TERM $pid 2>/dev/null || true
+            sleep 1
+            if kill -0 $pid 2>/dev/null; then
+                kill -9 $pid 2>/dev/null || true
+            fi
+        fi
+    done
+    print_message $GREEN "✅ uvicorn 进程已清理"
+fi
+
+if [ ! -z "$ALL_VITE_PIDS" ]; then
+    print_message $YELLOW "🔍 发现可能的 vite 进程: $ALL_VITE_PIDS"
+    for pid in $ALL_VITE_PIDS; do
+        if [ "$pid" != "$FRONTEND_PID" ]; then  # 避免重复停止
+            kill -TERM $pid 2>/dev/null || true
+            sleep 1
+            if kill -0 $pid 2>/dev/null; then
+                kill -9 $pid 2>/dev/null || true
+            fi
+        fi
+    done
+    print_message $GREEN "✅ vite 进程已清理"
+fi
+
+# 清理临时文件
+print_message $BLUE "🧹 清理临时文件..."
+if [ -d "backend/__pycache__" ]; then
+    rm -rf backend/__pycache__ 2>/dev/null || true
+fi
+
+if [ -d "backend/venv/lib/python*/__pycache__" ]; then
+    rm -rf backend/venv/lib/python*/__pycache__ 2>/dev/null || true
+fi
+
+print_message $GREEN "✅ 临时文件已清理"
+
+# 显示清理完成信息
+print_message $GREEN ""
+print_message $GREEN "🎉 WordMaster Pro 系统已完全停止！"
+print_message $GREEN ""
+
+print_message $BLUE "📋 清理完成项目:"
+print_message $GREEN "✅ 后端服务已停止"
+print_message $GREEN "✅ 前端服务已停止" 
+print_message $GREEN "✅ 进程ID文件已清理"
+print_message $GREEN "✅ 可能的残留进程已清理"
+print_message $GREEN "✅ 临时文件已清理"
+echo ""
+
+print_message $BLUE "📁 日志记录: $(pwd)/stop.log"
+
+log_message "INFO" "WordMaster Pro 系统停止完成"