first commit

.gitignore

@@ -0,0 +1,24 @@
+# Python
+backend/venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+
+# Node
+frontend/node_modules/
+frontend/dist/
+
+# 数据库（生产环境数据保留在服务器，不提交）
+backend/data/*.db
+
+# IDE / OS
+.vscode/
+.idea/
+*.swp
+.DS_Store
+Thumbs.db
+
+# PM2
+.pm2/
+logs/

DEPLOY.md

@@ -0,0 +1,193 @@
+# 部署文档
+
+> 代码仓库：[https://git.bz121.com/dekun/crypto-pre-trade-system.git](https://git.bz121.com/dekun/crypto-pre-trade-system.git)
+
+本文档说明如何在 **Ubuntu 服务器**上使用 **PM2** 守护进程部署本系统。
+
+---
+
+## 部署环境要求
+
+| 项目 | 要求 |
+|------|------|
+| 操作系统 | Ubuntu 20.04 / 22.04 / 24.04 |
+| 运行用户 | root |
+| 安装路径 | `/opt/crypto-pre-trade-system` |
+| 进程守护 | PM2 |
+| Python | 3.10+（虚拟环境） |
+| Node.js | 18+（仅构建前端时使用） |
+| 访问端口 | **1125** |
+
+---
+
+## 一键部署（推荐）
+
+以 **root** 用户登录服务器，执行：
+
+```bash
+# 首次部署：克隆仓库并运行安装脚本
+git clone https://git.bz121.com/dekun/crypto-pre-trade-system.git /opt/crypto-pre-trade-system
+cd /opt/crypto-pre-trade-system
+bash deploy/install.sh
+```
+
+脚本会自动完成：
+
+1. 安装系统依赖（git、python3、nodejs、pm2）
+2. 创建 Python 虚拟环境并安装后端依赖
+3. 构建前端静态资源
+4. 通过 PM2 启动服务并设置开机自启
+5. 执行健康检查
+
+部署完成后访问：**http://\<服务器IP\>:1125**
+
+---
+
+## 更新部署
+
+代码有更新时，在服务器上重新执行安装脚本即可：
+
+```bash
+cd /opt/crypto-pre-trade-system
+bash deploy/install.sh
+```
+
+脚本会自动 `git pull`、重新构建前端、重启 PM2 进程。
+
+---
+
+## 手动部署步骤
+
+若需手动逐步部署，按以下步骤操作：
+
+### 1. 克隆仓库
+
+```bash
+git clone https://git.bz121.com/dekun/crypto-pre-trade-system.git /opt/crypto-pre-trade-system
+cd /opt/crypto-pre-trade-system
+```
+
+### 2. 安装系统依赖
+
+```bash
+apt-get update
+apt-get install -y git python3 python3-venv python3-pip curl
+
+# Node.js 20
+curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
+apt-get install -y nodejs
+
+# PM2
+npm install -g pm2
+```
+
+### 3. 后端虚拟环境
+
+```bash
+cd /opt/crypto-pre-trade-system/backend
+python3 -m venv venv
+venv/bin/pip install -r requirements.txt
+mkdir -p data
+```
+
+### 4. 构建前端
+
+```bash
+cd /opt/crypto-pre-trade-system/frontend
+npm install
+npm run build
+```
+
+### 5. PM2 启动
+
+```bash
+cd /opt/crypto-pre-trade-system
+mkdir -p logs
+pm2 start ecosystem.config.cjs
+pm2 save
+pm2 startup systemd -u root --hp /root
+```
+
+---
+
+## PM2 常用命令
+
+```bash
+pm2 status                      # 查看进程状态
+pm2 logs crypto-pre-trade       # 查看实时日志
+pm2 restart crypto-pre-trade    # 重启服务
+pm2 stop crypto-pre-trade       # 停止服务
+pm2 delete crypto-pre-trade     # 删除进程
+```
+
+日志文件位置：
+
+- 标准输出：`/opt/crypto-pre-trade-system/logs/pm2-out.log`
+- 错误输出：`/opt/crypto-pre-trade-system/logs/pm2-error.log`
+
+---
+
+## 架构说明
+
+生产环境采用 **单进程单端口** 模式：
+
+```
+PM2 → uvicorn (0.0.0.0:1125)
+        ├── /api/*     → FastAPI 后端接口
+        └── /*         → Vue3 前端静态资源（frontend/dist）
+```
+
+- 前端构建产物由 FastAPI 直接托管，无需额外 Nginx
+- SQLite 数据库文件：`/opt/crypto-pre-trade-system/backend/data/pretrade.db`
+- 重启服务不丢失数据
+
+---
+
+## 防火墙
+
+若服务器开启了防火墙，需放行 1125 端口：
+
+```bash
+# ufw
+ufw allow 1125/tcp
+
+# firewalld
+firewall-cmd --permanent --add-port=1125/tcp
+firewall-cmd --reload
+```
+
+---
+
+## 重置数据库
+
+```bash
+pm2 stop crypto-pre-trade
+rm /opt/crypto-pre-trade-system/backend/data/pretrade.db
+pm2 start crypto-pre-trade
+```
+
+重启后系统自动重建表结构并写入默认数据。
+
+---
+
+## 故障排查
+
+| 现象 | 排查方式 |
+|------|---------|
+| 无法访问 | `pm2 status` 确认进程 online；`curl http://127.0.0.1:1125/api/health` |
+| 502 / 连接拒绝 | 检查防火墙是否放行 1125 端口 |
+| 前端白屏 | 确认 `frontend/dist` 存在；重新 `npm run build` |
+| API 报错 | `pm2 logs crypto-pre-trade --lines 50` |
+| 数据库问题 | 检查 `backend/data/` 目录权限 |
+
+---
+
+## 本地开发 vs 生产部署
+
+| | 本地开发 | 生产部署 |
+|---|---------|---------|
+| 后端 | `uvicorn --reload --port 8000` | PM2 + uvicorn `:1125` |
+| 前端 | `npm run dev :1125`（代理到 8000） | `npm run build`，由 FastAPI 托管 |
+| 访问 | http://localhost:1125 | http://\<服务器IP\>:1125 |
+
+本地开发说明见 [README.md](./README.md)。

README.md

@@ -0,0 +1,195 @@
+# 加密货币大盘-周期-阶段-强弱-方向-账户-策略前置匹配系统
+
+纯本地部署的前置策略匹配工具。前后端分离，SQLite 持久化，黑色极简主题，无登录。
+
+> **代码仓库**：[https://git.bz121.com/dekun/crypto-pre-trade-system.git](https://git.bz121.com/dekun/crypto-pre-trade-system.git)  
+> **生产部署**：见 [DEPLOY.md](./DEPLOY.md)（Ubuntu + PM2 一键部署）
+
+> **本系统仅做前置策略匹配**，不处理币种、K线识别、箱体判断、点位计算、突破校验、自动下单或交易所对接。
+> 所有箱体细节、触碰次数、突破确认条件、顺势/逆势箱体，全部由人工手动筛选输入。
+
+---
+
+## 技术栈
+
+| 层级 | 技术 |
+|------|------|
+| 后端 | Python 3.10+ / FastAPI / SQLAlchemy / SQLite |
+| 前端 | Vue 3 / Vite / TailwindCSS / Axios |
+| 数据库 | SQLite（`backend/data/pretrade.db`） |
+
+---
+
+## 项目结构
+
+```
+crypto-pre-trade-system/
+├── backend/
+│   ├── app/
+│   │   ├── main.py          # FastAPI 入口
+│   │   ├── database.py      # 数据库连接 + 默认数据初始化
+│   │   ├── models.py        # ORM 模型
+│   │   ├── schemas.py       # Pydantic 模型
+│   │   ├── crud.py          # CRUD 操作
+│   │   ├── matcher.py       # 前置匹配核心逻辑
+│   │   └── routes/          # API 路由
+│   ├── init_db.sql          # 建表 SQL（参考）
+│   ├── requirements.txt
+│   └── data/                # SQLite 数据库（自动创建）
+├── frontend/
+│   ├── src/
+│   │   ├── views/
+│   │   │   ├── DailyMatch.vue    # 日常使用页（核心）
+│   │   │   └── ConfigCenter.vue  # 系统配置中心
+│   │   ├── api/index.js          # API 封装
+│   │   └── ...
+│   └── package.json
+├── deploy/
+│   └── install.sh           # Ubuntu 一键部署脚本
+├── ecosystem.config.cjs     # PM2 进程配置
+├── DEPLOY.md                # 部署文档
+└── README.md
+```
+
+---
+
+## 快速启动
+
+### 1. 启动后端
+
+```bash
+cd backend
+
+# 创建虚拟环境（推荐）
+python -m venv venv
+# Windows:
+venv\Scripts\activate
+# macOS/Linux:
+# source venv/bin/activate
+
+pip install -r requirements.txt
+
+# 启动 API 服务（首次启动自动建表 + 写入默认数据）
+uvicorn app.main:app --reload --host 127.0.0.1 --port 8000
+```
+
+后端启动后访问：
+- API 文档：http://127.0.0.1:8000/docs
+- 健康检查：http://127.0.0.1:8000/api/health
+
+### 2. 启动前端
+
+```bash
+cd frontend
+
+npm install
+npm run dev
+```
+
+前端访问：http://localhost:1125
+
+---
+
+## 使用流程
+
+### 日常使用（核心页面）
+
+1. **人工选择**大盘周期（日线 / 4H / 1H）
+2. **人工选择**大盘阶段（8 个固定阶段）
+3. **人工选择**趋势强弱（强 / 弱 / 震荡）
+4. 点击「执行前置匹配」
+5. 系统自动输出：
+   - 交易类型（顺势 / 反转 / 观望）
+   - 允许开仓方向
+   - 可用账户列表
+   - 可用策略列表（含规则文本，仅展示）
+
+### 系统配置中心
+
+- **大盘管理**：增删改 8 个大盘阶段及交易方向
+- **账户管理**：动态管理账户（本金、周期、风险比）
+- **策略管理**：增删改策略及规则文本
+- **匹配配置**：绑定「大盘周期 + 阶段 + 强弱」→ 账户 + 策略 + 方向
+
+---
+
+## 匹配逻辑（默认规则）
+
+| 大盘阶段 | 趋势强弱 | 匹配策略 | 方向 |
+|---------|---------|---------|------|
+| 上涨初期/中期 | 强 | 箱体顺势突破 | 做多 |
+| 上涨初期/中期 | 弱 | 斐波回调 | 做多 |
+| 上涨末期 | 强/弱 | 手工主观 | 做空 |
+| 下跌初期/中期 | 强 | 箱体顺势突破 | 做空 |
+| 下跌初期/中期 | 弱 | 斐波回调 | 做空 |
+| 下跌末期 | 强/弱 | 手工主观 | 做多 |
+| 宽幅震荡末期 | 强/弱 | 收敛结构突破 | 多空均可 |
+| 宽幅震荡 | 任意 | **全部禁用** | 禁止 |
+| 任意阶段 | 震荡 | **全部禁用** | 观望 |
+
+---
+
+## API 接口
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| GET | `/api/regimes` | 获取大盘阶段列表 |
+| POST/PUT/DELETE | `/api/regimes` | 增删改大盘阶段 |
+| GET | `/api/accounts` | 获取账户列表 |
+| POST/PUT/DELETE | `/api/accounts` | 增删改账户 |
+| GET | `/api/strategies` | 获取策略列表 |
+| POST/PUT/DELETE | `/api/strategies` | 增删改策略 |
+| GET | `/api/matches` | 获取匹配配置 |
+| POST/PUT/DELETE | `/api/matches` | 增删改匹配配置 |
+| GET | `/api/match` | **前置匹配**（核心接口） |
+
+匹配接口参数：
+```
+GET /api/match?market_cycle=日线&market_regime_id=1&trend_strength=强
+```
+
+---
+
+## 数据库表
+
+| 表名 | 说明 |
+|------|------|
+| `market_regime` | 大盘阶段（名称、交易类型、允许方向） |
+| `account` | 账户（名称、本金、周期、风险比、启用状态） |
+| `strategy` | 策略（名称、适用周期/强弱、规则文本） |
+| `regime_match` | 匹配绑定（阶段+周期+强弱 → 账户+策略+方向） |
+
+建表 SQL 见 `backend/init_db.sql`，也可通过后端启动自动创建。
+
+---
+
+## 约束说明
+
+1. **黑色极简** UI，左右分栏布局
+2. **SQLite 持久化**，重启不丢数据
+3. **无登录**，纯本地部署
+4. **账户/策略/匹配规则** 全部可动态增删改
+5. **严格禁止**：自动 K 线识别、自动箱体判断、自动下单、交易所对接、币种输入、点位计算、突破条件校验
+6. 策略规则文本**仅作展示**，系统不做任何自动校验
+
+---
+
+## 重置数据库
+
+删除 `backend/data/pretrade.db` 后重启后端，系统将自动重建并写入默认数据。
+
+---
+
+## 生产部署
+
+服务器部署（Ubuntu + PM2 + root + `/opt`）详见 **[DEPLOY.md](./DEPLOY.md)**。
+
+一键部署：
+
+```bash
+git clone https://git.bz121.com/dekun/crypto-pre-trade-system.git /opt/crypto-pre-trade-system
+cd /opt/crypto-pre-trade-system
+bash deploy/install.sh
+```
+
+部署完成后访问：**http://\<服务器IP\>:1125**

backend/app/crud.py

@@ -0,0 +1,173 @@
+"""数据库 CRUD 操作"""
+
+from typing import List, Optional
+from sqlalchemy.orm import Session, joinedload
+
+from app.models import MarketRegime, Account, Strategy, RegimeMatch
+from app.schemas import (
+    MarketRegimeCreate, MarketRegimeUpdate,
+    AccountCreate, AccountUpdate,
+    StrategyCreate, StrategyUpdate,
+    RegimeMatchCreate, RegimeMatchUpdate,
+)
+
+
+# ── 大盘阶段 ──
+
+def get_regimes(db: Session) -> List[MarketRegime]:
+    return db.query(MarketRegime).order_by(MarketRegime.id).all()
+
+
+def get_regime(db: Session, regime_id: int) -> Optional[MarketRegime]:
+    return db.query(MarketRegime).filter(MarketRegime.id == regime_id).first()
+
+
+def create_regime(db: Session, data: MarketRegimeCreate) -> MarketRegime:
+    obj = MarketRegime(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def update_regime(db: Session, regime_id: int, data: MarketRegimeUpdate) -> Optional[MarketRegime]:
+    obj = get_regime(db, regime_id)
+    if not obj:
+        return None
+    for k, v in data.model_dump(exclude_unset=True).items():
+        setattr(obj, k, v)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def delete_regime(db: Session, regime_id: int) -> bool:
+    obj = get_regime(db, regime_id)
+    if not obj:
+        return False
+    db.delete(obj)
+    db.commit()
+    return True
+
+
+# ── 账户 ──
+
+def get_accounts(db: Session) -> List[Account]:
+    return db.query(Account).order_by(Account.id).all()
+
+
+def get_account(db: Session, account_id: int) -> Optional[Account]:
+    return db.query(Account).filter(Account.id == account_id).first()
+
+
+def create_account(db: Session, data: AccountCreate) -> Account:
+    obj = Account(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def update_account(db: Session, account_id: int, data: AccountUpdate) -> Optional[Account]:
+    obj = get_account(db, account_id)
+    if not obj:
+        return None
+    for k, v in data.model_dump(exclude_unset=True).items():
+        setattr(obj, k, v)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def delete_account(db: Session, account_id: int) -> bool:
+    obj = get_account(db, account_id)
+    if not obj:
+        return False
+    db.delete(obj)
+    db.commit()
+    return True
+
+
+# ── 策略 ──
+
+def get_strategies(db: Session) -> List[Strategy]:
+    return db.query(Strategy).order_by(Strategy.id).all()
+
+
+def get_strategy(db: Session, strategy_id: int) -> Optional[Strategy]:
+    return db.query(Strategy).filter(Strategy.id == strategy_id).first()
+
+
+def create_strategy(db: Session, data: StrategyCreate) -> Strategy:
+    obj = Strategy(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def update_strategy(db: Session, strategy_id: int, data: StrategyUpdate) -> Optional[Strategy]:
+    obj = get_strategy(db, strategy_id)
+    if not obj:
+        return None
+    for k, v in data.model_dump(exclude_unset=True).items():
+        setattr(obj, k, v)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def delete_strategy(db: Session, strategy_id: int) -> bool:
+    obj = get_strategy(db, strategy_id)
+    if not obj:
+        return False
+    db.delete(obj)
+    db.commit()
+    return True
+
+
+# ── 匹配绑定 ──
+
+def get_matches(db: Session) -> List[RegimeMatch]:
+    return (
+        db.query(RegimeMatch)
+        .options(
+            joinedload(RegimeMatch.regime),
+            joinedload(RegimeMatch.account),
+            joinedload(RegimeMatch.strategy),
+        )
+        .order_by(RegimeMatch.id)
+        .all()
+    )
+
+
+def get_match(db: Session, match_id: int) -> Optional[RegimeMatch]:
+    return db.query(RegimeMatch).filter(RegimeMatch.id == match_id).first()
+
+
+def create_match(db: Session, data: RegimeMatchCreate) -> RegimeMatch:
+    obj = RegimeMatch(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def update_match(db: Session, match_id: int, data: RegimeMatchUpdate) -> Optional[RegimeMatch]:
+    obj = get_match(db, match_id)
+    if not obj:
+        return None
+    for k, v in data.model_dump(exclude_unset=True).items():
+        setattr(obj, k, v)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def delete_match(db: Session, match_id: int) -> bool:
+    obj = get_match(db, match_id)
+    if not obj:
+        return False
+    db.delete(obj)
+    db.commit()
+    return True

backend/app/database.py

@@ -0,0 +1,175 @@
+"""数据库连接与初始化"""
+
+import os
+from pathlib import Path
+
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker, declarative_base
+
+# 数据库文件路径
+BASE_DIR = Path(__file__).resolve().parent.parent
+DB_PATH = BASE_DIR / "data" / "pretrade.db"
+DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+DATABASE_URL = f"sqlite:///{DB_PATH}"
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False},
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+def get_db():
+    """FastAPI 依赖：获取数据库会话"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def init_database():
+    """执行建表 SQL 并写入默认数据"""
+    from app.models import MarketRegime, Account, Strategy, RegimeMatch  # noqa: F401
+
+    # 建表
+    Base.metadata.create_all(bind=engine)
+
+    # 若已有数据则跳过初始化
+    db = SessionLocal()
+    try:
+        if db.query(MarketRegime).count() > 0:
+            return
+
+        _seed_default_data(db)
+    finally:
+        db.close()
+
+
+def _seed_default_data(db):
+    """写入默认大盘阶段、账户、策略及匹配规则"""
+    from app.models import MarketRegime, Account, Strategy, RegimeMatch
+
+    # ── 大盘阶段（8 个固定） ──
+    regimes = [
+        MarketRegime(name="上涨初期", trade_type="顺势", allow_direction="做多", remark="顺势做多，禁止做空"),
+        MarketRegime(name="上涨中期", trade_type="顺势", allow_direction="做多", remark="顺势做多，禁止做空"),
+        MarketRegime(name="上涨末期", trade_type="反转", allow_direction="做空", remark="反转做空"),
+        MarketRegime(name="宽幅震荡", trade_type="观望", allow_direction="禁止", remark="观望，禁止交易"),
+        MarketRegime(name="宽幅震荡末期", trade_type="反转", allow_direction="多空均可", remark="反转交易（收敛突破）"),
+        MarketRegime(name="下跌初期", trade_type="顺势", allow_direction="做空", remark="顺势做空，禁止做多"),
+        MarketRegime(name="下跌中期", trade_type="顺势", allow_direction="做空", remark="顺势做空，禁止做多"),
+        MarketRegime(name="下跌末期", trade_type="反转", allow_direction="做多", remark="反转做多"),
+    ]
+    db.add_all(regimes)
+    db.flush()
+
+    regime_map = {r.name: r.id for r in regimes}
+
+    # ── 账户（默认本金 100U） ──
+    accounts = [
+        Account(account_name="账户1-斐波回调", total_capital=100, trade_cycle="4H/1H", risk_ratio="5%~10%", remark="斐波回调专用"),
+        Account(account_name="账户2-箱体突破", total_capital=100, trade_cycle="日内", risk_ratio="0.5%~1%", remark="箱体顺势突破专用"),
+        Account(account_name="账户3-收敛突破", total_capital=100, trade_cycle="日内", risk_ratio="0.5%~1%", remark="收敛结构突破专用"),
+        Account(account_name="账户4-手工主观", total_capital=100, trade_cycle="灵活", risk_ratio="2%", remark="手工主观策略专用"),
+    ]
+    db.add_all(accounts)
+    db.flush()
+
+    acc_map = {a.account_name: a.id for a in accounts}
+
+    # ── 策略（4 个内置） ──
+    strategies = [
+        Strategy(
+            strategy_name="斐波回调",
+            fit_cycle="4H/1H",
+            fit_trend_strength="弱",
+            trade_type="顺势",
+            strategy_rule=(
+                "入场：仅 0.618 / 0.786\n"
+                "适用：通道式上涨/下跌\n"
+                "适用：弱趋势\n"
+                "周期：4H/1H\n"
+                "注意：点位、触碰次数、突破条件均由人工手动筛选输入"
+            ),
+        ),
+        Strategy(
+            strategy_name="箱体顺势突破",
+            fit_cycle="日内(5分钟K线)",
+            fit_trend_strength="强",
+            trade_type="顺势",
+            strategy_rule=(
+                "箱体时长要求：≥4小时（48根5分钟K线），优先8小时以上\n"
+                "成立条件：人工手动判断触碰上下沿次数、顺势/逆势箱体、突破确认条件\n"
+                "系统不校验，仅展示该策略可用\n"
+                "适用：强趋势顺势阶段"
+            ),
+        ),
+        Strategy(
+            strategy_name="收敛结构突破",
+            fit_cycle="日内",
+            fit_trend_strength="强",
+            trade_type="反转",
+            strategy_rule=(
+                "适用：宽幅震荡末期收敛三角\n"
+                "人工确认结构，系统仅匹配可用\n"
+                "注意：结构细节、突破条件均由人工手动确认"
+            ),
+        ),
+        Strategy(
+            strategy_name="手工主观",
+            fit_cycle="灵活",
+            fit_trend_strength="全部",
+            trade_type="全部",
+            strategy_rule="全场景人工自主判断，系统仅做前置匹配",
+        ),
+    ]
+    db.add_all(strategies)
+    db.flush()
+
+    strat_map = {s.strategy_name: s.id for s in strategies}
+
+    # ── 匹配绑定规则 ──
+    cycles = ["日线", "4H", "1H"]
+    matches = []
+
+    # 顺势阶段（上涨初/中期、下跌初/中期）：强→箱体，弱→斐波
+    shunshi_regimes = ["上涨初期", "上涨中期", "下跌初期", "下跌中期"]
+    for rname in shunshi_regimes:
+        rid = regime_map[rname]
+        for cycle in cycles:
+            matches.append(RegimeMatch(
+                market_regime_id=rid, market_cycle=cycle, trend_strength="强",
+                account_id=acc_map["账户2-箱体突破"], strategy_id=strat_map["箱体顺势突破"],
+            ))
+            matches.append(RegimeMatch(
+                market_regime_id=rid, market_cycle=cycle, trend_strength="弱",
+                account_id=acc_map["账户1-斐波回调"], strategy_id=strat_map["斐波回调"],
+            ))
+
+    # 反转阶段（上涨末期、下跌末期）：手工主观
+    fanzhuan_regimes = ["上涨末期", "下跌末期"]
+    for rname in fanzhuan_regimes:
+        rid = regime_map[rname]
+        for cycle in cycles:
+            for strength in ["强", "弱"]:
+                matches.append(RegimeMatch(
+                    market_regime_id=rid, market_cycle=cycle, trend_strength=strength,
+                    account_id=acc_map["账户4-手工主观"], strategy_id=strat_map["手工主观"],
+                ))
+
+    # 宽幅震荡末期：收敛突破
+    rid = regime_map["宽幅震荡末期"]
+    for cycle in cycles:
+        for strength in ["强", "弱"]:
+            matches.append(RegimeMatch(
+                market_regime_id=rid, market_cycle=cycle, trend_strength=strength,
+                account_id=acc_map["账户3-收敛突破"], strategy_id=strat_map["收敛结构突破"],
+            ))
+
+    # 宽幅震荡：不写入匹配（系统自动禁用）
+
+    db.add_all(matches)
+    db.commit()

backend/app/main.py

@@ -0,0 +1,74 @@
+"""FastAPI 应用入口"""
+
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from app.database import init_database
+from app.routes import regimes, accounts, strategies, matches, match
+
+# 前端构建产物目录（生产部署时由 PM2 单端口托管）
+FRONTEND_DIST = Path(__file__).resolve().parent.parent.parent / "frontend" / "dist"
+
+app = FastAPI(
+    title="加密货币前置匹配系统",
+    description="大盘-周期-阶段-强弱-方向-账户-策略前置匹配（纯本地，无登录）",
+    version="1.0.0",
+)
+
+# 允许前端跨域（本地开发）
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 注册 API 路由
+app.include_router(regimes.router)
+app.include_router(accounts.router)
+app.include_router(strategies.router)
+app.include_router(matches.router)
+app.include_router(match.router)
+
+
+@app.on_event("startup")
+def on_startup():
+    """启动时初始化数据库"""
+    init_database()
+
+
+@app.get("/api/health")
+def health():
+    return {"status": "ok", "message": "加密货币前置匹配系统运行中"}
+
+
+def _mount_frontend():
+    """生产环境：托管 Vue 前端静态资源，支持 SPA 路由"""
+    if not FRONTEND_DIST.exists():
+        return
+
+    assets_dir = FRONTEND_DIST / "assets"
+    if assets_dir.exists():
+        app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+    @app.get("/")
+    async def serve_index():
+        return FileResponse(FRONTEND_DIST / "index.html")
+
+    @app.get("/{path:path}")
+    async def serve_spa(path: str):
+        # API 路径不走 SPA 回退
+        if path.startswith("api"):
+            return {"detail": "Not Found"}
+        file = FRONTEND_DIST / path
+        if file.is_file():
+            return FileResponse(file)
+        return FileResponse(FRONTEND_DIST / "index.html")
+
+
+_mount_frontend()

backend/app/matcher.py

@@ -0,0 +1,138 @@
+"""前置策略匹配核心逻辑
+
+本模块仅根据人工选择的大盘周期、阶段、趋势强弱，
+查询匹配绑定表并输出可用账户与策略。
+不做任何 K 线识别、箱体判断、点位计算或突破校验。
+"""
+
+from sqlalchemy.orm import Session, joinedload
+
+from app.models import MarketRegime, RegimeMatch
+from app.schemas import MatchRequest, MatchResult, MatchAccountOut, MatchStrategyOut
+
+
+def run_match(db: Session, req: MatchRequest) -> MatchResult:
+    """执行前置匹配"""
+    regime = db.query(MarketRegime).filter(MarketRegime.id == req.market_regime_id).first()
+    if not regime:
+        return MatchResult(
+            market_cycle=req.market_cycle,
+            regime_name="未知",
+            trade_type="",
+            allow_direction="",
+            trend_strength=req.trend_strength,
+            status="disabled",
+            message="大盘阶段不存在",
+        )
+
+    base = dict(
+        market_cycle=req.market_cycle,
+        regime_name=regime.name,
+        trade_type=regime.trade_type,
+        allow_direction=regime.allow_direction,
+        trend_strength=req.trend_strength,
+    )
+
+    # 震荡 → 全部禁用
+    if req.trend_strength == "震荡":
+        return MatchResult(
+            **base,
+            status="watch",
+            message="趋势强弱为「震荡」，全部策略禁用，建议观望",
+        )
+
+    # 宽幅震荡阶段 → 观望
+    if regime.trade_type == "观望" or regime.allow_direction == "禁止":
+        return MatchResult(
+            **base,
+            status="watch",
+            message=f"大盘阶段「{regime.name}」为观望阶段，禁止交易",
+        )
+
+    # 查询匹配绑定
+    matches = (
+        db.query(RegimeMatch)
+        .options(
+            joinedload(RegimeMatch.account),
+            joinedload(RegimeMatch.strategy),
+        )
+        .filter(
+            RegimeMatch.market_regime_id == req.market_regime_id,
+            RegimeMatch.market_cycle == req.market_cycle,
+            RegimeMatch.trend_strength == req.trend_strength,
+        )
+        .all()
+    )
+
+    if not matches:
+        return MatchResult(
+            **base,
+            status="disabled",
+            message="未找到匹配的账户/策略绑定，请在配置中心添加匹配规则",
+        )
+
+    # 过滤：仅保留已启用账户
+    accounts_out = []
+    strategies_out = []
+    seen_acc = set()
+    seen_strat = set()
+
+    for m in matches:
+        if not m.account or m.account.enable != 1:
+            continue
+
+        # 趋势强弱过滤（双重保险）
+        strat = m.strategy
+        if not strat:
+            continue
+        if not _strength_compatible(req.trend_strength, strat.fit_trend_strength):
+            continue
+
+        direction = m.force_direction or regime.allow_direction
+
+        if m.account_id not in seen_acc:
+            seen_acc.add(m.account_id)
+            accounts_out.append(MatchAccountOut(
+                id=m.account.id,
+                account_name=m.account.account_name,
+                total_capital=m.account.total_capital,
+                trade_cycle=m.account.trade_cycle,
+                risk_ratio=m.account.risk_ratio,
+                force_direction=direction,
+            ))
+
+        if m.strategy_id not in seen_strat:
+            seen_strat.add(m.strategy_id)
+            strategies_out.append(MatchStrategyOut(
+                id=strat.id,
+                strategy_name=strat.strategy_name,
+                fit_cycle=strat.fit_cycle,
+                strategy_rule=strat.strategy_rule,
+                force_direction=direction,
+            ))
+
+    if not accounts_out:
+        return MatchResult(
+            **base,
+            status="disabled",
+            message="无可用账户（可能全部被禁用或不匹配当前趋势强弱）",
+        )
+
+    return MatchResult(
+        **base,
+        status="ok",
+        message="匹配成功，以下为前置策略匹配结果（箱体/点位/突破条件需人工确认）",
+        accounts=accounts_out,
+        strategies=strategies_out,
+    )
+
+
+def _strength_compatible(selected: str, fit: str) -> bool:
+    """判断趋势强弱是否与策略适配"""
+    if fit == "全部":
+        return True
+    if selected == "强" and fit == "强":
+        return True
+    if selected == "弱" and fit == "弱":
+        return True
+    return False

backend/app/models.py

@@ -0,0 +1,66 @@
+"""SQLAlchemy ORM 模型"""
+
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, Text
+from sqlalchemy.orm import relationship
+
+from app.database import Base
+
+
+class MarketRegime(Base):
+    """大盘阶段"""
+    __tablename__ = "market_regime"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False, unique=True)
+    trade_type = Column(String, nullable=False)       # 顺势 / 反转 / 观望
+    allow_direction = Column(String, nullable=False)  # 做多 / 做空 / 禁止 / 多空均可
+    remark = Column(Text, default="")
+
+    matches = relationship("RegimeMatch", back_populates="regime", cascade="all, delete-orphan")
+
+
+class Account(Base):
+    """交易账户"""
+    __tablename__ = "account"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    account_name = Column(String, nullable=False)
+    total_capital = Column(Float, nullable=False, default=100)
+    trade_cycle = Column(String, nullable=False)
+    risk_ratio = Column(String, nullable=False)
+    enable = Column(Integer, nullable=False, default=1)
+    remark = Column(Text, default="")
+
+    matches = relationship("RegimeMatch", back_populates="account", cascade="all, delete-orphan")
+
+
+class Strategy(Base):
+    """交易策略（规则文本仅展示，系统不做校验）"""
+    __tablename__ = "strategy"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    strategy_name = Column(String, nullable=False)
+    fit_cycle = Column(String, nullable=False)
+    fit_trend_strength = Column(String, nullable=False)  # 强 / 弱 / 全部
+    trade_type = Column(String, nullable=False)            # 顺势 / 反转 / 全部
+    strategy_rule = Column(Text, nullable=False)
+    remark = Column(Text, default="")
+
+    matches = relationship("RegimeMatch", back_populates="strategy", cascade="all, delete-orphan")
+
+
+class RegimeMatch(Base):
+    """匹配绑定：大盘周期+阶段+强弱 → 账户+策略+方向"""
+    __tablename__ = "regime_match"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    market_regime_id = Column(Integer, ForeignKey("market_regime.id", ondelete="CASCADE"), nullable=False)
+    market_cycle = Column(String, nullable=False)      # 日线 / 4H / 1H
+    trend_strength = Column(String, nullable=False)    # 强 / 弱 / 震荡
+    account_id = Column(Integer, ForeignKey("account.id", ondelete="CASCADE"), nullable=False)
+    strategy_id = Column(Integer, ForeignKey("strategy.id", ondelete="CASCADE"), nullable=False)
+    force_direction = Column(String, default="")       # 做多 / 做空 / 空=跟随大盘
+
+    regime = relationship("MarketRegime", back_populates="matches")
+    account = relationship("Account", back_populates="matches")
+    strategy = relationship("Strategy", back_populates="matches")

backend/app/routes/accounts.py

@@ -0,0 +1,35 @@
+"""API 路由：账户"""
+
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app import crud, schemas
+
+router = APIRouter(prefix="/api/accounts", tags=["账户"])
+
+
+@router.get("", response_model=List[schemas.AccountOut])
+def list_accounts(db: Session = Depends(get_db)):
+    return crud.get_accounts(db)
+
+
+@router.post("", response_model=schemas.AccountOut, status_code=201)
+def create_account(data: schemas.AccountCreate, db: Session = Depends(get_db)):
+    return crud.create_account(db, data)
+
+
+@router.put("/{account_id}", response_model=schemas.AccountOut)
+def update_account(account_id: int, data: schemas.AccountUpdate, db: Session = Depends(get_db)):
+    obj = crud.update_account(db, account_id, data)
+    if not obj:
+        raise HTTPException(404, "账户不存在")
+    return obj
+
+
+@router.delete("/{account_id}")
+def delete_account(account_id: int, db: Session = Depends(get_db)):
+    if not crud.delete_account(db, account_id):
+        raise HTTPException(404, "账户不存在")
+    return {"ok": True}

backend/app/routes/match.py

@@ -0,0 +1,31 @@
+"""API 路由：日常使用 - 前置匹配"""
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app import schemas
+from app.matcher import run_match
+
+router = APIRouter(prefix="/api/match", tags=["前置匹配"])
+
+
+@router.get("", response_model=schemas.MatchResult)
+def do_match(
+    market_cycle: str = Query(..., description="大盘周期：日线/4H/1H"),
+    market_regime_id: int = Query(..., description="大盘阶段 ID"),
+    trend_strength: str = Query(..., description="趋势强弱：强/弱/震荡"),
+    db: Session = Depends(get_db),
+):
+    """根据人工选择的三项参数，输出前置匹配结果"""
+    req = schemas.MatchRequest(
+        market_cycle=market_cycle,
+        market_regime_id=market_regime_id,
+        trend_strength=trend_strength,
+    )
+    return run_match(db, req)
+
+
+@router.post("", response_model=schemas.MatchResult)
+def do_match_post(req: schemas.MatchRequest, db: Session = Depends(get_db)):
+    return run_match(db, req)

backend/app/routes/matches.py

@@ -0,0 +1,61 @@
+"""API 路由：匹配绑定"""
+
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app import crud, schemas
+
+router = APIRouter(prefix="/api/matches", tags=["匹配配置"])
+
+
+def _enrich_match(m) -> schemas.RegimeMatchOut:
+    """填充关联名称"""
+    return schemas.RegimeMatchOut(
+        id=m.id,
+        market_regime_id=m.market_regime_id,
+        market_cycle=m.market_cycle,
+        trend_strength=m.trend_strength,
+        account_id=m.account_id,
+        strategy_id=m.strategy_id,
+        force_direction=m.force_direction or "",
+        regime_name=m.regime.name if m.regime else None,
+        account_name=m.account.account_name if m.account else None,
+        strategy_name=m.strategy.strategy_name if m.strategy else None,
+    )
+
+
+@router.get("", response_model=List[schemas.RegimeMatchOut])
+def list_matches(db: Session = Depends(get_db)):
+    return [_enrich_match(m) for m in crud.get_matches(db)]
+
+
+@router.post("", response_model=schemas.RegimeMatchOut, status_code=201)
+def create_match(data: schemas.RegimeMatchCreate, db: Session = Depends(get_db)):
+    obj = crud.create_match(db, data)
+    # 重新加载关联
+    matches = crud.get_matches(db)
+    for m in matches:
+        if m.id == obj.id:
+            return _enrich_match(m)
+    return schemas.RegimeMatchOut(id=obj.id, **data.model_dump())
+
+
+@router.put("/{match_id}", response_model=schemas.RegimeMatchOut)
+def update_match(match_id: int, data: schemas.RegimeMatchUpdate, db: Session = Depends(get_db)):
+    obj = crud.update_match(db, match_id, data)
+    if not obj:
+        raise HTTPException(404, "匹配规则不存在")
+    matches = crud.get_matches(db)
+    for m in matches:
+        if m.id == match_id:
+            return _enrich_match(m)
+    raise HTTPException(404, "匹配规则不存在")
+
+
+@router.delete("/{match_id}")
+def delete_match(match_id: int, db: Session = Depends(get_db)):
+    if not crud.delete_match(db, match_id):
+        raise HTTPException(404, "匹配规则不存在")
+    return {"ok": True}

backend/app/routes/regimes.py

@@ -0,0 +1,35 @@
+"""API 路由：大盘阶段"""
+
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app import crud, schemas
+
+router = APIRouter(prefix="/api/regimes", tags=["大盘阶段"])
+
+
+@router.get("", response_model=List[schemas.MarketRegimeOut])
+def list_regimes(db: Session = Depends(get_db)):
+    return crud.get_regimes(db)
+
+
+@router.post("", response_model=schemas.MarketRegimeOut, status_code=201)
+def create_regime(data: schemas.MarketRegimeCreate, db: Session = Depends(get_db)):
+    return crud.create_regime(db, data)
+
+
+@router.put("/{regime_id}", response_model=schemas.MarketRegimeOut)
+def update_regime(regime_id: int, data: schemas.MarketRegimeUpdate, db: Session = Depends(get_db)):
+    obj = crud.update_regime(db, regime_id, data)
+    if not obj:
+        raise HTTPException(404, "大盘阶段不存在")
+    return obj
+
+
+@router.delete("/{regime_id}")
+def delete_regime(regime_id: int, db: Session = Depends(get_db)):
+    if not crud.delete_regime(db, regime_id):
+        raise HTTPException(404, "大盘阶段不存在")
+    return {"ok": True}

backend/app/routes/strategies.py

@@ -0,0 +1,35 @@
+"""API 路由：策略"""
+
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app import crud, schemas
+
+router = APIRouter(prefix="/api/strategies", tags=["策略"])
+
+
+@router.get("", response_model=List[schemas.StrategyOut])
+def list_strategies(db: Session = Depends(get_db)):
+    return crud.get_strategies(db)
+
+
+@router.post("", response_model=schemas.StrategyOut, status_code=201)
+def create_strategy(data: schemas.StrategyCreate, db: Session = Depends(get_db)):
+    return crud.create_strategy(db, data)
+
+
+@router.put("/{strategy_id}", response_model=schemas.StrategyOut)
+def update_strategy(strategy_id: int, data: schemas.StrategyUpdate, db: Session = Depends(get_db)):
+    obj = crud.update_strategy(db, strategy_id, data)
+    if not obj:
+        raise HTTPException(404, "策略不存在")
+    return obj
+
+
+@router.delete("/{strategy_id}")
+def delete_strategy(strategy_id: int, db: Session = Depends(get_db)):
+    if not crud.delete_strategy(db, strategy_id):
+        raise HTTPException(404, "策略不存在")
+    return {"ok": True}

backend/app/schemas.py

@@ -0,0 +1,171 @@
+"""Pydantic 请求/响应模型"""
+
+from typing import Optional, List
+from pydantic import BaseModel, Field
+
+
+# ── 大盘阶段 ──
+
+class MarketRegimeBase(BaseModel):
+    name: str
+    trade_type: str
+    allow_direction: str
+    remark: str = ""
+
+
+class MarketRegimeCreate(MarketRegimeBase):
+    pass
+
+
+class MarketRegimeUpdate(BaseModel):
+    name: Optional[str] = None
+    trade_type: Optional[str] = None
+    allow_direction: Optional[str] = None
+    remark: Optional[str] = None
+
+
+class MarketRegimeOut(MarketRegimeBase):
+    id: int
+
+    class Config:
+        from_attributes = True
+
+
+# ── 账户 ──
+
+class AccountBase(BaseModel):
+    account_name: str
+    total_capital: float = 100
+    trade_cycle: str
+    risk_ratio: str
+    enable: int = 1
+    remark: str = ""
+
+
+class AccountCreate(AccountBase):
+    pass
+
+
+class AccountUpdate(BaseModel):
+    account_name: Optional[str] = None
+    total_capital: Optional[float] = None
+    trade_cycle: Optional[str] = None
+    risk_ratio: Optional[str] = None
+    enable: Optional[int] = None
+    remark: Optional[str] = None
+
+
+class AccountOut(AccountBase):
+    id: int
+
+    class Config:
+        from_attributes = True
+
+
+# ── 策略 ──
+
+class StrategyBase(BaseModel):
+    strategy_name: str
+    fit_cycle: str
+    fit_trend_strength: str
+    trade_type: str
+    strategy_rule: str
+    remark: str = ""
+
+
+class StrategyCreate(StrategyBase):
+    pass
+
+
+class StrategyUpdate(BaseModel):
+    strategy_name: Optional[str] = None
+    fit_cycle: Optional[str] = None
+    fit_trend_strength: Optional[str] = None
+    trade_type: Optional[str] = None
+    strategy_rule: Optional[str] = None
+    remark: Optional[str] = None
+
+
+class StrategyOut(StrategyBase):
+    id: int
+
+    class Config:
+        from_attributes = True
+
+
+# ── 匹配绑定 ──
+
+class RegimeMatchBase(BaseModel):
+    market_regime_id: int
+    market_cycle: str
+    trend_strength: str
+    account_id: int
+    strategy_id: int
+    force_direction: str = ""
+
+
+class RegimeMatchCreate(RegimeMatchBase):
+    pass
+
+
+class RegimeMatchUpdate(BaseModel):
+    market_regime_id: Optional[int] = None
+    market_cycle: Optional[str] = None
+    trend_strength: Optional[str] = None
+    account_id: Optional[int] = None
+    strategy_id: Optional[int] = None
+    force_direction: Optional[str] = None
+
+
+class RegimeMatchOut(RegimeMatchBase):
+    id: int
+    regime_name: Optional[str] = None
+    account_name: Optional[str] = None
+    strategy_name: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+
+# ── 日常使用：匹配查询 ──
+
+class MatchRequest(BaseModel):
+    market_cycle: str = Field(..., description="大盘周期：日线/4H/1H")
+    market_regime_id: int = Field(..., description="大盘阶段 ID")
+    trend_strength: str = Field(..., description="趋势强弱：强/弱/震荡")
+
+
+class MatchAccountOut(BaseModel):
+    id: int
+    account_name: str
+    total_capital: float
+    trade_cycle: str
+    risk_ratio: str
+    force_direction: str = ""
+
+    class Config:
+        from_attributes = True
+
+
+class MatchStrategyOut(BaseModel):
+    id: int
+    strategy_name: str
+    fit_cycle: str
+    strategy_rule: str
+    force_direction: str = ""
+
+    class Config:
+        from_attributes = True
+
+
+class MatchResult(BaseModel):
+    """匹配结果：系统仅做前置策略匹配，不做任何自动校验"""
+    market_cycle: str
+    regime_name: str
+    trade_type: str
+    allow_direction: str
+    trend_strength: str
+    status: str                          # ok / watch / disabled
+    message: str = ""
+    accounts: List[MatchAccountOut] = []
+    strategies: List[MatchStrategyOut] = []

backend/init_db.sql

@@ -0,0 +1,50 @@
+-- 加密货币前置匹配系统 - SQLite 建表脚本
+-- 本系统仅做前置策略匹配，不处理币种、点位、箱体细节
+
+-- 1. 大盘阶段表
+CREATE TABLE IF NOT EXISTS market_regime (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE,
+    trade_type TEXT NOT NULL,       -- 顺势 / 反转 / 观望
+    allow_direction TEXT NOT NULL,  -- 做多 / 做空 / 禁止 / 多空均可
+    remark TEXT DEFAULT ''
+);
+
+-- 2. 账户表
+CREATE TABLE IF NOT EXISTS account (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    account_name TEXT NOT NULL,
+    total_capital REAL NOT NULL DEFAULT 100,
+    trade_cycle TEXT NOT NULL,      -- 如 4H/1H、日内、灵活
+    risk_ratio TEXT NOT NULL,       -- 如 5%~10%
+    enable INTEGER NOT NULL DEFAULT 1,
+    remark TEXT DEFAULT ''
+);
+
+-- 3. 策略表
+CREATE TABLE IF NOT EXISTS strategy (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    strategy_name TEXT NOT NULL,
+    fit_cycle TEXT NOT NULL,            -- 适用周期
+    fit_trend_strength TEXT NOT NULL,   -- 强 / 弱 / 全部
+    trade_type TEXT NOT NULL,           -- 顺势 / 反转 / 全部
+    strategy_rule TEXT NOT NULL,        -- 策略规则文本（仅展示，不做校验）
+    remark TEXT DEFAULT ''
+);
+
+-- 4. 匹配绑定表
+CREATE TABLE IF NOT EXISTS regime_match (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    market_regime_id INTEGER NOT NULL,
+    market_cycle TEXT NOT NULL,         -- 日线 / 4H / 1H
+    trend_strength TEXT NOT NULL,       -- 强 / 弱 / 震荡
+    account_id INTEGER NOT NULL,
+    strategy_id INTEGER NOT NULL,
+    force_direction TEXT DEFAULT '',    -- 强制方向：做多 / 做空 / 空=跟随大盘
+    FOREIGN KEY (market_regime_id) REFERENCES market_regime(id) ON DELETE CASCADE,
+    FOREIGN KEY (account_id) REFERENCES account(id) ON DELETE CASCADE,
+    FOREIGN KEY (strategy_id) REFERENCES strategy(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_regime_match_lookup
+    ON regime_match(market_regime_id, market_cycle, trend_strength);

backend/requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+sqlalchemy==2.0.36
+pydantic==2.10.4

deploy/install.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# ============================================================
+# 加密货币前置匹配系统 — Ubuntu 一键部署脚本
+# 仓库：https://git.bz121.com/dekun/crypto-pre-trade-system.git
+# 部署路径：/opt/crypto-pre-trade-system
+# 运行用户：root
+# 进程守护：PM2
+# 访问端口：1125
+# ============================================================
+
+set -euo pipefail
+
+REPO_URL="https://git.bz121.com/dekun/crypto-pre-trade-system.git"
+INSTALL_DIR="/opt/crypto-pre-trade-system"
+PORT=1125
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+log()  { echo -e "${GREEN}[INFO]${NC} $*"; }
+warn() { echo -e "${YELLOW}[WARN]${NC} $*"; }
+err()  { echo -e "${RED}[ERROR]${NC} $*"; exit 1; }
+
+# ── 检查 root 权限 ──
+if [ "$(id -u)" -ne 0 ]; then
+  err "请使用 root 用户运行：sudo bash deploy/install.sh"
+fi
+
+log "========== 开始部署 crypto-pre-trade-system =========="
+
+# ── 1. 安装系统依赖 ──
+log "安装系统依赖..."
+export DEBIAN_FRONTEND=noninteractive
+apt-get update -qq
+apt-get install -y -qq git curl python3 python3-venv python3-pip
+
+# Node.js 18+（若未安装）
+if ! command -v node &>/dev/null; then
+  log "安装 Node.js 20 LTS..."
+  curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
+  apt-get install -y -qq nodejs
+fi
+
+# PM2（若未安装）
+if ! command -v pm2 &>/dev/null; then
+  log "安装 PM2..."
+  npm install -g pm2
+fi
+
+log "Node $(node -v) | Python $(python3 --version) | PM2 $(pm2 -v)"
+
+# ── 2. 拉取代码 ──
+if [ -d "$INSTALL_DIR/.git" ]; then
+  log "更新代码..."
+  cd "$INSTALL_DIR"
+  git pull origin main 2>/dev/null || git pull origin master 2>/dev/null || git pull
+else
+  log "克隆仓库..."
+  git clone "$REPO_URL" "$INSTALL_DIR"
+  cd "$INSTALL_DIR"
+fi
+
+# ── 3. 创建日志目录 ──
+mkdir -p "$INSTALL_DIR/logs"
+mkdir -p "$INSTALL_DIR/backend/data"
+
+# ── 4. Python 虚拟环境 + 依赖 ──
+log "配置 Python 虚拟环境..."
+cd "$INSTALL_DIR/backend"
+if [ ! -d "venv" ]; then
+  python3 -m venv venv
+fi
+venv/bin/pip install -q --upgrade pip
+venv/bin/pip install -q -r requirements.txt
+
+# ── 5. 构建前端 ──
+log "构建前端..."
+cd "$INSTALL_DIR/frontend"
+npm install --silent
+npm run build
+
+# ── 6. PM2 启动 / 重启 ──
+log "启动 PM2 守护进程..."
+cd "$INSTALL_DIR"
+pm2 delete crypto-pre-trade 2>/dev/null || true
+pm2 start ecosystem.config.cjs
+pm2 save
+
+# 设置 PM2 开机自启（已配置则跳过）
+pm2 startup systemd -u root --hp /root 2>/dev/null | tail -1 | bash 2>/dev/null || true
+
+# ── 7. 健康检查 ──
+log "等待服务启动..."
+sleep 3
+if curl -sf "http://127.0.0.1:${PORT}/api/health" > /dev/null; then
+  log "健康检查通过 ✓"
+else
+  warn "健康检查未通过，请查看日志：pm2 logs crypto-pre-trade"
+fi
+
+echo ""
+log "========== 部署完成 =========="
+echo -e "  访问地址：${GREEN}http://<服务器IP>:${PORT}${NC}"
+echo -e "  API 文档：${GREEN}http://<服务器IP>:${PORT}/docs${NC}"
+echo -e "  安装目录：${INSTALL_DIR}"
+echo -e "  常用命令："
+echo -e "    pm2 status                  # 查看状态"
+echo -e "    pm2 logs crypto-pre-trade   # 查看日志"
+echo -e "    pm2 restart crypto-pre-trade # 重启服务"
+echo -e "    bash deploy/install.sh      # 更新并重新部署"
+echo ""

ecosystem.config.cjs

@@ -0,0 +1,26 @@
+/**
+ * PM2 进程配置
+ * 部署路径：/opt/crypto-pre-trade-system
+ * 运行用户：root
+ * 访问端口：1125
+ */
+module.exports = {
+  apps: [
+    {
+      name: 'crypto-pre-trade',
+      cwd: '/opt/crypto-pre-trade-system/backend',
+      script: 'venv/bin/uvicorn',
+      args: 'app.main:app --host 0.0.0.0 --port 1125',
+      interpreter: 'none',
+      autorestart: true,
+      watch: false,
+      max_memory_restart: '300M',
+      env: {
+        NODE_ENV: 'production',
+      },
+      error_file: '/opt/crypto-pre-trade-system/logs/pm2-error.log',
+      out_file: '/opt/crypto-pre-trade-system/logs/pm2-out.log',
+      log_date_format: 'YYYY-MM-DD HH:mm:ss',
+    },
+  ],
+};

frontend/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>加密货币前置匹配系统</title>
+  </head>
+  <body class="bg-dark-bg text-dark-text">
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "crypto-pre-trade-frontend",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "vue": "^3.5.13",
+    "vue-router": "^4.5.0",
+    "axios": "^1.7.9"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.2.1",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.49",
+    "tailwindcss": "^3.4.17",
+    "vite": "^6.0.5"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.vue

@@ -0,0 +1,37 @@
+<template>
+  <div class="min-h-screen flex flex-col">
+    <!-- 顶部导航 -->
+    <header class="border-b border-dark-border bg-dark-card px-6 py-3 flex items-center justify-between">
+      <h1 class="text-lg font-semibold tracking-wide">加密货币前置匹配系统</h1>
+      <nav class="flex gap-1">
+        <router-link
+          to="/"
+          class="px-4 py-2 text-sm rounded-md transition-colors"
+          :class="$route.path === '/' ? 'bg-dark-accent text-white' : 'text-dark-muted hover:text-dark-text'"
+        >
+          日常使用
+        </router-link>
+        <router-link
+          to="/config"
+          class="px-4 py-2 text-sm rounded-md transition-colors"
+          :class="$route.path === '/config' ? 'bg-dark-accent text-white' : 'text-dark-muted hover:text-dark-text'"
+        >
+          系统配置
+        </router-link>
+      </nav>
+    </header>
+
+    <!-- 主内容 -->
+    <main class="flex-1 p-6">
+      <router-view />
+    </main>
+
+    <!-- 底部 -->
+    <footer class="border-t border-dark-border px-6 py-2 text-xs text-dark-muted text-center">
+      纯本地部署 · 无登录 · 仅做前置策略匹配 · 箱体/点位/突破条件需人工确认
+    </footer>
+  </div>
+</template>
+
+<script setup>
+</script>

frontend/src/api/index.js

@@ -0,0 +1,35 @@
+import axios from 'axios'
+
+const api = axios.create({
+  baseURL: '/api',
+  timeout: 10000,
+})
+
+// ── 大盘阶段 ──
+export const getRegimes = () => api.get('/regimes')
+export const createRegime = (data) => api.post('/regimes', data)
+export const updateRegime = (id, data) => api.put(`/regimes/${id}`, data)
+export const deleteRegime = (id) => api.delete(`/regimes/${id}`)
+
+// ── 账户 ──
+export const getAccounts = () => api.get('/accounts')
+export const createAccount = (data) => api.post('/accounts', data)
+export const updateAccount = (id, data) => api.put(`/accounts/${id}`, data)
+export const deleteAccount = (id) => api.delete(`/accounts/${id}`)
+
+// ── 策略 ──
+export const getStrategies = () => api.get('/strategies')
+export const createStrategy = (data) => api.post('/strategies', data)
+export const updateStrategy = (id, data) => api.put(`/strategies/${id}`, data)
+export const deleteStrategy = (id) => api.delete(`/strategies/${id}`)
+
+// ── 匹配配置 ──
+export const getMatches = () => api.get('/matches')
+export const createMatch = (data) => api.post('/matches', data)
+export const updateMatch = (id, data) => api.put(`/matches/${id}`, data)
+export const deleteMatch = (id) => api.delete(`/matches/${id}`)
+
+// ── 前置匹配 ──
+export const doMatch = (params) => api.get('/match', { params })
+
+export default api

frontend/src/main.js

@@ -0,0 +1,6 @@
+import { createApp } from 'vue'
+import App from './App.vue'
+import router from './router'
+import './style.css'
+
+createApp(App).use(router).mount('#app')

frontend/src/router/index.js

@@ -0,0 +1,13 @@
+import { createRouter, createWebHistory } from 'vue-router'
+import DailyMatch from '../views/DailyMatch.vue'
+import ConfigCenter from '../views/ConfigCenter.vue'
+
+const routes = [
+  { path: '/', name: 'DailyMatch', component: DailyMatch },
+  { path: '/config', name: 'ConfigCenter', component: ConfigCenter },
+]
+
+export default createRouter({
+  history: createWebHistory(),
+  routes,
+})

frontend/src/style.css

@@ -0,0 +1,51 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', sans-serif;
+  -webkit-font-smoothing: antialiased;
+}
+
+/* 滚动条样式 */
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: #141414; }
+::-webkit-scrollbar-thumb { background: #404040; border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: #525252; }
+
+/* 通用卡片 */
+.card {
+  @apply bg-dark-card border border-dark-border rounded-lg p-4;
+}
+
+/* 通用按钮 */
+.btn {
+  @apply px-4 py-2 rounded-md text-sm font-medium transition-colors;
+}
+.btn-primary {
+  @apply btn bg-dark-accent text-white hover:bg-blue-600;
+}
+.btn-danger {
+  @apply btn bg-dark-danger text-white hover:bg-red-600;
+}
+.btn-ghost {
+  @apply btn bg-dark-hover text-dark-text hover:bg-dark-border;
+}
+
+/* 表单元素 */
+.input {
+  @apply w-full bg-dark-bg border border-dark-border rounded-md px-3 py-2 text-sm
+         text-dark-text focus:outline-none focus:border-dark-accent;
+}
+.select {
+  @apply input appearance-none cursor-pointer;
+}
+.textarea {
+  @apply input resize-y min-h-[80px];
+}
+
+/* 标签页 */
+.tab-active {
+  @apply border-b-2 border-dark-accent text-dark-accent;
+}

frontend/src/views/ConfigCenter.vue

@@ -0,0 +1,367 @@
+<template>
+  <div>
+    <!-- 标签页切换 -->
+    <div class="flex gap-0 border-b border-dark-border mb-6">
+      <button
+        v-for="tab in tabs"
+        :key="tab.key"
+        @click="activeTab = tab.key"
+        class="px-5 py-3 text-sm font-medium transition-colors"
+        :class="activeTab === tab.key ? 'tab-active' : 'text-dark-muted hover:text-dark-text'"
+      >
+        {{ tab.label }}
+      </button>
+    </div>
+
+    <!-- 大盘管理 -->
+    <section v-if="activeTab === 'regimes'">
+      <div class="flex justify-between items-center mb-4">
+        <h2 class="text-base font-semibold">大盘阶段管理</h2>
+        <button @click="openRegimeForm()" class="btn-primary">新增阶段</button>
+      </div>
+      <table class="w-full text-sm">
+        <thead>
+          <tr class="border-b border-dark-border text-dark-muted text-left">
+            <th class="py-2 px-3">ID</th>
+            <th class="py-2 px-3">名称</th>
+            <th class="py-2 px-3">交易类型</th>
+            <th class="py-2 px-3">允许方向</th>
+            <th class="py-2 px-3">备注</th>
+            <th class="py-2 px-3 w-32">操作</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="r in regimes" :key="r.id" class="border-b border-dark-border/50 hover:bg-dark-hover">
+            <td class="py-2 px-3">{{ r.id }}</td>
+            <td class="py-2 px-3 font-medium">{{ r.name }}</td>
+            <td class="py-2 px-3">{{ r.trade_type }}</td>
+            <td class="py-2 px-3">{{ r.allow_direction }}</td>
+            <td class="py-2 px-3 text-dark-muted">{{ r.remark }}</td>
+            <td class="py-2 px-3">
+              <button @click="openRegimeForm(r)" class="text-dark-accent text-xs mr-2 hover:underline">编辑</button>
+              <button @click="handleDeleteRegime(r.id)" class="text-dark-danger text-xs hover:underline">删除</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </section>
+
+    <!-- 账户管理 -->
+    <section v-if="activeTab === 'accounts'">
+      <div class="flex justify-between items-center mb-4">
+        <h2 class="text-base font-semibold">账户管理</h2>
+        <button @click="openAccountForm()" class="btn-primary">新增账户</button>
+      </div>
+      <table class="w-full text-sm">
+        <thead>
+          <tr class="border-b border-dark-border text-dark-muted text-left">
+            <th class="py-2 px-3">ID</th>
+            <th class="py-2 px-3">账户名</th>
+            <th class="py-2 px-3">本金(U)</th>
+            <th class="py-2 px-3">交易周期</th>
+            <th class="py-2 px-3">风险比</th>
+            <th class="py-2 px-3">状态</th>
+            <th class="py-2 px-3 w-32">操作</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="a in accounts" :key="a.id" class="border-b border-dark-border/50 hover:bg-dark-hover">
+            <td class="py-2 px-3">{{ a.id }}</td>
+            <td class="py-2 px-3 font-medium">{{ a.account_name }}</td>
+            <td class="py-2 px-3">{{ a.total_capital }}</td>
+            <td class="py-2 px-3">{{ a.trade_cycle }}</td>
+            <td class="py-2 px-3">{{ a.risk_ratio }}</td>
+            <td class="py-2 px-3">
+              <span :class="a.enable ? 'text-dark-success' : 'text-dark-danger'">
+                {{ a.enable ? '启用' : '禁用' }}
+              </span>
+            </td>
+            <td class="py-2 px-3">
+              <button @click="openAccountForm(a)" class="text-dark-accent text-xs mr-2 hover:underline">编辑</button>
+              <button @click="handleDeleteAccount(a.id)" class="text-dark-danger text-xs hover:underline">删除</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </section>
+
+    <!-- 策略管理 -->
+    <section v-if="activeTab === 'strategies'">
+      <div class="flex justify-between items-center mb-4">
+        <h2 class="text-base font-semibold">策略管理</h2>
+        <button @click="openStrategyForm()" class="btn-primary">新增策略</button>
+      </div>
+      <div class="grid gap-4">
+        <div v-for="s in strategies" :key="s.id" class="card">
+          <div class="flex justify-between items-start mb-2">
+            <div>
+              <h3 class="font-medium">{{ s.strategy_name }}</h3>
+              <p class="text-xs text-dark-muted mt-1">
+                周期: {{ s.fit_cycle }} · 趋势: {{ s.fit_trend_strength }} · 类型: {{ s.trade_type }}
+              </p>
+            </div>
+            <div>
+              <button @click="openStrategyForm(s)" class="text-dark-accent text-xs mr-2 hover:underline">编辑</button>
+              <button @click="handleDeleteStrategy(s.id)" class="text-dark-danger text-xs hover:underline">删除</button>
+            </div>
+          </div>
+          <pre class="text-xs text-dark-muted whitespace-pre-wrap bg-dark-bg rounded p-3">{{ s.strategy_rule }}</pre>
+        </div>
+      </div>
+    </section>
+
+    <!-- 匹配配置 -->
+    <section v-if="activeTab === 'matches'">
+      <div class="flex justify-between items-center mb-4">
+        <h2 class="text-base font-semibold">匹配配置</h2>
+        <button @click="openMatchForm()" class="btn-primary">新增匹配</button>
+      </div>
+      <table class="w-full text-sm">
+        <thead>
+          <tr class="border-b border-dark-border text-dark-muted text-left">
+            <th class="py-2 px-3">ID</th>
+            <th class="py-2 px-3">大盘阶段</th>
+            <th class="py-2 px-3">周期</th>
+            <th class="py-2 px-3">强弱</th>
+            <th class="py-2 px-3">账户</th>
+            <th class="py-2 px-3">策略</th>
+            <th class="py-2 px-3">强制方向</th>
+            <th class="py-2 px-3 w-32">操作</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="m in matchList" :key="m.id" class="border-b border-dark-border/50 hover:bg-dark-hover">
+            <td class="py-2 px-3">{{ m.id }}</td>
+            <td class="py-2 px-3">{{ m.regime_name }}</td>
+            <td class="py-2 px-3">{{ m.market_cycle }}</td>
+            <td class="py-2 px-3">{{ m.trend_strength }}</td>
+            <td class="py-2 px-3">{{ m.account_name }}</td>
+            <td class="py-2 px-3">{{ m.strategy_name }}</td>
+            <td class="py-2 px-3 text-dark-muted">{{ m.force_direction || '跟随大盘' }}</td>
+            <td class="py-2 px-3">
+              <button @click="openMatchForm(m)" class="text-dark-accent text-xs mr-2 hover:underline">编辑</button>
+              <button @click="handleDeleteMatch(m.id)" class="text-dark-danger text-xs hover:underline">删除</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </section>
+
+    <!-- 通用弹窗 -->
+    <div v-if="showModal" class="fixed inset-0 bg-black/60 flex items-center justify-center z-50" @click.self="showModal = false">
+      <div class="card w-full max-w-lg max-h-[80vh] overflow-y-auto">
+        <h3 class="text-base font-semibold mb-4">{{ modalTitle }}</h3>
+        <form @submit.prevent="handleSubmit" class="flex flex-col gap-3">
+          <!-- 大盘阶段表单 -->
+          <template v-if="formType === 'regime'">
+            <input v-model="formData.name" class="input" placeholder="阶段名称" required />
+            <select v-model="formData.trade_type" class="select" required>
+              <option value="顺势">顺势</option>
+              <option value="反转">反转</option>
+              <option value="观望">观望</option>
+            </select>
+            <select v-model="formData.allow_direction" class="select" required>
+              <option value="做多">做多</option>
+              <option value="做空">做空</option>
+              <option value="禁止">禁止</option>
+              <option value="多空均可">多空均可</option>
+            </select>
+            <input v-model="formData.remark" class="input" placeholder="备注" />
+          </template>
+
+          <!-- 账户表单 -->
+          <template v-if="formType === 'account'">
+            <input v-model="formData.account_name" class="input" placeholder="账户名称" required />
+            <input v-model.number="formData.total_capital" type="number" class="input" placeholder="本金(U)" required />
+            <input v-model="formData.trade_cycle" class="input" placeholder="交易周期" required />
+            <input v-model="formData.risk_ratio" class="input" placeholder="风险比" required />
+            <select v-model.number="formData.enable" class="select">
+              <option :value="1">启用</option>
+              <option :value="0">禁用</option>
+            </select>
+            <input v-model="formData.remark" class="input" placeholder="备注" />
+          </template>
+
+          <!-- 策略表单 -->
+          <template v-if="formType === 'strategy'">
+            <input v-model="formData.strategy_name" class="input" placeholder="策略名称" required />
+            <input v-model="formData.fit_cycle" class="input" placeholder="适用周期" required />
+            <select v-model="formData.fit_trend_strength" class="select" required>
+              <option value="强">强</option>
+              <option value="弱">弱</option>
+              <option value="全部">全部</option>
+            </select>
+            <select v-model="formData.trade_type" class="select" required>
+              <option value="顺势">顺势</option>
+              <option value="反转">反转</option>
+              <option value="全部">全部</option>
+            </select>
+            <textarea v-model="formData.strategy_rule" class="textarea" placeholder="策略规则文本" required></textarea>
+            <input v-model="formData.remark" class="input" placeholder="备注" />
+          </template>
+
+          <!-- 匹配表单 -->
+          <template v-if="formType === 'match'">
+            <select v-model.number="formData.market_regime_id" class="select" required>
+              <option :value="null" disabled>选择大盘阶段</option>
+              <option v-for="r in regimes" :key="r.id" :value="r.id">{{ r.name }}</option>
+            </select>
+            <select v-model="formData.market_cycle" class="select" required>
+              <option value="日线">日线</option>
+              <option value="4H">4H</option>
+              <option value="1H">1H</option>
+            </select>
+            <select v-model="formData.trend_strength" class="select" required>
+              <option value="强">强</option>
+              <option value="弱">弱</option>
+              <option value="震荡">震荡</option>
+            </select>
+            <select v-model.number="formData.account_id" class="select" required>
+              <option :value="null" disabled>选择账户</option>
+              <option v-for="a in accounts" :key="a.id" :value="a.id">{{ a.account_name }}</option>
+            </select>
+            <select v-model.number="formData.strategy_id" class="select" required>
+              <option :value="null" disabled>选择策略</option>
+              <option v-for="s in strategies" :key="s.id" :value="s.id">{{ s.strategy_name }}</option>
+            </select>
+            <select v-model="formData.force_direction" class="select">
+              <option value="">跟随大盘</option>
+              <option value="做多">做多</option>
+              <option value="做空">做空</option>
+            </select>
+          </template>
+
+          <div class="flex gap-2 justify-end mt-2">
+            <button type="button" @click="showModal = false" class="btn-ghost">取消</button>
+            <button type="submit" class="btn-primary">保存</button>
+          </div>
+        </form>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref, onMounted } from 'vue'
+import {
+  getRegimes, createRegime, updateRegime, deleteRegime,
+  getAccounts, createAccount, updateAccount, deleteAccount,
+  getStrategies, createStrategy, updateStrategy, deleteStrategy,
+  getMatches, createMatch, updateMatch, deleteMatch,
+} from '../api'
+
+const tabs = [
+  { key: 'regimes', label: '大盘管理' },
+  { key: 'accounts', label: '账户管理' },
+  { key: 'strategies', label: '策略管理' },
+  { key: 'matches', label: '匹配配置' },
+]
+
+const activeTab = ref('regimes')
+const regimes = ref([])
+const accounts = ref([])
+const strategies = ref([])
+const matchList = ref([])
+
+// 弹窗
+const showModal = ref(false)
+const modalTitle = ref('')
+const formType = ref('')
+const formData = ref({})
+const editingId = ref(null)
+
+async function loadAll() {
+  const [r, a, s, m] = await Promise.all([
+    getRegimes(), getAccounts(), getStrategies(), getMatches(),
+  ])
+  regimes.value = r.data
+  accounts.value = a.data
+  strategies.value = s.data
+  matchList.value = m.data
+}
+
+// ── 大盘 ──
+function openRegimeForm(item = null) {
+  formType.value = 'regime'
+  editingId.value = item?.id || null
+  modalTitle.value = item ? '编辑大盘阶段' : '新增大盘阶段'
+  formData.value = item ? { ...item } : { name: '', trade_type: '顺势', allow_direction: '做多', remark: '' }
+  showModal.value = true
+}
+
+async function handleDeleteRegime(id) {
+  if (!confirm('确定删除此大盘阶段？关联匹配规则也会删除。')) return
+  await deleteRegime(id)
+  loadAll()
+}
+
+// ── 账户 ──
+function openAccountForm(item = null) {
+  formType.value = 'account'
+  editingId.value = item?.id || null
+  modalTitle.value = item ? '编辑账户' : '新增账户'
+  formData.value = item ? { ...item } : { account_name: '', total_capital: 100, trade_cycle: '', risk_ratio: '', enable: 1, remark: '' }
+  showModal.value = true
+}
+
+async function handleDeleteAccount(id) {
+  if (!confirm('确定删除此账户？')) return
+  await deleteAccount(id)
+  loadAll()
+}
+
+// ── 策略 ──
+function openStrategyForm(item = null) {
+  formType.value = 'strategy'
+  editingId.value = item?.id || null
+  modalTitle.value = item ? '编辑策略' : '新增策略'
+  formData.value = item ? { ...item } : { strategy_name: '', fit_cycle: '', fit_trend_strength: '强', trade_type: '顺势', strategy_rule: '', remark: '' }
+  showModal.value = true
+}
+
+async function handleDeleteStrategy(id) {
+  if (!confirm('确定删除此策略？')) return
+  await deleteStrategy(id)
+  loadAll()
+}
+
+// ── 匹配 ──
+function openMatchForm(item = null) {
+  formType.value = 'match'
+  editingId.value = item?.id || null
+  modalTitle.value = item ? '编辑匹配规则' : '新增匹配规则'
+  formData.value = item
+    ? { ...item }
+    : { market_regime_id: null, market_cycle: '日线', trend_strength: '强', account_id: null, strategy_id: null, force_direction: '' }
+  showModal.value = true
+}
+
+async function handleDeleteMatch(id) {
+  if (!confirm('确定删除此匹配规则？')) return
+  await deleteMatch(id)
+  loadAll()
+}
+
+// ── 提交 ──
+async function handleSubmit() {
+  const id = editingId.value
+  const data = { ...formData.value }
+  delete data.id
+  delete data.regime_name
+  delete data.account_name
+  delete data.strategy_name
+
+  const actions = {
+    regime: id ? () => updateRegime(id, data) : () => createRegime(data),
+    account: id ? () => updateAccount(id, data) : () => createAccount(data),
+    strategy: id ? () => updateStrategy(id, data) : () => createStrategy(data),
+    match: id ? () => updateMatch(id, data) : () => createMatch(data),
+  }
+
+  await actions[formType.value]()
+  showModal.value = false
+  loadAll()
+}
+
+onMounted(loadAll)
+</script>

frontend/src/views/DailyMatch.vue

@@ -0,0 +1,290 @@
+<template>
+  <div class="flex gap-6 h-[calc(100vh-120px)]">
+    <!-- 左侧：人工选择 -->
+    <div class="w-80 shrink-0 card flex flex-col gap-6">
+      <h2 class="text-base font-semibold border-b border-dark-border pb-3">人工选择</h2>
+
+      <!-- 大盘周期 -->
+      <div>
+        <label class="block text-sm text-dark-muted mb-2">大盘周期</label>
+        <div class="flex flex-col gap-2">
+          <button
+            v-for="c in cycles"
+            :key="c"
+            @click="selected.cycle = c"
+            class="px-4 py-2.5 rounded-md text-sm text-left transition-colors border"
+            :class="selected.cycle === c
+              ? 'border-dark-accent bg-dark-accent/10 text-dark-accent'
+              : 'border-dark-border hover:border-dark-muted text-dark-text'"
+          >
+            {{ c }}
+          </button>
+        </div>
+      </div>
+
+      <!-- 大盘阶段 -->
+      <div>
+        <label class="block text-sm text-dark-muted mb-2">大盘阶段</label>
+        <div class="flex flex-col gap-1.5 max-h-64 overflow-y-auto">
+          <button
+            v-for="r in regimes"
+            :key="r.id"
+            @click="selected.regimeId = r.id"
+            class="px-3 py-2 rounded-md text-sm text-left transition-colors border"
+            :class="selected.regimeId === r.id
+              ? 'border-dark-accent bg-dark-accent/10 text-dark-accent'
+              : 'border-dark-border hover:border-dark-muted text-dark-text'"
+          >
+            <span>{{ r.name }}</span>
+            <span class="ml-2 text-xs text-dark-muted">{{ r.trade_type }} · {{ r.allow_direction }}</span>
+          </button>
+        </div>
+      </div>
+
+      <!-- 趋势强弱 -->
+      <div>
+        <label class="block text-sm text-dark-muted mb-2">趋势强弱</label>
+        <div class="flex gap-2">
+          <button
+            v-for="s in strengths"
+            :key="s.value"
+            @click="selected.strength = s.value"
+            class="flex-1 px-3 py-2.5 rounded-md text-sm transition-colors border"
+            :class="selected.strength === s.value
+              ? strengthActiveClass(s.value)
+              : 'border-dark-border hover:border-dark-muted text-dark-text'"
+          >
+            {{ s.label }}
+          </button>
+        </div>
+      </div>
+
+      <!-- 匹配按钮 -->
+      <button
+        @click="runMatchQuery"
+        :disabled="!canMatch || loading"
+        class="btn-primary w-full py-3 disabled:opacity-40 disabled:cursor-not-allowed"
+      >
+        {{ loading ? '匹配中...' : '执行前置匹配' }}
+      </button>
+    </div>
+
+    <!-- 右侧：匹配结果 -->
+    <div class="flex-1 flex flex-col gap-4 overflow-y-auto">
+      <!-- 未匹配提示 -->
+      <div v-if="!result" class="card flex-1 flex items-center justify-center text-dark-muted">
+        <div class="text-center">
+          <p class="text-lg mb-2">请选择大盘周期、阶段、趋势强弱</p>
+          <p class="text-sm">点击「执行前置匹配」查看可用账户与策略</p>
+        </div>
+      </div>
+
+      <template v-else>
+        <!-- 状态提示 -->
+        <div
+          class="card border-l-4"
+          :class="statusBorderClass"
+        >
+          <div class="flex items-center gap-3">
+            <span class="text-2xl">{{ statusIcon }}</span>
+            <div>
+              <p class="font-medium">{{ result.message }}</p>
+              <p class="text-sm text-dark-muted mt-1">
+                {{ result.market_cycle }} · {{ result.regime_name }} · {{ result.trend_strength }}
+              </p>
+            </div>
+          </div>
+        </div>
+
+        <!-- 大盘信息 -->
+        <div class="grid grid-cols-3 gap-4">
+          <div class="card text-center">
+            <p class="text-xs text-dark-muted mb-1">交易类型</p>
+            <p class="text-lg font-semibold" :class="tradeTypeColor">{{ result.trade_type || '—' }}</p>
+          </div>
+          <div class="card text-center">
+            <p class="text-xs text-dark-muted mb-1">允许开仓方向</p>
+            <p class="text-lg font-semibold" :class="directionColor">{{ result.allow_direction || '—' }}</p>
+          </div>
+          <div class="card text-center">
+            <p class="text-xs text-dark-muted mb-1">匹配状态</p>
+            <p class="text-lg font-semibold" :class="statusTextColor">{{ statusLabel }}</p>
+          </div>
+        </div>
+
+        <!-- 可用账户 -->
+        <div class="card">
+          <h3 class="text-sm font-semibold mb-3 flex items-center gap-2">
+            <span class="w-2 h-2 rounded-full bg-dark-success"></span>
+            可用账户
+            <span class="text-dark-muted font-normal">({{ result.accounts?.length || 0 }})</span>
+          </h3>
+          <div v-if="!result.accounts?.length" class="text-dark-muted text-sm py-4 text-center">
+            无可用账户
+          </div>
+          <div v-else class="grid grid-cols-1 md:grid-cols-2 gap-3">
+            <div
+              v-for="acc in result.accounts"
+              :key="acc.id"
+              class="border border-dark-border rounded-md p-3 hover:border-dark-accent/50 transition-colors"
+            >
+              <div class="flex justify-between items-start">
+                <p class="font-medium">{{ acc.account_name }}</p>
+                <span class="text-xs px-2 py-0.5 rounded bg-dark-hover text-dark-muted">
+                  {{ acc.force_direction || result.allow_direction }}
+                </span>
+              </div>
+              <div class="mt-2 grid grid-cols-3 gap-2 text-xs text-dark-muted">
+                <div>
+                  <span class="block text-dark-text font-medium">{{ acc.total_capital }}U</span>
+                  本金
+                </div>
+                <div>
+                  <span class="block text-dark-text font-medium">{{ acc.trade_cycle }}</span>
+                  周期
+                </div>
+                <div>
+                  <span class="block text-dark-text font-medium">{{ acc.risk_ratio }}</span>
+                  风险
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <!-- 可用策略 -->
+        <div class="card">
+          <h3 class="text-sm font-semibold mb-3 flex items-center gap-2">
+            <span class="w-2 h-2 rounded-full bg-dark-accent"></span>
+            可用策略
+            <span class="text-dark-muted font-normal">({{ result.strategies?.length || 0 }})</span>
+          </h3>
+          <div v-if="!result.strategies?.length" class="text-dark-muted text-sm py-4 text-center">
+            无可用策略
+          </div>
+          <div v-else class="flex flex-col gap-3">
+            <div
+              v-for="strat in result.strategies"
+              :key="strat.id"
+              class="border border-dark-border rounded-md p-4 hover:border-dark-accent/50 transition-colors"
+            >
+              <div class="flex justify-between items-start mb-2">
+                <p class="font-medium text-base">{{ strat.strategy_name }}</p>
+                <span class="text-xs px-2 py-0.5 rounded bg-dark-hover text-dark-muted">
+                  {{ strat.fit_cycle }}
+                </span>
+              </div>
+              <pre class="text-xs text-dark-muted whitespace-pre-wrap leading-relaxed bg-dark-bg rounded p-3">{{ strat.strategy_rule }}</pre>
+              <p class="text-xs text-dark-warning mt-2">
+                ⚠ 策略规则仅作参考展示，箱体/点位/突破条件需人工手动确认
+              </p>
+            </div>
+          </div>
+        </div>
+      </template>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed, onMounted } from 'vue'
+import { getRegimes, doMatch } from '../api'
+
+const cycles = ['日线', '4H', '1H']
+const strengths = [
+  { value: '强', label: '强趋势' },
+  { value: '弱', label: '弱趋势' },
+  { value: '震荡', label: '震荡' },
+]
+
+const regimes = ref([])
+const selected = ref({ cycle: '', regimeId: null, strength: '' })
+const result = ref(null)
+const loading = ref(false)
+
+const canMatch = computed(() =>
+  selected.value.cycle && selected.value.regimeId && selected.value.strength
+)
+
+const statusLabel = computed(() => {
+  if (!result.value) return ''
+  const map = { ok: '可交易', watch: '观望', disabled: '禁用' }
+  return map[result.value.status] || result.value.status
+})
+
+const statusIcon = computed(() => {
+  if (!result.value) return ''
+  const map = { ok: '✅', watch: '⏸️', disabled: '🚫' }
+  return map[result.value.status] || '❓'
+})
+
+const statusBorderClass = computed(() => {
+  if (!result.value) return ''
+  const map = {
+    ok: 'border-l-dark-success',
+    watch: 'border-l-dark-warning',
+    disabled: 'border-l-dark-danger',
+  }
+  return map[result.value.status] || ''
+})
+
+const statusTextColor = computed(() => {
+  if (!result.value) return ''
+  const map = {
+    ok: 'text-dark-success',
+    watch: 'text-dark-warning',
+    disabled: 'text-dark-danger',
+  }
+  return map[result.value.status] || ''
+})
+
+const tradeTypeColor = computed(() => {
+  if (!result.value) return ''
+  const map = { '顺势': 'text-dark-success', '反转': 'text-dark-warning', '观望': 'text-dark-muted' }
+  return map[result.value.trade_type] || ''
+})
+
+const directionColor = computed(() => {
+  if (!result.value) return ''
+  if (result.value.allow_direction === '禁止') return 'text-dark-danger'
+  if (result.value.allow_direction === '做多') return 'text-dark-success'
+  if (result.value.allow_direction === '做空') return 'text-dark-danger'
+  return 'text-dark-accent'
+})
+
+function strengthActiveClass(val) {
+  const map = {
+    '强': 'border-dark-success bg-dark-success/10 text-dark-success',
+    '弱': 'border-dark-accent bg-dark-accent/10 text-dark-accent',
+    '震荡': 'border-dark-warning bg-dark-warning/10 text-dark-warning',
+  }
+  return map[val] || ''
+}
+
+async function loadRegimes() {
+  const { data } = await getRegimes()
+  regimes.value = data
+}
+
+async function runMatchQuery() {
+  if (!canMatch.value) return
+  loading.value = true
+  try {
+    const { data } = await doMatch({
+      market_cycle: selected.value.cycle,
+      market_regime_id: selected.value.regimeId,
+      trend_strength: selected.value.strength,
+    })
+    result.value = data
+  } catch (e) {
+    result.value = {
+      status: 'disabled',
+      message: '匹配请求失败：' + (e.response?.data?.detail || e.message),
+    }
+  } finally {
+    loading.value = false
+  }
+}
+
+onMounted(loadRegimes)
+</script>

frontend/tailwind.config.js

@@ -0,0 +1,23 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./index.html', './src/**/*.{vue,js}'],
+  theme: {
+    extend: {
+      colors: {
+        dark: {
+          bg: '#0a0a0a',
+          card: '#141414',
+          border: '#262626',
+          hover: '#1f1f1f',
+          text: '#e5e5e5',
+          muted: '#737373',
+          accent: '#3b82f6',
+          success: '#22c55e',
+          warning: '#eab308',
+          danger: '#ef4444',
+        },
+      },
+    },
+  },
+  plugins: [],
+}

frontend/vite.config.js

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+
+export default defineConfig({
+  plugins: [vue()],
+  server: {
+    port: 1125,
+    proxy: {
+      '/api': {
+        target: 'http://127.0.0.1:8000',
+        changeOrigin: true,
+      },
+    },
+  },
+})