deploy: auto-inject hf config & sync

.env.example

@@ -0,0 +1,93 @@
+# ======================================
+# GitHub Agent Demo - 环境变量配置
+# ======================================
+
+# --- LLM 供应商选择 ---
+# 支持: openai, deepseek, anthropic, gemini
+# 默认: deepseek
+LLM_PROVIDER=deepseek
+
+# --- API Keys (根据选择的供应商配置对应的 Key) ---
+
+# OpenAI (如果 LLM_PROVIDER=openai)
+OPENAI_API_KEY=
+# OPENAI_BASE_URL=  # 可选: 自定义端点 (如 Azure OpenAI)
+
+# DeepSeek (如果 LLM_PROVIDER=deepseek)
+DEEPSEEK_API_KEY=
+# DEEPSEEK_BASE_URL=https://api.deepseek.com  # 可选: 默认值
+
+# Anthropic Claude (如果 LLM_PROVIDER=anthropic)
+ANTHROPIC_API_KEY=
+
+# Google Gemini (如果 LLM_PROVIDER=gemini)
+GEMINI_API_KEY=
+# GEMINI_BASE_URL=  # 可选: OpenAI 兼容端点
+
+# --- 模型配置 ---
+# 如果不指定，将使用各供应商的默认模型:
+# - openai: gpt-4o-mini
+# - deepseek: deepseek-chat
+# - anthropic: claude-3-5-sonnet-20241022
+# - gemini: gemini-1.5-flash
+# MODEL_NAME=deepseek-chat
+
+# --- GitHub Token ---
+# 用于访问 GitHub API，提高请求限制
+GITHUB_TOKEN=
+
+# --- Embedding 服务 ---
+# SiliconFlow API Key (用于 BGE-M3 Embedding)
+SILICON_API_KEY=
+
+# --- Langfuse 追踪配置 (可选) ---
+# LANGFUSE_ENABLED=true
+# LANGFUSE_HOST=http://localhost:3000
+# LANGFUSE_PUBLIC_KEY=
+# LANGFUSE_SECRET_KEY=
+
+# --- Qdrant 向量数据库配置 ---
+# 模式选择: "local" | "server" | "cloud"
+# - local: 本地嵌入式存储 (开发环境, 单 Worker)
+# - server: Qdrant Server Docker (生产环境, 多 Worker)
+# - cloud: Qdrant Cloud 托管服务
+QDRANT_MODE=local
+QDRANT_LOCAL_PATH=data/qdrant_db
+
+# Server 模式: 连接 Qdrant Server (Docker)
+# QDRANT_MODE=server
+# QDRANT_URL=http://localhost:6333
+# 或分开配置:
+# QDRANT_HOST=localhost
+# QDRANT_PORT=6333
+
+# Cloud 模式: 连接 Qdrant Cloud
+# QDRANT_MODE=cloud
+# QDRANT_URL=https://xxx.qdrant.tech
+# QDRANT_API_KEY=your-api-key
+
+# 向量维度 (BGE-M3 = 1024)
+# QDRANT_VECTOR_SIZE=1024
+
+# --- Gunicorn Worker 配置 ---
+# 2核2G服务器建议设为 2
+# 4核8G服务器可设为 4
+GUNICORN_WORKERS=2
+
+# --- 分布式锁配置 ---
+# 锁后端: "memory" | "file" | "redis"
+# - memory: 内存锁 (单进程)
+# - file: 文件锁 (多 Worker 单节点)
+# - redis: Redis 分布式锁 (多节点)
+LOCK_BACKEND=file
+LOCK_DIR=data/locks
+# REDIS_URL=redis://localhost:6379/0
+
+# --- 服务配置 ---
+HOST=0.0.0.0
+PORT=8000
+
+# --- LLM 参数 (可选) ---
+# LLM_TEMPERATURE=0.1
+# LLM_MAX_TOKENS=4096
+# LLM_TIMEOUT=600

.github/workflows/sync_to_hub.yml

@@ -0,0 +1,58 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: realdexter   
+          SPACE_NAME: RepoReaper  
+        run: |
+          echo "🚀 Starting deployment to Hugging Face..."
+          
+          # 1. 配置 Git
+          git config --global user.email "bot@github.com"
+          git config --global user.name "GitHub Actions Bot"
+          
+          # 2. 【核心魔法】动态生成 Hugging Face 专用的 README
+          # 这一步会在发送给 HF 之前，强行在 README.md 顶部插入配置头
+          # GitHub 本地的文件不会受影响，依然保持干净漂亮
+          echo "---" > hf_header.yml
+          echo "title: RepoReaper" >> hf_header.yml
+          echo "emoji: 💀" >> hf_header.yml
+          echo "colorFrom: blue" >> hf_header.yml
+          echo "colorTo: indigo" >> hf_header.yml
+          echo "sdk: docker" >> hf_header.yml
+          echo "pinned: false" >> hf_header.yml
+          echo "app_port: 8000" >> hf_header.yml # 👈 关键：这里指定端口，你就不用改代码了
+          echo "---" >> hf_header.yml
+          echo "" >> hf_header.yml
+          
+          # 将配置头和原 README 内容拼接
+          cat hf_header.yml README.md > README_temp.md
+          mv README_temp.md README.md
+          
+          # 3. 清理不需要的文件
+          rm -rf docs/
+          rm -f *.jpg *.png *.gif hf_header.yml
+          rm -rf .git
+          
+          # 4. 初始化新仓库并推送
+          git init -b main
+          git add .
+          git commit -m "deploy: auto-inject hf config & sync"
+          
+          git remote add space https://$HF_USERNAME:$HF_TOKEN@huggingface.co/spaces/$HF_USERNAME/$SPACE_NAME
+          git push --force space main
+          
+          echo "✅ Deployment successful! Config header injected on-the-fly."

.gitignore

@@ -0,0 +1,43 @@
+# .gitignore
+__pycache__/
+*.py[cod]
+.env
+.venv/
+venv/
+.DS_Store
+data/
+# Vue 构建输出
+#frontend-dist/
+frontend-vue/node_modules/
+frontend-vue/dist/
+
+# 锁文件目录
+data/locks/
+
+# 日志
+logs/
+*.log
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# 临时文件
+*.tmp
+*.bak
+QUICKSTART.md
+docs/INTERVIEW_QA.md
+docs/ROADMAP.md
+docs/TECHNICAL_REPORT.md
+evaluation/000_START_HERE.md
+evaluation/golden_dataset.json
+evaluation/HIGH_QUALITY_QUESTIONS.md
+
+evaluation/README_EVALUATION_SYSTEM.md
+evaluation/ragas_eval_dataset.json
+evaluation/sft_data/eval_results.jsonl
+evaluation/sft_data/negative_samples.jsonl
+evaluation/sft_data/positive_samples.jsonl
+evaluation/sft_data/skipped_samples.jsonl
+evaluation/sft_data/cleaned/rejected_20260128_010745.jsonl

Dockerfile

@@ -0,0 +1,45 @@
+# 1. 基础镜像：选择 Python 3.10 的轻量版 (Slim)
+FROM python:3.10-slim
+
+# 2. 设置环境变量
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    # 默认 LLM 供应商 (可通过 docker run -e 覆盖)
+    LLM_PROVIDER=deepseek
+
+# 3. 设置工作目录
+WORKDIR /app
+
+# 4. 安装系统级依赖
+# build-essential: ChromaDB 编译需要
+# curl: 健康检查
+# git: 某些 pip 包可能需要
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# 5. 复制依赖文件并安装 (利用 Docker 层缓存)
+COPY requirements.txt .
+
+# 6. 安装 Python 依赖
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# 7. 复制项目代码
+COPY . .
+
+# 8. 创建数据目录 (Qdrant 本地存储 + 上下文缓存)
+RUN mkdir -p /app/data/qdrant_db /app/data/contexts
+
+# 9. 暴露端口
+EXPOSE 8000
+
+# 10. 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# 11. 启动命令
+CMD ["gunicorn", "-c", "gunicorn_conf.py", "app.main:app"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tzzp1224
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,224 @@
+---
+title: RepoReaper
+emoji: 💀
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+app_port: 8000
+---
+
+<div align="center">
+
+  <img src="./docs/logo.jpg" width="800" style="max-width: 100%;" height="auto" alt="RepoReaper Logo">
+
+  <h1>RepoReaper</h1>
+
+  <h3>💀 Harvest Logic. Dissect Architecture. Chat with Code.</h3>
+
+  <p>
+    <a href="./README.md">English</a> • 
+    <a href="./README_zh.md">简体中文</a>
+  </p>
+
+  <a href="./LICENSE">
+    <img src="https://img.shields.io/github/license/tzzp1224/RepoReaper?style=flat-square&color=blue" alt="License">
+  </a>
+  <img src="https://img.shields.io/badge/Python-3.10+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python Version">
+  <img src="https://img.shields.io/badge/Model-DeepSeek_V3-673AB7?style=flat-square&logo=openai&logoColor=white" alt="DeepSeek Powered">
+  <img src="https://img.shields.io/badge/Agent-ReAct-orange?style=flat-square" alt="Agent Architecture">
+
+  <br>
+
+  <img src="https://img.shields.io/badge/RAG-Hybrid_Search-009688?style=flat-square" alt="RAG">
+  <img src="https://img.shields.io/badge/VectorDB-Qdrant-important?style=flat-square" alt="Qdrant">
+  <img src="https://img.shields.io/badge/Framework-FastAPI-005571?style=flat-square&logo=fastapi&logoColor=white" alt="FastAPI">
+  <img src="https://img.shields.io/badge/Frontend-Vue_3-4FC08D?style=flat-square&logo=vue.js&logoColor=white" alt="Vue 3">
+  <img src="https://img.shields.io/badge/Docker-Ready-2496ED?style=flat-square&logo=docker&logoColor=white" alt="Docker">
+
+  <br>
+  <br>
+
+  <p>
+    <b>👇 Live Demo / 在线体验 👇</b>
+  </p>
+  <p align="center">
+    <a href="https://realdexter-reporeaper.hf.space" target="_blank" rel="noopener noreferrer">
+      <img src="https://img.shields.io/badge/🤗%20Hugging%20Face-Global%20Demo-ffd21e?style=for-the-badge&logo=huggingface&logoColor=black" alt="Global Demo" height="45">
+    </a>
+    &nbsp;&nbsp;&nbsp;
+    <a href="https://repo.realdexter.com/" target="_blank" rel="noopener noreferrer">
+      <img src="https://img.shields.io/badge/🚀%20Seoul%20Server-CN%20Optimized-red?style=for-the-badge&logo=rocket&logoColor=white" alt="China Demo" height="45">
+    </a>
+  </p>
+
+  <p align="center">
+    <small>
+      ⚠️ Public demos use shared API quotas. Deploy locally for the best experience.
+    </small>
+  </p>
+
+  <br>
+
+  <img src="./docs/demo_preview.gif" width="800" style="max-width: 100%; box-shadow: 0 4px 8px rgba(0,0,0,0.1); border-radius: 8px;" alt="RepoReaper Demo">
+
+  <br>
+</div>
+
+---
+
+An autonomous Agent that dissects any GitHub repository. It maps code architecture, warms up semantic cache, and answers questions with Just-In-Time context retrieval.
+
+---
+
+## ✨ Key Features
+
+| Feature | Description |
+|:--------|:------------|
+| **Multi-Language AST Parsing** | Python AST + Regex patterns for Java, TypeScript, Go, Rust, etc. |
+| **Hybrid Search** | Qdrant vectors + BM25 with RRF fusion |
+| **JIT Context Loading** | Auto-fetches missing files during Q&A |
+| **Query Rewrite** | Translates natural language to code keywords |
+| **End-to-End Tracing** | Langfuse integration for observability |
+| **Auto Evaluation** | LLM-as-Judge scoring pipeline |
+
+---
+
+## 🏗 Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Vue 3 Frontend (SSE Streaming + Mermaid Diagrams)          │
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────────┐
+│  FastAPI Backend                                            │
+│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐   │
+│  │ Agent       │ │ Chat        │ │ Evaluation          │   │
+│  │ Service     │ │ Service     │ │ Framework           │   │
+│  └──────┬──────┘ └──────┬──────┘ └─────────────────────┘   │
+│         │               │                                   │
+│  ┌──────▼───────────────▼──────┐  ┌─────────────────────┐  │
+│  │ Vector Service (Qdrant+BM25)│  │ Tracing (Langfuse)  │  │
+│  └─────────────────────────────┘  └─────────────────────┘  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🛠 Tech Stack
+
+**Backend:** Python 3.10+ · FastAPI · AsyncIO · Qdrant · BM25  
+**Frontend:** Vue 3 · Pinia · Mermaid.js · SSE  
+**LLM:** DeepSeek V3 · SiliconFlow BGE-M3  
+**Ops:** Docker · Gunicorn · Langfuse
+
+---
+
+## 🏁 Quick Start
+
+**Prerequisites:** Python 3.10+ · (Optional) Node 18+ for rebuilding frontend · GitHub Token (recommended) · LLM API Key (required)
+
+```bash
+# Clone & Setup
+git clone https://github.com/tzzp1224/RepoReaper.git && cd RepoReaper
+python -m venv venv && source venv/bin/activate
+pip install -r requirements.txt
+
+# Configure .env (copy from example and fill in your keys)
+cp .env.example .env
+# Required: set LLM_PROVIDER and the matching *_API_KEY
+# Recommended: GITHUB_TOKEN and SILICON_API_KEY (embeddings)
+
+# (Optional) Build frontend (repo already contains frontend-dist)
+cd frontend-vue
+npm install
+npm run build
+cd ..
+
+# Run
+python -m app.main
+```
+
+Open `http://localhost:8000` and paste any GitHub repo URL.
+
+**Docker (single container, local Qdrant):**
+```bash
+cp .env.example .env
+docker build -t reporeaper .
+docker run -d -p 8000:8000 --env-file .env reporeaper
+```
+
+**Docker Compose (recommended, with Qdrant Server):**
+```bash
+cp .env.example .env
+# Set QDRANT_MODE=server and QDRANT_URL=http://qdrant:6333 in .env
+docker compose up -d --build
+```
+
+
+
+
+
+## 📊 Evaluation & Tracing Status
+
+| Component | Status | Notes |
+|:----------|:------:|:------|
+| **Self-built Eval Engine** | ✅ Working | 4-layer metrics (QueryRewrite / Retrieval / Generation / Agentic), LLM-as-Judge |
+| **Auto Evaluation** | ✅ Working | Triggers after every `/chat`, async, writes to `evaluation/sft_data/` |
+| **Data Routing (SFT)** | ✅ Working | Auto-grades Gold/Silver/Bronze/Rejected → JSONL files |
+| **Eval API Endpoints** | ✅ Working | `/evaluate`, `/evaluation/stats`, `/dashboard/*`, `/auto-eval/*` (7 endpoints) |
+| **Offline Retrieval Eval** | ✅ Working | `test_retrieval.py` — Hit Rate, Recall@K, Precision@K, MRR |
+| **Langfuse Tracing** | ⚠️ Partial | Framework + 14 call sites wired in agent/chat services; falls back to local JSON logs (`logs/traces/`) when Langfuse unavailable |
+| **Ragas Integration** | ❌ Placeholder | `use_ragas=False` by default; `_ragas_eval()` API call doesn't match latest Ragas SDK |
+| **Langfuse ↔ Eval** | ❌ Not connected | Eval results only write JSONL, not reported to Langfuse Scores API |
+
+> **Overall completion: ~65%** — the self-built eval loop is production-ready; Ragas and Langfuse integrations are scaffolded but not functional.
+
+---
+
+## ⚠️ Known Issues
+
+1. **Python 3.14 + Langfuse import error**  
+   `pydantic.V1.errors.ConfigError: unable to infer type for attribute "description"` — Langfuse 3.x internally uses `pydantic.v1` compat layer which breaks on Python 3.14.  
+   **Workaround:** set `LANGFUSE_ENABLED=false` in `.env`, or use Python 3.10–3.12.
+
+2. **Langfuse Server not included in `docker-compose.yml`**  
+   Even if the import works, you need a running Langfuse instance. Add it yourself or use [app.langfuse.com](https://app.langfuse.com).
+
+3. **Trace spans are not linked**  
+   `tracing_service` records spans/events but doesn't pass `trace_id` to Langfuse API calls — the Langfuse UI will show isolated events instead of a connected trace tree.
+
+4. **Ragas `_ragas_eval()` uses outdated API**  
+   Passes a plain dict to `ragas.evaluate()`, but latest Ragas requires a `Dataset` object. The `ragas_eval_dataset.json` export exists but no script consumes it.
+
+5. **Golden dataset has no reference answers**  
+   All 26 test cases have `expected_answer: ""` — generation quality cannot be compared against ground truth.
+
+6. **Heuristic fallback is coarse**  
+   When no LLM client is available, `faithfulness` uses keyword overlap + 0.2 baseline; `completeness` is purely length-based.
+
+---
+
+## 🗺 Roadmap
+
+- [ ] **Fix Langfuse compat** — pin `langfuse`/`pydantic` versions or gate import behind Python version check
+- [ ] **Add Langfuse to `docker-compose.yml`** — one-command local observability
+- [ ] **Wire trace_id through spans** — enable full trace tree in Langfuse UI
+- [ ] **Integrate Ragas properly** — update `_ragas_eval()` to use `ragas.evaluate(Dataset(...))`, add a standalone eval script
+- [ ] **Enrich golden dataset** — add `expected_answer` for generation benchmarking, expand to 50+ cases
+- [ ] **Eval dashboard frontend** — Vue component to visualize quality distribution and bad cases
+- [ ] **CI regression baseline** — run `test_retrieval.py` in GitHub Actions, fail on metric regression
+- [ ] **Export to Langfuse Datasets** — push eval results to Langfuse Scores/Datasets API for unified observability
+
+---
+
+## 📈 Star History
+
+<a href="https://star-history.com/#tzzp1224/RepoReaper&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=tzzp1224/RepoReaper&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=tzzp1224/RepoReaper&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=tzzp1224/RepoReaper&type=Date" />
+ </picture>
+</a>

README_zh.md

@@ -0,0 +1,212 @@
+<div align="center">
+
+  <img src="./docs/logo.jpg" width="800" style="max-width: 100%;" height="auto" alt="RepoReaper Logo">
+
+  <h1>RepoReaper</h1>
+
+  <h3>💀 Harvest Logic. Dissect Architecture. Chat with Code.</h3>
+
+  <p>
+    <a href="./README.md">English</a> • 
+    <strong>简体中文</strong>
+  </p>
+
+  <a href="./LICENSE">
+    <img src="https://img.shields.io/github/license/tzzp1224/RepoReaper?style=flat-square&color=blue" alt="License">
+  </a>
+  <img src="https://img.shields.io/badge/Python-3.10+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python Version">
+  <img src="https://img.shields.io/badge/Model-DeepSeek_V3-673AB7?style=flat-square&logo=openai&logoColor=white" alt="DeepSeek Powered">
+  <img src="https://img.shields.io/badge/Agent-ReAct-orange?style=flat-square" alt="Agent Architecture">
+
+  <br>
+
+  <img src="https://img.shields.io/badge/RAG-Hybrid_Search-009688?style=flat-square" alt="RAG">
+  <img src="https://img.shields.io/badge/VectorDB-Qdrant-important?style=flat-square" alt="Qdrant">
+  <img src="https://img.shields.io/badge/Framework-FastAPI-005571?style=flat-square&logo=fastapi&logoColor=white" alt="FastAPI">
+  <img src="https://img.shields.io/badge/Frontend-Vue_3-4FC08D?style=flat-square&logo=vue.js&logoColor=white" alt="Vue 3">
+  <img src="https://img.shields.io/badge/Docker-Ready-2496ED?style=flat-square&logo=docker&logoColor=white" alt="Docker">
+
+  <br>
+  <br>
+
+  <p>
+    <b>👇 在线体验 👇</b>
+  </p>
+  <p align="center">
+    <a href="https://realdexter-reporeaper.hf.space" target="_blank" rel="noopener noreferrer">
+      <img src="https://img.shields.io/badge/🤗%20Hugging%20Face-Global%20Demo-ffd21e?style=for-the-badge&logo=huggingface&logoColor=black" alt="Global Demo" height="45">
+    </a>
+    &nbsp;&nbsp;&nbsp;
+    <a href="https://repo.realdexter.com/" target="_blank" rel="noopener noreferrer">
+      <img src="https://img.shields.io/badge/🚀%20Seoul%20Server-国内优化-red?style=for-the-badge&logo=rocket&logoColor=white" alt="China Demo" height="45">
+    </a>
+  </p>
+
+  <p align="center">
+    <small>
+      ⚠️ 中国用户请使用 Seoul Server。如遇限流，建议本地部署。
+    </small>
+  </p>
+
+  <br>
+
+  <img src="./docs/demo_preview.gif" width="800" style="max-width: 100%; box-shadow: 0 4px 8px rgba(0,0,0,0.1); border-radius: 8px;" alt="RepoReaper Demo">
+
+  <br>
+</div>
+
+---
+
+自治型代码审计 Agent：解析任意 GitHub 仓库架构，构建语义缓存，支持即时上下文检索问答。
+
+---
+
+## ✨ 核心特性
+
+| 特性 | 说明 |
+|:----|:----|
+| **多语言 AST 解析** | Python AST + 正则适配 Java / TS / Go / Rust 等 |
+| **混合检索** | Qdrant 向量 + BM25 关键词，RRF 融合排序 |
+| **JIT 动态加载** | 问答时自动拉取缺失文件 |
+| **查询重写** | 自然语言 → 代码检索关键词 |
+| **端到端追踪** | Langfuse 集成，全链路可观测 |
+| **自动评估** | LLM-as-Judge 质量评分 |
+
+---
+
+## 🏗 系统架构
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Vue 3 前端 (SSE 流式 + Mermaid 架构图)                       │
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────────┐
+│  FastAPI 后端                                               │
+│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐   │
+│  │ Agent       │ │ Chat        │ │ Evaluation          │   │
+│  │ Service     │ │ Service     │ │ Framework           │   │
+│  └──────┬──────┘ └──────┬──────┘ └─────────────────────┘   │
+│         │               │                                   │
+│  ┌──────▼───────────────▼──────┐  ┌─────────────────────┐  │
+│  │ Vector Service (Qdrant+BM25)│  │ Tracing (Langfuse)  │  │
+│  └─────────────────────────────┘  └─────────────────────┘  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🛠 技术栈
+
+**后端:** Python 3.10+ · FastAPI · AsyncIO · Qdrant · BM25  
+**前端:** Vue 3 · Pinia · Mermaid.js · SSE  
+**模型:** DeepSeek V3 · SiliconFlow BGE-M3  
+**运维:** Docker · Gunicorn · Langfuse
+
+---
+
+## 🏁 快速开始
+
+**前置要求:** Python 3.10+ ·（可选）Node 18+ 用于重新构建前端 · GitHub Token（推荐）· LLM API Key（必需）
+
+```bash
+# 克隆 & 安装
+git clone https://github.com/tzzp1224/RepoReaper.git && cd RepoReaper
+python -m venv venv && source venv/bin/activate
+pip install -r requirements.txt
+
+# 配置 .env（建议从示例复制）
+cp .env.example .env
+# 必需：设置 LLM_PROVIDER 以及对应的 *_API_KEY
+# 推荐：GITHUB_TOKEN 和 SILICON_API_KEY（Embedding）
+
+# （可选）构建前端（仓库已包含 frontend-dist）
+cd frontend-vue
+npm install
+npm run build
+cd ..
+
+# 启动
+python -m app.main
+```
+
+访问 `http://localhost:8000`，输入任意 GitHub 仓库地址开始审计。
+
+**Docker（单容器，本地 Qdrant）：**
+```bash
+cp .env.example .env
+docker build -t reporeaper .
+docker run -d -p 8000:8000 --env-file .env reporeaper
+```
+
+**Docker Compose（推荐，包含 Qdrant Server）：**
+```bash
+cp .env.example .env
+# 在 .env 中设置 QDRANT_MODE=server 与 QDRANT_URL=http://qdrant:6333
+docker compose up -d --build
+```
+
+---
+
+## 📊 评估与追踪现状
+
+| 组件 | 状态 | 说明 |
+|:----|:----:|:----|
+| **自研评估引擎** | ✅ 可用 | 四层指标（QueryRewrite / Retrieval / Generation / Agentic），LLM-as-Judge 判分 |
+| **在线自动评估** | ✅ 可用 | 每次 `/chat` 结束后异步触发，结果写入 `evaluation/sft_data/` |
+| **数据路由 (SFT)** | ✅ 可用 | 按评分自动分流 Gold/Silver/Bronze/Rejected → JSONL 文件 |
+| **评估 API** | ✅ 可用 | `/evaluate`、`/evaluation/stats`、`/dashboard/*`、`/auto-eval/*` 共 7 个端点 |
+| **离线检索评估** | ✅ 可用 | `test_retrieval.py` — Hit Rate、Recall@K、Precision@K、MRR |
+| **Langfuse 追踪** | ⚠️ 部分完成 | 框架 + 14 处埋点已就位（agent/chat service）；不可用时自动降级为本地日志 `logs/traces/` |
+| **Ragas 集成** | ❌ 占位 | 默认 `use_ragas=False`；`_ragas_eval()` 调用方式与最新 Ragas SDK 不兼容 |
+| **Langfuse ↔ 评估** | ❌ 未打通 | 评估结果仅写 JSONL，未上报 Langfuse Scores API |
+
+> **综合完成度约 65%**：自研评估链路已闭环可用；Ragas 与 Langfuse 集成均为半成品。
+
+---
+
+## ⚠️ 已知问题
+
+1. **Python 3.14 + Langfuse 导入报错**  
+   `pydantic.V1.errors.ConfigError: unable to infer type for attribute "description"` — Langfuse 3.x 内部依赖 `pydantic.v1` 兼容层，在 Python 3.14 下不兼容。  
+   **临时方案：** 在 `.env` 中设置 `LANGFUSE_ENABLED=false`，或使用 Python 3.10–3.12。
+
+2. **`docker-compose.yml` 未包含 Langfuse 服务**  
+   即使导入成功，仍需运行中的 Langfuse 实例。请自行添加或使用 [app.langfuse.com](https://app.langfuse.com)。
+
+3. **Trace 链路未关联**  
+   `tracing_service` 记录了 span/event，但调用 Langfuse API 时未传 `trace_id`，Langfuse UI 中只能看到孤立事件而非完整链路树。
+
+4. **Ragas `_ragas_eval()` API 过时**  
+   当前向 `ragas.evaluate()` 传递 dict，最新 Ragas 要求 `Dataset` 对象。已导出 `ragas_eval_dataset.json` 但无脚本消费它。
+
+5. **黄金数据集缺少标准答案**  
+   26 条测试用例的 `expected_answer` 均为空，无法做生成质量的 ground truth 对比。
+
+6. **启发式降级较粗糙**  
+   无 LLM client 时，`faithfulness` 用关键词重叠 + 0.2 基础分；`completeness` 纯粹按字数判断。
+
+---
+
+## 🗺 路线图
+
+- [ ] **修复 Langfuse 兼容性** — 固定 `langfuse`/`pydantic` 版本或按 Python 版本门控导入
+- [ ] **`docker-compose.yml` 加入 Langfuse** — 一键启动本地可观测平台
+- [ ] **串联 trace_id** — 让 Langfuse UI 展示完整链路树
+- [ ] **正式接入 Ragas** — 更新 `_ragas_eval()` 使用 `ragas.evaluate(Dataset(...))`，新增独立评估脚本
+- [ ] **丰富黄金数据集** — 补充 `expected_answer`，扩展至 50+ 条用例
+- [ ] **评估仪表盘前端** — Vue 组件可视化质量分布与 Bad Case
+- [ ] **CI 回归基线** — 在 GitHub Actions 中运行 `test_retrieval.py`，指标回退时失败
+- [ ] **对接 Langfuse Datasets** — 将评估结果推送到 Langfuse Scores/Datasets API，统一可观测
+
+---
+
+## 📈 Star History
+
+<a href="https://star-history.com/#tzzp1224/RepoReaper&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=tzzp1224/RepoReaper&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=tzzp1224/RepoReaper&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=tzzp1224/RepoReaper&type=Date" />
+ </picture>
+</a>

app/core/config.py

@@ -0,0 +1,246 @@
+# 文件路径: app/core/config.py
+"""
+应用配置模块 - 统一配置中心
+
+支持多 LLM 供应商配置:
+- OpenAI (GPT-4, GPT-4o 等)
+- DeepSeek (deepseek-chat 等)
+- Anthropic (Claude 系列)
+- Google Gemini (gemini-3-flash-preview 等)
+"""
+import os
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+from dotenv import load_dotenv
+
+# 加载 .env 文件
+load_dotenv()
+
+
+# ============================================================
+# Agent 分析配置
+# ============================================================
+
+@dataclass
+class AgentAnalysisConfig:
+    """Agent 分析引擎配置"""
+    # Repo Map 配置
+    initial_map_limit: int = 25           # 初始 Repo Map 文件数量 (提高精度)
+    max_symbols_per_file: int = 40        # 每文件最大符号数 (提高精度)
+    
+    # 分析轮次配置
+    max_rounds: int = 4                   # 最大分析轮数 (提高精度，因为报告可复用)
+    files_per_round: int = 5              # 每轮选择文件数 (提高精度)
+    max_context_length: int = 20000       # 上下文最大长度 (提高精度)
+    
+    # 优先级配置
+    priority_exts: Tuple[str, ...] = (
+        '.py', '.java', '.go', '.js', '.ts', '.tsx', '.cpp', '.cs', '.rs'
+    )
+    priority_keywords: Tuple[str, ...] = (
+        'main', 'app', 'core', 'api', 'service', 'utils', 'controller', 'model', 'config'
+    )
+
+
+# ============================================================
+# 向量服务配置
+# ============================================================
+
+@dataclass
+class VectorServiceConfig:
+    """向量服务配置"""
+    # 数据目录
+    data_dir: str = "data"
+    context_dir: str = "data/contexts"
+    cache_version: str = "2.0"
+    
+    # Embedding 配置
+    embedding_api_url: str = "https://api.siliconflow.cn/v1"
+    embedding_model: str = "BAAI/bge-m3"
+    embedding_batch_size: int = 50
+    embedding_max_length: int = 8000
+    embedding_concurrency: int = 5
+    embedding_dimensions: int = 1024
+    
+    # BM25 配置
+    tokenize_regex: str = r'[^a-zA-Z0-9_\.@\u4e00-\u9fa5]+'
+    
+    # 混合搜索 RRF 参数
+    rrf_k: int = 60
+    rrf_weight_vector: float = 1.0
+    rrf_weight_bm25: float = 0.3
+    search_oversample: int = 2
+    default_top_k: int = 3
+    
+    # Session LRU 缓存配置
+    session_max_count: int = 100          # 内存中最大 session 数
+
+
+# ============================================================
+# 对话记忆配置
+# ============================================================
+
+@dataclass
+class ConversationConfig:
+    """对话记忆配置"""
+    # 滑动窗口
+    max_recent_turns: int = 10             # 保留最近 N 轮对话
+    max_context_tokens: int = 8000        # 最大上下文 token 数
+    summary_threshold: int = 15           # 超过 N 轮开始压缩
+    # 对话记忆是纯内存存储，服务重启自动清空，无需定时清理
+
+
+# ============================================================
+# Qdrant 配置
+# ============================================================
+
+@dataclass
+class QdrantServiceConfig:
+    """
+    Qdrant 向量数据库配置
+    
+    支持三种模式 (通过环境变量 QDRANT_MODE 切换):
+    - local: 本地嵌入式存储 (开发环境, 单 Worker)
+    - server: Qdrant Server Docker (生产环境, 多 Worker)
+    - cloud: Qdrant Cloud 托管服务
+    
+    环境变量:
+    - QDRANT_MODE: "local" | "server" | "cloud"
+    - QDRANT_URL: 服务器 URL (server/cloud 模式)
+    - QDRANT_API_KEY: API 密钥 (cloud 模式必需)
+    - QDRANT_LOCAL_PATH: 本地存储路径 (local 模式)
+    """
+    mode: str = os.getenv("QDRANT_MODE", "local")
+    url: str = os.getenv("QDRANT_URL", "")
+    host: str = os.getenv("QDRANT_HOST", "localhost")
+    port: int = int(os.getenv("QDRANT_PORT", "6333"))
+    grpc_port: int = int(os.getenv("QDRANT_GRPC_PORT", "6334"))
+    prefer_grpc: bool = True
+    api_key: str = os.getenv("QDRANT_API_KEY", "")
+    
+    local_path: str = os.getenv("QDRANT_LOCAL_PATH", "data/qdrant_db")
+    
+    vector_size: int = 1024               # BGE-M3 维度
+    hnsw_m: int = 16
+    hnsw_ef_construct: int = 100
+    batch_size: int = 100
+    timeout: float = 30.0
+
+
+# ============================================================
+# LLM 供应商配置
+# ============================================================
+
+
+class Settings:
+    """应用配置类"""
+    
+    # --- LLM 供应商选择 ---
+    # 支持: "openai", "deepseek", "anthropic", "gemini"
+    LLM_PROVIDER = os.getenv("LLM_PROVIDER", "deepseek")
+    
+    # --- API Keys (根据选择的供应商配置对应的 Key) ---
+    GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+    
+    # OpenAI
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL")  # 可选自定义端点
+    
+    # DeepSeek
+    DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+    DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com")
+    
+    # Anthropic (Claude)
+    ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+    
+    # Google Gemini
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+    GEMINI_BASE_URL = os.getenv("GEMINI_BASE_URL")  # 可选 OpenAI 兼容端点
+    
+    # SiliconFlow (Embedding)
+    SILICON_API_KEY = os.getenv("SILICON_API_KEY")
+    
+    # --- 模型配置 ---
+    # 如果不指定，将使用各供应商的默认模型
+    MODEL_NAME = os.getenv("MODEL_NAME")
+    
+    # --- 服务配置 ---
+    HOST = os.getenv("HOST", "127.0.0.1")
+    PORT = int(os.getenv("PORT", 8000))
+    
+    # --- LLM 默认参数 ---
+    LLM_TEMPERATURE = float(os.getenv("LLM_TEMPERATURE", "0.1"))
+    LLM_MAX_TOKENS = int(os.getenv("LLM_MAX_TOKENS", "4096"))
+    LLM_TIMEOUT = int(os.getenv("LLM_TIMEOUT", "600"))
+    
+    @property
+    def current_api_key(self) -> Optional[str]:
+        """获取当前选择的供应商的 API Key"""
+        key_mapping = {
+            "openai": self.OPENAI_API_KEY,
+            "deepseek": self.DEEPSEEK_API_KEY,
+            "anthropic": self.ANTHROPIC_API_KEY,
+            "gemini": self.GEMINI_API_KEY,
+        }
+        return key_mapping.get(self.LLM_PROVIDER.lower())
+    
+    @property
+    def current_base_url(self) -> Optional[str]:
+        """获取当前选择的供应商的 Base URL"""
+        url_mapping = {
+            "openai": self.OPENAI_BASE_URL,
+            "deepseek": self.DEEPSEEK_BASE_URL,
+            "anthropic": None,
+            "gemini": self.GEMINI_BASE_URL,
+        }
+        return url_mapping.get(self.LLM_PROVIDER.lower())
+    
+    @property
+    def default_model_name(self) -> str:
+        """获取当前供应商的默认模型名称"""
+        defaults = {
+            "openai": "gpt-4o-mini",
+            "deepseek": "deepseek-chat",
+            "anthropic": "claude-3-5-sonnet-20241022",
+            "gemini": "gemini-3-flash-preview",
+        }
+        return self.MODEL_NAME or defaults.get(self.LLM_PROVIDER.lower(), "default")
+
+    def validate(self):
+        """启动时检查必要的配置是否存在"""
+        provider = self.LLM_PROVIDER.lower()
+        print(f"🔧 LLM Provider: {provider.upper()}")
+        
+        # 1. 检查选择的供应商的 API Key
+        if not self.current_api_key:
+            key_name = f"{provider.upper()}_API_KEY"
+            raise ValueError(
+                f"❌ 错误: 缺少 {key_name}。\n"
+                f"   当前选择的 LLM 供应商是: {provider}\n"
+                f"   请在 .env 文件中设置 {key_name}，或更改 LLM_PROVIDER 为其他供应商。"
+            )
+        
+        # 2. 检查 SiliconCloud Key (Embedding 功能)
+        if not self.SILICON_API_KEY:
+            print("⚠️ 警告: 未找到 SILICON_API_KEY，向量检索功能可能无法工作。")
+            
+        # 3. 检查 GitHub Token (可选但建议)
+        if not self.GITHUB_TOKEN:
+            print("⚠️ 警告: 未找到 GITHUB_TOKEN，GitHub API 请求将受到每小时 60 次的严格限制。")
+        
+        print(f"✅ 配置验证通过 (Model: {self.default_model_name})")
+
+
+# ============================================================
+# 全局配置实例
+# ============================================================
+
+# LLM 设置
+settings = Settings()
+settings.validate()
+
+# 子系统配置
+agent_config = AgentAnalysisConfig()
+vector_config = VectorServiceConfig()
+conversation_config = ConversationConfig()
+qdrant_config = QdrantServiceConfig()

app/main.py

@@ -0,0 +1,560 @@
+# 文件路径: app/main.py
+import sys
+import io
+import os
+import asyncio
+from contextlib import asynccontextmanager
+
+# 强制 stdout 使用 utf-8，防止 Windows 控制台乱码
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from sse_starlette.sse import EventSourceResponse
+from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+
+from app.core.config import settings
+from app.services.agent_service import agent_stream
+from app.services.chat_service import process_chat_stream, get_eval_data, clear_eval_data
+from app.services.vector_service import store_manager
+from app.services.auto_evaluation_service import (
+    init_auto_evaluation_service,
+    get_auto_evaluation_service,
+    EvaluationConfig
+)
+from evaluation.evaluation_framework import EvaluationEngine, EvaluationResult, DataRoutingEngine
+from datetime import datetime
+import uuid
+
+settings.validate()
+
+# === 生命周期管理 ===
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """应用生命周期管理"""
+    from app.services.vector_service import store_manager
+    
+    # 启动时运行
+    print("🚀 Application starting...")
+    # 仓库数据永久存储，对话记忆纯内存存储（重启自动清空）
+    
+    yield
+    
+    # 关闭时运行
+    print("🛑 Application shutting down...")
+    
+    # 清理 GitHub 客户端连接
+    from app.utils.github_client import close_github_client
+    await close_github_client()
+    
+    # 清理向量存储连接
+    await store_manager.close_all()
+    
+    # 关闭共享的 Qdrant 客户端
+    from app.storage.qdrant_store import close_shared_client
+    await close_shared_client()
+    
+    print("✅ Cleanup complete")
+
+app = FastAPI(title="GitHub RAG Agent", lifespan=lifespan)
+
+# === 初始化评估引擎 ===
+from app.utils.llm_client import client
+eval_engine = EvaluationEngine(llm_client=client, model_name=settings.default_model_name)
+data_router = DataRoutingEngine()
+
+# === 初始化自动评估服务 (Phase 1) ===
+auto_eval_config = EvaluationConfig(
+    enabled=True,
+    use_ragas=False,              # Phase 1: 先不用 Ragas，避免额外依赖
+    async_evaluation=True,        # 异步模式，不阻塞响应
+    min_quality_score=0.4,        # 最低分数阈值（0.4 = 只拒绝最差的）
+    min_query_length=10,          # 最小 query 长度
+    min_answer_length=100,        # 最小 answer 长度
+    require_repo_url=True,        # 必须有仓库 URL
+    require_code_in_context=True  # 上下文必须包含代码
+)
+auto_eval_service = init_auto_evaluation_service(
+    eval_engine=eval_engine,
+    data_router=data_router,
+    config=auto_eval_config
+)
+print("✅ Auto Evaluation Service Initialized")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True, 
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# === 静态文件与前端 ===
+app.mount("/static", StaticFiles(directory="app"), name="static")
+
+# Vue 3 构建输出的静态资源 (JS/CSS/assets)
+import os
+FRONTEND_DIST = os.path.join(os.path.dirname(os.path.dirname(__file__)), "frontend-dist")
+if os.path.exists(FRONTEND_DIST):
+    app.mount("/assets", StaticFiles(directory=os.path.join(FRONTEND_DIST, "assets")), name="vue-assets")
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    # 优先使用 Vue 3 构建版本，否则回退到原版
+    vue_index = os.path.join(FRONTEND_DIST, "index.html")
+    if os.path.exists(vue_index):
+        with open(vue_index, "r", encoding="utf-8") as f:
+            return f.read()
+    # 回退到原版前端
+    with open("frontend/index.html", "r", encoding="utf-8") as f:
+        return f.read()
+
+@app.get("/health")
+def health_check():
+    return {"status": "ok"}
+
+@app.get("/api/sessions")
+async def get_sessions():
+    """获取 session 管理状态"""
+    return JSONResponse(store_manager.get_stats())
+
+@app.post("/api/sessions/cleanup")
+async def trigger_cleanup():
+    """手动触发过期文件清理"""
+    stats = await store_manager.cleanup_expired_files()
+    return JSONResponse({"message": "Cleanup completed", "stats": stats})
+
+@app.delete("/api/sessions/{session_id}")
+async def close_session(session_id: str):
+    """关闭指定 session"""
+    await store_manager.close_session(session_id)
+    return JSONResponse({"message": f"Session {session_id} closed"})
+
+
+# === 仓库级 Session API ===
+
+@app.post("/api/repo/check")
+async def check_repo_session(request: Request):
+    """
+    检查仓库是否已有指定语言的索引和报告
+    
+    请求: { "url": "https://github.com/owner/repo", "language": "zh" }
+    响应: { 
+        "exists": true/false, 
+        "session_id": "repo_xxx",
+        "report": "..." (如果存在对应语言的报告),
+        "has_index": true/false,
+        "available_languages": ["en", "zh"]
+    }
+    """
+    from app.utils.session import generate_repo_session_id
+    
+    data = await request.json()
+    repo_url = data.get("url", "").strip()
+    language = data.get("language", "en")
+    
+    if not repo_url:
+        return JSONResponse({"error": "Missing URL"}, status_code=400)
+    
+    # 生成基于仓库的 Session ID
+    session_id = generate_repo_session_id(repo_url)
+    
+    # 检查是否存在
+    store = store_manager.get_store(session_id)
+    
+    # 尝试加载上下文
+    context = store.load_context()
+    
+    if context and context.get("repo_url"):
+        # 存在已分析的仓库
+        # 获取指定语言的报告
+        report = store.get_report(language)
+        available_languages = store.get_available_languages()
+        global_context = context.get("global_context", {})
+        has_index = bool(global_context.get("file_tree"))
+        
+        return JSONResponse({
+            "exists": True,
+            "session_id": session_id,
+            "repo_url": context.get("repo_url"),
+            "report": report,  # 指定语言的报告，可能为 None
+            "has_index": has_index,
+            "available_languages": available_languages,
+            "requested_language": language,
+        })
+    else:
+        return JSONResponse({
+            "exists": False,
+            "session_id": session_id,
+            "has_index": False,
+            "available_languages": [],
+        })
+
+
+@app.get("/analyze")
+async def analyze(url: str, session_id: str, language: str = "en", regenerate_only: bool = False): 
+    """
+    仓库分析端点
+    
+    Args:
+        url: 仓库 URL
+        session_id: Session ID
+        language: 报告语言 ("en" 或 "zh")
+        regenerate_only: True 时跳过抓取/索引，直接使用已有索引生成新语言报告
+    """
+    if not session_id:
+        return {"error": "Missing session_id"}
+    return EventSourceResponse(agent_stream(url, session_id, language, regenerate_only))
+
+@app.post("/chat")
+async def chat(request: Request):
+    """
+    聊天端点 - 自动评估版本
+    
+    改进点:
+    1. 立即返回聊天结果（不阻塞）
+    2. 后台异步进行自动评估
+    3. 评估结果自动存储到 evaluation/sft_data/
+    """
+    data = await request.json()
+    user_query = data.get("query")
+    session_id = data.get("session_id")
+    repo_url = data.get("repo_url", "")
+    
+    if not user_query:
+        return {"answer": "Please enter your question"}
+    if not session_id:
+        return {"answer": "Session lost"}
+
+    # 标记流是否完成
+    stream_completed = False
+    
+    async def chat_stream_with_eval():
+        """包装 process_chat_stream，流结束后触发评估"""
+        nonlocal stream_completed
+        
+        # 清除旧的评估数据
+        clear_eval_data(session_id)
+        
+        # 执行聊天流
+        async for chunk in process_chat_stream(user_query, session_id):
+            yield chunk
+        
+        # 流完成后标记
+        stream_completed = True
+        
+        # 流结束后触发评估（此时数据已存储在 chat_service 中）
+        try:
+            auto_eval_service = get_auto_evaluation_service()
+            eval_data = get_eval_data(session_id)
+            
+            if auto_eval_service and eval_data and eval_data.answer:
+                print(f"\n📊 [Auto-Eval] Starting evaluation for session {session_id}")
+                print(f"   - Query: {user_query[:50]}...")
+                print(f"   - Context length: {len(eval_data.retrieved_context)} chars")
+                print(f"   - Answer length: {len(eval_data.answer)} chars")
+                
+                # 异步执行评估（不阻塞流结束）
+                asyncio.create_task(
+                    auto_eval_service.auto_evaluate_async(
+                        query=user_query,
+                        retrieved_context=eval_data.retrieved_context,
+                        generated_answer=eval_data.answer,
+                        session_id=session_id,
+                        repo_url=repo_url,
+                        language="zh" if any('\u4e00' <= c <= '\u9fff' for c in user_query) else "en"
+                    )
+                )
+            else:
+                if not auto_eval_service:
+                    print("⚠️ Auto evaluation service not initialized")
+                elif not eval_data:
+                    print(f"⚠️ No eval data found for session {session_id}")
+                elif not eval_data.answer:
+                    print(f"⚠️ Empty answer for session {session_id}")
+        except Exception as e:
+            print(f"⚠️ Failed to trigger auto-eval: {e}")
+            import traceback
+            traceback.print_exc()
+    
+    # 返回流
+    return StreamingResponse(
+        chat_stream_with_eval(),
+        media_type="text/plain"
+    )
+
+# ===== Phase 2: 新增评估端点 =====
+
+@app.post("/evaluate")
+async def evaluate(request: Request):
+    """
+    评估端点: 接收生成结果,进行多维度评估
+    
+    POST /evaluate
+    {
+        "query": "用户问题",
+        "retrieved_context": "检索到的文件内容",
+        "generated_answer": "生成的回答",
+        "session_id": "会话ID",
+        "repo_url": "仓库URL（可选）"
+    }
+    """
+    try:
+        data = await request.json()
+        
+        # 提取必需字段
+        query = data.get("query")
+        retrieved_context = data.get("retrieved_context", "")
+        generated_answer = data.get("generated_answer")
+        session_id = data.get("session_id", "unknown")
+        repo_url = data.get("repo_url", "")
+        
+        if not query or not generated_answer:
+            return {
+                "error": "Missing required fields: query, generated_answer",
+                "status": "failed"
+            }
+        
+        # 调用评估引擎获取生成层指标
+        generation_metrics = await eval_engine.evaluate_generation(
+            query=query,
+            retrieved_context=retrieved_context,
+            generated_answer=generated_answer
+        )
+        
+        # 构建完整的评估结果对象
+        evaluation_result = EvaluationResult(
+            session_id=session_id,
+            query=query,
+            repo_url=repo_url,
+            timestamp=datetime.now(),
+            language="en",
+            generation_metrics=generation_metrics
+        )
+        
+        # 计算综合得分
+        evaluation_result.compute_overall_score()
+        
+        # 数据路由: 根据得分将样本分类
+        quality_tier = data_router.route_sample(evaluation_result)
+        
+        return {
+            "status": "success",
+            "evaluation": {
+                "faithfulness": generation_metrics.faithfulness,
+                "answer_relevance": generation_metrics.answer_relevance,
+                "answer_completeness": generation_metrics.answer_completeness,
+                "overall_score": evaluation_result.overall_score
+            },
+            "quality_tier": quality_tier,
+            "session_id": session_id
+        }
+    
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return {
+            "error": str(e),
+            "status": "failed"
+        }
+
+
+# ===== 自动评估相关端点 =====
+
+@app.get("/auto-eval/review-queue")
+async def get_review_queue():
+    """
+    获取需要人工审查的样本列表
+    
+    这些是评估出现异常（自己的分数和Ragas分数差异过大）的样本
+    需要人工判断哪个评估器更准确
+    
+    GET /auto-eval/review-queue
+    """
+    try:
+        auto_eval_service = get_auto_evaluation_service()
+        if not auto_eval_service:
+            return {"error": "Auto evaluation service not initialized", "status": "failed"}
+        
+        queue = auto_eval_service.get_review_queue()
+        
+        return {
+            "status": "success",
+            "queue_size": len(queue),
+            "samples": [
+                {
+                    "index": i,
+                    "query": item["eval_result"].query,
+                    "custom_score": item["custom_score"],
+                    "ragas_score": item["ragas_score"],
+                    "diff": item["diff"],
+                    "quality_tier": item["eval_result"].data_quality_tier.value,
+                    "timestamp": item["timestamp"]
+                }
+                for i, item in enumerate(queue)
+            ]
+        }
+    except Exception as e:
+        return {"error": str(e), "status": "failed"}
+
+
+@app.post("/auto-eval/approve/{index}")
+async def approve_sample(index: int):
+    """
+    人工批准某个样本（接受该评估结果）
+    
+    POST /auto-eval/approve/0
+    """
+    try:
+        auto_eval_service = get_auto_evaluation_service()
+        if not auto_eval_service:
+            return {"error": "Auto evaluation service not initialized", "status": "failed"}
+        
+        auto_eval_service.approve_sample(index)
+        
+        return {
+            "status": "success",
+            "message": f"Sample {index} approved and stored"
+        }
+    except Exception as e:
+        return {"error": str(e), "status": "failed"}
+
+
+@app.post("/auto-eval/reject/{index}")
+async def reject_sample(index: int):
+    """
+    人工拒绝某个样本（抛弃该评估结果）
+    
+    POST /auto-eval/reject/0
+    """
+    try:
+        auto_eval_service = get_auto_evaluation_service()
+        if not auto_eval_service:
+            return {"error": "Auto evaluation service not initialized", "status": "failed"}
+        
+        auto_eval_service.reject_sample(index)
+        
+        return {
+            "status": "success",
+            "message": f"Sample {index} rejected and removed from queue"
+        }
+    except Exception as e:
+        return {"error": str(e), "status": "failed"}
+
+
+@app.get("/auto-eval/stats")
+async def auto_eval_stats():
+    """
+    获取自动评估统计信息
+    
+    GET /auto-eval/stats
+    """
+    try:
+        auto_eval_service = get_auto_evaluation_service()
+        if not auto_eval_service:
+            return {"error": "Auto evaluation service not initialized", "status": "failed"}
+        
+        queue = auto_eval_service.get_review_queue()
+        
+        return {
+            "status": "success",
+            "auto_evaluation": {
+                "enabled": auto_eval_service.config.enabled,
+                "use_ragas": auto_eval_service.config.use_ragas,
+                "async_mode": auto_eval_service.config.async_evaluation,
+                "custom_weight": auto_eval_service.config.custom_weight,
+                "ragas_weight": auto_eval_service.config.ragas_weight,
+                "diff_threshold": auto_eval_service.config.diff_threshold
+            },
+            "review_queue_size": len(queue),
+            "last_update": datetime.now().isoformat()
+        }
+    except Exception as e:
+        return {"error": str(e), "status": "failed"}
+
+
+@app.get("/evaluation/stats")
+async def evaluation_stats():
+    """
+    获取评估统计信息
+    
+    GET /evaluation/stats
+    """
+    try:
+        stats = eval_engine.get_statistics()
+        return {
+            "status": "success",
+            "statistics": {
+                "total_evaluations": stats.get("total_evaluations", 0),
+                "average_score": stats.get("average_score", 0),
+                "quality_distribution": stats.get("quality_distribution", {}),
+                "top_issues": stats.get("top_issues", [])
+            }
+        }
+    except Exception as e:
+        return {
+            "error": str(e),
+            "status": "failed"
+        }
+
+
+@app.get("/dashboard/quality-distribution")
+async def quality_distribution():
+    """
+    获取数据质量分布 (用于仪表盘)
+    
+    GET /dashboard/quality-distribution
+    """
+    try:
+        distribution = data_router.get_distribution()
+        return {
+            "status": "success",
+            "distribution": {
+                "gold": distribution.get("gold", 0),
+                "silver": distribution.get("silver", 0),
+                "bronze": distribution.get("bronze", 0),
+                "rejected": distribution.get("rejected", 0),
+                "corrected": distribution.get("corrected", 0)
+            },
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        return {
+            "error": str(e),
+            "status": "failed"
+        }
+
+
+@app.get("/dashboard/bad-cases")
+async def bad_cases():
+    """
+    获取低质量样本 (用于人工审核)
+    
+    GET /dashboard/bad-cases
+    """
+    try:
+        bad_samples = data_router.get_bad_samples(limit=10)
+        return {
+            "status": "success",
+            "bad_cases": [
+                {
+                    "query": s.get("query", ""),
+                    "issue": s.get("issue", ""),
+                    "score": s.get("score", 0)
+                }
+                for s in bad_samples
+            ],
+            "total_bad_cases": len(bad_samples)
+        }
+    except Exception as e:
+        return {
+            "error": str(e),
+            "status": "failed"
+        }
+
+
+if __name__ == "__main__":
+    # 生产模式建议关掉 reload
+    uvicorn.run("app.main:app", host=settings.HOST, port=settings.PORT, reload=False)

app/services/agent_service.py

@@ -0,0 +1,779 @@
+# 文件路径: app/services/agent_service.py
+import json
+import asyncio
+import traceback
+import re
+import ast
+import httpx
+import time
+from typing import Set, Tuple, List
+from datetime import datetime
+from app.core.config import settings, agent_config
+from app.utils.llm_client import client
+from app.utils.repo_lock import RepoLock
+from app.services.github_service import get_repo_structure, get_file_content
+from app.services.vector_service import store_manager
+from app.services.chunking_service import UniversalChunker, ChunkingConfig
+from app.services.tracing_service import tracing_service
+from evaluation.evaluation_framework import EvaluationEngine, EvaluationResult, DataRoutingEngine
+
+# === Helper: 鲁棒的 JSON 提取 ===
+def extract_json_from_text(text):
+    try:
+        text = re.sub(r"^```(json)?|```$", "", text.strip(), flags=re.MULTILINE).strip()
+        return json.loads(text)
+    except:
+        pass
+    match = re.search(r"\[.*\]", text, re.DOTALL)
+    if match:
+        try: return json.loads(match.group(0))
+        except: pass
+    return []
+
+# === 多语言符号提取 ===
+def _extract_symbols(content, file_path):
+    """
+    根据文件类型，智能提取 Class 和 Function 签名生成地图。
+    """
+    ext = file_path.split('.')[-1].lower() if '.' in file_path else ""
+    
+    # 1. Python 使用 AST (最准)
+    if ext == 'py':
+        return _extract_symbols_python(content)
+    
+    # 2. 其他语言使用正则 (Java, TS, JS, Go, C++)
+    elif ext in ['java', 'ts', 'tsx', 'js', 'jsx', 'go', 'cpp', 'cs', 'rs']:
+        return _extract_symbols_regex(content, ext)
+        
+    return []
+
+def _extract_symbols_python(content):
+    try:
+        tree = ast.parse(content)
+        symbols = []
+        for node in tree.body:
+            if isinstance(node, ast.ClassDef):
+                symbols.append(f"  [C] {node.name}")
+                for sub in node.body:
+                    if isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        if not sub.name.startswith("_") or sub.name == "__init__":
+                            symbols.append(f"    - {sub.name}")
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                symbols.append(f"  [F] {node.name}")
+        return symbols
+    except:
+        return []
+    
+def _extract_symbols_regex(content, ext):
+    """
+    针对类 C 语言的通用正则提取。
+    """
+    symbols = []
+    lines = content.split('\n')
+    
+    # 定义各语言的正则模式
+    patterns = {
+        'java': {
+            'class': re.compile(r'(?:public|protected|private)?\s*(?:static|abstract)?\s*(?:class|interface|enum)\s+([a-zA-Z0-9_]+)'),
+            'func': re.compile(r'(?:public|protected|private)\s+(?:static\s+)?[\w<>[\]]+\s+([a-zA-Z0-9_]+)\s*\(')
+        },
+        'ts': { 
+            'class': re.compile(r'class\s+([a-zA-Z0-9_]+)'),
+            'func': re.compile(r'(?:function\s+([a-zA-Z0-9_]+)|const\s+([a-zA-Z0-9_]+)\s*=\s*(?:async\s*)?\(|([a-zA-Z0-9_]+)\s*\([^)]*\)\s*[:\{])') 
+        },
+        'go': {
+            'class': re.compile(r'type\s+([a-zA-Z0-9_]+)\s+(?:struct|interface)'),
+            'func': re.compile(r'func\s+(?:(?:\(.*\)\s+)?([a-zA-Z0-9_]+)|([a-zA-Z0-9_]+)\()')
+        }
+    }
+    
+    lang_key = 'java' if ext in ['java', 'cs', 'cpp', 'rs'] else 'go' if ext == 'go' else 'ts'
+    rules = patterns.get(lang_key, patterns['java'])
+    
+    count = 0 
+    for line in lines:
+        line = line.strip()
+        # === 正则解析优化 (过滤更多干扰项) ===
+        if not line or line.startswith(("//", "/*", "*", "#", "print", "console.")): continue
+        if count > agent_config.max_symbols_per_file: break
+
+        # 匹配类
+        c_match = rules['class'].search(line)
+        if c_match:
+            name = next((g for g in c_match.groups() if g), "Unknown")
+            symbols.append(f"  [C] {name}")
+            count += 1
+            continue
+            
+        # 匹配方法
+        if line.endswith('{') or "=>" in line: 
+            f_match = rules['func'].search(line)
+            if f_match:
+                name = next((g for g in f_match.groups() if g), None)
+                # 增强过滤
+                if name and len(name) > 2 and name not in ['if', 'for', 'switch', 'while', 'catch', 'return']:
+                    symbols.append(f"    - {name}")
+                    count += 1
+
+    return symbols
+
+async def generate_repo_map(repo_url, file_list, limit=agent_config.initial_map_limit) -> Tuple[str, Set[str]]:
+    """
+    生成增强版仓库地图 (多语言版)
+    Returns:
+        str: 地图字符串
+        set: 已包含在地图中的文件路径集合 (用于增量更新查重)
+    """
+    # === 扩展高优先级文件列表 (使用配置) ===
+    priority_files = [
+        f for f in file_list 
+        if f.endswith(agent_config.priority_exts) and 
+        (f.count('/') <= 2 or any(k in f.lower() for k in agent_config.priority_keywords))
+    ]
+    
+    # 去重并截取
+    targets = sorted(list(set(priority_files)))[:limit]
+    remaining = [f for f in file_list if f not in targets]
+    
+    repo_map_lines = []
+    mapped_files_set = set(targets) # === 记录已映射的文件 ===
+    
+    async def process_file(path):
+        content = await get_file_content(repo_url, path)
+        if not content: return f"{path} (Read Failed)"
+        
+        symbols = await asyncio.to_thread(_extract_symbols, content, path)
+        
+        if symbols:
+            return f"{path}\n" + "\n".join(symbols)
+        return path
+
+    repo_map_lines.append(f"--- Key Files Structure (Top {len(targets)}) ---")
+    
+    tasks = [process_file(f) for f in targets]
+    results = await asyncio.gather(*tasks)
+    repo_map_lines.extend(results)
+    
+    if remaining:
+        repo_map_lines.append("\n--- Other Files ---")
+        if len(remaining) > 300:
+            repo_map_lines.extend(remaining[:300])
+            repo_map_lines.append(f"... ({len(remaining)-300} more files)")
+        else:
+            repo_map_lines.extend(remaining)
+            
+    return "\n".join(repo_map_lines), mapped_files_set
+
+
+async def agent_stream(repo_url: str, session_id: str, language: str = "en", regenerate_only: bool = False):
+    """
+    主分析流程。
+    
+    Args:
+        repo_url: GitHub 仓库 URL
+        session_id: 会话 ID
+        language: 报告语言 (zh/en)
+        regenerate_only: 如果为 True，跳过索引步骤，直接使用已有数据生成新语言报告
+    """
+    short_id = session_id[-6:] if session_id else "unknown"
+    
+    # === 追踪初始化 ===
+    trace_id = tracing_service.start_trace(
+        trace_name="agent_analysis",
+        session_id=session_id,
+        metadata={"repo_url": repo_url, "language": language, "regenerate_only": regenerate_only}
+    )
+    start_time = time.time()
+    
+    # === 检查是否有其他用户正在分析同一仓库 ===
+    if not regenerate_only:
+        if await RepoLock.is_locked(session_id):
+            yield json.dumps({
+                "step": "waiting", 
+                "message": f"⏳ Another user is analyzing this repository. Please wait..."
+            })
+    
+    # === 获取仓库锁 (仅写操作需要) ===
+    try:
+        async with RepoLock.acquire(session_id):
+            async for event in _agent_stream_inner(
+                repo_url, session_id, language, regenerate_only, 
+                short_id, trace_id, start_time
+            ):
+                yield event
+    except TimeoutError as e:
+        yield json.dumps({
+            "step": "error",
+            "message": f"❌ {str(e)}. The repository is being analyzed by another user."
+        })
+
+
+async def _agent_stream_inner(
+    repo_url: str, session_id: str, language: str, regenerate_only: bool,
+    short_id: str, trace_id: str, start_time: float
+):
+    """
+    实际的分析流程 (在锁保护下执行)
+    """
+    try:
+        vector_db = store_manager.get_store(session_id)
+        
+        # 调试日志：确认 session 隔离
+        print(f"🔍 [DEBUG] session_id: {session_id}, collection: {vector_db.collection_name}, context_file: {vector_db._context_file}")
+        
+        # === regenerate_only 模式：跳过索引，直接生成报告 ===
+        if regenerate_only:
+            yield json.dumps({"step": "init", "message": f"🔄 [Session: {short_id}] Regenerating report in {language}..."})
+            await asyncio.sleep(0.3)
+            
+            # 从已有索引加载上下文
+            context = vector_db.load_context()
+            if not context:
+                yield json.dumps({"step": "error", "message": "❌ No existing index found. Please analyze the repository first."})
+                return
+            
+            # 正确读取 global_context 内的字段
+            global_ctx = context.get("global_context", {})
+            file_tree_str = global_ctx.get("file_tree", "")
+            context_summary = global_ctx.get("summary", "")
+            visited_files = set()  # regenerate 模式不需要这个，但报告生成需要引用
+            
+            # 验证上下文与请求的仓库匹配
+            stored_repo_url = context.get("repo_url", "")
+            if stored_repo_url and repo_url not in stored_repo_url and stored_repo_url not in repo_url:
+                print(f"⚠️ [WARNING] repo_url mismatch! Request: {repo_url}, Stored: {stored_repo_url}")
+            
+            yield json.dumps({"step": "generating", "message": f"📝 Generating report in {'Chinese' if language == 'zh' else 'English'}..."})
+        else:
+            # === 正常分析模式 ===
+            yield json.dumps({"step": "init", "message": f"🚀 [Session: {short_id}] Connecting to GitHub..."})
+            await asyncio.sleep(0.5)
+            
+            await vector_db.reset()  # 使用异步方法
+            
+            chunker = UniversalChunker(config=ChunkingConfig(min_chunk_size=50))
+
+            file_list = await get_repo_structure(repo_url)
+            if not file_list:
+                raise Exception("Repository is empty or unreadable.")
+
+            yield json.dumps({"step": "fetched", "message": f"📦 Found {len(file_list)} files. Building Repo Map (AST Parsing)..."})        
+            
+            # === 接收 mapped_files 用于后续查重 + 计时 ===
+            map_start = time.time()
+            file_tree_str, mapped_files = await generate_repo_map(repo_url, file_list, limit=agent_config.initial_map_limit)
+            map_latency_ms = (time.time() - map_start) * 1000
+            tracing_service.add_event("repo_map_generated", {"latency_ms": map_latency_ms, "files_mapped": len(mapped_files)})
+            
+            visited_files = set()
+            context_summary = ""
+            readme_file = next((f for f in file_list if f.lower().endswith("readme.md")), None)
+
+            for round_idx in range(agent_config.max_rounds):
+                yield json.dumps({"step": "thinking", "message": f"🕵️ [Round {round_idx+1}/{agent_config.max_rounds}] DeepSeek is analyzing Repo Map..."})
+                
+                system_prompt = "You are a Senior Software Architect. Your goal is to understand the codebase."
+                user_content = f"""
+                [Project Repo Map]
+                (Contains file paths and key Class/Function signatures)
+                {file_tree_str}
+                
+                [Files Already Read]
+                {list(visited_files)}
+                
+                [Current Knowledge]
+                {context_summary}
+                
+                [Task]
+                Select 1-{agent_config.files_per_round} MOST CRITICAL files to read next to understand the core logic.
+                Focus on files that seem to contain main logic based on the Repo Map symbols.
+                
+                [Constraint]
+                Return ONLY a raw JSON list of strings. No markdown.
+                Example: ["src/main.py", "app/auth.py"]
+                """
+                
+                if not client:
+                     yield json.dumps({"step": "error", "message": "❌ LLM Client Not Initialized."})
+                     return
+                
+                # === Token & Latency Tracing ===
+                llm_start_time = time.time()
+                plan_messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content}
+                ]
+                
+                response = await client.chat.completions.create(
+                    model=settings.default_model_name,
+                    messages=plan_messages,
+                    temperature=0.1,
+                    timeout=settings.LLM_TIMEOUT 
+                )
+                
+                llm_latency_ms = (time.time() - llm_start_time) * 1000
+                raw_content = response.choices[0].message.content
+                
+                # 记录 Token 使用量
+                usage = getattr(response, 'usage', None)
+                tracing_service.record_llm_generation(
+                    model=settings.default_model_name,
+                    prompt_messages=plan_messages,
+                    generated_text=raw_content,
+                    total_latency_ms=llm_latency_ms,
+                    prompt_tokens=usage.prompt_tokens if usage else None,
+                    completion_tokens=usage.completion_tokens if usage else None,
+                    total_tokens=usage.total_tokens if usage else None,
+                    is_streaming=False,
+                    metadata={"step": "file_selection", "round": round_idx + 1}
+                )
+                target_files = extract_json_from_text(raw_content)
+
+                valid_files = [f for f in target_files if f in file_list and f not in visited_files]
+
+                if round_idx == 0 and readme_file and readme_file not in visited_files and readme_file not in valid_files:
+                    valid_files.insert(0, readme_file)
+
+                if not valid_files:
+                    yield json.dumps({"step": "plan", "message": f"🛑 [Round {round_idx+1}] Sufficient context gathered."})
+                    break
+                
+                yield json.dumps({"step": "plan", "message": f"👉 [Round {round_idx+1}] Selected: {valid_files}"})
+                
+                # === 并发模型缺陷优化 (并行下载处理) ===
+                async def process_single_file(file_path):
+                    try:
+                        file_start = time.time()
+                        
+                        # 🔧 异步 GitHub API (已优化为非阻塞)
+                        content = await get_file_content(repo_url, file_path)
+                        if not content: 
+                            tracing_service.add_event("file_read_failed", {"file": file_path})
+                            return None
+
+                        # 1. 摘要与 Context
+                        lines = content.split('\n')[:50]
+                        preview = "\n".join(lines)
+                        file_knowledge = f"\n--- File: {file_path} ---\n{preview}\n"
+                        
+                        # 2. Repo Map 增量更新与查重
+                        new_map_entry = None
+                        if file_path not in mapped_files:
+                            symbols = await asyncio.to_thread(_extract_symbols, content, file_path)
+                            if symbols:
+                                new_map_entry = f"{file_path}\n" + "\n".join(symbols)
+
+                        # 3. 切片与入库
+                        chunks = await asyncio.to_thread(chunker.chunk_file, content, file_path)
+                        if chunks:
+                            documents = [c["content"] for c in chunks]
+                            metadatas = []
+                            for c in chunks:
+                                meta = c["metadata"]
+                                metadatas.append({
+                                    "file": meta["file"],
+                                    "type": meta["type"],
+                                    "name": meta.get("name", ""),
+                                    "class": meta.get("class") or ""
+                                })
+                            if documents:
+                                try:
+                                    await vector_db.add_documents(documents, metadatas)
+                                except Exception as e:
+                                    print(f"❌ 索引错误 {file_path}: {e}")
+                                    # 不中断，继续处理其他文件
+                                    return None
+                        
+                        file_latency_ms = (time.time() - file_start) * 1000
+                        tracing_service.add_event("file_processed", {
+                            "file": file_path,
+                            "latency_ms": file_latency_ms,
+                            "chunks_count": len(chunks) if chunks else 0
+                        })
+
+                        return {
+                            "path": file_path,
+                            "knowledge": file_knowledge,
+                            "map_entry": new_map_entry
+                        }
+                    except Exception as e:
+                        print(f"❌ 处理文件错误 {file_path}: {e}")
+                        return None
+
+                # 提示开始并发下载
+                yield json.dumps({"step": "download", "message": f"📥 Starting parallel download for {len(valid_files)} files..."})
+
+                # 启动并发任务 (return_exceptions=True 防止单个失败导致整个中断)
+                tasks = [process_single_file(f) for f in valid_files]
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+
+                # 聚合结果
+                download_count = 0
+                for res in results:
+                    if not res or isinstance(res, Exception): 
+                        if isinstance(res, Exception):
+                            print(f"❌ Task 异常: {res}")
+                        continue
+                    download_count += 1
+                    visited_files.add(res["path"])
+                    context_summary += res["knowledge"]
+                    
+                    # 增量更新 Map
+                    if res["map_entry"]:
+                        file_tree_str = f"{res['map_entry']}\n\n{file_tree_str}"
+                        mapped_files.add(res["path"])
+                
+                # === 硬编码截断解耦 ===
+                context_summary = context_summary[:agent_config.max_context_length]
+                
+                global_context_data = {
+                    "file_tree": file_tree_str,
+                    "summary": context_summary[:8000]
+                }
+                await vector_db.save_context(repo_url, global_context_data)
+                
+                yield json.dumps({"step": "indexing", "message": f"🧠 [Round {round_idx+1}] Processed {download_count} files. Knowledge graph updated."})
+
+            # Final Report (正常分析模式下的提示)
+            yield json.dumps({"step": "generating", "message": "📝 Generating technical report..."})
+        
+        # === 报告生成 (两种模式共用) ===
+        
+        # === P0: 向量检索补充关键代码片段 ===
+        yield json.dumps({"step": "enriching", "message": "🔍 Retrieving key code snippets..."})
+        
+        key_queries = [
+            "main entry point initialization startup",
+            "core business logic handler processor",
+            "API routes endpoints controllers",
+            "database models schema ORM",
+            "authentication authorization middleware"
+        ]
+        
+        retrieved_snippets = []
+        try:
+            await vector_db.initialize()
+            for query in key_queries:
+                results = await vector_db.search_hybrid(query, top_k=2)
+                for r in results:
+                    snippet = r.get("content", "")[:400]
+                    file_path = r.get("file", "unknown")
+                    if snippet and snippet not in [s.split("]")[1] if "]" in s else s for s in retrieved_snippets]:
+                        retrieved_snippets.append(f"[{file_path}]\n{snippet}")
+        except Exception as e:
+            print(f"⚠️ 向量检索失败: {e}")
+        
+        code_snippets_section = "\n\n".join(retrieved_snippets[:8]) if retrieved_snippets else ""
+        
+        # === P1: 依赖文件解析 ===
+        dep_files = ["requirements.txt", "pyproject.toml", "package.json", "go.mod", "Cargo.toml", "pom.xml", "build.gradle"]
+        dependencies_info = ""
+        
+        # 获取 file_list（regenerate_only 模式下需要重新获取）
+        if regenerate_only:
+            try:
+                temp_file_list = await get_repo_structure(repo_url)
+            except:
+                temp_file_list = []
+        else:
+            temp_file_list = file_list if 'file_list' in dir() else []
+        
+        for dep_file in dep_files:
+            matching = [f for f in temp_file_list if f.endswith(dep_file)]
+            for f in matching[:1]:  # 只取第一个匹配
+                try:
+                    content = await get_file_content(repo_url, f)
+                    if content:
+                        dependencies_info += f"\n[{f}]\n{content[:800]}\n"
+                except:
+                    pass
+        
+        # 构建增强的上下文
+        enhanced_context = f"""
+        {context_summary[:12000]}
+        
+        [Key Code Snippets (Retrieved by Semantic Search)]
+        {code_snippets_section}
+        
+        [Project Dependencies]
+        {dependencies_info if dependencies_info else "No dependency file found."}
+        """
+
+        repo_map_injection = f"""
+        [Project Repo Map (Structure)]
+        {file_tree_str}
+        """
+
+        # === 根据语言选择 Prompt ===
+        if language == "zh":
+            # --- 中文 Prompt ---
+            system_role = "你是一位务实的技术专家。目标是为开发者创建一个'3页纸'架构概览，让他们能在5分钟内看懂这个仓库。重点关注架构和数据流，不要纠结细节。"
+            analysis_user_content = f"""
+            [角色]
+            你是一位务实的技术专家（Tech Lead）。
+            
+            [输入数据]
+            {repo_map_injection}
+
+            分析的文件: {list(visited_files)}
+            
+            [代码知识库与关键片段]
+            {enhanced_context}
+            
+            [严格限制]
+            1. **不进行代码审查**: 不要列出 Bug、缺失功能或改进建议。
+            2. **不评价**: 不要评价代码质量，只描述它**如何工作**。
+            3. **语调**: 专业、结构化、描述性。使用中文回答。
+            4. **不要废话**: 不要写"安全性"、"未来规划"等未请求的章节。
+
+            [输出格式要求 (Markdown)]
+            
+            # 项目分析报告
+
+            ## 1. 执行摘要 (Executive Summary)
+            - **用途**: (这个项目具体解决什么问题？1-2句话)
+            - **核心功能**: (列出Top 3功能点)
+            - **技术栈**: (语言、框架、数据库、关键库)
+
+            ## 2. 系统架构 (Mermaid)
+            创建一个 `graph TD` 图。
+            - 展示高层组件 (如 Client, API Server, Database, Worker, External Service)。
+            - 在连线上标注数据流 (如 "HTTP", "SQL")。
+            - **风格**: 保持概念清晰简单，节点数量控制在 8 个以内。
+            
+            **⚠️ Mermaid 语法严格要求 (v10.x)**:
+            1. **所有节点文本必须用双引号包裹**: `A["用户界面"]` ✓, `A[用户界面]` ✗
+            2. **所有连线标签必须用双引号包裹**: `-->|"HTTP请求"|` ✓, `-->|HTTP请求|` ✗
+            3. **禁止使用特殊字符**: 不要在文本中使用 `<br/>`, `/`, `(`, `)`, `&`, `<`, `>` 等
+            4. **使用简短英文ID**: 节点ID用简短英文如 `A`, `B`, `Client`, `API`
+            5. **subgraph 标题也需引号**: `subgraph "核心服务"` ✓
+            6. **数据库节点**: 使用 `[("数据库")]` 格式
+            
+            - **正确示例**:
+            ```mermaid
+            graph TD
+                Client["客户端"] -->|"HTTP请求"| API["API网关"]
+                API --> Service["业务服务"]
+                Service --> DB[("数据库")]
+                Service -->|"调用"| External["外部服务"]
+            ```
+
+            ## 3. 核心逻辑分析 (Table)
+            (总结关键模块，不要列出所有文件，只列最重要的)
+
+            | 组件/文件 | 职责 (它做什么？) | 关键设计模式/逻辑 |
+            | :--- | :--- | :--- |
+            | 例如 `auth_service.py` | 处理JWT颁发与验证 | 单例模式, 路由装饰器 |
+            | ... | ... | ... |
+
+            ## 4. 🔬 核心方法深度解析
+            (精选 3-5 个最关键的 `.py` 文件。针对每个文件，列出驱动逻辑的 Top 2-3 个方法)
+
+            ### 4.1 `[文件名]`
+            * **`[方法名]`**: [解释它做什么以及为什么重要，不要贴代码]
+            * **`[方法名]`**: [解释...]
+
+            ## 5. 主要工作流 (Mermaid)
+            选择**一个最重要**的业务流程 (Happy Path)。
+            创建一个 `sequenceDiagram`。
+            - 参与者应该是高层概念 (如 User, API, DB)，不要用具体变量名。
+            
+            **⚠️ sequenceDiagram 语法要求**:
+            1. **participant 别名格式**: `participant API as "API服务"` ✓
+            2. **消息文本用双引号**: `User->>API: "发起请求"` ✓
+            3. **避免特殊字符**: 不要在消息中使用 `/`, `&`, `<`, `>` 等
+            
+            - **正确示例**:
+            ```mermaid
+            sequenceDiagram
+                participant User as "用户"
+                participant API as "API服务"
+                participant DB as "数据库"
+                User->>API: "发起请求"
+                API->>DB: "查询数据"
+                DB-->>API: "返回结果"
+                API-->>User: "响应数据"
+            ```
+            
+            ## 6. 快速开始 (Quick Start)
+            - **前置条件**: (如 Docker, Python 3.9+, .env 配置)
+            - **入口**: (如何启动主逻辑？如 `python main.py`)
+            """
+        else:
+            analysis_user_content = f"""
+            [Role]
+            You are a **Pragmatic Tech Lead**. Your goal is to create a **"3-Pages" Architecture Overview** for a developer who wants to understand this repo in 5 minutes.
+            [Input Data]
+            {repo_map_injection}
+
+            Files analyzed: {list(visited_files)}
+            
+            [Code Knowledge & Key Snippets]
+            {enhanced_context}
+            
+            [Strict Constraints]
+            1. **NO Code Review**: Do NOT list bugs, issues, missing features, or recommendations.
+            2. **NO Critique**: Do not judge the code quality. Focus on HOW it works.
+            3. **Tone**: Professional, descriptive, and structural.
+            4. **NO "FLUFF"**: Do NOT add unrequested sections like "Security", "Scalability", "Data Models", "Future Enhancements", etc.
+
+            [Required Output Format (Markdown)]
+            
+            # Project Analysis Report
+
+            ## 1. Executive Summary
+            - **Purpose**: (What specific problem does this project solve? 1-2 sentences)
+            - **Key Features**: (Bullet points of top 3 features)
+            - **Tech Stack**: (List languages, frameworks, databases, and key libs)
+
+            ## 2. System Architecture
+            Create a `graph TD` diagram.
+            - Show high-level components (e.g., Client, API Server, Database, Worker, External Service).
+            - Label the edges with data flow (e.g., "HTTP", "SQL").
+            - **Style**: Keep it simple and conceptual. Limit to 8 nodes max.
+            
+            **⚠️ Mermaid Syntax Rules (v10.x - MUST FOLLOW)**:
+            1. **Wrap ALL node text in double quotes**: `A["User Client"]` ✓, `A[User Client]` ✗
+            2. **Wrap ALL edge labels in double quotes**: `-->|"HTTP Request"|` ✓, `-->|HTTP Request|` ✗
+            3. **NO special characters in text**: Avoid `/`, `()`, `&`, `<>`, `<br/>` in labels
+            4. **Use short alphanumeric IDs**: e.g., `A`, `B`, `Client`, `API`, `DB`
+            5. **Subgraph titles need quotes**: `subgraph "Core Services"` ✓
+            6. **Database node format**: Use `[("Database")]` for cylinder shape
+            
+            - **Correct Example**:
+            ```mermaid
+            graph TD
+                Client["User Client"] -->|"HTTP Request"| API["API Gateway"]
+                API --> Service["Business Service"]
+                Service --> DB[("Database")]
+                Service -->|"Calls"| External["External API"]
+            ```
+
+            ## 3. Core Logic Analysis
+            (Create a Markdown Table to summarize key modules. Do not list every file, only the most important ones.)
+
+            | Component/File | Responsibility (What does it do?) | Key Design Pattern / Logic |
+            | :--- | :--- | :--- |
+            | e.g. `auth_service.py` | Handles JWT issuance and verification | Singleton, Decorator for routes |
+            | ... | ... | ... |
+
+            ## 4. Core Methods Deep Dive
+            (Select the 3-5 most critical `.py` files. For each, list the top 2-3 methods that drive the logic.)
+
+            ### 4.1 `[Filename, e.g., agent_service.py]`
+            * **`[Method Name]`**: [Explanation of what it does and why it matters. No code.]
+            * **`[Method Name]`**: [Explanation...]
+
+            ### 4.2 `[Filename, e.g., vector_service.py]`
+            * **`[Method Name]`**: [Explanation...]
+            * ...
+
+            ## 5. Main Workflow (Mermaid)
+            Select the **Single Most Important** business flow (The "Happy Path").
+            Create a `sequenceDiagram`.
+            - Participants should be high-level (e.g., User, API, DB), not specific variable names.
+            
+            **⚠️ sequenceDiagram Syntax Rules**:
+            1. **Wrap participant aliases in quotes**: `participant API as "API Server"` ✓
+            2. **Wrap message text in quotes**: `User->>API: "Send Request"` ✓
+            3. **NO special characters**: Avoid `/`, `&`, `<`, `>` in messages
+            
+            - **Correct Example**:
+            ```mermaid
+            sequenceDiagram
+                participant User as "User"
+                participant API as "API Server"
+                participant DB as "Database"
+                User->>API: "Send Request"
+                API->>DB: "Query Data"
+                DB-->>API: "Return Result"
+                API-->>User: "Send Response"
+            ```
+            
+            ## 6. Quick Start Guide
+            - **Prerequisites**: (e.g. Docker, Python 3.9+, .env file)
+            - **Entry Point**: (How to run the main logic? e.g. `python main.py` or `uvicorn`)
+
+            """
+        
+        # === 增加 timeout 防止长文本生成时断连 ===
+        report_messages = [
+            {"role": "system", "content": "You are a pragmatic Tech Lead. Focus on architecture and data flow, not implementation details."},
+            {"role": "user", "content": analysis_user_content}
+        ]
+        
+        stream_start_time = time.time()
+        stream = await client.chat.completions.create(
+            model=settings.default_model_name,
+            messages=report_messages,
+            stream=True,
+            timeout=settings.LLM_TIMEOUT  # 使用统一配置
+        )
+        
+        # === TTFT & Token Tracking ===
+        first_token_received = False
+        ttft_ms = None
+        generated_text = ""
+        completion_tokens_estimate = 0
+        
+        # === 增加 try-except 捕获流式传输中断 ===
+        try:
+            async for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    content = chunk.choices[0].delta.content
+                    
+                    # 记录 TTFT (首 Token 时间)
+                    if not first_token_received:
+                        ttft_ms = (time.time() - stream_start_time) * 1000
+                        tracing_service.record_ttft(
+                            ttft_ms=ttft_ms,
+                            model=settings.default_model_name,
+                            metadata={"step": "report_generation"}
+                        )
+                        first_token_received = True
+                    
+                    generated_text += content
+                    completion_tokens_estimate += 1  # 粗略估计每个 chunk 约 1 token
+                    yield json.dumps({"step": "report_chunk", "chunk": content})
+        except (httpx.ReadError, httpx.ConnectError) as e:
+            yield json.dumps({"step": "error", "message": f"⚠️ Network Timeout during generation: {str(e)}"})
+            return
+        
+        # 流结束后记录完整的 LLM 生成信息
+        total_latency_ms = (time.time() - stream_start_time) * 1000
+        tracing_service.record_llm_generation(
+            model=settings.default_model_name,
+            prompt_messages=report_messages,
+            generated_text=generated_text,
+            ttft_ms=ttft_ms,
+            total_latency_ms=total_latency_ms,
+            completion_tokens=completion_tokens_estimate,
+            is_streaming=True,
+            metadata={"step": "report_generation", "generated_chars": len(generated_text)}
+        )
+        
+        # === 保存报告 (按语言存储，异步避免阻塞) ===
+        await vector_db.save_report(generated_text, language)
+
+        yield json.dumps({"step": "finish", "message": "✅ Analysis Complete!"})
+
+    except Exception as e:
+        # === 全局异常捕获 ===
+        import traceback
+        traceback.print_exc()
+        
+        # 提取友好的错误信息
+        error_msg = str(e)
+        if "401" in error_msg:
+            ui_msg = "❌ GitHub Token Invalid. Please check your settings."
+        elif "403" in error_msg:
+            ui_msg = "❌ GitHub API Rate Limit Exceeded. Try again later or add a Token."
+        elif "404" in error_msg:
+            ui_msg = "❌ Repository Not Found. Check the URL."
+        elif "Timeout" in error_msg or "ConnectError" in error_msg:
+            ui_msg = "❌ Network Timeout. LLM or GitHub is not responding."
+        else:
+            ui_msg = f"💥 System Error: {error_msg}"
+            
+        yield json.dumps({"step": "error", "message": ui_msg})
+        return # 终止流

app/services/auto_evaluation_service.py

@@ -0,0 +1,481 @@
+# 文件路径: app/services/auto_evaluation_service.py
+"""
+自动评估服务 - Phase 1
+在后台异步进行评估，不阻塞用户请求
+
+工作流程:
+  1. 用户调用 /chat 或 /analyze
+  2. 获得立即响应
+  3. 后台异步执行评估
+  4. 评估结果存储到 evaluation/sft_data/
+"""
+
+import asyncio
+import json
+import os
+from datetime import datetime
+from typing import Optional
+from dataclasses import dataclass
+
+from evaluation.evaluation_framework import (
+    EvaluationEngine, 
+    EvaluationResult, 
+    DataRoutingEngine,
+    DataQualityTier
+)
+from evaluation.utils import is_chatty_query, has_code_indicators
+from app.services.tracing_service import tracing_service
+
+
+@dataclass
+class EvaluationConfig:
+    """
+    自动评估配置
+    
+    数据路由阈值说明（与 data_router.py 一致）:
+    - score > 0.9  → Gold   → positive_samples.jsonl
+    - score > 0.6  → Silver → positive_samples.jsonl  
+    - score > 0.4  → Bronze → negative_samples.jsonl
+    - score <= 0.4 → Rejected → 不存储
+    """
+    enabled: bool = True                    # 是否启用自动评估
+    use_ragas: bool = False                 # 是否使用 Ragas 进行 sanity check
+    custom_weight: float = 0.7              # custom_eval 的权重
+    ragas_weight: float = 0.3               # ragas_eval 的权重
+    diff_threshold: float = 0.2             # 差异阈值（超过则标记 needs_review）
+    min_quality_score: float = 0.4          # 最低质量分数（<=0.4 才拒绝）
+    async_evaluation: bool = True           # 是否异步执行（推荐 True）
+    min_query_length: int = 10              # 最小 query 长度
+    min_answer_length: int = 100            # 最小 answer 长度
+    require_repo_url: bool = True           # 是否要求有仓库 URL
+    require_code_in_context: bool = True    # 是否要求上下文包含代码
+
+
+class AutoEvaluationService:
+    """自动评估服务"""
+    
+    def __init__(
+        self,
+        eval_engine: EvaluationEngine,
+        data_router: DataRoutingEngine,
+        config: EvaluationConfig = None
+    ):
+        self.eval_engine = eval_engine
+        self.data_router = data_router
+        self.config = config or EvaluationConfig()
+        self.needs_review_queue: list = []  # 需要人工审查的样本队列
+        self._evaluated_keys: set = set()   # 防重复评估（session_id:query_hash）
+        
+        # 被过滤数据的记录文件
+        self.skipped_samples_file = "evaluation/sft_data/skipped_samples.jsonl"
+        os.makedirs(os.path.dirname(self.skipped_samples_file), exist_ok=True)
+    
+    def _record_skipped(self, reason: str, query: str, session_id: str, 
+                        repo_url: str = "", context_len: int = 0, answer_len: int = 0) -> None:
+        """记录被跳过的样本（供日后分析）"""
+        record = {
+            "timestamp": datetime.now().isoformat(),
+            "reason": reason,
+            "session_id": session_id,
+            "query": query[:200] if query else "",
+            "repo_url": repo_url,
+            "context_length": context_len,
+            "answer_length": answer_len
+        }
+        try:
+            with open(self.skipped_samples_file, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(record, ensure_ascii=False) + '\n')
+        except Exception as e:
+            print(f"  ⚠️ 记录跳过样本失败: {e}")
+    
+    def _validate_input(
+        self,
+        query: str,
+        retrieved_context: str,
+        generated_answer: str,
+        session_id: str,
+        repo_url: str
+    ) -> tuple[bool, Optional[str]]:
+        """
+        验证输入是否满足评估条件
+        
+        Returns:
+            (is_valid, skip_reason) - 如果有效返回 (True, None)，否则返回 (False, reason)
+        """
+        context_len = len(retrieved_context) if retrieved_context else 0
+        answer_len = len(generated_answer) if generated_answer else 0
+        
+        # Query 验证
+        if not query or not query.strip():
+            self._record_skipped("query_empty", query or "", session_id, repo_url, context_len, answer_len)
+            return False, "query 为空"
+        
+        if len(query.strip()) < self.config.min_query_length:
+            self._record_skipped("query_too_short", query, session_id, repo_url, context_len, answer_len)
+            return False, f"query 太短 ({len(query)} < {self.config.min_query_length})"
+        
+        if is_chatty_query(query):
+            self._record_skipped("chatty_query", query, session_id, repo_url, context_len, answer_len)
+            return False, f"闲聊/无效 query: {query[:30]}"
+        
+        # Repo URL 验证
+        if self.config.require_repo_url and not repo_url:
+            self._record_skipped("missing_repo_url", query, session_id, repo_url, context_len, answer_len)
+            return False, "缺少 repo_url"
+        
+        # Answer 验证
+        if not generated_answer or len(generated_answer.strip()) < self.config.min_answer_length:
+            self._record_skipped("answer_too_short", query, session_id, repo_url, context_len, answer_len)
+            return False, f"回答太短 ({answer_len} < {self.config.min_answer_length})"
+        
+        # Context 验证
+        if self.config.require_code_in_context and not has_code_indicators(retrieved_context):
+            self._record_skipped("no_code_in_context", query, session_id, repo_url, context_len, answer_len)
+            return False, "上下文中未检测到代码"
+        
+        return True, None
+    
+    def _check_duplicate(self, query: str, session_id: str) -> bool:
+        """检查是否重复评估，返回 True 表示是重复的"""
+        import hashlib
+        query_hash = hashlib.md5(query.encode()).hexdigest()[:8]
+        eval_key = f"{session_id}:{query_hash}"
+        
+        if eval_key in self._evaluated_keys:
+            return True
+        
+        self._evaluated_keys.add(eval_key)
+        
+        # 限制缓存大小，防止内存泄漏
+        if len(self._evaluated_keys) > 1000:
+            self._evaluated_keys = set(list(self._evaluated_keys)[-500:])
+        
+        return False
+    
+    async def auto_evaluate(
+        self,
+        query: str,
+        retrieved_context: str,
+        generated_answer: str,
+        session_id: str = "auto",
+        repo_url: str = "",
+        language: str = "en"
+    ) -> Optional[str]:
+        """
+        自动评估单个查询-回答对
+        
+        Returns:
+            质量等级 (gold/silver/bronze/rejected/needs_review) 或 None
+        """
+        # 输入验证
+        is_valid, skip_reason = self._validate_input(
+            query, retrieved_context, generated_answer, session_id, repo_url
+        )
+        if not is_valid:
+            print(f"  ⚠️ [AutoEval] 跳过: {skip_reason}")
+            return None
+        
+        # 防重复评估
+        if self._check_duplicate(query, session_id):
+            print(f"  ⏭️ [AutoEval] 跳过重复评估: {query[:30]}...")
+            return None
+        
+        start_time = datetime.now()
+        
+        try:
+            # Step 1: 自定义评估
+            print(f"📊 [AutoEval] 开始评估: {query[:50]}...")
+            
+            custom_metrics = await self.eval_engine.evaluate_generation(
+                query=query,
+                retrieved_context=retrieved_context,
+                generated_answer=generated_answer
+            )
+            custom_score = custom_metrics.overall_score()
+            
+            print(f"  ✓ Custom Score: {custom_score:.3f}")
+            print(f"    - Faithfulness: {custom_metrics.faithfulness:.3f}")
+            print(f"    - Answer Relevance: {custom_metrics.answer_relevance:.3f}")
+            print(f"    - Completeness: {custom_metrics.answer_completeness:.3f}")
+            
+            # Step 2: Ragas Sanity Check (如果启用)
+            ragas_score = None
+            ragas_details = None
+            
+            if self.config.use_ragas:
+                try:
+                    ragas_score, ragas_details = await self._ragas_eval(
+                        query=query,
+                        context=retrieved_context,
+                        answer=generated_answer
+                    )
+                    print(f"  ✓ Ragas Score: {ragas_score:.3f}")
+                    if ragas_details:
+                        print(f"    - {ragas_details}")
+                except Exception as e:
+                    print(f"  ⚠️ Ragas 评估失败: {e}")
+                    # Ragas 失败不应该中断主流程
+            
+            # ============================================================
+            # Step 3: 混合评估 + 异常检测
+            # ============================================================
+            final_score, quality_status = self._compute_final_score(
+                custom_score=custom_score,
+                ragas_score=ragas_score
+            )
+            
+            print(f"  ✓ Final Score: {final_score:.3f} | Status: {quality_status}")
+            
+            # ============================================================
+            # Step 4: 构建评估结果并存储
+            # ============================================================
+            eval_result = EvaluationResult(
+                session_id=session_id,
+                query=query,
+                repo_url=repo_url,
+                timestamp=start_time,
+                language=language,
+                generation_metrics=custom_metrics,
+                notes=f"ragas_score={ragas_score:.3f}" if ragas_score else ""
+            )
+            
+            # 设置综合得分
+            eval_result.overall_score = final_score
+            
+            # 根据状态和得分确定质量等级
+            print(f"  [DEBUG] quality_status={quality_status}, final_score={final_score:.3f}, threshold={self.config.min_quality_score}")
+            
+            if quality_status == "needs_review":
+                eval_result.data_quality_tier = DataQualityTier.BRONZE
+                eval_result.notes += " | needs_review=true"
+                # 加入审查队列
+                self.needs_review_queue.append({
+                    "eval_result": eval_result,
+                    "custom_score": custom_score,
+                    "ragas_score": ragas_score,
+                    "diff": abs(custom_score - (ragas_score or custom_score)),
+                    "timestamp": start_time.isoformat()
+                })
+                print(f"  ⚠️ 需要人工审查 (needs_review)，暂存队列")
+                # 同时也路由到数据存储，便于后续分析
+                self.data_router.route_sample(eval_result)
+            elif final_score > self.config.min_quality_score:
+                # score > 0.4: 路由到 positive (>0.6) 或 negative (0.4-0.6)
+                print(f"  ✓ 路由到 data_router (score {final_score:.2f} > {self.config.min_quality_score})")
+                self.data_router.route_sample(eval_result)
+            else:
+                # score <= 0.4: 质量太差，直接拒绝
+                eval_result.data_quality_tier = DataQualityTier.REJECTED
+                print(f"  ❌ 评分过低 ({final_score:.2f} <= {self.config.min_quality_score})，拒绝存储")
+            
+            # 记录到 tracing
+            tracing_service.add_event("auto_evaluation_completed", {
+                "query": query[:100],
+                "custom_score": custom_score,
+                "ragas_score": ragas_score,
+                "final_score": final_score,
+                "status": quality_status,
+                "quality_tier": eval_result.data_quality_tier.value
+            })
+            
+            print(f"  ✅ 评估完成\n")
+            
+            return eval_result.data_quality_tier.value
+        
+        except Exception as e:
+            print(f"  ❌ 自动评估异常: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+    
+    async def auto_evaluate_async(
+        self,
+        query: str,
+        retrieved_context: str,
+        generated_answer: str,
+        session_id: str = "auto",
+        repo_url: str = "",
+        language: str = "en"
+    ) -> None:
+        """
+        异步版本 - 不阻塞主流程
+        
+        在后台执行评估，不等待结果
+        """
+        if not self.config.async_evaluation:
+            # 同步模式（不推荐在生产环境）
+            await self.auto_evaluate(
+                query=query,
+                retrieved_context=retrieved_context,
+                generated_answer=generated_answer,
+                session_id=session_id,
+                repo_url=repo_url,
+                language=language
+            )
+        else:
+            # 异步模式（推荐）- 在后台执行
+            asyncio.create_task(
+                self._eval_task(
+                    query=query,
+                    retrieved_context=retrieved_context,
+                    generated_answer=generated_answer,
+                    session_id=session_id,
+                    repo_url=repo_url,
+                    language=language
+                )
+            )
+    
+    async def _eval_task(
+        self,
+        query: str,
+        retrieved_context: str,
+        generated_answer: str,
+        session_id: str,
+        repo_url: str,
+        language: str
+    ) -> None:
+        """后台评估任务包装"""
+        try:
+            await asyncio.sleep(0.1)  # 让用户请求先返回
+            await self.auto_evaluate(
+                query=query,
+                retrieved_context=retrieved_context,
+                generated_answer=generated_answer,
+                session_id=session_id,
+                repo_url=repo_url,
+                language=language
+            )
+        except Exception as e:
+            print(f"❌ Background eval task failed: {e}")
+    
+    def _compute_final_score(
+        self,
+        custom_score: float,
+        ragas_score: Optional[float]
+    ) -> tuple[float, str]:
+        """
+        计算最终得分和状态
+        
+        Returns:
+            (final_score, status)
+            status: "normal" / "needs_review" / "high_confidence"
+        """
+        
+        if ragas_score is None:
+            # 没有 Ragas 分数，直接用 custom 分数
+            return custom_score, "normal"
+        
+        # 计算差异
+        diff = abs(custom_score - ragas_score)
+        
+        # 判断异常
+        if diff > self.config.diff_threshold:
+            # 差异过大，标记为需要审查
+            return custom_score, "needs_review"
+        
+        # 混合评分
+        final_score = (
+            self.config.custom_weight * custom_score +
+            self.config.ragas_weight * ragas_score
+        )
+        
+        # 两者都高分 → 高置信度
+        if custom_score > 0.75 and ragas_score > 0.75:
+            status = "high_confidence"
+        else:
+            status = "normal"
+        
+        return final_score, status
+    
+    async def _ragas_eval(
+        self,
+        query: str,
+        context: str,
+        answer: str
+    ) -> tuple[Optional[float], Optional[str]]:
+        """
+        使用 Ragas 进行 sanity check
+        
+        Returns:
+            (score, details)
+        """
+        try:
+            from ragas.metrics import faithfulness, answer_relevancy
+            from ragas import evaluate
+            
+            # 构造 Ragas 数据集
+            dataset_dict = {
+                "question": [query],
+                "contexts": [[context]],
+                "answer": [answer]
+            }
+            
+            # 执行评估
+            result = evaluate(
+                dataset=dataset_dict,
+                metrics=[faithfulness, answer_relevancy]
+            )
+            
+            # 提取分数
+            faithfulness_score = result["faithfulness"][0] if "faithfulness" in result else 0.5
+            relevancy_score = result["answer_relevancy"][0] if "answer_relevancy" in result else 0.5
+            
+            # 平均得分
+            ragas_score = (faithfulness_score + relevancy_score) / 2
+            
+            details = f"Ragas: faithfulness={faithfulness_score:.3f}, relevancy={relevancy_score:.3f}"
+            
+            return ragas_score, details
+        
+        except ImportError:
+            print("⚠️ Ragas 未安装，跳过 sanity check")
+            return None, None
+        except Exception as e:
+            print(f"⚠️ Ragas 评估异常: {e}")
+            return None, None
+    
+    def get_review_queue(self) -> list:
+        """获取需要审查的样本列表"""
+        return self.needs_review_queue
+    
+    def clear_review_queue(self) -> None:
+        """清空审查队列"""
+        self.needs_review_queue.clear()
+    
+    def approve_sample(self, index: int) -> None:
+        """人工批准某个样本"""
+        if 0 <= index < len(self.needs_review_queue):
+            item = self.needs_review_queue[index]
+            # 直接存储到评估结果
+            self.data_router.route_sample(item["eval_result"])
+            print(f"✅ 样本 {index} 已批准")
+    
+    def reject_sample(self, index: int) -> None:
+        """人工拒绝某个样本"""
+        if 0 <= index < len(self.needs_review_queue):
+            print(f"❌ 样本 {index} 已拒绝")
+            self.needs_review_queue.pop(index)
+
+
+# 全局实例
+auto_eval_service: Optional[AutoEvaluationService] = None
+
+
+def init_auto_evaluation_service(
+    eval_engine: EvaluationEngine,
+    data_router: DataRoutingEngine,
+    config: EvaluationConfig = None
+) -> AutoEvaluationService:
+    """初始化自动评估服务"""
+    global auto_eval_service
+    auto_eval_service = AutoEvaluationService(
+        eval_engine=eval_engine,
+        data_router=data_router,
+        config=config
+    )
+    return auto_eval_service
+
+
+def get_auto_evaluation_service() -> Optional[AutoEvaluationService]:
+    """获取自动评估服务实例"""
+    return auto_eval_service

app/services/chat_service.py

@@ -0,0 +1,601 @@
+# 文件路径: app/services/chat_service.py
+import json
+import asyncio
+import re
+import time
+from dataclasses import dataclass, field
+from typing import Dict, Optional, AsyncGenerator, List, Set
+from app.core.config import settings
+from app.utils.llm_client import client
+from app.services.vector_service import store_manager
+from app.services.github_service import get_file_content
+from app.services.chunking_service import UniversalChunker, ChunkingConfig
+from app.services.tracing_service import tracing_service
+from app.utils.session import get_conversation_memory, ConversationMemory
+
+
+# ============================================================
+# 配置类 - 解耦所有可调参数
+# ============================================================
+
+@dataclass
+class ChatConfig:
+    """Chat 服务配置 - 集中管理所有参数"""
+    # JIT 动态加载配置
+    max_jit_rounds: int = 2           # 最大 JIT 轮数
+    max_files_per_round: int = 3      # 每轮最多加载文件数
+    
+    # LLM 配置
+    temperature_thinking: float = 0.1  # 思考阶段温度
+    temperature_final: float = 0.2     # 最终回答温度
+    max_tokens: int = 4096             # 最大 token 数
+    
+    # 检索配置
+    retrieval_top_k: int = 6          # RAG 检索 top-k
+    context_max_chars: int = 2000     # 单文档最大字符数
+    
+    # 对话上下文配置
+    max_history_turns: int = 6        # 保留最近 N 轮对话
+    summary_threshold: int = 10       # 超过 N 轮开始压缩
+    
+    # 调试配置
+    show_debug_info: bool = False     # 是否显示调试信息
+
+
+# 全局配置实例
+chat_config = ChatConfig()
+
+
+@dataclass
+class ChatResult:
+    """聊天结果 - 用于后续自动评估"""
+    answer: str                    # 最终回答
+    retrieved_context: str        # 检索到的上下文
+    generation_latency_ms: float  # 生成耗时
+    retrieval_latency_ms: float = 0  # 检索耗时
+
+
+# === 评估数据存储 (供 main.py 获取) ===
+# 存储每个 session 的评估数据，key 为 session_id
+_eval_data_store: Dict[str, ChatResult] = {}
+
+def get_eval_data(session_id: str) -> Optional[ChatResult]:
+    """获取指定 session 的评估数据"""
+    return _eval_data_store.get(session_id)
+
+def clear_eval_data(session_id: str) -> None:
+    """清除指定 session 的评估数据"""
+    if session_id in _eval_data_store:
+        del _eval_data_store[session_id]
+
+
+# [Fix 2] 使用 Config 对象初始化，而非直接传参
+# 之前的写法: chunker = UniversalChunker(min_chunk_size=100)
+# 现在的写法:
+chunker = UniversalChunker(config=ChunkingConfig(min_chunk_size=100))
+
+# === 新增：简单的中文检测 ===
+def is_chinese_query(text: str) -> bool:
+    """检测字符串中是否包含中文字符"""
+    for char in text:
+        if '\u4e00' <= char <= '\u9fff':
+            return True
+    return False
+
+# === 优化 2：查询重写 (解决中英文检索不匹配问题) ===
+async def _rewrite_query(user_query: str):
+    """
+    使用 LLM 将用户的自然语言（可能是中文）转换为 3-5 个代码搜索关键词（英文）。
+    """
+    prompt = f"""
+    You are a Code Search Expert.
+    Task: Convert the user's query into 3-5 English keywords for code search (BM25/Vector).
+    
+    User Query: "{user_query}"
+    
+    Rules:
+    1. Output ONLY a JSON list of strings.
+    2. Translate concepts to technical terms (e.g., "鉴权" -> "auth", "login", "middleware").
+    3. Keep it short.
+    
+    Example Output: ["authentication", "login_handler", "jwt_verify"]
+    """
+    try:
+        response = await client.chat.completions.create(
+            model=settings.default_model_name,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=100
+        )
+        content = response.choices[0].message.content
+        # 简单清洗
+        content = re.sub(r"^```(json)?|```$", "", content.strip(), flags=re.MULTILINE).strip()
+        keywords = json.loads(content)
+        if isinstance(keywords, list):
+            return " ".join(keywords) # 返回空格分隔的字符串供 BM25 使用
+        return user_query
+    except Exception as e:
+        print(f"⚠️ Query Rewrite Failed: {e}")
+        return user_query # 降级：直接用原句
+
+async def process_chat_stream(user_query: str, session_id: str):
+    """
+    处理聊天流 - 支持多轮 JIT 动态加载文件 + 对话上下文记忆
+    
+    流程:
+    1. 获取对话记忆，构建上下文
+    2. 初始检索 RAG 上下文
+    3. LLM 思考并回答，可能请求文件
+    4. 如果请求文件，加载后继续对话 (最多 max_jit_rounds 轮)
+    5. 最终生成答案并保存到对话记忆
+    """
+    vector_db = store_manager.get_store(session_id)
+    cfg = chat_config  # 使用全局配置
+    
+    # === 获取对话记忆 ===
+    memory = get_conversation_memory(session_id)
+    memory.add_user_message(user_query)  # 立即记录用户消息
+    
+    # 检查是否需要摘要压缩
+    if memory.needs_summarization():
+        yield "> 📝 *Compressing conversation history...*\n\n"
+        await _compress_conversation_history(memory)
+    
+    # === 评估数据收集变量 ===
+    collected_context = ""
+    collected_response = ""
+    collected_retrieval_latency = 0.0
+    collected_generation_latency = 0.0
+    
+    # === JIT 状态跟踪 ===
+    all_loaded_files: Set[str] = set()      # 所有已加载的文件
+    all_failed_files: Set[str] = set()      # 所有失败的文件
+    jit_round = 0                            # 当前 JIT 轮数
+    
+    # === 语言环境检测 ===
+    use_chinese = is_chinese_query(user_query)
+    
+    # UI 提示语
+    ui_msgs = _get_ui_messages(use_chinese)
+
+    # === 步骤 0: 查询重写 ===
+    search_query = await _rewrite_query(user_query)
+    yield f"{ui_msgs['thinking']}`{search_query}`...\n\n"
+    
+    # === 步骤 1: 初始 RAG 检索 ===
+    retrieval_start = time.time()
+    relevant_docs = await vector_db.search_hybrid(search_query, top_k=cfg.retrieval_top_k)
+    retrieval_latency_ms = (time.time() - retrieval_start) * 1000
+    collected_retrieval_latency = retrieval_latency_ms
+    tracing_service.add_event("retrieval_completed", {
+        "latency_ms": retrieval_latency_ms,
+        "documents_retrieved": len(relevant_docs) if relevant_docs else 0
+    })
+    
+    rag_context = _build_context(relevant_docs, cfg.context_max_chars)
+    collected_context = rag_context
+    
+    # === 步骤 2: 构建初始 Prompt ===
+    global_context = vector_db.global_context or {}
+    file_tree = global_context.get("file_tree", "(File tree not available.)")
+    agent_summary = global_context.get("summary", "")
+    
+    # 获取对话历史上下文
+    conversation_context = _build_conversation_context(memory)
+    
+    system_instruction = _build_system_prompt(
+        file_tree=file_tree,
+        agent_summary=agent_summary,
+        rag_context=rag_context,
+        use_chinese=use_chinese,
+        is_final_round=False,
+        conversation_context=conversation_context
+    )
+    
+    augmented_user_query = f"""
+    {user_query}
+    
+    (System Note: Priority 1: Answer using context. Priority 2: Use <tool_code> ONLY if critical info is missing.)
+    """
+    
+    if not client: 
+        yield "❌ LLM Error: Client not initialized"
+        return
+
+    # 初始化对话历史
+    messages = [
+        {"role": "system", "content": system_instruction},
+        {"role": "user", "content": augmented_user_query}
+    ]
+
+    try:
+        generation_start = time.time()
+        
+        # === 多轮 JIT 循环 ===
+        while jit_round <= cfg.max_jit_rounds:
+            is_final_round = (jit_round == cfg.max_jit_rounds)
+            
+            # 如果是最终轮，更新系统提示禁用工具
+            if is_final_round and jit_round > 0:
+                # 更新系统消息，告知这是最后一轮
+                messages[0] = {"role": "system", "content": _build_system_prompt(
+                    file_tree=file_tree,
+                    agent_summary=agent_summary,
+                    rag_context=collected_context,
+                    use_chinese=use_chinese,
+                    is_final_round=True,
+                    failed_files=list(all_failed_files)
+                )}
+            
+            # LLM 流式生成
+            stream = await client.chat.completions.create(
+                model=settings.default_model_name,
+                messages=messages,
+                stream=True,
+                temperature=cfg.temperature_final if is_final_round else cfg.temperature_thinking,
+                max_tokens=cfg.max_tokens
+            )
+            
+            buffer = ""
+            round_response = ""
+            requested_files: Set[str] = set()
+            
+            async for chunk in stream:
+                content = chunk.choices[0].delta.content or ""
+                if not content:
+                    continue
+                
+                buffer += content
+                round_response += content
+                collected_response += content
+                
+                # 检测 tool_code 标签
+                if "</tool_code>" in buffer:
+                    matches = re.findall(r"<tool_code>\s*(.*?)\s*</tool_code>", buffer, re.DOTALL)
+                    for f in matches:
+                        clean_f = f.strip().replace("'", "").replace('"', "").replace("`", "")
+                        # 过滤已加载和已失败的文件
+                        if clean_f and clean_f not in all_loaded_files and clean_f not in all_failed_files:
+                            requested_files.add(clean_f)
+                    yield content
+                    buffer = ""
+                else:
+                    yield content
+            
+            # 处理缓冲区残留
+            if "</tool_code>" in buffer:
+                matches = re.findall(r"<tool_code>\s*(.*?)\s*</tool_code>", buffer, re.DOTALL)
+                for f in matches:
+                    clean_f = f.strip().replace("'", "").replace('"', "").replace("`", "")
+                    if clean_f and clean_f not in all_loaded_files and clean_f not in all_failed_files:
+                        requested_files.add(clean_f)
+            
+            # === 判断是否需要继续 JIT ===
+            if not requested_files or is_final_round:
+                # 没有新文件请求，或已达最大轮数，结束循环
+                break
+            
+            # === JIT 文件加载 ===
+            jit_round += 1
+            
+            # 限制每轮文件数
+            files_to_load = list(requested_files)[:cfg.max_files_per_round]
+            file_list_str = ", ".join([f"`{f}`" for f in files_to_load])
+            
+            yield f"\n\n> 🔍 **[JIT Round {jit_round}/{cfg.max_jit_rounds}]** {ui_msgs['action_short']}{file_list_str}...\n\n"
+            
+            if not vector_db.repo_url:
+                yield ui_msgs['error_url']
+                break
+            
+            # 加载文件
+            round_loaded_docs = []
+            round_failed_files = []
+            
+            for file_path in files_to_load:
+                if file_path in vector_db.indexed_files:
+                    docs = vector_db.get_documents_by_file(file_path)
+                    round_loaded_docs.extend(docs)
+                    all_loaded_files.add(file_path)
+                    yield f"> ✅ Loaded: `{file_path}`\n"
+                else:
+                    success = await _download_and_index(vector_db, file_path)
+                    if success:
+                        docs = vector_db.get_documents_by_file(file_path)
+                        round_loaded_docs.extend(docs)
+                        all_loaded_files.add(file_path)
+                        yield f"> ✅ Downloaded: `{file_path}`\n"
+                    else:
+                        round_failed_files.append(file_path)
+                        all_failed_files.add(file_path)
+                        yield f"> ⚠️ Failed: `{file_path}`\n"
+            
+            # 构建后续消息
+            if round_loaded_docs:
+                new_context = _build_context(round_loaded_docs, cfg.context_max_chars)
+                collected_context += f"\n\n[JIT Round {jit_round} Context]\n{new_context}"
+            
+            # 构建状态消息
+            status_msg = _build_jit_status_message(
+                loaded_count=len(round_loaded_docs),
+                failed_files=round_failed_files,
+                remaining_rounds=cfg.max_jit_rounds - jit_round,
+                use_chinese=use_chinese
+            )
+            
+            context_section = f"\n\n[New Code Context]\n{_build_context(round_loaded_docs, cfg.context_max_chars)}" if round_loaded_docs else ""
+            
+            # 更新对话历史，继续对话
+            messages.append({"role": "assistant", "content": round_response})
+            messages.append({"role": "user", "content": f"{status_msg}{context_section}\n\nPlease continue your analysis."})
+            
+            yield "\n\n"  # 分隔符
+        
+        # === 生成完成 ===
+        generation_latency_ms = (time.time() - generation_start) * 1000
+        collected_generation_latency = generation_latency_ms
+        
+        tracing_service.add_event("generation_completed", {
+            "latency_ms": generation_latency_ms,
+            "jit_rounds": jit_round,
+            "files_loaded": len(all_loaded_files),
+            "files_failed": len(all_failed_files)
+        })
+        
+        # === 保存助手回复到对话记忆 ===
+        memory.add_assistant_message(collected_response)
+        
+        # 存储评估数据
+        _eval_data_store[session_id] = ChatResult(
+            answer=collected_response,
+            retrieved_context=collected_context,
+            generation_latency_ms=collected_generation_latency,
+            retrieval_latency_ms=collected_retrieval_latency
+        )
+        print(f"📦 [EvalData] Session {session_id}: {len(collected_context)} chars context, {len(collected_response)} chars answer, {jit_round} JIT rounds, {memory.get_turn_count()} turns")
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        error_msg = str(e)
+        # 即使出错也保存部分回复
+        if collected_response:
+            memory.add_assistant_message(collected_response + f"\n\n[Error: {error_msg}]")
+        tracing_service.add_event("generation_error", {
+            "error": error_msg,
+            "error_type": type(e).__name__,
+            "jit_round": jit_round
+        })
+        yield f"\n\n❌ System Error: {error_msg}"
+
+
+# ============================================================
+# 辅助函数
+# ============================================================
+
+def _get_ui_messages(use_chinese: bool) -> Dict[str, str]:
+    """获取 UI 消息（根据语言）"""
+    if use_chinese:
+        return {
+            "thinking": "> 🧠 **思考中:** 正在检索相关代码: ",
+            "action_short": "正在读取文件: ",
+            "error_url": "> ⚠️ 错误: 仓库链接丢失。\n",
+        }
+    else:
+        return {
+            "thinking": "> 🧠 **Thinking:** Searching for code related to: ",
+            "action_short": "Retrieving files: ",
+            "error_url": "> ⚠️ Error: Repository URL lost.\n",
+        }
+
+
+def _build_system_prompt(
+    file_tree: str,
+    agent_summary: str,
+    rag_context: str,
+    use_chinese: bool,
+    is_final_round: bool,
+    failed_files: List[str] = None,
+    conversation_context: str = ""
+) -> str:
+    """构建系统提示词"""
+    lang_instruction = (
+        "IMPORTANT: The user is asking in Chinese. You MUST reply in Simplified Chinese (简体中文)."
+        if use_chinese else "Reply in English."
+    )
+    
+    if is_final_round:
+        tool_instruction = """
+    [INSTRUCTIONS - FINAL ROUND]
+    This is your FINAL response. You MUST provide a complete answer NOW.
+    - DO NOT request any more files
+    - DO NOT use <tool_code> tags
+    - Synthesize all available context and give your best answer
+    - If some files were not accessible, explain what information is missing and provide the best possible answer with what you have
+    """
+        if failed_files:
+            tool_instruction += f"\n    Note: The following files could not be accessed: {', '.join(failed_files)}"
+    else:
+        tool_instruction = """
+    [INSTRUCTIONS]
+    1. **CHECK CONTEXT FIRST**: Look at the [Current Code Context]. Does it contain the answer?
+    2. **IF YES**: Answer directly. DO NOT use tools.
+    3. **IF NO**: Request missing files using tags: <tool_code>path/to/file</tool_code>
+    """
+    
+    # 添加对话历史上下文
+    conversation_section = ""
+    if conversation_context:
+        conversation_section = f"""
+    [Previous Conversation]
+    {conversation_context}
+    """
+    
+    return f"""
+    You are a Senior GitHub Repository Analyst.
+    {lang_instruction}
+    
+    [Global Context - Repo Map]
+    {file_tree}
+    
+    [Agent Analysis Summary]
+    {agent_summary}
+    {conversation_section}
+    [Current Code Context (Retrieved)]
+    {rag_context}
+    {tool_instruction}
+    """
+
+
+def _build_conversation_context(memory: ConversationMemory) -> str:
+    """
+    构建对话历史上下文字符串
+    
+    只包含最近几轮对话的摘要，用于 system prompt
+    """
+    messages = memory.get_context_messages()
+    
+    if len(messages) <= 2:
+        # 只有当前轮，不需要历史
+        return ""
+    
+    # 排除最后一条（当前用户消息）
+    history_messages = messages[:-1]
+    
+    if not history_messages:
+        return ""
+    
+    context_parts = []
+    for msg in history_messages[-6:]:  # 最多 6 条（3 轮）
+        role = "User" if msg["role"] == "user" else "Assistant"
+        # 截断过长的内容
+        content = msg["content"][:500]
+        if len(msg["content"]) > 500:
+            content += "..."
+        context_parts.append(f"{role}: {content}")
+    
+    return "\n".join(context_parts)
+
+
+async def _compress_conversation_history(memory: ConversationMemory) -> None:
+    """
+    压缩对话历史 - 使用 LLM 生成摘要
+    """
+    messages_to_summarize = memory.get_messages_to_summarize()
+    
+    if not messages_to_summarize:
+        return
+    
+    # 构建摘要请求
+    conversation_text = "\n".join([
+        f"{'User' if m['role'] == 'user' else 'Assistant'}: {m['content'][:300]}"
+        for m in messages_to_summarize
+    ])
+    
+    prompt = f"""Summarize the following conversation in 2-3 sentences, focusing on:
+1. What questions were asked
+2. Key information discovered
+3. Important conclusions
+
+Conversation:
+{conversation_text}
+
+Summary (be concise):"""
+
+    try:
+        response = await client.chat.completions.create(
+            model=settings.default_model_name,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.3,
+            max_tokens=200
+        )
+        summary = response.choices[0].message.content.strip()
+        
+        # 保存摘要
+        end_idx = len(memory._messages) - chat_config.max_history_turns * 2
+        memory.set_summary(summary, end_idx)
+        
+        print(f"📝 Conversation compressed: {len(messages_to_summarize)} messages -> summary")
+    except Exception as e:
+        print(f"⚠️ Failed to compress conversation: {e}")
+
+
+def _build_jit_status_message(
+    loaded_count: int,
+    failed_files: List[str],
+    remaining_rounds: int,
+    use_chinese: bool
+) -> str:
+    """构建 JIT 状态消息"""
+    if use_chinese:
+        if loaded_count > 0 and not failed_files:
+            return f"系统通知: 成功加载 {loaded_count} 个文件。"
+        elif loaded_count > 0 and failed_files:
+            failed_list = ", ".join(failed_files)
+            return f"系统通知: 加载了 {loaded_count} 个文件，但以下文件无法访问: {failed_list}。"
+        else:
+            failed_list = ", ".join(failed_files)
+            if remaining_rounds > 0:
+                return f"系统通知: 文件 ({failed_list}) 无法访问。你还有 {remaining_rounds} 次机会请求其他文件，或者基于现有上下文回答。"
+            else:
+                return f"系统通知: 文件 ({failed_list}) 无法访问。请基于现有上下文给出最佳回答。"
+    else:
+        if loaded_count > 0 and not failed_files:
+            return f"System Notification: Successfully loaded {loaded_count} files."
+        elif loaded_count > 0 and failed_files:
+            failed_list = ", ".join(failed_files)
+            return f"System Notification: Loaded {loaded_count} files, but the following could not be accessed: {failed_list}."
+        else:
+            failed_list = ", ".join(failed_files)
+            if remaining_rounds > 0:
+                return f"System Notification: Files ({failed_list}) could not be accessed. You have {remaining_rounds} more attempts to request other files, or answer based on available context."
+            else:
+                return f"System Notification: Files ({failed_list}) could not be accessed. Please provide the best possible answer based on existing context."
+
+async def _download_and_index(vector_db, file_path):
+    """下载并索引文件"""
+    try:
+        content = await get_file_content(vector_db.repo_url, file_path)
+        if not content: return False
+        
+        chunks = await asyncio.to_thread(chunker.chunk_file, content, file_path)
+        if not chunks: 
+            chunks = [{
+                "content": content,
+                "metadata": {"file": file_path, "type": "text", "name": "root", "class": ""}
+            }]
+            
+        documents = [c["content"] for c in chunks]
+        metadatas = []
+        for c in chunks:
+            meta = c["metadata"]
+            metadatas.append({
+                "file": meta["file"],
+                "type": meta["type"],
+                "name": meta.get("name", ""),
+                "class": meta.get("class") or ""
+            })
+        await vector_db.add_documents(documents, metadatas)
+        return True
+    except Exception as e:
+        print(f"Download Error: {e}")
+        return False
+
+
+def _build_context(docs: List[Dict], max_chars: int = 2000) -> str:
+    """构建上下文字符串"""
+    if not docs:
+        return "(No relevant code snippets found yet)"
+    
+    context = ""
+    for doc in docs:
+        file_info = doc.get('file', 'unknown')
+        metadata = doc.get('metadata', {})
+        
+        if 'class' in metadata and metadata['class']:
+            file_info += f" (Class: {metadata['class']})"
+        
+        content = doc.get('content', '')[:max_chars]
+        context += f"\n--- File: {file_info} ---\n{content}\n"
+    
+    return context

app/services/chunking_service.py

@@ -0,0 +1,372 @@
+import ast
+import re
+import os
+from dataclasses import dataclass
+
+# --- 配置类 ---
+@dataclass
+class ChunkingConfig:
+    """
+    统一管理切分服务的配置参数
+    """
+    min_chunk_size: int = 50          # 最小分块阈值 (chars)
+    max_chunk_size: int = 2000        # 最大分块阈值 (chars)
+    fallback_line_size: int = 100     # 兜底策略的行数 (lines)
+    max_context_chars: int = 500      # 允许注入到每个Chunk的上下文最大长度
+                                      # 超过此长度则不再注入，避免冗余内容撑爆 Token
+
+class UniversalChunker:
+    def __init__(self, config: ChunkingConfig = None):
+        # 如果未传入配置，使用默认配置
+        self.config = config if config else ChunkingConfig()
+
+    def chunk_file(self, content: str, file_path: str):
+        if not content:
+            return []
+        
+        ext = os.path.splitext(file_path)[1].lower()
+        
+        if ext == '.py':
+            return self._chunk_python(content, file_path)
+        
+        # 2. C-Style 语言优化
+        elif ext in ['.java', '.js', '.ts', '.jsx', '.tsx', '.go', '.cpp', '.c', '.h', '.cs', '.php', '.rs']:
+            return self._chunk_c_style(content, file_path)
+        
+        else:
+            return self._fallback_chunking(content, file_path)
+
+    def _chunk_python(self, content, file_path):
+        """
+        分级注入策略
+        """
+        chunks = []
+        try:
+            tree = ast.parse(content)
+        except SyntaxError:
+            return self._fallback_chunking(content, file_path)
+
+        import_nodes = []
+        other_nodes = []
+        function_class_chunks = []
+
+        # A. 遍历与分类
+        for node in tree.body:
+            if isinstance(node, ast.ClassDef):
+                class_code = ast.get_source_segment(content, node)
+                if not class_code: continue
+                if len(class_code) <= self.config.max_chunk_size:
+                    function_class_chunks.append(self._create_chunk(
+                        class_code, file_path, "class", node.name, node.lineno, node.name
+                    ))
+                else:
+                    # function_class_chunks 包含了从大类中拆分出的方法
+                    function_class_chunks.extend(
+                        self._chunk_large_python_class(node, content, file_path)
+                    )
+
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                func_code = ast.get_source_segment(content, node)
+                if func_code and len(func_code) >= self.config.min_chunk_size:
+                    function_class_chunks.append(self._create_chunk(
+                        func_code, file_path, "function", node.name, node.lineno
+                    ))
+
+            else:
+                segment = ast.get_source_segment(content, node)
+                if segment and len(segment.strip()) > 0:
+                    if isinstance(node, (ast.Import, ast.ImportFrom)):
+                        import_nodes.append(segment)
+                    else:
+                        other_nodes.append(segment)
+
+        # B. 决策准备
+        has_core_code = len(function_class_chunks) > 0
+        others_text = "\n".join(other_nodes).strip()
+        should_inject_others = len(others_text) <= self.config.max_context_chars
+
+        # C. 构建 Context Header
+        context_parts = []
+        # 1. Import 永远注入
+        if import_nodes:
+            context_parts.append("\n".join(import_nodes))
+        # 2. Globals 按需注入
+        if others_text and should_inject_others:
+            context_parts.append(others_text)
+
+        full_header = "\n".join(context_parts).strip()
+        if full_header:
+            full_header = f"# --- Context ---\n{full_header}\n# ---------------\n"
+
+        # D. 注入 Header 到核心 Chunk (函数/类)
+        # 此时 function_class_chunks 已经包含了大类拆分出来的方法
+        # 这里的循环会给它们都加上 Import/Global Context
+        for chunk in function_class_chunks:
+            chunk["content"] = full_header + chunk["content"]
+
+        # E. 处理溢出 (仅当有核心代码时，才独立存储溢出的 Globals)
+        if has_core_code and others_text and not should_inject_others:
+             chunks.append(self._create_chunk(
+                others_text, file_path, "global_context", "globals", 1
+            ))
+            
+        # F. 纯脚本兜底
+        if not has_core_code:
+             # 这是一个纯脚本文件 (只有 Import 和 顶层逻辑)
+             full_script = (("\n".join(import_nodes) + "\n") if import_nodes else "") + others_text
+             if full_script.strip():
+                 # 如果脚本太长，不要硬切成一个大块，而是走 Fallback 按行切分
+                 if len(full_script) > self.config.max_chunk_size * 1.5: # 1.5倍宽容度
+                     return self._fallback_chunking(content, file_path)
+                 else:
+                     chunks.append(self._create_chunk(
+                        full_script, file_path, "script", "main", 1
+                    ))
+
+        chunks.extend(function_class_chunks)
+        
+        if not chunks and len(content.strip()) > 0:
+             return self._fallback_chunking(content, file_path)
+             
+        return chunks
+
+    def _chunk_large_python_class(self, class_node, content, file_path):
+        chunks = []
+        class_name = class_node.name
+        docstring = ast.get_docstring(class_node) or ""
+        
+        # === 尝试收集类级别的变量定义 ===
+        class_vars = []
+        for node in class_node.body:
+            # 如果是赋值语句，且在方法定义之前 (通常 AST 是有序的)
+            if isinstance(node, (ast.Assign, ast.AnnAssign)):
+                seg = ast.get_source_segment(content, node)
+                if seg: class_vars.append(seg)
+            # 一旦遇到函数，就停止收集变量，避免把乱七八糟的逻辑也收进去
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                break
+        
+        vars_text = "\n    ".join(class_vars) 
+        if vars_text:
+            vars_text = "\n    " + vars_text # 缩进对齐
+
+        # 将变量拼接到 Header 中
+        context_header = f"class {class_name}:{vars_text}\n    \"\"\"{docstring}\"\"\"\n    # ... (Parent Context)\n"
+
+        for node in class_node.body:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                method_code = ast.get_source_segment(content, node)
+                if not method_code: continue
+                
+                full_chunk_content = context_header + "\n" + method_code
+                chunks.append(self._create_chunk(
+                    full_chunk_content, file_path, "method", node.name, node.lineno, class_name
+                ))
+        return chunks
+
+    def _chunk_c_style(self, content, file_path):
+        """
+        解决宏干扰、全局变量丢失、跨行函数头问题
+        """
+        chunks = []
+        if not content: return []
+
+        # === 1. 定义正则 Token ===
+        # 使用 Named Groups 避免 startswith 的模糊匹配
+        # 顺序至关重要：长匹配优先
+        token_pattern = re.compile(
+            r'(?P<BLOCK_COMMENT>/\*.*?\*/)|'       # 块注释
+            r'(?P<LINE_COMMENT>//[^\n]*)|'         # 行注释
+            r'(?P<STRING>"(?:\\.|[^"\\])*")|'      # 双引号字符串
+            r'(?P<CHAR>\'(?:\\.|[^\'\\])*\')|'     # 单引号字符
+            r'(?P<TEMPLATE>`(?:\\.|[^`\\])*`)|'    # 反引号模板 (JS/Go)
+            r'(?P<MACRO>^\s*#.*(?:\\\n.*)*)|'      # 宏定义 (支持跨行)
+            r'(?P<BRACE_OPEN>\{)|'                 # 开括号
+            r'(?P<BRACE_CLOSE>\})|'                # 闭括号
+            r'(?P<SEMICOLON>;)',                   # 分号 (用于分割全局变量和函数头)
+            re.DOTALL | re.MULTILINE
+        )
+
+        # 全局上下文收集器
+        global_context_parts = []
+        
+        last_index = 0  # 上一个 Token 结束位置
+        block_start_index = 0 # 当前 Block (函数/类) 的签名开始位置
+        
+        brace_balance = 0
+        in_structural_block = False # 是否在最外层的类/函数块内
+        
+        # 暂存当前块的前置文本 (从上一个块结束 到 当前块开始)
+        # 这段文本里可能混杂着：全局变量、Import、以及当前函数的签名
+        pending_pre_text_start = 0
+
+        # 扫描
+        for match in token_pattern.finditer(content):
+            kind = match.lastgroup
+            start, end = match.span()
+            
+            # 跳过非结构化 Token (注释、字符串、宏)
+            if kind in ('BLOCK_COMMENT', 'LINE_COMMENT', 'STRING', 'CHAR', 'TEMPLATE', 'MACRO'):
+                continue
+            
+            # 忽略括号 () 和 []，只认 {}。
+            # C-style 语言只有 {} 定义 Scope Body。忽略 () [] 是为了防止 if(a[i]){...} 误判。
+            # 只要 regex 不匹配 () []，它们就被视为普通文本，不会影响 brace_balance。
+            if kind == 'BRACE_OPEN':
+                if brace_balance == 0:
+                    # === 发现一个新的顶层 Block ===
+                    in_structural_block = True
+                    
+                    # 1. 分析 "空隙文本" (从上一个块结束 到 这个 { 之前)
+                    gap_text = content[pending_pre_text_start:start]
+                    
+                    # [策略] 拆分 Global Context 和 Signature
+                    # 寻找最后一个分号 ';' 或 '}' (在 gap_text 内部的逻辑结束点)
+                    # 倒序查找比较安全。
+                    # 如果找不到，说明整段 gap 都是签名 (e.g. void foo() {)
+                    # 如果找到，分号前是 Global，分号后是 Signature
+                    split_idx = gap_text.rfind(';')
+                    if split_idx != -1:
+                        # 分号前：归入全局上下文
+                        global_part = gap_text[:split_idx+1].strip()
+                        if global_part:
+                            global_context_parts.append(global_part)
+                        # 分号后：是当前函数的签名
+                        # 自动处理了跨行函数头，因为 gap_text 包含换行
+                        block_signature_start = pending_pre_text_start + split_idx + 1
+                    else:
+                        # 没有分号，假设全是签名 (e.g. 紧接着上一个块，或者是文件开头)
+                        # 但要小心 include/import 等没有分号的语句 (Python 思维在 C 里不适用，C 几乎都有分号)
+                        # Go 语言除外 (Go 没分号)。这里做一个简单的 heuristic:
+                        # 如果是 Go/JS/TS，可能没有分号。暂且全部视为 Signature，
+                        # 除非它看起来像 import。
+                        # 这是一个 trade-off。
+                        block_signature_start = pending_pre_text_start
+
+                    # 记录当前 Block 真正的“视觉开始点” (包含签名)
+                    block_start_index = block_signature_start
+
+                brace_balance += 1
+
+            elif kind == 'BRACE_CLOSE':
+                brace_balance -= 1
+                
+                if brace_balance == 0 and in_structural_block:
+                    # === 顶层 Block 结束 ===
+                    in_structural_block = False
+                    
+                    # 提取完整代码块 (Signature + Body)
+                    # 范围：block_start_index -> end
+                    full_block_text = content[block_start_index:end]
+                    
+                    # 小块合并策略
+                    # 如果块太小 (e.g. Getter/Setter)，暂不生成 Chunk
+                    # 架构决策：为了代码完整性，工业界 RAG 通常不建议丢弃小块，
+                    # 尤其是 Getter/Setter 可能包含关键字段名。
+                    # 这里我们生成 Chunk，但后续入库时可以由 Embedding 模型决定权重。
+                    
+                    # 提取元数据
+                    meta = self._extract_c_style_metadata(full_block_text)
+                    start_line = content.count('\n', 0, block_start_index) + 1
+                    
+                    chunks.append(self._create_chunk(
+                        full_block_text, # 暂时不加 Global Header，最后统一加
+                        file_path, meta["type"], meta["name"], start_line
+                    ))
+                    
+                    # 更新游标：下一个块的前置文本从这里开始
+                    pending_pre_text_start = end
+
+        # === 循环结束后的收尾 ===
+        # 处理文件末尾的剩余文本 (Tail)
+        tail_text = content[pending_pre_text_start:].strip()
+        if tail_text:
+            global_context_parts.append(tail_text)
+
+        # === Global Context 重排序 ===
+        # 目标顺序: Includes > Macros (#define) > Others (Typedefs/Vars)
+        # 简单策略：基于字符串内容的优先级排序
+        
+        def context_priority(text):
+            text = text.strip()
+            if text.startswith("#include") or text.startswith("import") or text.startswith("using"):
+                return 0 # 最高优先级
+            if text.startswith("#define") or text.startswith("#macro"):
+                return 1 # 宏定义
+            if text.startswith("typedef") or text.startswith("enum") or text.startswith("struct"):
+                return 2 # 类型定义
+            return 3 # 普通全局变量和其他
+
+        # 稳定排序
+        global_context_parts.sort(key=context_priority)
+
+        # === 组装与注入 ===
+        full_global_context = "\n".join(global_context_parts).strip()
+        
+        should_inject = len(full_global_context) <= self.config.max_context_chars
+        
+        context_header = ""
+        if full_global_context and should_inject:
+            context_header = f"/* --- Global Context --- */\n{full_global_context}\n/* ---------------------- */\n"
+        
+        for chunk in chunks:
+            chunk["content"] = context_header + chunk["content"]
+            
+        if (full_global_context and not should_inject) or (not chunks and full_global_context):
+            chunks.insert(0, self._create_chunk(
+                full_global_context, file_path, "global_context", "header", 1
+            ))
+
+        if not chunks:
+            return self._fallback_chunking(content, file_path)
+            
+        return chunks
+
+    def _extract_c_style_metadata(self, code_block):
+        """
+        从包含签名的代码块中提取元数据 (支持多行签名)
+        """
+        # 截取到第一个 { 为止
+        header_part = code_block.split('{')[0]
+        # 压缩多余空白，变成单行以便正则匹配
+        header_clean = " ".join(header_part.split())
+        
+        # 1. Class/Struct/Interface
+        type_pattern = re.compile(r'\b(class|struct|interface|enum|record|type)\s+([a-zA-Z0-9_]+)')
+        match = type_pattern.search(header_clean)
+        if match:
+            return {"type": "class", "name": match.group(2)}
+            
+        # 2. Function
+        # 匹配: 单词 + (
+        # 排除关键字: if, for, while, switch, catch, return
+        func_pattern = re.compile(r'\b([a-zA-Z0-9_]+)\s*\(')
+        for match in func_pattern.finditer(header_clean):
+            name = match.group(1)
+            if name not in {'if', 'for', 'while', 'switch', 'catch', 'return', 'sizeof'}:
+                return {"type": "function", "name": name}
+
+        return {"type": "code_block", "name": "anonymous"}
+
+    def _fallback_chunking(self, content, file_path):
+        """兜底策略：使用 Config 中的行数设置"""
+        chunks = []
+        lines = content.split('\n')
+        chunk_size = self.config.fallback_line_size
+        
+        for i in range(0, len(lines), chunk_size):
+            chunk_content = "\n".join(lines[i:i+chunk_size])
+            chunks.append(self._create_chunk(chunk_content, file_path, "text_chunk", f"chunk_{i}", i+1))
+        return chunks
+
+    def _create_chunk(self, content, file_path, type_, name, start_line, class_name=""):
+        return {
+            "content": content,
+            "metadata": {
+                "file": file_path,
+                "type": type_,
+                "name": name,
+                "start_line": start_line,
+                "class": class_name
+            }
+        }

app/services/github_service.py

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+"""
+GitHub 服务层
+
+职责:
+- 提供业务级别的 GitHub 操作
+- 封装底层客户端，提供简洁 API
+- 保持向后兼容的函数签名
+"""
+
+import logging
+from typing import List, Optional, Dict
+
+from app.utils.github_client import (
+    GitHubClient,
+    GitHubRepo,
+    GitHubFile,
+    FileFilter,
+    GitHubError,
+    GitHubNotFoundError,
+    get_github_client,
+    parse_repo_url,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================
+# 服务类
+# ============================================================
+
+class GitHubService:
+    """
+    GitHub 服务
+    
+    提供高层业务操作，内部使用异步客户端。
+    
+    使用示例:
+    ```python
+    service = GitHubService()
+    
+    # 获取仓库文件列表
+    files = await service.get_repo_structure("https://github.com/owner/repo")
+    
+    # 获取文件内容
+    content = await service.get_file_content(
+        "https://github.com/owner/repo",
+        "src/main.py"
+    )
+    
+    # 批量获取文件
+    contents = await service.get_files_content(
+        "https://github.com/owner/repo",
+        ["README.md", "src/main.py", "requirements.txt"]
+    )
+    ```
+    """
+    
+    def __init__(self, client: Optional[GitHubClient] = None):
+        self._client = client
+    
+    @property
+    def client(self) -> GitHubClient:
+        """获取客户端 (延迟初始化)"""
+        if self._client is None:
+            self._client = get_github_client()
+        return self._client
+    
+    async def _get_repo_from_url(self, repo_url: str) -> GitHubRepo:
+        """从 URL 获取仓库对象"""
+        parsed = parse_repo_url(repo_url)
+        if not parsed:
+            raise ValueError(f"无效的 GitHub URL: {repo_url}")
+        
+        owner, name = parsed
+        return await self.client.get_repo(owner, name)
+    
+    async def get_repo_structure(
+        self,
+        repo_url: str,
+        file_filter: Optional[FileFilter] = None
+    ) -> List[str]:
+        """
+        获取仓库文件列表
+        
+        Args:
+            repo_url: GitHub 仓库 URL
+            file_filter: 自定义文件过滤器
+            
+        Returns:
+            文件路径列表
+        """
+        repo = await self._get_repo_from_url(repo_url)
+        files = await self.client.get_repo_tree(repo, file_filter)
+        return [f.path for f in files]
+    
+    async def get_file_content(
+        self,
+        repo_url: str,
+        file_path: str
+    ) -> Optional[str]:
+        """
+        获取单个文件内容
+        
+        Args:
+            repo_url: GitHub 仓库 URL
+            file_path: 文件路径
+            
+        Returns:
+            文件内容，失败返回 None
+        """
+        repo = await self._get_repo_from_url(repo_url)
+        return await self.client.get_file_content(repo, file_path)
+    
+    async def get_files_content(
+        self,
+        repo_url: str,
+        file_paths: List[str]
+    ) -> Dict[str, Optional[str]]:
+        """
+        批量获取文件内容 (并发)
+        
+        Args:
+            repo_url: GitHub 仓库 URL
+            file_paths: 文件路径列表
+            
+        Returns:
+            {path: content} 字典
+        """
+        repo = await self._get_repo_from_url(repo_url)
+        return await self.client.get_files_content(repo, file_paths, show_progress=True)
+    
+    async def get_repo_info(self, repo_url: str) -> GitHubRepo:
+        """
+        获取仓库基本信息
+        
+        Args:
+            repo_url: GitHub 仓库 URL
+            
+        Returns:
+            GitHubRepo 对象
+        """
+        return await self._get_repo_from_url(repo_url)
+
+
+# ============================================================
+# 全局服务实例
+# ============================================================
+
+_github_service: Optional[GitHubService] = None
+
+
+def get_github_service() -> GitHubService:
+    """获取 GitHub 服务单例"""
+    global _github_service
+    if _github_service is None:
+        _github_service = GitHubService()
+    return _github_service
+
+
+# ============================================================
+# 兼容旧接口 (同步风格的函数签名，但返回协程)
+# ============================================================
+
+# 保留 parse_repo_url 的旧签名兼容
+def parse_repo_url_compat(url: str) -> Optional[str]:
+    """
+    解析 GitHub URL (兼容旧接口)
+    
+    Returns:
+        "owner/repo" 字符串，无效返回 None
+    """
+    result = parse_repo_url(url)
+    if result:
+        return f"{result[0]}/{result[1]}"
+    return None
+
+
+async def get_repo_structure(repo_url: str) -> List[str]:
+    """
+    获取仓库文件列表 (兼容旧接口)
+    
+    注意: 这是一个异步函数，需要 await 调用
+    """
+    service = get_github_service()
+    return await service.get_repo_structure(repo_url)
+
+
+async def get_file_content(repo_url: str, file_path: str) -> Optional[str]:
+    """
+    获取文件内容 (兼容旧接口)
+    
+    注意: 这是一个异步函数，需要 await 调用
+    """
+    service = get_github_service()
+    return await service.get_file_content(repo_url, file_path)
+
+
+# 导出
+__all__ = [
+    "GitHubService",
+    "get_github_service",
+    "get_repo_structure",
+    "get_file_content",
+    "parse_repo_url_compat",
+    "GitHubError",
+    "GitHubNotFoundError",
+    "FileFilter",
+    "GitHubRepo",
+]

app/services/tracing_service.py

@@ -0,0 +1,549 @@
+# 文件路径: app/services/tracing_service.py
+"""
+Langfuse集成模块 - 用于端到端追踪和观测
+
+核心能力:
+1. 自动捕获每一步的延迟、Token成本、输入输出
+2. 记录完整的调用链路: Query -> Rewrite -> Retrieval -> Generation
+3. 记录Tool调用和参数
+4. 集成到评估流程
+
+Langfuse支持:
+- 本地部署 (docker run ... langfuse)
+- 云端托管 (app.langfuse.com)
+
+Author: Dexter
+Date: 2025-01-27
+"""
+
+import time
+import json
+import os
+from typing import Dict, Any, Optional, List, Callable
+from functools import wraps
+from datetime import datetime
+from dataclasses import dataclass
+
+
+# ============================================================================
+# 第一部分: Langfuse客户端初始化 (可选)
+# ============================================================================
+
+LANGFUSE_IMPORT_ERROR = None
+_LANGFUSE_ENABLED_ENV = os.getenv("LANGFUSE_ENABLED", "true").strip().lower()
+_LANGFUSE_ENABLED = _LANGFUSE_ENABLED_ENV not in {"0", "false", "no", "off"}
+
+if _LANGFUSE_ENABLED:
+    try:
+        from langfuse import Langfuse
+        from langfuse.decorators import observe, langfuse_context
+        LANGFUSE_AVAILABLE = True
+    except Exception as e:
+        LANGFUSE_IMPORT_ERROR = e
+        LANGFUSE_AVAILABLE = False
+else:
+    LANGFUSE_AVAILABLE = False
+
+
+@dataclass
+class TracingConfig:
+    """追踪配置"""
+    enabled: bool = True
+    backend: str = "langfuse"  # "langfuse" or "local"
+    langfuse_host: str = os.getenv("LANGFUSE_HOST", "http://localhost:3000")
+    langfuse_public_key: str = os.getenv("LANGFUSE_PUBLIC_KEY", "")
+    langfuse_secret_key: str = os.getenv("LANGFUSE_SECRET_KEY", "")
+    capture_token_usage: bool = True
+    capture_latency: bool = True
+    local_log_dir: str = "logs/traces"
+
+
+class TracingService:
+    """
+    统一的追踪服务
+    支持Langfuse和本地日志两种后端
+    """
+    
+    def __init__(self, config: TracingConfig = None):
+        self.config = config or TracingConfig()
+        self.langfuse_client = None
+        self.current_trace_id = None
+        
+        if self.config.enabled and self.config.backend == "langfuse":
+            if not LANGFUSE_AVAILABLE:
+                print("⚠️ Langfuse not installed. Install with: pip install langfuse. Falling back to local logging.")
+                self.config.backend = "local"
+            else:
+                try:
+                    self.langfuse_client = Langfuse(
+                        host=self.config.langfuse_host,
+                        public_key=self.config.langfuse_public_key,
+                        secret_key=self.config.langfuse_secret_key,
+                        enabled=True,
+                        debug=False
+                    )
+                    print("✅ Langfuse client initialized successfully")
+                except Exception as e:
+                    print(f"⚠️ Langfuse initialization failed: {e}. Falling back to local logging.")
+                    self.config.backend = "local"
+        
+        # 创建本地日志目录
+        os.makedirs(self.config.local_log_dir, exist_ok=True)
+    
+    def start_trace(self, trace_name: str, session_id: str, metadata: Dict = None) -> str:
+        """启动一个新的追踪链"""
+        import uuid
+        trace_id = str(uuid.uuid4())
+        self.current_trace_id = trace_id
+        
+        if self.langfuse_client:
+            self.langfuse_client.trace(
+                name=trace_name,
+                input=metadata or {},
+                session_id=session_id
+            )
+            print(f"📍 Trace started: {trace_id}")
+        else:
+            self._log_locally("trace_start", {
+                "trace_id": trace_id,
+                "name": trace_name,
+                "session_id": session_id,
+                "metadata": metadata,
+                "timestamp": datetime.now().isoformat()
+            })
+        
+        return trace_id
+    
+    def record_span(
+        self,
+        span_name: str,
+        operation: str,
+        input_data: Any,
+        output_data: Any,
+        latency_ms: float,
+        token_usage: Dict[str, int] = None,
+        metadata: Dict = None
+    ) -> None:
+        """记录一个操作的跨度"""
+        
+        span_record = {
+            "span_name": span_name,
+            "operation": operation,
+            "latency_ms": latency_ms,
+            "timestamp": datetime.now().isoformat(),
+            "token_usage": token_usage or {},
+            "metadata": metadata or {}
+        }
+        
+        if self.langfuse_client:
+            try:
+                # Langfuse:记录到云端
+                self.langfuse_client.span(
+                    name=span_name,
+                    input=input_data,
+                    output=output_data,
+                    metadata={
+                        "operation": operation,
+                        "latency_ms": latency_ms,
+                        **(token_usage or {}),
+                        **(metadata or {})
+                    }
+                )
+            except Exception as e:
+                print(f"⚠️ Failed to record span to Langfuse: {e}")
+        
+        # 本地日志
+        self._log_locally("span", span_record)
+    
+    def record_tool_call(
+        self,
+        tool_name: str,
+        parameters: Dict,
+        result: Any,
+        latency_ms: float,
+        success: bool,
+        error: str = None
+    ) -> None:
+        """记录工具调用"""
+        
+        tool_record = {
+            "tool_name": tool_name,
+            "parameters": parameters,
+            "result": str(result)[:500] if result else None,
+            "latency_ms": latency_ms,
+            "success": success,
+            "error": error,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        if self.langfuse_client:
+            try:
+                self.langfuse_client.event(
+                    name=f"tool_call:{tool_name}",
+                    input=parameters,
+                    output=result,
+                    metadata={
+                        "latency_ms": latency_ms,
+                        "success": success,
+                        "error": error
+                    }
+                )
+            except Exception as e:
+                print(f"⚠️ Failed to record tool call: {e}")
+        
+        self._log_locally("tool_call", tool_record)
+    
+    def record_retrieval_debug(
+        self,
+        query: str,
+        retrieved_files: List[str],
+        vector_scores: List[float],
+        bm25_scores: List[float],
+        latency_ms: float
+    ) -> None:
+        """记录检索过程的调试信息"""
+        
+        retrieval_record = {
+            "query": query,
+            "retrieved_count": len(retrieved_files),
+            "files": retrieved_files,
+            "vector_scores": vector_scores,
+            "bm25_scores": bm25_scores,
+            "latency_ms": latency_ms,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        if self.langfuse_client:
+            try:
+                self.langfuse_client.event(
+                    name="retrieval_debug",
+                    input={"query": query},
+                    output={"files": retrieved_files},
+                    metadata=retrieval_record
+                )
+            except Exception as e:
+                print(f"⚠️ Failed to record retrieval debug: {e}")
+        
+        self._log_locally("retrieval", retrieval_record)
+    
+    def record_llm_generation(
+        self,
+        model: str,
+        prompt_messages: List[Dict],
+        generated_text: str,
+        ttft_ms: float = None,
+        total_latency_ms: float = None,
+        prompt_tokens: int = None,
+        completion_tokens: int = None,
+        total_tokens: int = None,
+        is_streaming: bool = False,
+        metadata: Dict = None
+    ) -> None:
+        """
+        记录 LLM 生成的完整信息，包括 Token 消耗和 TTFT
+        
+        Args:
+            model: 模型名称 (如 "gpt-4", "claude-3")
+            prompt_messages: 发送给 LLM 的消息列表
+            generated_text: 生成的文本（可截断）
+            ttft_ms: Time To First Token，首 token 延迟（毫秒）
+            total_latency_ms: 总生成延迟（毫秒）
+            prompt_tokens: 输入 token 数
+            completion_tokens: 输出 token 数
+            total_tokens: 总 token 数
+            is_streaming: 是否流式输出
+            metadata: 额外元数据
+        """
+        llm_record = {
+            "model": model,
+            "is_streaming": is_streaming,
+            "prompt_preview": str(prompt_messages)[:500],  # 截断避免日志过大
+            "generated_preview": generated_text[:500] if generated_text else "",
+            "generated_length": len(generated_text) if generated_text else 0,
+            # Token 统计
+            "token_usage": {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens
+            },
+            # 延迟统计
+            "latency": {
+                "ttft_ms": ttft_ms,  # Time To First Token
+                "total_ms": total_latency_ms,
+                "tokens_per_second": round(completion_tokens / (total_latency_ms / 1000), 2) 
+                    if completion_tokens and total_latency_ms and total_latency_ms > 0 else None
+            },
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        }
+        
+        if self.langfuse_client:
+            try:
+                self.langfuse_client.generation(
+                    name="llm_generation",
+                    model=model,
+                    input=prompt_messages,
+                    output=generated_text[:1000] if generated_text else "",
+                    usage={
+                        "prompt_tokens": prompt_tokens or 0,
+                        "completion_tokens": completion_tokens or 0,
+                        "total_tokens": total_tokens or 0
+                    },
+                    metadata={
+                        "ttft_ms": ttft_ms,
+                        "total_latency_ms": total_latency_ms,
+                        "is_streaming": is_streaming,
+                        **(metadata or {})
+                    }
+                )
+            except Exception as e:
+                print(f"⚠️ Failed to record LLM generation to Langfuse: {e}")
+        
+        self._log_locally("llm_generation", llm_record)
+    
+    def record_ttft(self, ttft_ms: float, model: str = None, metadata: Dict = None) -> None:
+        """
+        单独记录 TTFT (Time To First Token)
+        用于流式生成时在收到第一个 token 时立即记录
+        
+        Args:
+            ttft_ms: 首 token 延迟（毫秒）
+            model: 模型名称
+            metadata: 额外元数据
+        """
+        ttft_record = {
+            "ttft_ms": ttft_ms,
+            "model": model,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        }
+        
+        if self.langfuse_client:
+            try:
+                self.langfuse_client.event(
+                    name="ttft",
+                    input={},
+                    output={"ttft_ms": ttft_ms},
+                    metadata=ttft_record
+                )
+            except Exception as e:
+                print(f"⚠️ Failed to record TTFT: {e}")
+        
+        self._log_locally("ttft", ttft_record)
+
+    def add_event(self, event_name: str, event_data: Dict[str, Any] = None) -> None:
+        """
+        添加事件记录
+        
+        Args:
+            event_name: 事件名称 (如 "repo_map_generated", "file_read_failed" 等)
+            event_data: 事件相关数据
+        """
+        event_record = {
+            "event_name": event_name,
+            "event_data": event_data or {},
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        if self.langfuse_client:
+            try:
+                self.langfuse_client.event(
+                    name=event_name,
+                    input={},
+                    output=event_data or {},
+                    metadata=event_data or {}
+                )
+            except Exception as e:
+                print(f"⚠️ Failed to record event '{event_name}': {e}")
+        
+        self._log_locally("event", event_record)
+    
+    def _log_locally(self, log_type: str, data: Dict) -> None:
+        """本地日志记录"""
+        log_file = os.path.join(
+            self.config.local_log_dir,
+            f"{log_type}_{datetime.now().strftime('%Y%m%d')}.jsonl"
+        )
+        
+        with open(log_file, 'a', encoding='utf-8') as f:
+            f.write(json.dumps(data, ensure_ascii=False, default=str) + '\n')
+    
+    def get_trace_url(self, trace_id: str = None) -> str:
+        """获取Langfuse中该trace的URL (用于前端跳转)"""
+        if not self.langfuse_client or not trace_id:
+            return None
+        
+        # Langfuse云端URL格式
+        return f"{self.config.langfuse_host}/traces/{trace_id}"
+
+
+# ============================================================================
+# 第二部分: 装饰器 - 自动追踪
+# ============================================================================
+
+def traced(operation_name: str, capture_args: List[str] = None):
+    """
+    装饰器: 自动为被装饰函数添加追踪
+    
+    使用示例:
+    @traced("query_rewrite", capture_args=["user_query"])
+    async def rewrite_query(user_query: str):
+        ...
+    """
+    
+    def decorator(func: Callable):
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            start_time = time.time()
+            
+            # 捕获输入参数
+            input_data = {}
+            if capture_args:
+                for arg_name in capture_args:
+                    if arg_name in kwargs:
+                        input_data[arg_name] = kwargs[arg_name]
+            
+            try:
+                result = await func(*args, **kwargs)
+                latency_ms = (time.time() - start_time) * 1000
+                
+                # 记录跨度
+                tracing_service.record_span(
+                    span_name=operation_name,
+                    operation=func.__name__,
+                    input_data=input_data,
+                    output_data={"success": True},
+                    latency_ms=latency_ms
+                )
+                
+                return result
+            except Exception as e:
+                latency_ms = (time.time() - start_time) * 1000
+                tracing_service.record_span(
+                    span_name=operation_name,
+                    operation=func.__name__,
+                    input_data=input_data,
+                    output_data={"error": str(e)},
+                    latency_ms=latency_ms,
+                    metadata={"error": True}
+                )
+                raise
+        
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            start_time = time.time()
+            
+            input_data = {}
+            if capture_args:
+                for arg_name in capture_args:
+                    if arg_name in kwargs:
+                        input_data[arg_name] = kwargs[arg_name]
+            
+            try:
+                result = func(*args, **kwargs)
+                latency_ms = (time.time() - start_time) * 1000
+                
+                tracing_service.record_span(
+                    span_name=operation_name,
+                    operation=func.__name__,
+                    input_data=input_data,
+                    output_data={"success": True},
+                    latency_ms=latency_ms
+                )
+                
+                return result
+            except Exception as e:
+                latency_ms = (time.time() - start_time) * 1000
+                tracing_service.record_span(
+                    span_name=operation_name,
+                    operation=func.__name__,
+                    input_data=input_data,
+                    output_data={"error": str(e)},
+                    latency_ms=latency_ms,
+                    metadata={"error": True}
+                )
+                raise
+        
+        # 判断是async还是sync
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+    
+    return decorator
+
+
+# ============================================================================
+# 第三部分: 全局实例
+# ============================================================================
+
+tracing_config = TracingConfig(
+    enabled=True,
+    backend="langfuse" if LANGFUSE_AVAILABLE else "local"
+)
+
+tracing_service = TracingService(config=tracing_config)
+
+
+# ============================================================================
+# 第四部分: 集成示例 (如何在agent_service.py中使用)
+# ============================================================================
+
+"""
+在你的agent_service.py中添加:
+
+1. 导入追踪服务:
+   from app.services.tracing_service import tracing_service
+
+2. 在agent_stream函数开始:
+   trace_id = tracing_service.start_trace(
+       trace_name="github_agent_analysis",
+       session_id=session_id,
+       metadata={"repo_url": repo_url, "language": language}
+   )
+
+3. 在generate_repo_map函数周围:
+   start_time = time.time()
+   file_tree_str, mapped_files = await generate_repo_map(repo_url, file_list, limit=limit)
+   latency_ms = (time.time() - start_time) * 1000
+   
+   tracing_service.record_span(
+       span_name="generate_repo_map",
+       operation="repo_mapping",
+       input_data={"file_count": len(file_list), "limit": limit},
+       output_data={"files_in_map": len(mapped_files)},
+       latency_ms=latency_ms
+   )
+
+4. 在process_single_file中记录检索:
+   tracing_service.record_retrieval_debug(
+       query=search_query,
+       retrieved_files=valid_files,
+       vector_scores=vector_scores,
+       bm25_scores=bm25_scores,
+       latency_ms=search_latency
+   )
+
+5. 工具调用记录:
+   start_time = time.time()
+   try:
+       result = get_file_content(repo_url, file_path)
+       tracing_service.record_tool_call(
+           tool_name="get_file_content",
+           parameters={"file_path": file_path},
+           result=result[:100] if result else None,
+           latency_ms=(time.time() - start_time) * 1000,
+           success=True
+       )
+   except Exception as e:
+       tracing_service.record_tool_call(
+           tool_name="get_file_content",
+           parameters={"file_path": file_path},
+           result=None,
+           latency_ms=(time.time() - start_time) * 1000,
+           success=False,
+           error=str(e)
+       )
+"""
+
+import asyncio

app/services/vector_service.py

@@ -0,0 +1,676 @@
+# -*- coding: utf-8 -*-
+"""
+向量服务层 - Qdrant 版
+
+特性:
+1. 混合搜索 - Qdrant 向量 + BM25 关键词，RRF 融合
+2. 异步原生 - 全链路异步
+3. 会话隔离 - 每个 session 独立集合
+4. 状态持久化 - 仓库信息、BM25 索引缓存
+"""
+
+import asyncio
+import json
+import logging
+import os
+import pickle
+import re
+import tempfile
+import time
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional, Set
+
+from rank_bm25 import BM25Okapi
+
+from app.core.config import settings
+from app.storage.base import Document, SearchResult, CollectionStats
+from app.storage.qdrant_store import QdrantVectorStore, QdrantConfig, get_qdrant_factory
+from app.utils.embedding import get_embedding_service, EmbeddingConfig
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================
+# 使用统一配置
+# ============================================================
+
+from app.core.config import vector_config as config
+
+# 确保目录存在
+os.makedirs(config.context_dir, exist_ok=True)
+
+# === 向后兼容导出 (供 main.py 使用) ===
+vector_config = config  # 兼容旧名称
+CONTEXT_DIR = config.context_dir
+QDRANT_DIR = config.data_dir  # Qdrant 数据目录
+
+
+# ============================================================
+# Embedding 服务
+# ============================================================
+
+_embedding_service = None
+
+def get_embedding():
+    """获取 Embedding 服务单例"""
+    global _embedding_service
+    if _embedding_service is None:
+        emb_config = EmbeddingConfig(
+            api_base_url=config.embedding_api_url,
+            model_name=config.embedding_model,
+            batch_size=config.embedding_batch_size,
+            max_text_length=config.embedding_max_length,
+            max_concurrent_batches=config.embedding_concurrency,
+        )
+        _embedding_service = get_embedding_service(emb_config)
+    return _embedding_service
+
+
+# ============================================================
+# 向量存储服务
+# ============================================================
+
+class VectorStore:
+    """
+    向量存储服务
+    
+    整合 Qdrant 向量搜索和 BM25 关键词搜索
+    
+    使用示例:
+    ```python
+    store = VectorStore("session_123")
+    await store.initialize()
+    
+    # 重置 (分析新仓库时)
+    await store.reset()
+    
+    # 添加文档
+    await store.add_documents(documents, metadatas)
+    
+    # 混合搜索
+    results = await store.search_hybrid("how does auth work?")
+    
+    await store.close()
+    ```
+    """
+    
+    def __init__(self, session_id: str):
+        self.session_id = self._sanitize_id(session_id)
+        self.collection_name = f"repo_{self.session_id}"
+        
+        # Qdrant 存储
+        self._qdrant: Optional[QdrantVectorStore] = None
+        
+        # BM25 索引 (内存)
+        self._bm25: Optional[BM25Okapi] = None
+        self._doc_store: List[Document] = []
+        self._indexed_files: Set[str] = set()
+        
+        # 上下文
+        self.repo_url: Optional[str] = None
+        self.global_context: Dict[str, Any] = {}
+        
+        # 文件路径
+        self._context_file = os.path.join(config.context_dir, f"{self.session_id}.json")
+        self._cache_file = os.path.join(config.context_dir, f"{self.session_id}_bm25.pkl")
+        
+        self._initialized = False
+    
+    @staticmethod
+    def _sanitize_id(session_id: str) -> str:
+        """清理 session ID"""
+        clean = re.sub(r'[^a-zA-Z0-9_-]', '', session_id)
+        if not clean:
+            raise ValueError("Invalid session_id")
+        return clean
+    
+    async def initialize(self) -> None:
+        """初始化存储"""
+        if self._initialized:
+            return
+        
+        # 初始化 Qdrant
+        factory = get_qdrant_factory()
+        self._qdrant = factory.create(self.collection_name)
+        await self._qdrant.initialize()
+        
+        # 加载本地状态
+        await self._load_state()
+        
+        self._initialized = True
+        logger.debug(f"✅ VectorStore 初始化: {self.session_id}")
+    
+    async def close(self) -> None:
+        """关闭连接"""
+        if self._qdrant:
+            await self._qdrant.close()
+            self._qdrant = None
+        self._initialized = False
+    
+    async def _load_state(self) -> None:
+        """加载状态"""
+        # 1. 加载上下文 JSON
+        if os.path.exists(self._context_file):
+            try:
+                with open(self._context_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self.repo_url = data.get("repo_url")
+                    self.global_context = data.get("global_context", {})
+            except Exception as e:
+                logger.warning(f"加载上下文失败: {e}")
+        
+        # 2. 尝试加载 BM25 缓存
+        cache_loaded = False
+        if os.path.exists(self._cache_file):
+            try:
+                with open(self._cache_file, 'rb') as f:
+                    cache = pickle.load(f)
+                    if isinstance(cache, dict) and cache.get("version") == config.cache_version:
+                        self._bm25 = cache.get("bm25")
+                        self._doc_store = cache.get("doc_store", [])
+                        self._indexed_files = cache.get("indexed_files", set())
+                        cache_loaded = True
+                        logger.debug(f"📦 BM25 缓存命中: {len(self._doc_store)} 文档")
+            except Exception as e:
+                logger.warning(f"BM25 缓存损坏: {e}")
+                os.remove(self._cache_file)
+        
+        # 3. 缓存未命中: 从 Qdrant 重建
+        if not cache_loaded and self._qdrant:
+            await self._rebuild_bm25_index()
+    
+    async def _rebuild_bm25_index(self) -> None:
+        """从 Qdrant 重建 BM25 索引"""
+        logger.info(f"🔄 重建 BM25 索引: {self.session_id}")
+        
+        documents = await self._qdrant.get_all_documents()
+        
+        if documents:
+            self._doc_store = documents
+            self._indexed_files = {doc.file_path for doc in documents if doc.file_path}
+            
+            tokenized = [self._tokenize(doc.content) for doc in documents]
+            if tokenized:
+                self._bm25 = BM25Okapi(tokenized)
+            
+            self._save_bm25_cache()
+            logger.info(f"✅ BM25 索引重建完成: {len(documents)} 文档")
+    
+    def _save_bm25_cache(self) -> None:
+        """保存 BM25 缓存 (原子写入)"""
+        if not self._doc_store:
+            return
+        
+        try:
+            fd, tmp_path = tempfile.mkstemp(dir=config.context_dir)
+            with os.fdopen(fd, 'wb') as f:
+                pickle.dump({
+                    "version": config.cache_version,
+                    "bm25": self._bm25,
+                    "doc_store": self._doc_store,
+                    "indexed_files": self._indexed_files,
+                }, f)
+            
+            if os.path.exists(self._cache_file):
+                os.remove(self._cache_file)
+            os.rename(tmp_path, self._cache_file)
+            
+        except Exception as e:
+            logger.error(f"保存 BM25 缓存失败: {e}")
+    
+    def _tokenize(self, text: str) -> List[str]:
+        """分词"""
+        return [
+            t.lower() for t in re.split(config.tokenize_regex, text)
+            if t.strip()
+        ]
+    
+    async def save_context(self, repo_url: str, context_data: Dict[str, Any]) -> None:
+        """保存仓库上下文 (异步，不阻塞事件循环)"""
+        self.repo_url = repo_url
+        self.global_context = context_data
+        await asyncio.to_thread(self._write_context_file, {
+            "repo_url": repo_url,
+            "global_context": context_data,
+        })
+    
+    def _write_context_file(self, updates: Dict[str, Any]) -> None:
+        """写入上下文文件 (同步，供线程池调用)"""
+        try:
+            existing = {}
+            if os.path.exists(self._context_file):
+                with open(self._context_file, 'r', encoding='utf-8') as f:
+                    existing = json.load(f)
+            existing.update(updates)
+            with open(self._context_file, 'w', encoding='utf-8') as f:
+                json.dump(existing, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            logger.error(f"写入上下文失败: {e}")
+    
+    async def save_report(self, report: str, language: str = "en") -> None:
+        """保存技术报告 (异步，不阻塞事件循环)"""
+        await asyncio.to_thread(self._write_report, report, language)
+    
+    def _write_report(self, report: str, language: str) -> None:
+        """写入报告 (同步，供线程池调用)"""
+        try:
+            existing = {}
+            if os.path.exists(self._context_file):
+                with open(self._context_file, 'r', encoding='utf-8') as f:
+                    existing = json.load(f)
+            
+            if "reports" not in existing:
+                existing["reports"] = {}
+            existing["reports"][language] = report
+            existing["report"] = report
+            existing["report_language"] = language
+            
+            with open(self._context_file, 'w', encoding='utf-8') as f:
+                json.dump(existing, f, ensure_ascii=False, indent=2)
+            logger.info(f"📝 报告已保存: {self.session_id} ({language})")
+        except Exception as e:
+            logger.error(f"保存报告失败: {e}")
+    
+    def get_report(self, language: str = "en") -> Optional[str]:
+        """
+        获取指定语言的报告
+        
+        Args:
+            language: 语言代码 ('en', 'zh')
+            
+        Returns:
+            报告内容，不存在返回 None
+        """
+        context = self.load_context()
+        if not context:
+            return None
+        
+        # 优先从 reports 字典获取
+        reports = context.get("reports", {})
+        if language in reports:
+            return reports[language]
+        
+        # 兼容旧格式：如果只有 report 字段且语言匹配
+        if "report" in context:
+            stored_lang = context.get("report_language", "en")
+            if stored_lang == language:
+                return context["report"]
+        
+        return None
+    
+    def get_available_languages(self) -> List[str]:
+        """获取已有报告的语言列表"""
+        context = self.load_context()
+        if not context:
+            return []
+        
+        reports = context.get("reports", {})
+        return list(reports.keys())
+    
+    def load_context(self) -> Optional[Dict[str, Any]]:
+        """
+        加载仓库上下文
+        
+        Returns:
+            包含 repo_url, global_context, report 等的字典，不存在返回 None
+        """
+        if not os.path.exists(self._context_file):
+            return None
+        
+        try:
+            with open(self._context_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # 恢复内存状态
+            self.repo_url = data.get("repo_url")
+            self.global_context = data.get("global_context", {})
+            
+            return data
+        except Exception as e:
+            logger.error(f"加载上下文失败: {e}")
+            return None
+    
+    def has_index(self) -> bool:
+        """检查是否已有索引"""
+        context = self.load_context()
+        return context is not None and context.get("repo_url") is not None
+    
+    async def reset(self) -> None:
+        """重置存储 (分析新仓库时调用)"""
+        await self.initialize()
+        
+        # 删除 Qdrant 集合
+        if self._qdrant:
+            await self._qdrant.delete_collection()
+            await self._qdrant.initialize()
+        
+        # 清理本地文件
+        for f in [self._context_file, self._cache_file]:
+            if os.path.exists(f):
+                os.remove(f)
+        
+        # 重置内存状态
+        self._bm25 = None
+        self._doc_store = []
+        self._indexed_files = set()
+        self.repo_url = None
+        self.global_context = {}
+        
+        logger.info(f"🗑️ 重置存储: {self.session_id}")
+    
+    # 兼容旧接口
+    def reset_collection(self) -> None:
+        """同步重置 (兼容旧代码)"""
+        asyncio.get_event_loop().run_until_complete(self.reset())
+    
+    async def add_documents(
+        self,
+        documents: List[str],
+        metadatas: List[Dict[str, Any]]
+    ) -> int:
+        """
+        添加文档
+        
+        Args:
+            documents: 文档内容列表
+            metadatas: 元数据列表
+            
+        Returns:
+            成功添加的数量
+        """
+        if not documents:
+            return 0
+        
+        await self.initialize()
+        
+        # 1. 批量获取 Embedding
+        logger.info(f"📊 Embedding: {len(documents)} 个文档")
+        embedding_service = get_embedding()
+        embeddings = await embedding_service.embed_batch(documents, show_progress=True)
+        
+        # 过滤无效的
+        valid_indices = [i for i, emb in enumerate(embeddings) if emb]
+        if not valid_indices:
+            logger.error("所有 Embedding 都失败了")
+            return 0
+        
+        # 2. 构建 Document 对象
+        docs = []
+        for i in valid_indices:
+            doc_id = f"{metadatas[i].get('file', 'unknown')}_{len(self._doc_store) + len(docs)}"
+            doc = Document(
+                id=doc_id,
+                content=documents[i],
+                metadata=metadatas[i],
+            )
+            docs.append(doc)
+        
+        valid_embeddings = [embeddings[i] for i in valid_indices]
+        
+        # 3. 写入 Qdrant
+        added = await self._qdrant.add_documents(docs, valid_embeddings)
+        
+        # 4. 更新 BM25 索引 (放入线程池，避免阻塞)
+        self._doc_store.extend(docs)
+        self._indexed_files.update(doc.file_path for doc in docs)
+        
+        await asyncio.to_thread(self._rebuild_bm25_sync)
+        
+        return added
+    
+    def _rebuild_bm25_sync(self) -> None:
+        """重建 BM25 索引 (同步，用于线程池)"""
+        tokenized = [self._tokenize(doc.content) for doc in self._doc_store]
+        self._bm25 = BM25Okapi(tokenized)
+        self._save_bm25_cache()
+    
+    async def embed_text(self, text: str) -> List[float]:
+        """获取文本 Embedding"""
+        embedding_service = get_embedding()
+        return await embedding_service.embed_text(text)
+    
+    async def search_hybrid(
+        self,
+        query: str,
+        top_k: int = None
+    ) -> List[Dict[str, Any]]:
+        """
+        混合搜索 (向量 + BM25，RRF 融合)
+        
+        Args:
+            query: ���询文本
+            top_k: 返回数量
+            
+        Returns:
+            搜索结果列表
+        """
+        await self.initialize()
+        
+        top_k = top_k or config.default_top_k
+        candidate_k = top_k * config.search_oversample
+        
+        # 1. 向量搜索
+        vector_results: List[SearchResult] = []
+        query_embedding = await self.embed_text(query)
+        
+        if query_embedding and self._qdrant:
+            vector_results = await self._qdrant.search(
+                query_embedding,
+                top_k=candidate_k
+            )
+        
+        # 2. BM25 搜索
+        bm25_results: List[SearchResult] = []
+        if self._bm25 and self._doc_store:
+            tokens = self._tokenize(query)
+            if not tokens:
+                tokens = [""]
+            
+            try:
+                scores = self._bm25.get_scores(tokens)
+                top_indices = sorted(
+                    range(len(scores)),
+                    key=lambda i: scores[i],
+                    reverse=True
+                )[:candidate_k]
+                
+                for idx in top_indices:
+                    if scores[idx] > 0:
+                        doc = self._doc_store[idx]
+                        bm25_results.append(SearchResult(
+                            document=doc,
+                            score=scores[idx],
+                            source="bm25",
+                        ))
+            except Exception as e:
+                logger.error(f"BM25 搜索失败: {e}")
+        
+        # 3. RRF 融合
+        fused = self._rrf_fusion(vector_results, bm25_results)
+        
+        # 4. 格式化输出 (兼容旧接口)
+        results = []
+        for item in fused[:top_k]:
+            doc = item.document
+            results.append({
+                "id": doc.id,
+                "content": doc.content,
+                "file": doc.file_path,
+                "metadata": doc.metadata,
+                "score": item.score,
+            })
+        
+        return results
+    
+    def _rrf_fusion(
+        self,
+        vector_results: List[SearchResult],
+        bm25_results: List[SearchResult]
+    ) -> List[SearchResult]:
+        """RRF (Reciprocal Rank Fusion) 融合"""
+        k = config.rrf_k
+        fused: Dict[str, Dict] = {}
+        
+        # 向量结果
+        for rank, result in enumerate(vector_results):
+            doc_id = result.document.id
+            if doc_id not in fused:
+                fused[doc_id] = {"result": result, "score": 0}
+            fused[doc_id]["score"] += config.rrf_weight_vector / (k + rank + 1)
+        
+        # BM25 结果
+        for rank, result in enumerate(bm25_results):
+            doc_id = result.document.id
+            if doc_id not in fused:
+                fused[doc_id] = {"result": result, "score": 0}
+            fused[doc_id]["score"] += config.rrf_weight_bm25 / (k + rank + 1)
+        
+        # 排序
+        sorted_items = sorted(
+            fused.values(),
+            key=lambda x: x["score"],
+            reverse=True
+        )
+        
+        return [
+            SearchResult(
+                document=item["result"].document,
+                score=item["score"],
+                source="hybrid",
+            )
+            for item in sorted_items
+        ]
+    
+    def get_documents_by_file(self, file_path: str) -> List[Dict[str, Any]]:
+        """根据文件路径获取文档 (兼容旧接口)"""
+        docs = [
+            doc for doc in self._doc_store
+            if doc.file_path == file_path
+        ]
+        
+        result = []
+        for doc in sorted(docs, key=lambda d: d.metadata.get("start_line", 0)):
+            result.append({
+                "id": doc.id,
+                "content": doc.content,
+                "file": doc.file_path,
+                "metadata": doc.metadata,
+                "score": 1.0,
+            })
+        
+        return result
+    
+    @property
+    def indexed_files(self) -> Set[str]:
+        """已索引的文件"""
+        return self._indexed_files
+
+
+# ============================================================
+# 管理器 - LRU Cache + 过期清理
+# ============================================================
+
+class SessionEntry:
+    """Session 条目 - 包含存储实例和访问时间"""
+    __slots__ = ('store', 'last_access', 'created_at')
+    
+    def __init__(self, store: VectorStore):
+        self.store = store
+        self.last_access = time.time()
+        self.created_at = time.time()
+    
+    def touch(self) -> None:
+        """更新访问时间"""
+        self.last_access = time.time()
+
+
+class VectorStoreManager:
+    """
+    向量存储管理器 - LRU Cache 实现
+    
+    特性:
+    1. LRU 淘汰 - 超过 max_count 时淘汰最久未访问的内存中的 session
+    2. 仓库数据永久存储 - 不清理仓库索引和报告
+    3. 线程安全 - 使用 asyncio.Lock
+    """
+    
+    def __init__(self, max_count: int = None):
+        self._max_count = max_count or config.session_max_count
+        self._sessions: Dict[str, SessionEntry] = {}
+        self._lock = asyncio.Lock()
+    
+    def get_store(self, session_id: str) -> VectorStore:
+        """
+        获取或创建存储实例 (同步接口，兼容现有代码)
+        
+        会触发 LRU 淘汰检查
+        """
+        if session_id in self._sessions:
+            entry = self._sessions[session_id]
+            entry.touch()
+            # 移动到最后（模拟 LRU）
+            self._sessions.pop(session_id)
+            self._sessions[session_id] = entry
+            return entry.store
+        
+        # 创建新 session
+        store = VectorStore(session_id)
+        entry = SessionEntry(store)
+        self._sessions[session_id] = entry
+        
+        # 检查是否需要 LRU 淘汰（异步执行）
+        if len(self._sessions) > self._max_count:
+            asyncio.create_task(self._evict_lru())
+        
+        logger.info(f"📦 Session 创建: {session_id} (总数: {len(self._sessions)})")
+        return store
+    
+    async def _evict_lru(self) -> None:
+        """淘汰最久未访问的 session"""
+        async with self._lock:
+            while len(self._sessions) > self._max_count:
+                # 找到最久未访问的
+                oldest_id = min(
+                    self._sessions.keys(),
+                    key=lambda k: self._sessions[k].last_access
+                )
+                entry = self._sessions.pop(oldest_id)
+                await entry.store.close()
+                logger.info(f"🗑️ LRU 淘汰: {oldest_id}")
+    
+    async def close_session(self, session_id: str) -> None:
+        """关闭指定 session"""
+        async with self._lock:
+            if session_id in self._sessions:
+                entry = self._sessions.pop(session_id)
+                await entry.store.close()
+                logger.info(f"🔒 Session 关闭: {session_id}")
+    
+    async def close_all(self) -> None:
+        """关闭所有连接"""
+        async with self._lock:
+            for session_id, entry in list(self._sessions.items()):
+                await entry.store.close()
+            self._sessions.clear()
+            logger.info("🔒 所有 Session 已关闭")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """获取管理器统计信息"""
+        now = time.time()
+        sessions_info = []
+        for sid, entry in self._sessions.items():
+            sessions_info.append({
+                "session_id": sid,
+                "age_hours": round((now - entry.created_at) / 3600, 2),
+                "idle_minutes": round((now - entry.last_access) / 60, 2),
+            })
+        
+        return {
+            "total_sessions": len(self._sessions),
+            "max_sessions": self._max_count,
+            "sessions": sorted(sessions_info, key=lambda x: x["idle_minutes"], reverse=True)
+        }
+
+
+# 全局管理器
+store_manager = VectorStoreManager()

app/storage/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+"""
+存储层模块
+
+提供向量存储的抽象和实现
+"""
+
+from app.storage.base import (
+    Document,
+    SearchResult,
+    CollectionStats,
+    StorageBackend,
+    BaseVectorStore,
+)
+from app.storage.qdrant_store import (
+    QdrantConfig,
+    QdrantVectorStore,
+    QdrantStoreFactory,
+    get_qdrant_factory,
+)
+
+__all__ = [
+    # 基础类型
+    "Document",
+    "SearchResult",
+    "CollectionStats",
+    "StorageBackend",
+    "BaseVectorStore",
+    # Qdrant
+    "QdrantConfig",
+    "QdrantVectorStore",
+    "QdrantStoreFactory",
+    "get_qdrant_factory",
+]

app/storage/base.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+"""
+向量存储抽象层
+
+设计原则:
+1. 接口与实现分离 - 易于切换存储后端
+2. 异步优先 - 所有 I/O 操作都是异步的
+3. 类型安全 - 完整的类型注解
+4. 可观测 - 内置指标收集
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional, Set
+from enum import Enum
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================
+# 数据模型
+# ============================================================
+
+@dataclass
+class Document:
+    """文档数据模型"""
+    id: str
+    content: str
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    embedding: Optional[List[float]] = None
+    
+    @property
+    def file_path(self) -> str:
+        return self.metadata.get("file", "")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "content": self.content,
+            "metadata": self.metadata,
+        }
+
+
+@dataclass
+class SearchResult:
+    """搜索结果"""
+    document: Document
+    score: float
+    source: str = "vector"  # "vector" | "bm25" | "hybrid"
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.document.id,
+            "content": self.document.content,
+            "file": self.document.file_path,
+            "metadata": self.document.metadata,
+            "score": self.score,
+            "source": self.source,
+        }
+
+
+@dataclass
+class CollectionStats:
+    """集合统计信息"""
+    name: str
+    document_count: int
+    indexed_files: Set[str] = field(default_factory=set)
+    vector_dimension: int = 0
+
+
+class StorageBackend(Enum):
+    """存储后端类型"""
+    QDRANT = "qdrant"
+    CHROMA = "chroma"  # 保留兼容性
+
+
+# ============================================================
+# 抽象基类
+# ============================================================
+
+class BaseVectorStore(ABC):
+    """
+    向量存储抽象基类
+    
+    所有存储后端必须实现这些方法
+    """
+    
+    @abstractmethod
+    async def initialize(self) -> None:
+        """初始化存储连接"""
+        pass
+    
+    @abstractmethod
+    async def close(self) -> None:
+        """关闭连接"""
+        pass
+    
+    @abstractmethod
+    async def add_documents(
+        self,
+        documents: List[Document],
+        embeddings: List[List[float]]
+    ) -> int:
+        """
+        添加文档
+        
+        Args:
+            documents: 文档列表
+            embeddings: 对应的嵌入向量
+            
+        Returns:
+            成功添加的文档数量
+        """
+        pass
+    
+    @abstractmethod
+    async def search(
+        self,
+        query_embedding: List[float],
+        top_k: int = 10,
+        filter_conditions: Optional[Dict[str, Any]] = None
+    ) -> List[SearchResult]:
+        """
+        向量相似度搜索
+        
+        Args:
+            query_embedding: 查询向量
+            top_k: 返回数量
+            filter_conditions: 过滤条件
+            
+        Returns:
+            搜索结果列表
+        """
+        pass
+    
+    @abstractmethod
+    async def delete_collection(self) -> bool:
+        """删除当前集合"""
+        pass
+    
+    @abstractmethod
+    async def get_stats(self) -> CollectionStats:
+        """获取集合统计信息"""
+        pass
+    
+    @abstractmethod
+    async def get_documents_by_file(self, file_path: str) -> List[Document]:
+        """根据文件路径获取文档"""
+        pass
+
+
+class BaseVectorStoreFactory(ABC):
+    """向量存储工厂基类"""
+    
+    @abstractmethod
+    def create(self, collection_name: str) -> BaseVectorStore:
+        """创建存储实例"""
+        pass

app/storage/qdrant_store.py

@@ -0,0 +1,578 @@
+# -*- coding: utf-8 -*-
+"""
+Qdrant 向量存储实现
+
+特性:
+1. 异步原生 - 使用 qdrant-client AsyncQdrantClient
+2. 高性能 - 批量 upsert、HNSW 索引、payload 索引
+3. 混合搜索 - 向量 + 稀疏向量 (FastEmbed)
+4. 连接池 - gRPC 长连接复用
+5. 可观测 - 完整的日志和指标
+"""
+
+import asyncio
+import logging
+import os
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Set
+from contextlib import asynccontextmanager
+
+from qdrant_client import AsyncQdrantClient, models
+from qdrant_client.models import (
+    Distance,
+    VectorParams,
+    PointStruct,
+    Filter,
+    FieldCondition,
+    MatchValue,
+    PayloadSchemaType,
+)
+
+from app.storage.base import (
+    BaseVectorStore,
+    Document,
+    SearchResult,
+    CollectionStats,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================
+# 配置
+# ============================================================
+
+@dataclass
+class QdrantConfig:
+    """
+    Qdrant 配置
+    
+    支持三种模式:
+    - local: 本地嵌入式 (开发/单进程)
+    - server: Qdrant Server (多 Worker 生产环境)
+    - cloud: Qdrant Cloud (托管服务)
+    
+    环境变量:
+    - QDRANT_MODE: "local" | "server" | "cloud"
+    - QDRANT_URL: 服务器地址 (server/cloud 模式)
+    - QDRANT_API_KEY: API 密钥 (cloud 模式必需)
+    - QDRANT_LOCAL_PATH: 本地存储路径 (local 模式)
+    """
+    # 模式: "local" | "server" | "cloud"
+    mode: str = "local"
+    
+    # Server/Cloud 模式配置
+    url: Optional[str] = None
+    host: str = "localhost"
+    port: int = 6333
+    grpc_port: int = 6334
+    prefer_grpc: bool = True
+    api_key: Optional[str] = None
+    
+    # Local 模式配置
+    local_path: str = "data/qdrant_db"
+    
+    # 向量配置
+    vector_size: int = 1024  # BGE-M3 维度
+    distance: Distance = Distance.COSINE
+    
+    # 索引配置
+    hnsw_m: int = 16              # HNSW 图的边数
+    hnsw_ef_construct: int = 100  # 构建时的搜索深度
+    
+    # 批量操作
+    batch_size: int = 100
+    
+    # 超时
+    timeout: float = 30.0
+    
+    @classmethod
+    def from_env(cls) -> "QdrantConfig":
+        """从环境变量加载配置"""
+        mode = os.getenv("QDRANT_MODE", "local").lower()
+        
+        return cls(
+            mode=mode,
+            url=os.getenv("QDRANT_URL"),
+            host=os.getenv("QDRANT_HOST", "localhost"),
+            port=int(os.getenv("QDRANT_PORT", "6333")),
+            grpc_port=int(os.getenv("QDRANT_GRPC_PORT", "6334")),
+            api_key=os.getenv("QDRANT_API_KEY"),
+            local_path=os.getenv("QDRANT_LOCAL_PATH", "data/qdrant_db"),
+            vector_size=int(os.getenv("QDRANT_VECTOR_SIZE", "1024")),
+            prefer_grpc=os.getenv("QDRANT_PREFER_GRPC", "true").lower() == "true",
+        )
+    
+    @property
+    def is_local(self) -> bool:
+        return self.mode == "local"
+    
+    @property
+    def is_server(self) -> bool:
+        return self.mode == "server"
+    
+    @property
+    def is_cloud(self) -> bool:
+        return self.mode == "cloud"
+    
+    def validate(self) -> None:
+        """验证配置"""
+        if self.is_cloud and not self.api_key:
+            raise ValueError("QDRANT_API_KEY is required for cloud mode")
+        if (self.is_server or self.is_cloud) and not (self.url or self.host):
+            raise ValueError("QDRANT_URL or QDRANT_HOST is required for server/cloud mode")
+
+
+# ============================================================
+# 全局共享客户端单例
+# ============================================================
+
+_shared_client: Optional[AsyncQdrantClient] = None
+_shared_config: Optional[QdrantConfig] = None
+_client_lock = asyncio.Lock()
+
+
+async def get_shared_client(config: Optional[QdrantConfig] = None) -> AsyncQdrantClient:
+    """
+    获取共享的 Qdrant 客户端单例
+    
+    支持三种模式:
+    - local: 本地嵌入式存储 (单进程，开发环境)
+    - server: Qdrant Server (多 Worker，Docker 部署)
+    - cloud: Qdrant Cloud (托管服务)
+    """
+    global _shared_client, _shared_config
+    
+    async with _client_lock:
+        if _shared_client is None:
+            _shared_config = config or QdrantConfig.from_env()
+            _shared_config.validate()
+            
+            if _shared_config.is_local:
+                # Local 模式: 嵌入式存储
+                os.makedirs(_shared_config.local_path, exist_ok=True)
+                _shared_client = AsyncQdrantClient(
+                    path=_shared_config.local_path,
+                    timeout=_shared_config.timeout,
+                )
+                logger.info(f"📦 Qdrant 本地模式: {_shared_config.local_path}")
+                
+            elif _shared_config.is_server:
+                # Server 模式: 连接 Qdrant Server
+                if _shared_config.url:
+                    _shared_client = AsyncQdrantClient(
+                        url=_shared_config.url,
+                        prefer_grpc=_shared_config.prefer_grpc,
+                        timeout=_shared_config.timeout,
+                    )
+                    logger.info(f"🌐 Qdrant Server 模式: {_shared_config.url}")
+                else:
+                    _shared_client = AsyncQdrantClient(
+                        host=_shared_config.host,
+                        port=_shared_config.port,
+                        grpc_port=_shared_config.grpc_port,
+                        prefer_grpc=_shared_config.prefer_grpc,
+                        timeout=_shared_config.timeout,
+                    )
+                    logger.info(f"🌐 Qdrant Server 模式: {_shared_config.host}:{_shared_config.port}")
+                    
+            else:
+                # Cloud 模式: 连接 Qdrant Cloud
+                _shared_client = AsyncQdrantClient(
+                    url=_shared_config.url,
+                    api_key=_shared_config.api_key,
+                    timeout=_shared_config.timeout,
+                )
+                logger.info(f"☁️ Qdrant Cloud 模式: {_shared_config.url}")
+        
+        return _shared_client
+        
+        return _shared_client
+
+
+async def close_shared_client() -> None:
+    """关闭共享客户端"""
+    global _shared_client
+    if _shared_client is not None:
+        await _shared_client.close()
+        _shared_client = None
+        logger.info("🔒 Qdrant 共享客户端已关闭")
+
+
+# ============================================================
+# Qdrant 存储实现
+# ============================================================
+
+class QdrantVectorStore(BaseVectorStore):
+    """
+    Qdrant 向量存储
+    
+    使用示例:
+    ```python
+    config = QdrantConfig.from_env()
+    store = QdrantVectorStore("my_collection", config)
+    
+    await store.initialize()
+    
+    # 添加文档
+    docs = [Document(id="1", content="hello", metadata={"file": "a.py"})]
+    embeddings = [[0.1, 0.2, ...]]
+    await store.add_documents(docs, embeddings)
+    
+    # 搜索
+    results = await store.search(query_embedding, top_k=5)
+    
+    await store.close()
+    ```
+    """
+    
+    # Payload 字段名常量
+    FIELD_CONTENT = "content"
+    FIELD_FILE = "file"
+    FIELD_METADATA = "metadata"
+    
+    def __init__(
+        self,
+        collection_name: str,
+        config: Optional[QdrantConfig] = None
+    ):
+        self.collection_name = self._sanitize_name(collection_name)
+        self.config = config or QdrantConfig.from_env()
+        self._initialized = False
+    
+    @staticmethod
+    def _sanitize_name(name: str) -> str:
+        """清理集合名称"""
+        import re
+        clean = re.sub(r'[^a-zA-Z0-9_-]', '_', name)
+        return clean[:63] if clean else "default"
+    
+    async def _get_client(self) -> AsyncQdrantClient:
+        """获取共享客户端 (解决 Qdrant Local 并发访问问题)"""
+        return await get_shared_client(self.config)
+    
+    async def initialize(self) -> None:
+        """初始化集合"""
+        if self._initialized:
+            return
+        
+        client = await self._get_client()
+        
+        # 检查集合是否存在
+        collections = await client.get_collections()
+        exists = any(c.name == self.collection_name for c in collections.collections)
+        
+        if not exists:
+            # 创建集合
+            await client.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=VectorParams(
+                    size=self.config.vector_size,
+                    distance=self.config.distance,
+                    hnsw_config=models.HnswConfigDiff(
+                        m=self.config.hnsw_m,
+                        ef_construct=self.config.hnsw_ef_construct,
+                    ),
+                ),
+                # 启用 payload 索引以加速过滤
+                optimizers_config=models.OptimizersConfigDiff(
+                    indexing_threshold=0,  # 立即索引
+                ),
+            )
+            
+            # 创建 payload 索引
+            await client.create_payload_index(
+                collection_name=self.collection_name,
+                field_name=self.FIELD_FILE,
+                field_schema=PayloadSchemaType.KEYWORD,
+            )
+            
+            logger.info(f"✅ 创建集合: {self.collection_name}")
+        else:
+            logger.debug(f"📂 集合已存在: {self.collection_name}")
+        
+        self._initialized = True
+    
+    async def close(self) -> None:
+        """
+        关闭连接 (使用共享客户端时不实际关闭)
+        
+        注意: 由于使用共享客户端，单个 Store 的 close() 不会关闭客户端。
+        全局关闭请使用 close_shared_client()
+        """
+        self._initialized = False
+        logger.debug(f"🔌 Store 已关闭: {self.collection_name}")
+    
+    async def add_documents(
+        self,
+        documents: List[Document],
+        embeddings: List[List[float]]
+    ) -> int:
+        """批量添加文档"""
+        if not documents or not embeddings:
+            return 0
+        
+        if len(documents) != len(embeddings):
+            raise ValueError(f"文档数量 ({len(documents)}) 与向量数量 ({len(embeddings)}) 不匹配")
+        
+        await self.initialize()
+        client = await self._get_client()
+        
+        # 过滤空向量
+        valid_pairs = [
+            (doc, emb) for doc, emb in zip(documents, embeddings)
+            if emb and len(emb) == self.config.vector_size
+        ]
+        
+        if not valid_pairs:
+            logger.warning("没有有效的文档向量对")
+            return 0
+        
+        # 构建 Points
+        points = []
+        for doc, embedding in valid_pairs:
+            point = PointStruct(
+                id=self._generate_point_id(doc.id),
+                vector=embedding,
+                payload={
+                    self.FIELD_CONTENT: doc.content,
+                    self.FIELD_FILE: doc.file_path,
+                    self.FIELD_METADATA: doc.metadata,
+                    "doc_id": doc.id,
+                },
+            )
+            points.append(point)
+        
+        # 批量 upsert
+        total_added = 0
+        batch_size = self.config.batch_size
+        
+        for i in range(0, len(points), batch_size):
+            batch = points[i:i + batch_size]
+            try:
+                await client.upsert(
+                    collection_name=self.collection_name,
+                    points=batch,
+                    wait=True,
+                )
+                total_added += len(batch)
+            except Exception as e:
+                logger.error(f"批次 {i // batch_size + 1} 写入失败: {e}")
+        
+        logger.info(f"✅ 写入 {total_added}/{len(points)} 个文档到 {self.collection_name}")
+        return total_added
+    
+    def _generate_point_id(self, doc_id: str) -> int:
+        """生成数值型 Point ID (Qdrant 要求)"""
+        import hashlib
+        hash_bytes = hashlib.sha256(doc_id.encode()).digest()
+        # 取前 8 字节转为正整数
+        return int.from_bytes(hash_bytes[:8], byteorder='big') & 0x7FFFFFFFFFFFFFFF
+    
+    async def search(
+        self,
+        query_embedding: List[float],
+        top_k: int = 10,
+        filter_conditions: Optional[Dict[str, Any]] = None
+    ) -> List[SearchResult]:
+        """向量相似度搜索"""
+        if not query_embedding:
+            return []
+        
+        await self.initialize()
+        client = await self._get_client()
+        
+        # 构建过滤器
+        query_filter = None
+        if filter_conditions:
+            must_conditions = []
+            for field, value in filter_conditions.items():
+                must_conditions.append(
+                    FieldCondition(
+                        key=field,
+                        match=MatchValue(value=value),
+                    )
+                )
+            query_filter = Filter(must=must_conditions)
+        
+        try:
+            # 使用 query_points (qdrant-client >= 1.7.0)
+            results = await client.query_points(
+                collection_name=self.collection_name,
+                query=query_embedding,
+                limit=top_k,
+                query_filter=query_filter,
+                with_payload=True,
+                score_threshold=0.0,
+            )
+            
+            search_results = []
+            for hit in results.points:
+                payload = hit.payload or {}
+                doc = Document(
+                    id=payload.get("doc_id", str(hit.id)),
+                    content=payload.get(self.FIELD_CONTENT, ""),
+                    metadata=payload.get(self.FIELD_METADATA, {}),
+                )
+                search_results.append(SearchResult(
+                    document=doc,
+                    score=hit.score,
+                    source="vector",
+                ))
+            
+            return search_results
+            
+        except Exception as e:
+            logger.error(f"搜索失败: {e}")
+            return []
+    
+    async def delete_collection(self) -> bool:
+        """删除集合"""
+        try:
+            client = await self._get_client()
+            await client.delete_collection(self.collection_name)
+            self._initialized = False
+            logger.info(f"🗑️ 删除集合: {self.collection_name}")
+            return True
+        except Exception as e:
+            logger.error(f"删除集合失败: {e}")
+            return False
+    
+    async def get_stats(self) -> CollectionStats:
+        """获取集合统计"""
+        await self.initialize()
+        client = await self._get_client()
+        
+        try:
+            info = await client.get_collection(self.collection_name)
+            
+            # 获取所有唯一文件
+            indexed_files: Set[str] = set()
+            scroll_result = await client.scroll(
+                collection_name=self.collection_name,
+                limit=10000,
+                with_payload=[self.FIELD_FILE],
+            )
+            
+            for point in scroll_result[0]:
+                if point.payload:
+                    file_path = point.payload.get(self.FIELD_FILE)
+                    if file_path:
+                        indexed_files.add(file_path)
+            
+            return CollectionStats(
+                name=self.collection_name,
+                document_count=info.points_count or 0,
+                indexed_files=indexed_files,
+                vector_dimension=self.config.vector_size,
+            )
+        except Exception as e:
+            logger.error(f"获取统计失败: {e}")
+            return CollectionStats(name=self.collection_name, document_count=0)
+    
+    async def get_documents_by_file(self, file_path: str) -> List[Document]:
+        """根据文件路径获取文档"""
+        await self.initialize()
+        client = await self._get_client()
+        
+        try:
+            scroll_result = await client.scroll(
+                collection_name=self.collection_name,
+                scroll_filter=Filter(
+                    must=[
+                        FieldCondition(
+                            key=self.FIELD_FILE,
+                            match=MatchValue(value=file_path),
+                        )
+                    ]
+                ),
+                limit=1000,
+                with_payload=True,
+            )
+            
+            documents = []
+            for point in scroll_result[0]:
+                payload = point.payload or {}
+                doc = Document(
+                    id=payload.get("doc_id", str(point.id)),
+                    content=payload.get(self.FIELD_CONTENT, ""),
+                    metadata=payload.get(self.FIELD_METADATA, {}),
+                )
+                documents.append(doc)
+            
+            # 按行号排序
+            documents.sort(key=lambda d: d.metadata.get("start_line", 0))
+            return documents
+            
+        except Exception as e:
+            logger.error(f"获取文件文档失败: {e}")
+            return []
+    
+    async def get_all_documents(self) -> List[Document]:
+        """获取所有文档 (用于 BM25 索引构建)"""
+        await self.initialize()
+        client = await self._get_client()
+        
+        documents = []
+        offset = None
+        
+        try:
+            while True:
+                scroll_result = await client.scroll(
+                    collection_name=self.collection_name,
+                    limit=1000,
+                    offset=offset,
+                    with_payload=True,
+                )
+                
+                points, next_offset = scroll_result
+                
+                for point in points:
+                    payload = point.payload or {}
+                    doc = Document(
+                        id=payload.get("doc_id", str(point.id)),
+                        content=payload.get(self.FIELD_CONTENT, ""),
+                        metadata=payload.get(self.FIELD_METADATA, {}),
+                    )
+                    documents.append(doc)
+                
+                if next_offset is None:
+                    break
+                offset = next_offset
+            
+            return documents
+            
+        except Exception as e:
+            logger.error(f"获取所有文档失败: {e}")
+            return []
+
+
+# ============================================================
+# 工厂
+# ============================================================
+
+class QdrantStoreFactory:
+    """Qdrant 存储工厂"""
+    
+    def __init__(self, config: Optional[QdrantConfig] = None):
+        self.config = config or QdrantConfig.from_env()
+    
+    def create(self, collection_name: str) -> QdrantVectorStore:
+        """创建存储实例"""
+        return QdrantVectorStore(collection_name, self.config)
+    
+    async def get_client(self) -> AsyncQdrantClient:
+        """获取共享的 Qdrant 客户端"""
+        return await get_shared_client(self.config)
+
+
+# 全局工厂实例
+_qdrant_factory: Optional[QdrantStoreFactory] = None
+
+
+def get_qdrant_factory(config: Optional[QdrantConfig] = None) -> QdrantStoreFactory:
+    """获取工厂单例"""
+    global _qdrant_factory
+    if _qdrant_factory is None:
+        _qdrant_factory = QdrantStoreFactory(config)
+    return _qdrant_factory

app/utils/embedding.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+"""
+Embedding 服务 - 并发优化版
+
+特性:
+1. 并发批量请求 - 使用 asyncio.gather 并行处理多个批次
+2. 信号量控制 - 限制最大并发数，避免 API 限流
+3. 重试机制 - 使用 tenacity 处理临时性错误
+4. 智能分批 - 根据 token 数量动态调整批次大小
+"""
+
+import asyncio
+import logging
+from typing import List, Optional
+from dataclasses import dataclass
+
+from openai import AsyncOpenAI
+
+from app.core.config import settings
+from app.utils.retry import llm_retry, is_retryable_error
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class EmbeddingConfig:
+    """Embedding 服务配置"""
+    # API 配置
+    api_base_url: str = "https://api.siliconflow.cn/v1"
+    model_name: str = "BAAI/bge-m3"
+    
+    # 批处理配置
+    batch_size: int = 50              # 每批文本数量
+    max_text_length: int = 8000       # 单个文本最大字符数
+    
+    # 并发控制
+    max_concurrent_batches: int = 5   # 最大并发批次数
+    
+    # 超时配置
+    timeout: int = 60                 # 单次请求超时 (秒)
+
+
+class EmbeddingService:
+    """
+    高性能 Embedding 服务
+    
+    使用示例:
+    ```python
+    service = EmbeddingService()
+    
+    # 单文本
+    embedding = await service.embed_text("Hello world")
+    
+    # 批量文本 (自动并发优化)
+    texts = ["text1", "text2", ..., "text100"]
+    embeddings = await service.embed_batch(texts)
+    ```
+    """
+    
+    def __init__(self, config: Optional[EmbeddingConfig] = None):
+        self.config = config or EmbeddingConfig()
+        
+        # 初始化 OpenAI 客户端 (SiliconFlow 兼容 OpenAI 协议)
+        self._client = AsyncOpenAI(
+            api_key=settings.SILICON_API_KEY,
+            base_url=self.config.api_base_url,
+            timeout=self.config.timeout
+        )
+        
+        # 并发信号量
+        self._semaphore = asyncio.Semaphore(self.config.max_concurrent_batches)
+        
+        # 统计信息
+        self._stats = {
+            "total_requests": 0,
+            "successful_requests": 0,
+            "failed_requests": 0,
+            "total_texts": 0,
+            "retried_requests": 0
+        }
+    
+    def _preprocess_text(self, text: str) -> str:
+        """预处理文本: 移除换行、截断长度"""
+        text = text.replace("\n", " ").strip()
+        if len(text) > self.config.max_text_length:
+            text = text[:self.config.max_text_length]
+        return text
+    
+    @llm_retry
+    async def _embed_single_batch(self, texts: List[str]) -> List[List[float]]:
+        """
+        处理单个批次的 Embedding 请求 (带重试)
+        
+        Args:
+            texts: 预处理后的文本列表
+            
+        Returns:
+            embedding 向量列表
+        """
+        self._stats["total_requests"] += 1
+        
+        response = await self._client.embeddings.create(
+            input=texts,
+            model=self.config.model_name
+        )
+        
+        self._stats["successful_requests"] += 1
+        return [item.embedding for item in response.data]
+    
+    async def _embed_batch_with_semaphore(
+        self, 
+        batch_texts: List[str], 
+        batch_index: int
+    ) -> tuple[int, List[List[float]]]:
+        """
+        带信号量控制的批次处理
+        
+        Returns:
+            (batch_index, embeddings) - 返回索引用于结果排序
+        """
+        async with self._semaphore:
+            try:
+                embeddings = await self._embed_single_batch(batch_texts)
+                logger.debug(f"✅ 批次 {batch_index} 完成: {len(batch_texts)} 文本")
+                return (batch_index, embeddings)
+            except Exception as e:
+                self._stats["failed_requests"] += 1
+                logger.error(f"❌ 批次 {batch_index} 失败: {type(e).__name__}: {e}")
+                raise
+    
+    async def embed_text(self, text: str) -> List[float]:
+        """
+        获取单个文本的 Embedding
+        
+        Args:
+            text: 输入文本
+            
+        Returns:
+            embedding 向量，失败返回空列表
+        """
+        try:
+            processed = self._preprocess_text(text)
+            if not processed:
+                return []
+            
+            self._stats["total_texts"] += 1
+            embeddings = await self._embed_single_batch([processed])
+            return embeddings[0] if embeddings else []
+        except Exception as e:
+            logger.error(f"embed_text 失败: {e}")
+            return []
+    
+    async def embed_batch(
+        self, 
+        texts: List[str],
+        show_progress: bool = False
+    ) -> List[List[float]]:
+        """
+        批量获取 Embedding (并发优化)
+        
+        Args:
+            texts: 文本列表
+            show_progress: 是否显示进度日志
+            
+        Returns:
+            embedding 向量列表 (���输入顺序一致)
+            失败的文本对应空列表
+        """
+        if not texts:
+            return []
+        
+        # 预处理所有文本
+        processed_texts = [self._preprocess_text(t) for t in texts]
+        self._stats["total_texts"] += len(texts)
+        
+        # 分批
+        batch_size = self.config.batch_size
+        batches = [
+            processed_texts[i:i + batch_size] 
+            for i in range(0, len(processed_texts), batch_size)
+        ]
+        
+        total_batches = len(batches)
+        if show_progress:
+            logger.info(
+                f"📊 Embedding: {len(texts)} 文本 → {total_batches} 批次 "
+                f"(并发: {self.config.max_concurrent_batches})"
+            )
+        
+        # 并发执行所有批次
+        tasks = [
+            self._embed_batch_with_semaphore(batch, idx)
+            for idx, batch in enumerate(batches)
+        ]
+        
+        # 收集结果
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # 按批次索引排序并合并结果
+        embeddings = []
+        for result in sorted(results, key=lambda x: x[0] if isinstance(x, tuple) else float('inf')):
+            if isinstance(result, tuple):
+                batch_idx, batch_embeddings = result
+                embeddings.extend(batch_embeddings)
+            else:
+                # 异常情况: 填充空向量
+                # 找出这个批次有多少文本
+                failed_batch_size = batch_size  # 保守估计
+                embeddings.extend([[] for _ in range(failed_batch_size)])
+                logger.warning(f"批次失败，填充 {failed_batch_size} 个空向量")
+        
+        # 确保返回数量与输入一致
+        if len(embeddings) < len(texts):
+            embeddings.extend([[] for _ in range(len(texts) - len(embeddings))])
+        elif len(embeddings) > len(texts):
+            embeddings = embeddings[:len(texts)]
+        
+        if show_progress:
+            success_count = sum(1 for e in embeddings if e)
+            logger.info(f"✅ Embedding 完成: {success_count}/{len(texts)} 成功")
+        
+        return embeddings
+    
+    def get_stats(self) -> dict:
+        """获取统计信息"""
+        return self._stats.copy()
+    
+    def reset_stats(self):
+        """重置统计信息"""
+        for key in self._stats:
+            self._stats[key] = 0
+
+
+# 全局单例
+_embedding_service: Optional[EmbeddingService] = None
+
+
+def get_embedding_service(config: Optional[EmbeddingConfig] = None) -> EmbeddingService:
+    """获取 Embedding 服务单例"""
+    global _embedding_service
+    if _embedding_service is None:
+        _embedding_service = EmbeddingService(config)
+    return _embedding_service
+
+
+# 便捷函数
+async def embed_text(text: str) -> List[float]:
+    """快捷方式: 获取单个文本的 Embedding"""
+    return await get_embedding_service().embed_text(text)
+
+
+async def embed_batch(texts: List[str], show_progress: bool = False) -> List[List[float]]:
+    """快捷方式: 批量获取 Embedding"""
+    return await get_embedding_service().embed_batch(texts, show_progress)

app/utils/github_client.py

@@ -0,0 +1,478 @@
+# -*- coding: utf-8 -*-
+"""
+GitHub 异步客户端
+
+设计原则:
+1. 异步非阻塞 - 使用 httpx.AsyncClient
+2. 连接池复用 - 单例模式管理客户端生命周期
+3. 自动重试 - 集成 tenacity 处理瞬时错误
+4. 类型安全 - 完整的类型注解
+5. 可扩展 - 易于添加新的 API 端点
+"""
+
+import asyncio
+import base64
+import logging
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any, Set
+from contextlib import asynccontextmanager
+
+import httpx
+
+from app.core.config import settings
+from app.utils.retry import llm_retry  # 复用已有的重试装饰器
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================
+# 数据模型
+# ============================================================
+
+@dataclass
+class GitHubFile:
+    """GitHub 文件信息"""
+    path: str
+    type: str  # "blob" | "tree"
+    size: int = 0
+    sha: str = ""
+    
+    @property
+    def is_file(self) -> bool:
+        return self.type == "blob"
+    
+    @property
+    def is_directory(self) -> bool:
+        return self.type == "tree"
+
+
+@dataclass
+class GitHubRepo:
+    """GitHub 仓库信息"""
+    owner: str
+    name: str
+    default_branch: str = "main"
+    description: str = ""
+    stars: int = 0
+    
+    @property
+    def full_name(self) -> str:
+        return f"{self.owner}/{self.name}"
+
+
+@dataclass
+class FileFilter:
+    """文件过滤配置"""
+    ignored_extensions: Set[str] = field(default_factory=lambda: {
+        '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.mp4', '.webp',
+        '.pyc', '.pyo', '.lock', '.zip', '.tar', '.gz', '.pdf', '.woff', '.woff2',
+        '.DS_Store', '.gitignore', '.gitattributes', '.editorconfig'
+    })
+    
+    ignored_directories: Set[str] = field(default_factory=lambda: {
+        '.git', '.github', '.vscode', '.idea', '__pycache__',
+        'node_modules', 'venv', 'env', '.env', 'build', 'dist',
+        'site-packages', 'migrations', '.next', '.nuxt', 'coverage',
+        'vendor', 'target', 'out', 'bin', 'obj'
+    })
+    
+    max_file_size: int = 500_000  # 500KB
+    
+    def should_include(self, file: GitHubFile) -> bool:
+        """判断文件是否应该被包含"""
+        if not file.is_file:
+            return False
+        
+        # 检查目录
+        path_parts = file.path.split("/")
+        if any(part in self.ignored_directories for part in path_parts):
+            return False
+        
+        # 检查扩展名
+        ext = os.path.splitext(file.path)[1].lower()
+        if ext in self.ignored_extensions:
+            return False
+        
+        # 检查文件大小
+        if file.size > self.max_file_size:
+            return False
+        
+        return True
+
+
+# ============================================================
+# 异常定义
+# ============================================================
+
+class GitHubError(Exception):
+    """GitHub API 错误基类"""
+    def __init__(self, message: str, status_code: int = 0):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class GitHubAuthError(GitHubError):
+    """认证错误 (401)"""
+    pass
+
+
+class GitHubRateLimitError(GitHubError):
+    """速率限制错误 (403)"""
+    pass
+
+
+class GitHubNotFoundError(GitHubError):
+    """资源不存在 (404)"""
+    pass
+
+
+# ============================================================
+# GitHub 异步客户端
+# ============================================================
+
+class GitHubClient:
+    """
+    GitHub 异步 API 客户端
+    
+    使用示例:
+    ```python
+    async with GitHubClient() as client:
+        repo = await client.get_repo("owner", "repo")
+        files = await client.get_repo_tree(repo)
+        content = await client.get_file_content(repo, "README.md")
+    ```
+    """
+    
+    BASE_URL = "https://api.github.com"
+    
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        timeout: float = 30.0,
+        max_concurrent_requests: int = 10
+    ):
+        self.token = token or settings.GITHUB_TOKEN
+        self.timeout = timeout
+        self._client: Optional[httpx.AsyncClient] = None
+        self._semaphore = asyncio.Semaphore(max_concurrent_requests)
+    
+    @property
+    def _headers(self) -> Dict[str, str]:
+        """构建请求头"""
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "GitHub-Agent-Demo/1.0"
+        }
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+    
+    async def _ensure_client(self) -> httpx.AsyncClient:
+        """确保客户端已初始化"""
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=self.BASE_URL,
+                headers=self._headers,
+                timeout=httpx.Timeout(self.timeout),
+                follow_redirects=True,
+                limits=httpx.Limits(
+                    max_keepalive_connections=20,
+                    max_connections=50
+                )
+            )
+        return self._client
+    
+    async def close(self):
+        """关闭客户端连接"""
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+            self._client = None
+    
+    async def __aenter__(self):
+        await self._ensure_client()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+    
+    def _handle_error(self, response: httpx.Response, context: str = ""):
+        """统一错误处理"""
+        status = response.status_code
+        
+        try:
+            data = response.json()
+            message = data.get("message", response.text)
+        except Exception:
+            message = response.text
+        
+        error_msg = f"{context}: {message}" if context else message
+        
+        if status == 401:
+            raise GitHubAuthError(
+                "GitHub Token 无效或已过期，请检查 .env 配置",
+                status
+            )
+        elif status == 403:
+            if "rate limit" in message.lower():
+                raise GitHubRateLimitError(
+                    "GitHub API 请求已达上限，请稍后重试或添加 Token",
+                    status
+                )
+            raise GitHubError(error_msg, status)
+        elif status == 404:
+            raise GitHubNotFoundError(error_msg, status)
+        else:
+            raise GitHubError(error_msg, status)
+    
+    @llm_retry
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        发送 API 请求 (带重试)
+        
+        Args:
+            method: HTTP 方法
+            endpoint: API 端点 (如 /repos/{owner}/{repo})
+            **kwargs: 传递给 httpx 的参数
+            
+        Returns:
+            JSON 响应
+        """
+        async with self._semaphore:
+            client = await self._ensure_client()
+            response = await client.request(method, endpoint, **kwargs)
+            
+            if response.status_code >= 400:
+                self._handle_error(response, endpoint)
+            
+            return response.json()
+    
+    async def _request_raw(
+        self,
+        method: str,
+        endpoint: str,
+        **kwargs
+    ) -> httpx.Response:
+        """发送请求并返回原始响应"""
+        async with self._semaphore:
+            client = await self._ensure_client()
+            return await client.request(method, endpoint, **kwargs)
+    
+    # --------------------------------------------------------
+    # 仓库相关 API
+    # --------------------------------------------------------
+    
+    async def get_repo(self, owner: str, name: str) -> GitHubRepo:
+        """获取仓库信息"""
+        data = await self._request("GET", f"/repos/{owner}/{name}")
+        
+        return GitHubRepo(
+            owner=owner,
+            name=name,
+            default_branch=data.get("default_branch", "main"),
+            description=data.get("description", ""),
+            stars=data.get("stargazers_count", 0)
+        )
+    
+    async def get_repo_tree(
+        self,
+        repo: GitHubRepo,
+        file_filter: Optional[FileFilter] = None
+    ) -> List[GitHubFile]:
+        """
+        获取仓库文件树
+        
+        Args:
+            repo: 仓库信息
+            file_filter: 文件过滤器 (默认使用标准过滤)
+            
+        Returns:
+            过滤后的文件列表
+        """
+        filter_config = file_filter or FileFilter()
+        
+        data = await self._request(
+            "GET",
+            f"/repos/{repo.owner}/{repo.name}/git/trees/{repo.default_branch}",
+            params={"recursive": "1"}
+        )
+        
+        files = []
+        for item in data.get("tree", []):
+            file = GitHubFile(
+                path=item["path"],
+                type=item["type"],
+                size=item.get("size", 0),
+                sha=item.get("sha", "")
+            )
+            
+            if filter_config.should_include(file):
+                files.append(file)
+        
+        logger.info(f"📂 仓库 {repo.full_name}: 共 {len(data.get('tree', []))} 项, 过滤后 {len(files)} 文件")
+        return files
+    
+    # --------------------------------------------------------
+    # 文件内容 API
+    # --------------------------------------------------------
+    
+    async def get_file_content(
+        self,
+        repo: GitHubRepo,
+        path: str
+    ) -> Optional[str]:
+        """
+        获取单个文件内容
+        
+        Args:
+            repo: 仓库信息
+            path: 文件路径
+            
+        Returns:
+            文件内容 (UTF-8 解码)，失败返回 None
+        """
+        try:
+            data = await self._request(
+                "GET",
+                f"/repos/{repo.owner}/{repo.name}/contents/{path}",
+                params={"ref": repo.default_branch}
+            )
+            
+            # 处理目录情况
+            if isinstance(data, list):
+                file_names = [f["name"] for f in data]
+                return f"Directory '{path}' contains:\n" + "\n".join(
+                    f"- {name}" for name in file_names
+                )
+            
+            # 解码文件内容
+            content = data.get("content", "")
+            encoding = data.get("encoding", "base64")
+            
+            if encoding == "base64":
+                return base64.b64decode(content).decode("utf-8")
+            
+            return content
+            
+        except GitHubNotFoundError:
+            logger.warning(f"文件不存在: {path}")
+            return None
+        except UnicodeDecodeError:
+            logger.warning(f"文件无法解码为 UTF-8: {path}")
+            return None
+        except Exception as e:
+            logger.error(f"获取文件失败 {path}: {e}")
+            return None
+    
+    async def get_files_content(
+        self,
+        repo: GitHubRepo,
+        paths: List[str],
+        show_progress: bool = False
+    ) -> Dict[str, Optional[str]]:
+        """
+        批量获取文件内容 (并发优化)
+        
+        Args:
+            repo: 仓库信息
+            paths: 文件路径列表
+            show_progress: 是否显示进度
+            
+        Returns:
+            {path: content} 字典
+        """
+        if not paths:
+            return {}
+        
+        if show_progress:
+            logger.info(f"📥 开始下载 {len(paths)} 个文件 (并发: {self._semaphore._value})")
+        
+        # 并发获取所有文件
+        tasks = [
+            self.get_file_content(repo, path)
+            for path in paths
+        ]
+        
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # 组装结果
+        content_map = {}
+        success_count = 0
+        
+        for path, result in zip(paths, results):
+            if isinstance(result, Exception):
+                logger.error(f"下载失败 {path}: {result}")
+                content_map[path] = None
+            else:
+                content_map[path] = result
+                if result is not None:
+                    success_count += 1
+        
+        if show_progress:
+            logger.info(f"✅ 文件下载完成: {success_count}/{len(paths)} 成功")
+        
+        return content_map
+
+
+# ============================================================
+# 全局单例管理
+# ============================================================
+
+_github_client: Optional[GitHubClient] = None
+
+
+def get_github_client() -> GitHubClient:
+    """获取 GitHub 客户端单例"""
+    global _github_client
+    if _github_client is None:
+        _github_client = GitHubClient()
+    return _github_client
+
+
+async def close_github_client():
+    """关闭全局客户端 (应用关闭时调用)"""
+    global _github_client
+    if _github_client:
+        await _github_client.close()
+        _github_client = None
+
+
+# ============================================================
+# 便捷函数 (兼容旧接口)
+# ============================================================
+
+def parse_repo_url(url: str) -> Optional[tuple[str, str]]:
+    """
+    解析 GitHub URL
+    
+    Args:
+        url: GitHub 仓库 URL
+        
+    Returns:
+        (owner, repo) 元组，无效返回 None
+    """
+    if url.endswith(".git"):
+        url = url[:-4]
+    
+    # 支持多种格式
+    # https://github.com/owner/repo
+    # github.com/owner/repo
+    # owner/repo
+    
+    parts = url.replace("https://", "").replace("http://", "").split("/")
+    
+    if "github.com" in parts:
+        idx = parts.index("github.com")
+        if len(parts) > idx + 2:
+            return (parts[idx + 1], parts[idx + 2])
+    elif len(parts) == 2:
+        # 直接是 owner/repo 格式
+        return (parts[0], parts[1])
+    
+    return None

app/utils/llm_client.py

@@ -0,0 +1,108 @@
+# 文件路径: app/utils/llm_client.py
+"""
+统一 LLM 客户端入口
+
+支持多个 LLM 供应商，通过 LLM_PROVIDER 环境变量切换:
+- openai: OpenAI (GPT-4, GPT-4o 等)
+- deepseek: DeepSeek (deepseek-chat, deepseek-coder 等)
+- anthropic: Anthropic (Claude 3.5, Claude 3 等)
+- gemini: Google Gemini (gemini-1.5-pro 等)
+
+使用方式 (与原来完全兼容):
+    from app.utils.llm_client import client
+    
+    response = await client.chat.completions.create(
+        model=settings.default_model_name,
+        messages=[{"role": "user", "content": "Hello"}],
+        stream=True
+    )
+"""
+
+from app.core.config import settings
+from app.utils.llm_providers import LLMFactory, BaseLLMProvider
+from typing import Optional
+
+# 全局客户端实例
+client: Optional[BaseLLMProvider] = None
+
+def _initialize_client() -> Optional[BaseLLMProvider]:
+    """
+    初始化 LLM 客户端
+    
+    根据配置的 LLM_PROVIDER 创建对应的客户端实例。
+    """
+    provider = settings.LLM_PROVIDER.lower()
+    api_key = settings.current_api_key
+    base_url = settings.current_base_url
+    model_name = settings.default_model_name
+    
+    if not api_key:
+        print(f"❌ 未找到 {provider.upper()}_API_KEY")
+        return None
+    
+    try:
+        return LLMFactory.create(
+            provider=provider,
+            api_key=api_key,
+            model_name=model_name,
+            base_url=base_url,
+            temperature=settings.LLM_TEMPERATURE,
+            max_tokens=settings.LLM_MAX_TOKENS,
+            timeout=settings.LLM_TIMEOUT,
+        )
+    except Exception as e:
+        print(f"❌ LLM Client 初始化失败: {e}")
+        return None
+
+
+def get_client() -> Optional[BaseLLMProvider]:
+    """
+    获取 LLM 客户端实例
+    
+    如果客户端尚未初始化，会自动初始化。
+    """
+    global client
+    if client is None:
+        client = _initialize_client()
+    return client
+
+
+def reinitialize_client(
+    provider: str = None,
+    api_key: str = None,
+    model_name: str = None,
+    base_url: str = None,
+) -> Optional[BaseLLMProvider]:
+    """
+    重新初始化客户端
+    
+    用于运行时切换 LLM 供应商或模型。
+    
+    Args:
+        provider: 新的供应商 (可选)
+        api_key: 新的 API Key (可选)
+        model_name: 新的模型名称 (可选)
+        base_url: 新的 Base URL (可选)
+    """
+    global client
+    
+    _provider = provider or settings.LLM_PROVIDER
+    _api_key = api_key or settings.current_api_key
+    _model_name = model_name or settings.default_model_name
+    _base_url = base_url or settings.current_base_url
+    
+    try:
+        client = LLMFactory.create(
+            provider=_provider,
+            api_key=_api_key,
+            model_name=_model_name,
+            base_url=_base_url,
+        )
+        return client
+    except Exception as e:
+        print(f"❌ 重新初始化失败: {e}")
+        return None
+
+
+# 自动初始化客户端
+client = _initialize_client()

app/utils/llm_providers/__init__.py

@@ -0,0 +1,29 @@
+# 文件路径: app/utils/llm_providers/__init__.py
+"""
+多 LLM 供应商支持模块
+
+支持的供应商:
+- OpenAI (GPT-4, GPT-4o, GPT-3.5-turbo 等)
+- DeepSeek (deepseek-chat, deepseek-coder 等)
+- Anthropic (Claude 3.5, Claude 3 等)
+- Google Gemini (gemini-pro, gemini-1.5-pro 等)
+"""
+
+from .base import BaseLLMProvider, LLMResponse, LLMConfig
+from .openai_provider import OpenAIProvider
+from .deepseek_provider import DeepSeekProvider
+from .anthropic_provider import AnthropicProvider
+from .gemini_provider import GeminiProvider
+from .factory import LLMFactory, get_llm_client
+
+__all__ = [
+    "BaseLLMProvider",
+    "LLMResponse",
+    "LLMConfig",
+    "OpenAIProvider",
+    "DeepSeekProvider",
+    "AnthropicProvider",
+    "GeminiProvider",
+    "LLMFactory",
+    "get_llm_client",
+]

app/utils/llm_providers/anthropic_provider.py

@@ -0,0 +1,196 @@
+# 文件路径: app/utils/llm_providers/anthropic_provider.py
+"""
+Anthropic (Claude) LLM 提供商实现
+
+支持模型: claude-3-5-sonnet, claude-3-opus, claude-3-haiku 等
+"""
+
+import uuid
+import time
+from typing import List, AsyncIterator
+
+from .base import (
+    BaseLLMProvider, 
+    LLMConfig, 
+    LLMMessage, 
+    LLMResponse, 
+    LLMChoice, 
+    LLMUsage,
+    LLMProviderType
+)
+
+
+class AnthropicProvider(BaseLLMProvider):
+    """
+    Anthropic (Claude) API 提供商
+    
+    注意: Anthropic 的消息格式与 OpenAI 略有不同:
+    - system 消息需要单独传递
+    - messages 只包含 user/assistant 轮次
+    """
+    
+    def __init__(self, config: LLMConfig):
+        super().__init__(config)
+        try:
+            from anthropic import AsyncAnthropic
+            self._client = AsyncAnthropic(
+                api_key=config.api_key,
+                timeout=config.timeout
+            )
+            self._available = True
+        except ImportError:
+            print("⚠️ anthropic 包未安装，请运行: pip install anthropic")
+            self._client = None
+            self._available = False
+    
+    def _extract_system_message(self, messages: List[LLMMessage]) -> tuple:
+        """
+        提取 system 消息
+        
+        Anthropic 需要将 system 消息单独传递,
+        不能放在 messages 列表中。
+        
+        Returns:
+            (system_prompt, filtered_messages)
+        """
+        system_prompt = None
+        filtered_messages = []
+        
+        for msg in messages:
+            if msg.role == "system":
+                system_prompt = msg.content
+            else:
+                filtered_messages.append(msg)
+        
+        return system_prompt, filtered_messages
+    
+    async def chat_completions_create(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> LLMResponse:
+        """非流式请求"""
+        if not self._available:
+            raise RuntimeError("Anthropic client not available. Please install: pip install anthropic")
+        
+        system_prompt, filtered_messages = self._extract_system_message(messages)
+        
+        # 转换消息格式
+        api_messages = [
+            {"role": m.role, "content": m.content} 
+            for m in filtered_messages
+        ]
+        
+        # 构建请求参数
+        request_params = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        
+        if system_prompt:
+            request_params["system"] = system_prompt
+        
+        response = await self._client.messages.create(**request_params)
+        
+        # 转换为统一格式
+        content = ""
+        if response.content:
+            # Anthropic 的 content 是一个 list
+            for block in response.content:
+                if hasattr(block, 'text'):
+                    content += block.text
+        
+        choices = [
+            LLMChoice(
+                index=0,
+                message=LLMMessage(role="assistant", content=content),
+                finish_reason=response.stop_reason
+            )
+        ]
+        
+        usage = LLMUsage(
+            prompt_tokens=response.usage.input_tokens,
+            completion_tokens=response.usage.output_tokens,
+            total_tokens=response.usage.input_tokens + response.usage.output_tokens
+        )
+        
+        return LLMResponse(
+            id=response.id,
+            model=response.model,
+            choices=choices,
+            usage=usage,
+            created=int(time.time())
+        )
+    
+    async def chat_completions_create_stream(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> AsyncIterator[LLMResponse]:
+        """流式请求"""
+        if not self._available:
+            raise RuntimeError("Anthropic client not available. Please install: pip install anthropic")
+        
+        system_prompt, filtered_messages = self._extract_system_message(messages)
+        
+        api_messages = [
+            {"role": m.role, "content": m.content} 
+            for m in filtered_messages
+        ]
+        
+        request_params = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        
+        if system_prompt:
+            request_params["system"] = system_prompt
+        
+        response_id = f"msg_{uuid.uuid4().hex[:24]}"
+        
+        async with self._client.messages.stream(**request_params) as stream:
+            async for text in stream.text_stream:
+                choices = [
+                    LLMChoice(
+                        index=0,
+                        delta=LLMMessage(role="assistant", content=text),
+                        finish_reason=None
+                    )
+                ]
+                yield LLMResponse(
+                    id=response_id,
+                    model=model,
+                    choices=choices,
+                    created=int(time.time())
+                )
+    
+    def validate_connection(self) -> bool:
+        """验证连接"""
+        return self._available and bool(self.config.api_key)
+
+
+def create_anthropic_provider(
+    api_key: str,
+    model_name: str = "claude-3-5-sonnet-20241022",
+    **kwargs
+) -> AnthropicProvider:
+    """工厂函数：创建 Anthropic 提供商"""
+    config = LLMConfig(
+        provider=LLMProviderType.ANTHROPIC,
+        api_key=api_key,
+        model_name=model_name,
+        **kwargs
+    )
+    return AnthropicProvider(config)

app/utils/llm_providers/base.py

@@ -0,0 +1,320 @@
+# 文件路径: app/utils/llm_providers/base.py
+"""
+LLM 提供商基类定义
+
+定义统一的接口规范，所有供应商实现都必须遵循此规范。
+采用适配器模式，将不同供应商的 API 统一为 OpenAI 兼容格式。
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional, AsyncIterator, Union
+from enum import Enum
+
+from app.utils.retry import llm_retry, is_retryable_error
+
+# 配置日志
+logger = logging.getLogger("llm_provider")
+
+
+class LLMProviderType(str, Enum):
+    """支持的 LLM 供应商类型"""
+    OPENAI = "openai"
+    DEEPSEEK = "deepseek"
+    ANTHROPIC = "anthropic"
+    GEMINI = "gemini"
+
+
+@dataclass
+class LLMConfig:
+    """LLM 配置"""
+    provider: LLMProviderType
+    api_key: str
+    model_name: str
+    base_url: Optional[str] = None
+    temperature: float = 0.1
+    max_tokens: int = 4096
+    timeout: int = 600
+    extra_params: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass 
+class LLMMessage:
+    """消息格式 (兼容 OpenAI)"""
+    role: str  # "system", "user", "assistant"
+    content: str
+
+
+@dataclass
+class LLMUsage:
+    """Token 使用量"""
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+
+@dataclass
+class LLMChoice:
+    """响应选项 (兼容 OpenAI)"""
+    index: int
+    message: Optional[LLMMessage] = None
+    delta: Optional[LLMMessage] = None  # 流式响应时使用
+    finish_reason: Optional[str] = None
+
+
+@dataclass
+class LLMResponse:
+    """
+    统一的 LLM 响应格式
+    
+    设计为兼容 OpenAI 的 ChatCompletion 格式，
+    使得现有代码无需大幅修改即可使用。
+    """
+    id: str
+    model: str
+    choices: List[LLMChoice]
+    usage: Optional[LLMUsage] = None
+    created: int = 0
+    
+    @property
+    def content(self) -> str:
+        """便捷方法：获取第一个选项的内容"""
+        if self.choices and self.choices[0].message:
+            return self.choices[0].message.content
+        return ""
+
+
+# 辅助类定义（在 BaseLLMProvider 外部，避免嵌套类问题）
+class _CompletionsNamespace:
+    """模拟 client.chat.completions 命名空间"""
+    def __init__(self, provider: 'BaseLLMProvider'):
+        self._provider = provider
+    
+    async def create(
+        self,
+        model: str = None,
+        messages: List[Dict[str, str]] = None,
+        temperature: float = None,
+        max_tokens: int = None,
+        stream: bool = False,
+        timeout: int = None,
+        **kwargs
+    ) -> Union[LLMResponse, AsyncIterator[LLMResponse]]:
+        """
+        统一的 completions.create 接口
+        
+        兼容 OpenAI SDK 调用方式:
+        response = await client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True
+        )
+        
+        内置重试机制:
+        - 自动重试网络错误、超时、速率限制
+        - 指数退避策略
+        - 最多重试 3 次
+        """
+        # 合并配置
+        _model = model or self._provider.config.model_name
+        _temperature = temperature if temperature is not None else self._provider.config.temperature
+        _max_tokens = max_tokens or self._provider.config.max_tokens
+        _timeout = timeout or self._provider.config.timeout
+        
+        # 转换消息格式
+        _messages = [
+            LLMMessage(role=m["role"], content=m["content"]) 
+            for m in (messages or [])
+        ]
+        
+        if stream:
+            # 流式请求: 返回带重试的异步生成器
+            return self._create_stream_with_retry(
+                messages=_messages,
+                model=_model,
+                temperature=_temperature,
+                max_tokens=_max_tokens,
+                timeout=_timeout,
+                **kwargs
+            )
+        else:
+            # 非流式请求: 使用 tenacity 重试
+            return await self._create_with_retry(
+                messages=_messages,
+                model=_model,
+                temperature=_temperature,
+                max_tokens=_max_tokens,
+                timeout=_timeout,
+                **kwargs
+            )
+    
+    @llm_retry
+    async def _create_with_retry(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> LLMResponse:
+        """带重试的非流式请求"""
+        logger.debug(f"🔄 LLM 请求: model={model}, messages_count={len(messages)}")
+        return await self._provider.chat_completions_create(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            **kwargs
+        )
+    
+    async def _create_stream_with_retry(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        max_retries: int = 3,
+        **kwargs
+    ) -> AsyncIterator[LLMResponse]:
+        """
+        带重试的流式请求
+        
+        注意: 流式请求的重试策略与非流式不同
+        - 如果在获取流之前失败，可以重试
+        - 如果在流传输过程中失败，需要重新开始
+        """
+        last_error = None
+        
+        for attempt in range(1, max_retries + 1):
+            try:
+                logger.debug(f"🔄 LLM 流式请求 (尝试 {attempt}/{max_retries}): model={model}")
+                
+                # 获取流生成器
+                stream = self._provider.chat_completions_create_stream(
+                    messages=messages,
+                    model=model,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                    **kwargs
+                )
+                
+                # 迭代流并 yield
+                async for chunk in stream:
+                    yield chunk
+                
+                # 成功完成，退出重试循环
+                return
+                
+            except Exception as e:
+                last_error = e
+                if is_retryable_error(e) and attempt < max_retries:
+                    wait_time = min(2 ** attempt, 30)  # 指数退避
+                    logger.warning(
+                        f"🔄 LLM 流式请求失败 (尝试 {attempt}/{max_retries}): "
+                        f"{type(e).__name__}: {e}. 等待 {wait_time}s 后重试..."
+                    )
+                    import asyncio
+                    await asyncio.sleep(wait_time)
+                else:
+                    # 不可重试的错误或已达到最大重试次数
+                    logger.error(f"❌ LLM 流式请求最终失败: {type(e).__name__}: {e}")
+                    raise
+        
+        # 如果走到这里，说明所有重试都失败了
+        if last_error:
+            raise last_error
+
+
+class _ChatNamespace:
+    """模拟 client.chat 命名空间"""
+    def __init__(self, provider: 'BaseLLMProvider'):
+        self._provider = provider
+        self.completions = _CompletionsNamespace(provider)
+
+
+class BaseLLMProvider(ABC):
+    """
+    LLM 提供商抽象基类
+    
+    所有供应商实现都需要继承此类并实现以下方法:
+    - chat_completions_create: 非流式请求
+    - chat_completions_create_stream: 流式请求
+    
+    为了兼容现有代码，提供一个模拟 OpenAI 客户端的 chat.completions 接口。
+    """
+    
+    def __init__(self, config: LLMConfig):
+        self.config = config
+        self._client = None
+        # 模拟 OpenAI SDK 的接口结构
+        self.chat = _ChatNamespace(self)
+    
+    @abstractmethod
+    async def chat_completions_create(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> LLMResponse:
+        """
+        非流式 Chat Completion 请求
+        
+        Args:
+            messages: 消息列表
+            model: 模型名称
+            temperature: 温度参数
+            max_tokens: 最大 Token 数
+            timeout: 超时时间
+            
+        Returns:
+            LLMResponse: 统一格式的响应
+        """
+        pass
+    
+    @abstractmethod
+    async def chat_completions_create_stream(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> AsyncIterator[LLMResponse]:
+        """
+        流式 Chat Completion 请求
+        
+        Args:
+            messages: 消息列表
+            model: 模型名称
+            temperature: 温度参数
+            max_tokens: 最大 Token 数
+            timeout: 超时时间
+            
+        Yields:
+            LLMResponse: 流式响应块
+        """
+        pass
+    
+    @abstractmethod
+    def validate_connection(self) -> bool:
+        """验证连接是否正常"""
+        pass
+    
+    @property
+    def provider_name(self) -> str:
+        """获取供应商名称"""
+        return self.config.provider.value
+    
+    @property
+    def model_name(self) -> str:
+        """获取当前模型名称"""
+        return self.config.model_name

app/utils/llm_providers/deepseek_provider.py

@@ -0,0 +1,154 @@
+# 文件路径: app/utils/llm_providers/deepseek_provider.py
+"""
+DeepSeek LLM 提供商实现
+
+DeepSeek API 兼容 OpenAI 协议，因此直接复用 OpenAI SDK。
+支持模型: deepseek-chat, deepseek-coder, deepseek-reasoner 等
+"""
+
+from typing import List, AsyncIterator
+from openai import AsyncOpenAI
+
+from .base import (
+    BaseLLMProvider, 
+    LLMConfig, 
+    LLMMessage, 
+    LLMResponse, 
+    LLMChoice, 
+    LLMUsage,
+    LLMProviderType
+)
+
+
+# DeepSeek 默认 API 端点
+DEEPSEEK_DEFAULT_BASE_URL = "https://api.deepseek.com"
+
+
+class DeepSeekProvider(BaseLLMProvider):
+    """
+    DeepSeek API 提供商
+    
+    DeepSeek 使用 OpenAI 兼容协议，因此可以直接使用 OpenAI SDK。
+    """
+    
+    def __init__(self, config: LLMConfig):
+        super().__init__(config)
+        # 确保使用正确的 base_url
+        base_url = config.base_url or DEEPSEEK_DEFAULT_BASE_URL
+        self._client = AsyncOpenAI(
+            api_key=config.api_key,
+            base_url=base_url,
+            timeout=config.timeout
+        )
+    
+    async def chat_completions_create(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> LLMResponse:
+        """非流式请求"""
+        api_messages = [
+            {"role": m.role, "content": m.content} 
+            for m in messages
+        ]
+        
+        response = await self._client.chat.completions.create(
+            model=model,
+            messages=api_messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            **kwargs
+        )
+        
+        choices = [
+            LLMChoice(
+                index=c.index,
+                message=LLMMessage(role=c.message.role, content=c.message.content),
+                finish_reason=c.finish_reason
+            )
+            for c in response.choices
+        ]
+        
+        usage = None
+        if response.usage:
+            usage = LLMUsage(
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens
+            )
+        
+        return LLMResponse(
+            id=response.id,
+            model=response.model,
+            choices=choices,
+            usage=usage,
+            created=response.created
+        )
+    
+    async def chat_completions_create_stream(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> AsyncIterator[LLMResponse]:
+        """流式请求"""
+        api_messages = [
+            {"role": m.role, "content": m.content} 
+            for m in messages
+        ]
+        
+        stream = await self._client.chat.completions.create(
+            model=model,
+            messages=api_messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            stream=True,
+            **kwargs
+        )
+        
+        async for chunk in stream:
+            if chunk.choices:
+                delta_content = chunk.choices[0].delta.content or ""
+                choices = [
+                    LLMChoice(
+                        index=0,
+                        delta=LLMMessage(role="assistant", content=delta_content),
+                        finish_reason=chunk.choices[0].finish_reason
+                    )
+                ]
+                yield LLMResponse(
+                    id=chunk.id,
+                    model=chunk.model,
+                    choices=choices,
+                    created=chunk.created
+                )
+    
+    def validate_connection(self) -> bool:
+        """验证 API Key 有效性"""
+        return bool(self.config.api_key)
+
+
+def create_deepseek_provider(
+    api_key: str,
+    model_name: str = "deepseek-chat",
+    base_url: str = None,
+    **kwargs
+) -> DeepSeekProvider:
+    """工厂函数：创建 DeepSeek 提供商"""
+    config = LLMConfig(
+        provider=LLMProviderType.DEEPSEEK,
+        api_key=api_key,
+        model_name=model_name,
+        base_url=base_url or DEEPSEEK_DEFAULT_BASE_URL,
+        **kwargs
+    )
+    return DeepSeekProvider(config)

app/utils/llm_providers/factory.py

@@ -0,0 +1,171 @@
+# 文件路径: app/utils/llm_providers/factory.py
+"""
+LLM 工厂模块
+
+提供统一的 LLM 客户端创建接口，根据配置自动选择合适的供应商。
+"""
+
+import os
+from typing import Optional
+
+from .base import BaseLLMProvider, LLMConfig, LLMProviderType
+from .openai_provider import OpenAIProvider
+from .deepseek_provider import DeepSeekProvider, DEEPSEEK_DEFAULT_BASE_URL
+from .anthropic_provider import AnthropicProvider
+from .gemini_provider import GeminiProvider
+
+
+class LLMFactory:
+    """
+    LLM 客户端工厂
+    
+    根据提供商类型创建对应的客户端实例。
+    支持从环境变量自动配置。
+    """
+    
+    # 提供商类到枚举的映射
+    _providers = {
+        LLMProviderType.OPENAI: OpenAIProvider,
+        LLMProviderType.DEEPSEEK: DeepSeekProvider,
+        LLMProviderType.ANTHROPIC: AnthropicProvider,
+        LLMProviderType.GEMINI: GeminiProvider,
+    }
+    
+    # 默认模型名称映射
+    _default_models = {
+        LLMProviderType.OPENAI: "gpt-4o-mini",
+        LLMProviderType.DEEPSEEK: "deepseek-chat",
+        LLMProviderType.ANTHROPIC: "claude-3-5-sonnet-20241022",
+        LLMProviderType.GEMINI: "gemini-1.5-flash",
+    }
+    
+    # 默认 Base URL 映射
+    _default_base_urls = {
+        LLMProviderType.OPENAI: None,  # 使用 SDK 默认
+        LLMProviderType.DEEPSEEK: DEEPSEEK_DEFAULT_BASE_URL,
+        LLMProviderType.ANTHROPIC: None,
+        LLMProviderType.GEMINI: None,
+    }
+    
+    @classmethod
+    def create(
+        cls,
+        provider: str,
+        api_key: str,
+        model_name: str = None,
+        base_url: str = None,
+        **kwargs
+    ) -> Optional[BaseLLMProvider]:
+        """
+        创建 LLM 客户端
+        
+        Args:
+            provider: 提供商名称 ("openai", "deepseek", "anthropic", "gemini")
+            api_key: API Key
+            model_name: 模型名称 (可选，使用默认值)
+            base_url: 自定义 API 端点 (可选)
+            **kwargs: 其他配置参数
+            
+        Returns:
+            BaseLLMProvider 实例，或 None (如果创建失败)
+        """
+        try:
+            # 解析提供商类型
+            provider_type = LLMProviderType(provider.lower())
+        except ValueError:
+            print(f"❌ 不支持的 LLM 提供商: {provider}")
+            print(f"   支持的提供商: {', '.join([p.value for p in LLMProviderType])}")
+            return None
+        
+        if not api_key:
+            print(f"❌ 未提供 {provider} 的 API Key")
+            return None
+        
+        # 获取提供商类
+        provider_class = cls._providers.get(provider_type)
+        if not provider_class:
+            print(f"❌ 提供商 {provider} 未实现")
+            return None
+        
+        # 构建配置
+        config = LLMConfig(
+            provider=provider_type,
+            api_key=api_key,
+            model_name=model_name or cls._default_models.get(provider_type, "default"),
+            base_url=base_url or cls._default_base_urls.get(provider_type),
+            **kwargs
+        )
+        
+        try:
+            client = provider_class(config)
+            if client.validate_connection():
+                print(f"✅ {provider.upper()} Client 初始化成功 (Model: {config.model_name})")
+                return client
+            else:
+                print(f"❌ {provider.upper()} Client 验证失败")
+                return None
+        except Exception as e:
+            print(f"❌ {provider.upper()} Client 初始化失败: {e}")
+            return None
+    
+    @classmethod
+    def create_from_env(cls, provider: str = None) -> Optional[BaseLLMProvider]:
+        """
+        从环境变量创建 LLM 客户端
+        
+        环境变量命名规范:
+        - LLM_PROVIDER: 提供商名称 (可被参数覆盖)
+        - {PROVIDER}_API_KEY: API Key (如 OPENAI_API_KEY, DEEPSEEK_API_KEY)
+        - {PROVIDER}_BASE_URL: 自定义端点 (可选)
+        - MODEL_NAME: 模型名称 (可选)
+        
+        Args:
+            provider: 提供商名称 (可选，默认从 LLM_PROVIDER 环境变量读取)
+            
+        Returns:
+            BaseLLMProvider 实例
+        """
+        # 确定提供商
+        _provider = provider or os.getenv("LLM_PROVIDER", "deepseek")
+        _provider = _provider.lower()
+        
+        # 获取 API Key (支持多种命名方式)
+        key_env_names = [
+            f"{_provider.upper()}_API_KEY",
+            f"{_provider.upper()}API_KEY",
+        ]
+        
+        api_key = None
+        for key_name in key_env_names:
+            api_key = os.getenv(key_name)
+            if api_key:
+                break
+        
+        if not api_key:
+            print(f"❌ 未找到 {_provider.upper()} API Key")
+            print(f"   请设置环境变量: {key_env_names[0]}")
+            return None
+        
+        # 获取可选配置
+        base_url = os.getenv(f"{_provider.upper()}_BASE_URL")
+        model_name = os.getenv("MODEL_NAME")
+        
+        return cls.create(
+            provider=_provider,
+            api_key=api_key,
+            model_name=model_name,
+            base_url=base_url
+        )
+
+
+def get_llm_client(provider: str = None) -> Optional[BaseLLMProvider]:
+    """
+    便捷函数：获取 LLM 客户端
+    
+    Args:
+        provider: 提供商名称 (可选)
+        
+    Returns:
+        BaseLLMProvider 实例
+    """
+    return LLMFactory.create_from_env(provider)

app/utils/llm_providers/gemini_provider.py

@@ -0,0 +1,301 @@
+# 文件路径: app/utils/llm_providers/gemini_provider.py
+"""
+Google Gemini LLM 提供商实现
+
+支持模型: gemini-1.5-pro, gemini-1.5-flash, gemini-pro 等
+"""
+
+import uuid
+import time
+from typing import List, AsyncIterator
+
+from .base import (
+    BaseLLMProvider, 
+    LLMConfig, 
+    LLMMessage, 
+    LLMResponse, 
+    LLMChoice, 
+    LLMUsage,
+    LLMProviderType
+)
+
+
+class GeminiProvider(BaseLLMProvider):
+    """
+    Google Gemini API 提供商
+    
+    支持两种方式:
+    1. 使用 google-generativeai SDK (原生)
+    2. 使用 OpenAI 兼容接口 (通过 AI Studio 或 Vertex AI)
+    """
+    
+    def __init__(self, config: LLMConfig):
+        super().__init__(config)
+        self._available = False
+        self._use_openai_compat = config.base_url is not None
+        
+        if self._use_openai_compat:
+            # 使用 OpenAI 兼容模式 (推荐)
+            try:
+                from openai import AsyncOpenAI
+                self._client = AsyncOpenAI(
+                    api_key=config.api_key,
+                    base_url=config.base_url,
+                    timeout=config.timeout
+                )
+                self._available = True
+                print(f"✅ Gemini Provider (OpenAI Compatible) initialized")
+            except ImportError:
+                print("⚠️ openai 包未安装")
+        else:
+            # 使用 Google AI SDK (原生模式)
+            try:
+                import google.generativeai as genai
+                genai.configure(api_key=config.api_key)
+                self._genai = genai
+                self._model = genai.GenerativeModel(config.model_name)
+                self._available = True
+                print(f"✅ Gemini Provider (Native SDK) initialized")
+            except ImportError:
+                print("⚠️ google-generativeai 包未安装，请运行: pip install google-generativeai")
+                self._genai = None
+                self._model = None
+    
+    def _convert_messages_to_gemini(self, messages: List[LLMMessage]) -> tuple:
+        """
+        转换消息格式为 Gemini 格式
+        
+        Gemini 的消息格式:
+        - 不支持 system 角色，需要将其合并到第一条 user 消息
+        - role: "user" | "model" (不是 "assistant")
+        
+        Returns:
+            (history, current_message)
+        """
+        system_content = ""
+        converted = []
+        
+        for msg in messages:
+            if msg.role == "system":
+                system_content = msg.content + "\n\n"
+            elif msg.role == "assistant":
+                converted.append({"role": "model", "parts": [msg.content]})
+            else:  # user
+                content = msg.content
+                if system_content and len(converted) == 0:
+                    content = system_content + content
+                    system_content = ""
+                converted.append({"role": "user", "parts": [content]})
+        
+        if not converted:
+            return [], ""
+        
+        # 最后一条作为当前消息
+        if len(converted) == 1:
+            return [], converted[0]["parts"][0]
+        else:
+            return converted[:-1], converted[-1]["parts"][0]
+    
+    async def chat_completions_create(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> LLMResponse:
+        """非流式请求"""
+        if not self._available:
+            raise RuntimeError("Gemini client not available")
+        
+        if self._use_openai_compat:
+            # OpenAI 兼容模式
+            api_messages = [
+                {"role": m.role, "content": m.content} 
+                for m in messages
+            ]
+            
+            response = await self._client.chat.completions.create(
+                model=model,
+                messages=api_messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                timeout=timeout,
+                **kwargs
+            )
+            
+            choices = [
+                LLMChoice(
+                    index=c.index,
+                    message=LLMMessage(role=c.message.role, content=c.message.content),
+                    finish_reason=c.finish_reason
+                )
+                for c in response.choices
+            ]
+            
+            usage = None
+            if response.usage:
+                usage = LLMUsage(
+                    prompt_tokens=response.usage.prompt_tokens,
+                    completion_tokens=response.usage.completion_tokens,
+                    total_tokens=response.usage.total_tokens
+                )
+            
+            return LLMResponse(
+                id=response.id,
+                model=response.model,
+                choices=choices,
+                usage=usage,
+                created=response.created
+            )
+        else:
+            # Native SDK 模式
+            history, current_msg = self._convert_messages_to_gemini(messages)
+            
+            generation_config = {
+                "temperature": temperature,
+                "max_output_tokens": max_tokens,
+            }
+            
+            chat = self._model.start_chat(history=history)
+            response = await chat.send_message_async(
+                current_msg,
+                generation_config=generation_config
+            )
+            
+            content = response.text if response.text else ""
+            
+            choices = [
+                LLMChoice(
+                    index=0,
+                    message=LLMMessage(role="assistant", content=content),
+                    finish_reason="stop"
+                )
+            ]
+            
+            # Gemini 原生 SDK 的 token 统计
+            usage = None
+            if hasattr(response, 'usage_metadata') and response.usage_metadata:
+                usage = LLMUsage(
+                    prompt_tokens=getattr(response.usage_metadata, 'prompt_token_count', 0),
+                    completion_tokens=getattr(response.usage_metadata, 'candidates_token_count', 0),
+                    total_tokens=getattr(response.usage_metadata, 'total_token_count', 0)
+                )
+            
+            return LLMResponse(
+                id=f"gemini-{uuid.uuid4().hex[:12]}",
+                model=model,
+                choices=choices,
+                usage=usage,
+                created=int(time.time())
+            )
+    
+    async def chat_completions_create_stream(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> AsyncIterator[LLMResponse]:
+        """流式请求"""
+        if not self._available:
+            raise RuntimeError("Gemini client not available")
+        
+        if self._use_openai_compat:
+            # OpenAI 兼容模式
+            api_messages = [
+                {"role": m.role, "content": m.content} 
+                for m in messages
+            ]
+            
+            stream = await self._client.chat.completions.create(
+                model=model,
+                messages=api_messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                timeout=timeout,
+                stream=True,
+                **kwargs
+            )
+            
+            async for chunk in stream:
+                if chunk.choices:
+                    delta_content = chunk.choices[0].delta.content or ""
+                    choices = [
+                        LLMChoice(
+                            index=0,
+                            delta=LLMMessage(role="assistant", content=delta_content),
+                            finish_reason=chunk.choices[0].finish_reason
+                        )
+                    ]
+                    yield LLMResponse(
+                        id=chunk.id,
+                        model=chunk.model,
+                        choices=choices,
+                        created=chunk.created
+                    )
+        else:
+            # Native SDK 流式
+            history, current_msg = self._convert_messages_to_gemini(messages)
+            
+            generation_config = {
+                "temperature": temperature,
+                "max_output_tokens": max_tokens,
+            }
+            
+            chat = self._model.start_chat(history=history)
+            response = await chat.send_message_async(
+                current_msg,
+                generation_config=generation_config,
+                stream=True
+            )
+            
+            response_id = f"gemini-{uuid.uuid4().hex[:12]}"
+            
+            async for chunk in response:
+                if chunk.text:
+                    choices = [
+                        LLMChoice(
+                            index=0,
+                            delta=LLMMessage(role="assistant", content=chunk.text),
+                            finish_reason=None
+                        )
+                    ]
+                    yield LLMResponse(
+                        id=response_id,
+                        model=model,
+                        choices=choices,
+                        created=int(time.time())
+                    )
+    
+    def validate_connection(self) -> bool:
+        """验证连接"""
+        return self._available and bool(self.config.api_key)
+
+
+def create_gemini_provider(
+    api_key: str,
+    model_name: str = "gemini-1.5-flash",
+    base_url: str = None,
+    **kwargs
+) -> GeminiProvider:
+    """
+    工厂函数：创建 Gemini 提供商
+    
+    Args:
+        api_key: Google AI API Key
+        model_name: 模型名称
+        base_url: OpenAI 兼容端点 (可选)
+                  如果不提供，则使用原生 SDK
+    """
+    config = LLMConfig(
+        provider=LLMProviderType.GEMINI,
+        api_key=api_key,
+        model_name=model_name,
+        base_url=base_url,
+        **kwargs
+    )
+    return GeminiProvider(config)

app/utils/llm_providers/openai_provider.py

@@ -0,0 +1,145 @@
+# 文件路径: app/utils/llm_providers/openai_provider.py
+"""
+OpenAI LLM 提供商实现
+
+支持模型: GPT-4, GPT-4o, GPT-4o-mini, GPT-3.5-turbo 等
+"""
+
+from typing import List, AsyncIterator
+from openai import AsyncOpenAI
+
+from .base import (
+    BaseLLMProvider, 
+    LLMConfig, 
+    LLMMessage, 
+    LLMResponse, 
+    LLMChoice, 
+    LLMUsage,
+    LLMProviderType
+)
+
+
+class OpenAIProvider(BaseLLMProvider):
+    """OpenAI API 提供商"""
+    
+    def __init__(self, config: LLMConfig):
+        super().__init__(config)
+        self._client = AsyncOpenAI(
+            api_key=config.api_key,
+            base_url=config.base_url,  # 可选自定义 base_url
+            timeout=config.timeout
+        )
+    
+    async def chat_completions_create(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> LLMResponse:
+        """非流式请求"""
+        # 转换消息格式
+        api_messages = [
+            {"role": m.role, "content": m.content} 
+            for m in messages
+        ]
+        
+        response = await self._client.chat.completions.create(
+            model=model,
+            messages=api_messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            **kwargs
+        )
+        
+        # 转换为统一格式
+        choices = [
+            LLMChoice(
+                index=c.index,
+                message=LLMMessage(role=c.message.role, content=c.message.content),
+                finish_reason=c.finish_reason
+            )
+            for c in response.choices
+        ]
+        
+        usage = None
+        if response.usage:
+            usage = LLMUsage(
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens
+            )
+        
+        return LLMResponse(
+            id=response.id,
+            model=response.model,
+            choices=choices,
+            usage=usage,
+            created=response.created
+        )
+    
+    async def chat_completions_create_stream(
+        self,
+        messages: List[LLMMessage],
+        model: str,
+        temperature: float,
+        max_tokens: int,
+        timeout: int,
+        **kwargs
+    ) -> AsyncIterator[LLMResponse]:
+        """流式请求"""
+        api_messages = [
+            {"role": m.role, "content": m.content} 
+            for m in messages
+        ]
+        
+        stream = await self._client.chat.completions.create(
+            model=model,
+            messages=api_messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            stream=True,
+            **kwargs
+        )
+        
+        async for chunk in stream:
+            if chunk.choices:
+                delta_content = chunk.choices[0].delta.content or ""
+                choices = [
+                    LLMChoice(
+                        index=0,
+                        delta=LLMMessage(role="assistant", content=delta_content),
+                        finish_reason=chunk.choices[0].finish_reason
+                    )
+                ]
+                yield LLMResponse(
+                    id=chunk.id,
+                    model=chunk.model,
+                    choices=choices,
+                    created=chunk.created
+                )
+    
+    def validate_connection(self) -> bool:
+        """验证 API Key 有效性"""
+        return bool(self.config.api_key)
+
+
+def create_openai_provider(
+    api_key: str,
+    model_name: str = "gpt-4o-mini",
+    base_url: str = None,
+    **kwargs
+) -> OpenAIProvider:
+    """工厂函数：创建 OpenAI 提供商"""
+    config = LLMConfig(
+        provider=LLMProviderType.OPENAI,
+        api_key=api_key,
+        model_name=model_name,
+        base_url=base_url,
+        **kwargs
+    )
+    return OpenAIProvider(config)

app/utils/repo_lock.py

@@ -0,0 +1,390 @@
+# -*- coding: utf-8 -*-
+"""
+仓库级分布式锁
+
+解决问题:
+1. 同一仓库的并发写入竞争 (两人同时输入同一 URL)
+2. 重新分析时的数据一致性 (用户 A 重分析，用户 B 同时查询)
+
+设计原则:
+- 单进程: asyncio.Lock (内存锁)
+- 多进程: 文件锁 (fcntl/msvcrt)
+- 多节点: 可选 Redis 分布式锁 (生产环境)
+
+使用示例:
+```python
+async with RepoLock.acquire(session_id):
+    # 独占访问该仓库的写操作
+    await vector_store.reset()
+    await vector_store.add_documents(docs)
+```
+"""
+
+import asyncio
+import logging
+import os
+import time
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================
+# 锁配置
+# ============================================================
+
+@dataclass
+class LockConfig:
+    """锁配置"""
+    # 锁类型: "memory" | "file" | "redis"
+    backend: str = os.getenv("LOCK_BACKEND", "file")
+    
+    # 文件锁目录
+    lock_dir: str = os.getenv("LOCK_DIR", "data/locks")
+    
+    # Redis 配置 (可选)
+    redis_url: str = os.getenv("REDIS_URL", "redis://localhost:6379/0")
+    
+    # 锁超时 (秒)
+    lock_timeout: float = float(os.getenv("LOCK_TIMEOUT", "300"))  # 5分钟
+    
+    # 等待超时 (秒)
+    acquire_timeout: float = float(os.getenv("LOCK_ACQUIRE_TIMEOUT", "60"))
+
+
+# ============================================================
+# 锁后端抽象
+# ============================================================
+
+class LockBackend(ABC):
+    """锁后端接口"""
+    
+    @abstractmethod
+    async def acquire(self, key: str, timeout: float) -> bool:
+        """获取锁"""
+        pass
+    
+    @abstractmethod
+    async def release(self, key: str) -> None:
+        """释放锁"""
+        pass
+    
+    @abstractmethod
+    async def is_locked(self, key: str) -> bool:
+        """检查是否已锁定"""
+        pass
+
+
+# ============================================================
+# 内存锁 (单进程)
+# ============================================================
+
+class MemoryLockBackend(LockBackend):
+    """
+    内存锁后端 (asyncio.Lock)
+    
+    适用于: 单 Worker 部署
+    """
+    
+    def __init__(self):
+        self._locks: Dict[str, asyncio.Lock] = {}
+        self._meta_lock = asyncio.Lock()
+    
+    async def _get_lock(self, key: str) -> asyncio.Lock:
+        async with self._meta_lock:
+            if key not in self._locks:
+                self._locks[key] = asyncio.Lock()
+            return self._locks[key]
+    
+    async def acquire(self, key: str, timeout: float) -> bool:
+        lock = await self._get_lock(key)
+        try:
+            await asyncio.wait_for(lock.acquire(), timeout=timeout)
+            return True
+        except asyncio.TimeoutError:
+            return False
+    
+    async def release(self, key: str) -> None:
+        if key in self._locks:
+            lock = self._locks[key]
+            if lock.locked():
+                lock.release()
+    
+    async def is_locked(self, key: str) -> bool:
+        if key not in self._locks:
+            return False
+        return self._locks[key].locked()
+
+
+# ============================================================
+# 文件锁 (多进程，单节点)
+# ============================================================
+
+class FileLockBackend(LockBackend):
+    """
+    文件锁后端
+    
+    适用于: 多 Worker 单节点部署 (Gunicorn + Qdrant Server)
+    
+    实现:
+    - Windows: msvcrt.locking
+    - Unix: fcntl.flock
+    """
+    
+    def __init__(self, lock_dir: str):
+        self._lock_dir = Path(lock_dir)
+        self._lock_dir.mkdir(parents=True, exist_ok=True)
+        self._handles: Dict[str, object] = {}
+        self._memory_locks: Dict[str, asyncio.Lock] = {}
+        self._meta_lock = asyncio.Lock()
+    
+    def _get_lock_path(self, key: str) -> Path:
+        # 清理 key，避免路径注入
+        safe_key = "".join(c if c.isalnum() or c in "_-" else "_" for c in key)
+        return self._lock_dir / f"{safe_key}.lock"
+    
+    async def _get_memory_lock(self, key: str) -> asyncio.Lock:
+        """同进程内的内存锁，防止同一进程内多个协程竞争文件锁"""
+        async with self._meta_lock:
+            if key not in self._memory_locks:
+                self._memory_locks[key] = asyncio.Lock()
+            return self._memory_locks[key]
+    
+    async def acquire(self, key: str, timeout: float) -> bool:
+        # 先获取内存锁
+        mem_lock = await self._get_memory_lock(key)
+        try:
+            await asyncio.wait_for(mem_lock.acquire(), timeout=timeout)
+        except asyncio.TimeoutError:
+            return False
+        
+        # 再获取文件锁
+        lock_path = self._get_lock_path(key)
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            try:
+                # 尝试获取文件锁
+                handle = open(lock_path, 'w')
+                
+                if os.name == 'nt':
+                    # Windows
+                    import msvcrt
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+                else:
+                    # Unix
+                    import fcntl
+                    fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                
+                self._handles[key] = handle
+                logger.debug(f"🔒 文件锁获取成功: {key}")
+                return True
+                
+            except (IOError, OSError):
+                # 锁被占用，等待后重试
+                if 'handle' in dir() and handle:
+                    handle.close()
+                await asyncio.sleep(0.1)
+        
+        # 超时，释放内存锁
+        mem_lock.release()
+        logger.warning(f"⏰ 文件锁获取超时: {key}")
+        return False
+    
+    async def release(self, key: str) -> None:
+        if key in self._handles:
+            handle = self._handles.pop(key)
+            try:
+                if os.name == 'nt':
+                    import msvcrt
+                    try:
+                        msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+                    except:
+                        pass
+                else:
+                    import fcntl
+                    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+                handle.close()
+            except:
+                pass
+            logger.debug(f"🔓 文件锁已释放: {key}")
+        
+        # 释放内存锁
+        if key in self._memory_locks:
+            lock = self._memory_locks[key]
+            if lock.locked():
+                lock.release()
+    
+    async def is_locked(self, key: str) -> bool:
+        lock_path = self._get_lock_path(key)
+        if not lock_path.exists():
+            return False
+        
+        try:
+            handle = open(lock_path, 'w')
+            if os.name == 'nt':
+                import msvcrt
+                msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+            handle.close()
+            return False
+        except (IOError, OSError):
+            return True
+
+
+# ============================================================
+# Redis 锁 (分布式，多节点)
+# ============================================================
+
+class RedisLockBackend(LockBackend):
+    """
+    Redis 分布式锁后端
+    
+    适用于: 多节点部署 (K8s + Redis)
+    
+    依赖: redis[hiredis]
+    """
+    
+    def __init__(self, redis_url: str, lock_timeout: float):
+        self._redis_url = redis_url
+        self._lock_timeout = lock_timeout
+        self._client = None
+        self._locks: Dict[str, object] = {}
+    
+    async def _get_client(self):
+        if self._client is None:
+            try:
+                import redis.asyncio as aioredis
+                self._client = await aioredis.from_url(self._redis_url)
+            except ImportError:
+                raise RuntimeError(
+                    "Redis 锁需要安装 redis 包: pip install redis[hiredis]"
+                )
+        return self._client
+    
+    async def acquire(self, key: str, timeout: float) -> bool:
+        client = await self._get_client()
+        lock_key = f"repo_lock:{key}"
+        
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            # 尝试设置锁
+            acquired = await client.set(
+                lock_key,
+                "locked",
+                nx=True,
+                ex=int(self._lock_timeout)
+            )
+            if acquired:
+                logger.debug(f"🔒 Redis 锁获取成功: {key}")
+                return True
+            await asyncio.sleep(0.1)
+        
+        logger.warning(f"⏰ Redis 锁获取超时: {key}")
+        return False
+    
+    async def release(self, key: str) -> None:
+        client = await self._get_client()
+        lock_key = f"repo_lock:{key}"
+        await client.delete(lock_key)
+        logger.debug(f"🔓 Redis 锁已释放: {key}")
+    
+    async def is_locked(self, key: str) -> bool:
+        client = await self._get_client()
+        lock_key = f"repo_lock:{key}"
+        return await client.exists(lock_key) > 0
+
+
+# ============================================================
+# 统一锁接口
+# ============================================================
+
+class RepoLock:
+    """
+    仓库级锁 - 统一接口
+    
+    自动根据配置选择后端:
+    - memory: 单进程内存锁 (开发)
+    - file: 文件锁 (多进程单节点)
+    - redis: 分布式锁 (多节点)
+    
+    使用:
+    ```python
+    async with RepoLock.acquire(session_id):
+        # 独占写操作
+        await store.reset()
+    ```
+    """
+    
+    _backend: Optional[LockBackend] = None
+    _config: Optional[LockConfig] = None
+    
+    @classmethod
+    def _get_backend(cls) -> LockBackend:
+        if cls._backend is None:
+            cls._config = LockConfig()
+            
+            if cls._config.backend == "redis":
+                cls._backend = RedisLockBackend(
+                    cls._config.redis_url,
+                    cls._config.lock_timeout
+                )
+                logger.info("🔐 使用 Redis 分布式锁")
+            elif cls._config.backend == "file":
+                cls._backend = FileLockBackend(cls._config.lock_dir)
+                logger.info(f"🔐 使用文件锁: {cls._config.lock_dir}")
+            else:
+                cls._backend = MemoryLockBackend()
+                logger.info("🔐 使用内存锁 (单进程)")
+        
+        return cls._backend
+    
+    @classmethod
+    @asynccontextmanager
+    async def acquire(cls, session_id: str, timeout: float = None):
+        """
+        获取仓库写锁
+        
+        Args:
+            session_id: 仓库的 session ID
+            timeout: 获取锁的超时时间 (默认从配置读取)
+        
+        Raises:
+            TimeoutError: 获取锁超时
+        """
+        backend = cls._get_backend()
+        config = cls._config or LockConfig()
+        wait_timeout = timeout or config.acquire_timeout
+        
+        acquired = await backend.acquire(session_id, wait_timeout)
+        if not acquired:
+            raise TimeoutError(f"无法获取仓库锁: {session_id} (等待 {wait_timeout}s)")
+        
+        try:
+            yield
+        finally:
+            await backend.release(session_id)
+    
+    @classmethod
+    async def is_locked(cls, session_id: str) -> bool:
+        """检查仓库是否被锁定"""
+        backend = cls._get_backend()
+        return await backend.is_locked(session_id)
+    
+    @classmethod
+    async def try_acquire(cls, session_id: str, timeout: float = 0.1):
+        """
+        尝试获取锁 (非阻塞)
+        
+        用于检测是否有其他用户正在分析同一仓库
+        """
+        backend = cls._get_backend()
+        return await backend.acquire(session_id, timeout)

app/utils/retry.py

@@ -0,0 +1,198 @@
+# 文件路径: app/utils/retry.py
+"""
+LLM 调用重试机制
+
+使用 tenacity 库实现智能重试策略:
+- 指数退避 (Exponential Backoff)
+- 可重试异常识别
+- 最大重试次数限制
+- 详细日志记录
+"""
+
+import logging
+from typing import Callable, Type, Tuple, Any
+from functools import wraps
+
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception_type,
+    before_sleep_log,
+    after_log,
+    RetryError,
+)
+
+# 配置日志
+logger = logging.getLogger("llm_retry")
+logger.setLevel(logging.INFO)
+
+
+# ============================================================================
+# 可重试的异常类型定义
+# ============================================================================
+
+# 网络/临时性错误 - 应该重试
+RETRYABLE_EXCEPTIONS: Tuple[Type[Exception], ...] = (
+    ConnectionError,
+    TimeoutError,
+)
+
+# 尝试导入各 SDK 的异常类型
+try:
+    from openai import (
+        APIConnectionError,
+        APITimeoutError,
+        RateLimitError,
+        InternalServerError,
+    )
+    RETRYABLE_EXCEPTIONS = RETRYABLE_EXCEPTIONS + (
+        APIConnectionError,
+        APITimeoutError,
+        RateLimitError,
+        InternalServerError,
+    )
+except ImportError:
+    pass
+
+try:
+    from anthropic import (
+        APIConnectionError as AnthropicConnectionError,
+        APITimeoutError as AnthropicTimeoutError,
+        RateLimitError as AnthropicRateLimitError,
+        InternalServerError as AnthropicServerError,
+    )
+    RETRYABLE_EXCEPTIONS = RETRYABLE_EXCEPTIONS + (
+        AnthropicConnectionError,
+        AnthropicTimeoutError,
+        AnthropicRateLimitError,
+        AnthropicServerError,
+    )
+except ImportError:
+    pass
+
+try:
+    import httpx
+    RETRYABLE_EXCEPTIONS = RETRYABLE_EXCEPTIONS + (
+        httpx.ConnectError,
+        httpx.ReadTimeout,
+        httpx.ConnectTimeout,
+    )
+except ImportError:
+    pass
+
+
+# ============================================================================
+# 重试配置
+# ============================================================================
+
+class RetryConfig:
+    """重试配置"""
+    MAX_ATTEMPTS: int = 3                    # 最大重试次数
+    MIN_WAIT_SECONDS: float = 1.0           # 最小等待时间
+    MAX_WAIT_SECONDS: float = 30.0          # 最大等待时间
+    EXPONENTIAL_MULTIPLIER: float = 2.0     # 指数退避乘数
+
+
+# ============================================================================
+# 重试装饰器
+# ============================================================================
+
+def create_retry_decorator(
+    max_attempts: int = RetryConfig.MAX_ATTEMPTS,
+    min_wait: float = RetryConfig.MIN_WAIT_SECONDS,
+    max_wait: float = RetryConfig.MAX_WAIT_SECONDS,
+):
+    """
+    创建 LLM 调用重试装饰器
+    
+    Args:
+        max_attempts: 最大重试次数
+        min_wait: 最小等待时间 (秒)
+        max_wait: 最大等待时间 (秒)
+        
+    Returns:
+        tenacity retry 装饰器
+    """
+    return retry(
+        # 重试条件: 仅对可重试异常进行重试
+        retry=retry_if_exception_type(RETRYABLE_EXCEPTIONS),
+        # 停止条件: 达到最大重试次数
+        stop=stop_after_attempt(max_attempts),
+        # 等待策略: 指数退避
+        wait=wait_exponential(
+            multiplier=RetryConfig.EXPONENTIAL_MULTIPLIER,
+            min=min_wait,
+            max=max_wait,
+        ),
+        # 日志: 重试前记录
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+        # 日志: 重试后记录
+        after=after_log(logger, logging.DEBUG),
+        # 重新抛出最后一个异常
+        reraise=True,
+    )
+
+
+# 默认的重试装饰器实例
+llm_retry = create_retry_decorator()
+
+
+def with_retry(func: Callable) -> Callable:
+    """
+    为异步函数添加重试能力的装饰器
+    
+    Usage:
+        @with_retry
+        async def call_llm(...):
+            ...
+    """
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        @llm_retry
+        async def _inner():
+            return await func(*args, **kwargs)
+        return await _inner()
+    return wrapper
+
+
+# ============================================================================
+# 便捷函数
+# ============================================================================
+
+async def retry_async(
+    coro_func: Callable,
+    *args,
+    max_attempts: int = RetryConfig.MAX_ATTEMPTS,
+    **kwargs
+) -> Any:
+    """
+    带重试的异步调用
+    
+    Usage:
+        result = await retry_async(
+            client.chat.completions.create,
+            model="gpt-4",
+            messages=[...]
+        )
+    """
+    decorator = create_retry_decorator(max_attempts=max_attempts)
+    
+    @decorator
+    async def _call():
+        return await coro_func(*args, **kwargs)
+    
+    return await _call()
+
+
+def is_retryable_error(error: Exception) -> bool:
+    """判断异常是否可重试"""
+    return isinstance(error, RETRYABLE_EXCEPTIONS)
+
+
+def log_retry_info(attempt: int, max_attempts: int, error: Exception, wait_time: float):
+    """记录重试信息的辅助函数"""
+    logger.warning(
+        f"🔄 LLM 调用失败 (尝试 {attempt}/{max_attempts}): {type(error).__name__}: {error}. "
+        f"等待 {wait_time:.1f}s 后重试..."
+    )

app/utils/session.py

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+"""
+Session 工具模块
+
+提供基于仓库 URL 的 Session ID 生成和管理
+"""
+
+import hashlib
+import re
+from typing import Optional, Tuple, Dict
+from urllib.parse import urlparse
+
+from app.core.config import conversation_config
+
+
+def normalize_repo_url(url: str) -> str:
+    """
+    标准化 GitHub 仓库 URL
+    
+    支持格式:
+    - https://github.com/owner/repo
+    - https://github.com/owner/repo.git
+    - https://github.com/owner/repo/tree/main
+    - git@github.com:owner/repo.git
+    
+    Returns:
+        标准化的 URL: https://github.com/owner/repo (全小写)
+    """
+    url = url.strip().lower()  # 统一转为小写
+    
+    # 处理 SSH 格式
+    if url.startswith('git@'):
+        # git@github.com:owner/repo.git -> https://github.com/owner/repo
+        match = re.match(r'git@github\.com:(.+?)(?:\.git)?$', url)
+        if match:
+            return f"https://github.com/{match.group(1)}"
+    
+    # 处理 HTTPS 格式
+    parsed = urlparse(url)
+    path = parsed.path.strip('/')
+    
+    # 移除 .git 后缀
+    if path.endswith('.git'):
+        path = path[:-4]
+    
+    # 只保留 owner/repo 部分
+    parts = path.split('/')
+    if len(parts) >= 2:
+        path = f"{parts[0]}/{parts[1]}"
+    
+    return f"https://github.com/{path}"
+
+
+def extract_repo_info(url: str) -> Tuple[str, str]:
+    """
+    从 URL 提取仓库信息
+    
+    Returns:
+        (owner, repo) 元组
+    """
+    normalized = normalize_repo_url(url)
+    path = urlparse(normalized).path.strip('/')
+    parts = path.split('/')
+    
+    if len(parts) >= 2:
+        return parts[0], parts[1]
+    return "", ""
+
+
+def generate_repo_session_id(repo_url: str) -> str:
+    """
+    基于仓库 URL 生成稳定的 Session ID
+    
+    同一仓库 URL -> 同一 Session ID
+    
+    格式: repo_{short_hash}_{owner}_{repo}
+    """
+    normalized = normalize_repo_url(repo_url)
+    owner, repo = extract_repo_info(repo_url)
+    
+    # 生成短 hash (8 字符)
+    url_hash = hashlib.sha256(normalized.encode()).hexdigest()[:8]
+    
+    # 清理 owner 和 repo 名称
+    clean_owner = re.sub(r'[^a-zA-Z0-9]', '', owner)[:10]
+    clean_repo = re.sub(r'[^a-zA-Z0-9]', '', repo)[:15]
+    
+    return f"repo_{url_hash}_{clean_owner}_{clean_repo}"
+
+
+def is_repo_session_id(session_id: str) -> bool:
+    """判断是否为仓库级 Session ID"""
+    return session_id.startswith("repo_")
+
+
+# === 对话历史管理 ===
+
+class ConversationMemory:
+    """
+    对话记忆管理 - 滑动窗口 + 摘要压缩
+    
+    特性:
+    1. 保留最近 N 轮完整对话
+    2. 早期对话自动压缩为摘要
+    3. 支持 token 估算
+    """
+    
+    def __init__(
+        self,
+        max_recent_turns: int = None,
+        max_context_tokens: int = None,
+        summary_threshold: int = None,
+    ):
+        # 使用统一配置
+        self.max_recent_turns = max_recent_turns or conversation_config.max_recent_turns
+        self.max_context_tokens = max_context_tokens or conversation_config.max_context_tokens
+        self.summary_threshold = summary_threshold or conversation_config.summary_threshold
+        
+        self._messages: list = []            # 完整消息历史
+        self._summary: Optional[str] = None  # 早期对话摘要
+        self._summary_up_to: int = 0         # 摘要覆盖到第 N 条消息
+    
+    def add_message(self, role: str, content: str) -> None:
+        """添加消息"""
+        self._messages.append({
+            "role": role,
+            "content": content
+        })
+    
+    def add_user_message(self, content: str) -> None:
+        """添加用户消息"""
+        self.add_message("user", content)
+    
+    def add_assistant_message(self, content: str) -> None:
+        """添加助手消息"""
+        self.add_message("assistant", content)
+    
+    def get_context_messages(self) -> list:
+        """
+        获取用于 LLM 的上下文消息
+        
+        策略:
+        1. 如果消息数 <= max_recent_turns * 2，返回全部
+        2. 否则返回: [摘要] + 最近 N 轮
+        """
+        total_messages = len(self._messages)
+        max_messages = self.max_recent_turns * 2  # user + assistant = 1 轮
+        
+        if total_messages <= max_messages:
+            return list(self._messages)
+        
+        # 需要截断
+        recent_messages = self._messages[-max_messages:]
+        
+        # 如果有摘要，加在前面
+        if self._summary:
+            return [
+                {"role": "system", "content": f"[Earlier conversation summary]\n{self._summary}"}
+            ] + recent_messages
+        
+        return recent_messages
+    
+    def needs_summarization(self) -> bool:
+        """检查是否需要生成摘要"""
+        unsummarized = len(self._messages) - self._summary_up_to
+        return unsummarized > self.summary_threshold * 2
+    
+    def get_messages_to_summarize(self) -> list:
+        """获取需要摘要的消息"""
+        if not self.needs_summarization():
+            return []
+        
+        # 保留最近的，摘要早期的
+        end_idx = len(self._messages) - self.max_recent_turns * 2
+        return self._messages[self._summary_up_to:end_idx]
+    
+    def set_summary(self, summary: str, up_to_index: int) -> None:
+        """设置摘要"""
+        if self._summary:
+            # 合并旧摘要
+            self._summary = f"{self._summary}\n\n{summary}"
+        else:
+            self._summary = summary
+        self._summary_up_to = up_to_index
+    
+    def clear(self) -> None:
+        """清空对话历史"""
+        self._messages = []
+        self._summary = None
+        self._summary_up_to = 0
+    
+    def get_turn_count(self) -> int:
+        """获取对话轮数"""
+        return len(self._messages) // 2
+    
+    def get_stats(self) -> dict:
+        """获取统计信息"""
+        return {
+            "total_messages": len(self._messages),
+            "turn_count": self.get_turn_count(),
+            "has_summary": self._summary is not None,
+            "summary_covers": self._summary_up_to,
+        }
+
+
+# === 全局对话记忆存储 ===
+# key: session_id, value: ConversationMemory
+# 纯内存存储，服务重启自动清空
+_conversation_memories: Dict[str, ConversationMemory] = {}
+
+
+def get_conversation_memory(session_id: str) -> ConversationMemory:
+    """获取或创建对话记忆"""
+    if session_id not in _conversation_memories:
+        _conversation_memories[session_id] = ConversationMemory()
+    return _conversation_memories[session_id]
+
+
+def clear_conversation_memory(session_id: str) -> None:
+    """清除对话记忆"""
+    if session_id in _conversation_memories:
+        del _conversation_memories[session_id]
+
+
+def get_memory_stats() -> dict:
+    """获取对话记忆统计"""
+    return {
+        "total_memories": len(_conversation_memories),
+        "sessions": list(_conversation_memories.keys()),
+    }

deploy.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+# ============================================================
+# GitHub RAG Agent - 生产环境部署脚本 (2核2G服务器优化版)
+# ============================================================
+# 
+# 使用方法:
+#   chmod +x deploy.sh
+#   ./deploy.sh
+#
+# 前置要求:
+#   - Python 3.10+
+#   - Docker (用于运行 Qdrant)
+#
+# ============================================================
+
+set -e
+
+echo "🚀 GitHub RAG Agent 部署脚本"
+echo "=========================================="
+
+# 检查是否在项目目录
+if [ ! -f "requirements.txt" ]; then
+    echo "❌ 请在项目根目录运行此脚本"
+    exit 1
+fi
+
+# 检查 .env 文件
+if [ ! -f ".env" ]; then
+    echo "❌ 未找到 .env 文件，请先复制 .env.example 并配置"
+    echo "   cp .env.example .env"
+    echo "   vim .env"
+    exit 1
+fi
+
+# ============================================================
+# 1. 启动 Qdrant Server (Docker)
+# ============================================================
+echo ""
+echo "📦 步骤 1: 启动 Qdrant Server..."
+
+# 检查 Docker 是否运行
+if ! docker info > /dev/null 2>&1; then
+    echo "❌ Docker 未运行，请先启动 Docker"
+    exit 1
+fi
+
+# 检查 Qdrant 容器是否已存在
+if docker ps -a --format '{{.Names}}' | grep -q "^qdrant-server$"; then
+    echo "   Qdrant 容器已存在，检查状态..."
+    if docker ps --format '{{.Names}}' | grep -q "^qdrant-server$"; then
+        echo "   ✅ Qdrant 已在运行"
+    else
+        echo "   🔄 启动已有的 Qdrant 容器..."
+        docker start qdrant-server
+    fi
+else
+    echo "   🆕 创建并启动 Qdrant 容器 (内存限制 512MB)..."
+    docker run -d \
+        --name qdrant-server \
+        --restart unless-stopped \
+        -p 6333:6333 \
+        -p 6334:6334 \
+        -v qdrant_data:/qdrant/storage \
+        -m 512m \
+        -e QDRANT__STORAGE__ON_DISK_PAYLOAD=true \
+        qdrant/qdrant:latest
+fi
+
+# 等待 Qdrant 就绪
+echo "   ⏳ 等待 Qdrant 就绪..."
+for i in {1..30}; do
+    if curl -s http://localhost:6333/health > /dev/null 2>&1; then
+        echo "   ✅ Qdrant 已就绪"
+        break
+    fi
+    sleep 1
+done
+
+# ============================================================
+# 2. 创建 Python 虚拟环境
+# ============================================================
+echo ""
+echo "🐍 步骤 2: 配置 Python 环境..."
+
+if [ ! -d "venv" ]; then
+    echo "   创建虚拟环境..."
+    python3 -m venv venv
+fi
+
+echo "   激活虚拟环境..."
+source venv/bin/activate
+
+echo "   安装依赖..."
+pip install -q --upgrade pip
+pip install -q -r requirements.txt
+
+# ============================================================
+# 3. 创建必要目录
+# ============================================================
+echo ""
+echo "📁 步骤 3: 创建数据目录..."
+mkdir -p data/locks
+mkdir -p data/contexts
+mkdir -p logs
+
+# ============================================================
+# 4. 设置环境变量
+# ============================================================
+echo ""
+echo "⚙️ 步骤 4: 配置环境变量..."
+
+# 从 .env 加载
+set -a
+source .env
+set +a
+
+# 设置 Server 模式
+export QDRANT_MODE=server
+export QDRANT_URL=http://localhost:6333
+export LOCK_BACKEND=file
+export LOCK_DIR=data/locks
+export GUNICORN_WORKERS=2
+
+echo "   QDRANT_MODE=$QDRANT_MODE"
+echo "   QDRANT_URL=$QDRANT_URL"
+echo "   GUNICORN_WORKERS=$GUNICORN_WORKERS"
+
+# ============================================================
+# 5. 启动应用
+# ============================================================
+echo ""
+echo "🌐 步骤 5: 启动 FastAPI 应用..."
+echo "=========================================="
+echo "   Workers: 2 (优化2核CPU)"
+echo "   监听地址: 0.0.0.0:8000"
+echo "   Qdrant: http://localhost:6333"
+echo "=========================================="
+echo ""
+echo "   按 Ctrl+C 停止服务"
+echo ""
+
+# 使用 Gunicorn 启动 (2 Workers)
+gunicorn app.main:app -c gunicorn_conf.py

docker-compose.yml

@@ -0,0 +1,102 @@
+# Docker Compose 配置 - 生产环境部署 (优化版: 2核2G服务器)
+# 包含: FastAPI 应用 + Qdrant Server
+
+version: '3.8'
+
+services:
+  # ============================================================
+  # Qdrant 向量数据库 (限制内存 512MB)
+  # ============================================================
+  qdrant:
+    image: qdrant/qdrant:latest
+    container_name: github-rag-qdrant
+    restart: unless-stopped
+    ports:
+      - "6333:6333"  # REST API
+      - "6334:6334"  # gRPC
+    volumes:
+      - qdrant_data:/qdrant/storage
+    environment:
+      - QDRANT__SERVICE__GRPC_PORT=6334
+      - QDRANT__STORAGE__ON_DISK_PAYLOAD=true  # Payload 存磁盘，省内存
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+        reservations:
+          memory: 256M
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:6333/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  # ============================================================
+  # FastAPI 应用 (2 Workers, 限制内存 1GB)
+  # ============================================================
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: github-rag-app
+    restart: unless-stopped
+    ports:
+      - "8000:8000"
+    environment:
+      # Qdrant Server 模式
+      - QDRANT_MODE=server
+      - QDRANT_URL=http://qdrant:6333
+      
+      # Worker 数量 (2核服务器建议2个)
+      - GUNICORN_WORKERS=2
+      
+      # 文件锁 (多 Worker)
+      - LOCK_BACKEND=file
+      - LOCK_DIR=/app/data/locks
+      
+      # LLM 配置 (从 .env 读取)
+      - LLM_PROVIDER=${LLM_PROVIDER:-deepseek}
+      - DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+      - GEMINI_API_KEY=${GEMINI_API_KEY}
+      - SILICON_API_KEY=${SILICON_API_KEY}
+      - GITHUB_TOKEN=${GITHUB_TOKEN}
+    volumes:
+      - app_data:/app/data
+      - app_logs:/app/logs
+    deploy:
+      resources:
+        limits:
+          memory: 1G
+        reservations:
+          memory: 512M
+    depends_on:
+      qdrant:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+volumes:
+  qdrant_data:
+    driver: local
+  app_data:
+    driver: local
+  app_logs:
+    driver: local
+
+# ============================================================
+# 使用说明
+# ============================================================
+# 1. 复制 .env.example 为 .env 并配置 API Keys
+# 2. 启动服务: docker-compose up -d
+# 3. 查看日志: docker-compose logs -f app
+# 4. 停止服务: docker-compose down
+# 
+# 扩展到多 Worker:
+# 修改 Dockerfile 中的 gunicorn workers 数量，或使用:
+# docker-compose up -d --scale app=3
+# 配合 Nginx/Traefik 做负载均衡

evaluation/__init__.py

@@ -0,0 +1,64 @@
+# evaluation/__init__.py
+"""
+Evaluation 模块
+
+提供完整的评估框架，包括：
+- 数据模型 (models.py)
+- 评估引擎 (evaluation_framework.py)
+- 数据路由 (data_router.py)
+- 工具函数 (utils.py)
+- 数据分析 (analyze_eval_results.py)
+- 数据清洗 (clean_and_export_sft_data.py)
+
+使用示例:
+    from evaluation import EvaluationEngine, DataRoutingEngine, EvaluationResult
+    from evaluation.models import GenerationMetrics
+"""
+
+# 核心导出
+from evaluation.models import (
+    EvaluationLayer,
+    DataQualityTier,
+    QueryRewriteMetrics,
+    RetrievalMetrics,
+    GenerationMetrics,
+    AgenticMetrics,
+    EvaluationResult,
+)
+
+from evaluation.data_router import DataRoutingEngine
+from evaluation.evaluation_framework import EvaluationEngine
+
+# 工具函数
+from evaluation.utils import (
+    is_chatty_query,
+    has_code_indicators,
+    read_jsonl,
+    append_jsonl,
+    safe_truncate,
+    smart_truncate,
+    SFTLengthConfig,
+)
+
+__all__ = [
+    # 枚举
+    "EvaluationLayer",
+    "DataQualityTier",
+    # 数据模型
+    "QueryRewriteMetrics",
+    "RetrievalMetrics", 
+    "GenerationMetrics",
+    "AgenticMetrics",
+    "EvaluationResult",
+    # 引擎
+    "EvaluationEngine",
+    "DataRoutingEngine",
+    # 工具函数
+    "is_chatty_query",
+    "has_code_indicators",
+    "read_jsonl",
+    "append_jsonl",
+    "safe_truncate",
+    "smart_truncate",
+    "SFTLengthConfig",
+]

evaluation/analyze_eval_results.py

@@ -0,0 +1,379 @@
+# 文件路径: evaluation/analyze_eval_results.py
+"""
+自动化数据分析脚本
+用于分析评估结果，识别问题并生成诊断报告
+
+核心功能:
+1. 自动读取所有评估结果
+2. 按问题类型分类 Bad Case
+3. 生成可视化报告
+4. 推荐优化方向
+
+Author: Dexter
+Date: 2025-01-27
+"""
+
+import os
+from typing import Dict, List
+from collections import Counter, defaultdict
+from datetime import datetime
+
+from evaluation.utils import read_jsonl
+
+
+class EvaluationAnalyzer:
+    """评估结果分析器"""
+    
+    def __init__(self, eval_results_file: str = "evaluation/sft_data/eval_results.jsonl"):
+        self.eval_results_file = eval_results_file
+        self.results: List[Dict] = read_jsonl(eval_results_file)
+        if not self.results:
+            print(f"⚠️ No results loaded from: {eval_results_file}")
+    
+    def get_basic_stats(self) -> Dict:
+        """获取基本统计"""
+        if not self.results:
+            return {}
+        
+        scores = [r.get("overall_score", 0) for r in self.results]
+        tiers = [r.get("data_quality_tier", "unknown") for r in self.results]
+        
+        return {
+            "total_evaluations": len(self.results),
+            "avg_score": sum(scores) / len(scores) if scores else 0,
+            "max_score": max(scores) if scores else 0,
+            "min_score": min(scores) if scores else 0,
+            "median_score": sorted(scores)[len(scores)//2] if scores else 0,
+            "quality_distribution": dict(Counter(tiers)),
+            "sft_ready_count": sum(1 for r in self.results if r.get("sft_ready", False))
+        }
+    
+    def identify_bad_cases(self, threshold: float = 0.6) -> List[Dict]:
+        """
+        识别 Bad Case (得分低于阈值的结果)
+        返回按得分排序的结果
+        """
+        bad_cases = [r for r in self.results if r.get("overall_score", 1) < threshold]
+        return sorted(bad_cases, key=lambda x: x.get("overall_score", 1))
+    
+    def categorize_failures(self) -> Dict[str, List[Dict]]:
+        """
+        按失败原因分类 Bad Case
+        
+        失败类型:
+        - retrieval_failure: 检索未命中
+        - generation_hallucination: 生成幻觉
+        - generation_incomplete: 回答不完整
+        - tool_call_error: 工具调用失败
+        """
+        categorized = defaultdict(list)
+        
+        for result in self.identify_bad_cases():
+            reasons = []
+            
+            # 检查检索失败
+            if result.get("retrieval"):
+                retrieval = result["retrieval"]
+                if retrieval.get("hit_rate", 1) == 0:
+                    reasons.append("retrieval_failure")
+                elif retrieval.get("recall_at_k", 1) < 0.5:
+                    reasons.append("retrieval_low_recall")
+            
+            # 检查生成问题
+            if result.get("generation"):
+                generation = result["generation"]
+                if generation.get("faithfulness", 1) < 0.5:
+                    reasons.append("generation_hallucination")
+                if generation.get("answer_completeness", 1) < 0.4:
+                    reasons.append("generation_incomplete")
+                if generation.get("hallucination_count", 0) > 0:
+                    reasons.append("hallucination_detected")
+            
+            # 检查Agent行为
+            if result.get("agentic"):
+                agentic = result["agentic"]
+                if not agentic.get("success", True):
+                    reasons.append("agentic_failure")
+            
+            # 如果没有具体原因,标记为unknown
+            if not reasons:
+                reasons.append("unknown")
+            
+            for reason in reasons:
+                categorized[reason].append(result)
+        
+        return dict(categorized)
+    
+    def layer_performance(self) -> Dict[str, Dict]:
+        """分析各层性能"""
+        layer_scores = defaultdict(list)
+        
+        for result in self.results:
+            if result.get("query_rewrite"):
+                score = result["query_rewrite"].get("overall_score", 0)
+                if score:
+                    layer_scores["query_rewrite"].append(score)
+            
+            if result.get("retrieval"):
+                score = result["retrieval"].get("overall_score", 0)
+                if score:
+                    layer_scores["retrieval"].append(score)
+            
+            if result.get("generation"):
+                score = result["generation"].get("overall_score", 0)
+                if score:
+                    layer_scores["generation"].append(score)
+            
+            if result.get("agentic"):
+                score = result["agentic"].get("overall_score", 0)
+                if score:
+                    layer_scores["agentic"].append(score)
+        
+        # 计算每层的统计
+        layer_stats = {}
+        for layer, scores in layer_scores.items():
+            if scores:
+                layer_stats[layer] = {
+                    "avg": sum(scores) / len(scores),
+                    "min": min(scores),
+                    "max": max(scores),
+                    "count": len(scores)
+                }
+        
+        return layer_stats
+    
+    def get_recommendations(self) -> List[str]:
+        """基于分析结果生成优化建议"""
+        recommendations = []
+        
+        # 分析各层性能
+        layer_perf = self.layer_performance()
+        
+        # 检索层分析
+        if "retrieval" in layer_perf:
+            retrieval_score = layer_perf["retrieval"]["avg"]
+            if retrieval_score < 0.7:
+                recommendations.append(
+                    "🔴 RETRIEVAL 层性能差 (avg: {:.2f})\n"
+                    "  建议:\n"
+                    "  1. 检查 chunking 策略是否过度分割\n"
+                    "  2. 优化 embedding 模型 (考虑更强的模型)\n"
+                    "  3. 调整混合检索的权重 (BM25 vs Vector)\n"
+                    "  4. 分析实际召回的文件,看是否与预期偏离".format(retrieval_score)
+                )
+        
+        # 生成层分析
+        if "generation" in layer_perf:
+            gen_score = layer_perf["generation"]["avg"]
+            if gen_score < 0.7:
+                recommendations.append(
+                    "🟡 GENERATION 层存在问题 (avg: {:.2f})\n"
+                    "  建议:\n"
+                    "  1. 检查 Prompt 是否清晰 (可能LLM理解偏差)\n"
+                    "  2. 检查是否存在幻觉 (生成不存在的函数名等)\n"
+                    "  3. 优化 Context 的组织方式\n"
+                    "  4. 考虑使用更强的LLM模型".format(gen_score)
+                )
+        
+        # Query Rewrite 分析
+        if "query_rewrite" in layer_perf:
+            rewrite_score = layer_perf["query_rewrite"]["avg"]
+            if rewrite_score < 0.6:
+                recommendations.append(
+                    "🟠 QUERY_REWRITE 层准确度低 (avg: {:.2f})\n"
+                    "  建议:\n"
+                    "  1. 优化关键词提取 Prompt\n"
+                    "  2. 增加多语言处理支持\n"
+                    "  3. 添加领域词汇表 (Domain Vocabulary)".format(rewrite_score)
+                )
+        
+        # 通用建议
+        stats = self.get_basic_stats()
+        if stats.get("sft_ready_count", 0) / max(stats.get("total_evaluations", 1), 1) < 0.5:
+            recommendations.append(
+                "⚠️ SFT 可用数据不足 (< 50%)\n"
+                "  立即行动:\n"
+                "  1. 运行 continuous_eval 脚本收集更多数据\n"
+                "  2. 对现有数据进行自纠正 (Self-Correction)\n"
+                "  3. 扩展黄金数据集来改进模型"
+            )
+        
+        return recommendations
+    
+    def generate_report(self, output_file: str = "evaluation/analysis_report.md") -> str:
+        """生成完整的分析报告"""
+        
+        report = []
+        report.append("# 📊 GitHub Agent 评估分析报告\n")
+        report.append(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+        report.append("---\n")
+        
+        # 1. 基本统计
+        stats = self.get_basic_stats()
+        report.append("## 📈 基本统计\n")
+        report.append(f"- 总评估次数: {stats.get('total_evaluations', 0)}\n")
+        report.append(f"- 平均得分: {stats.get('avg_score', 0):.3f}\n")
+        report.append(f"- 最高得分: {stats.get('max_score', 0):.3f}\n")
+        report.append(f"- 最低得分: {stats.get('min_score', 0):.3f}\n")
+        report.append(f"- 中位数得分: {stats.get('median_score', 0):.3f}\n")
+        report.append(f"- SFT 可用样本: {stats.get('sft_ready_count', 0)}\n\n")
+        
+        # 2. 质量分级分布
+        report.append("## 🏆 质量分级分布\n")
+        distribution = stats.get("quality_distribution", {})
+        for tier, count in sorted(distribution.items()):
+            percentage = (count / stats.get('total_evaluations', 1)) * 100
+            report.append(f"- {tier.upper()}: {count} ({percentage:.1f}%)\n")
+        report.append("\n")
+        
+        # 3. 各层性能
+        report.append("## 🎯 各层性能分析\n\n")
+        layer_perf = self.layer_performance()
+        for layer in ["query_rewrite", "retrieval", "generation", "agentic"]:
+            if layer in layer_perf:
+                perf = layer_perf[layer]
+                report.append(f"### {layer.upper()}\n")
+                report.append(f"- 平均得分: {perf['avg']:.3f}\n")
+                report.append(f"- 范围: [{perf['min']:.3f}, {perf['max']:.3f}]\n")
+                report.append(f"- 样本数: {perf['count']}\n\n")
+        
+        # 4. Bad Case 分类
+        report.append("## 🔴 Bad Case 分析\n\n")
+        failures = self.categorize_failures()
+        for reason, cases in sorted(failures.items(), key=lambda x: -len(x[1])):
+            report.append(f"### {reason} ({len(cases)} cases)\n")
+            for case in cases[:3]:  # 显示top 3
+                report.append(f"- 查询: {case.get('query', 'N/A')[:60]}...\n")
+                report.append(f"  得分: {case.get('overall_score', 0):.3f}\n")
+        report.append("\n")
+        
+        # 5. 推荐行动
+        report.append("## 💡 优化建议\n\n")
+        recommendations = self.get_recommendations()
+        for i, rec in enumerate(recommendations, 1):
+            report.append(f"{i}. {rec}\n\n")
+        
+        # 写入文件
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.writelines(report)
+        
+        return "".join(report)
+    
+    def export_bad_cases_csv(self, output_file: str = "evaluation/bad_cases.csv") -> None:
+        """导出 Bad Case 为 CSV (用于人工审查)"""
+        import csv
+        
+        bad_cases = self.identify_bad_cases()
+        
+        with open(output_file, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=[
+                "query", "overall_score", "tier",
+                "retrieval_score", "generation_score", "agentic_score",
+                "error_message", "timestamp"
+            ])
+            
+            writer.writeheader()
+            for case in bad_cases:
+                writer.writerow({
+                    "query": case.get("query", ""),
+                    "overall_score": case.get("overall_score", 0),
+                    "tier": case.get("data_quality_tier", "unknown"),
+                    "retrieval_score": case.get("retrieval", {}).get("overall_score", 0),
+                    "generation_score": case.get("generation", {}).get("overall_score", 0),
+                    "agentic_score": case.get("agentic", {}).get("overall_score", 0),
+                    "error_message": case.get("error_message", ""),
+                    "timestamp": case.get("timestamp", "")
+                })
+        
+        print(f"✅ Exported {len(bad_cases)} bad cases to {output_file}")
+
+
+# ============================================================================
+# 命令行工具
+# ============================================================================
+
+def print_summary(analyzer: EvaluationAnalyzer):
+    """打印摘要"""
+    print("\n" + "=" * 70)
+    print("📊 评估结果摘要")
+    print("=" * 70)
+    
+    stats = analyzer.get_basic_stats()
+    
+    print(f"\n📈 基本统计:")
+    print(f"  总评估: {stats.get('total_evaluations', 0)}")
+    print(f"  平均分: {stats.get('avg_score', 0):.3f}")
+    print(f"  分布: {stats.get('quality_distribution', {})}")
+    print(f"  SFT可用: {stats.get('sft_ready_count', 0)}")
+    
+    print(f"\n🎯 各层性能:")
+    layer_perf = analyzer.layer_performance()
+    for layer, perf in layer_perf.items():
+        print(f"  {layer:.<30} {perf['avg']:.3f} (avg)")
+    
+    print(f"\n🔴 Bad Case Top 5:")
+    bad_cases = analyzer.identify_bad_cases()[:5]
+    for i, case in enumerate(bad_cases, 1):
+        print(f"  {i}. {case.get('query', 'N/A')[:40]:<40} Score: {case.get('overall_score', 0):.3f}")
+    
+    print(f"\n💡 优化建议:")
+    recommendations = analyzer.get_recommendations()
+    for rec in recommendations[:3]:
+        print(f"  - {rec.split(chr(10))[0]}")
+    
+    print("\n" + "=" * 70)
+
+
+def main():
+    import sys
+    
+    analyzer = EvaluationAnalyzer()
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "summary":
+            print_summary(analyzer)
+        
+        elif command == "report":
+            report = analyzer.generate_report()
+            print(report)
+        
+        elif command == "bad-cases":
+            analyzer.export_bad_cases_csv()
+            bad_cases = analyzer.identify_bad_cases()
+            print(f"\n✅ Found {len(bad_cases)} bad cases")
+            print("详见 evaluation/bad_cases.csv")
+        
+        elif command == "layer-perf":
+            layer_perf = analyzer.layer_performance()
+            print("\n🎯 各层性能:")
+            for layer, perf in layer_perf.items():
+                print(f"\n{layer.upper()}:")
+                print(f"  Average: {perf['avg']:.3f}")
+                print(f"  Range: [{perf['min']:.3f}, {perf['max']:.3f}]")
+                print(f"  Samples: {perf['count']}")
+        
+        elif command == "recommendations":
+            recs = analyzer.get_recommendations()
+            print("\n💡 优化建议:\n")
+            for i, rec in enumerate(recs, 1):
+                print(f"{i}.\n{rec}\n")
+        
+        else:
+            print(f"Unknown command: {command}")
+    
+    else:
+        print("自动化评估数据分析工具")
+        print()
+        print("用法:")
+        print("  python analyze_eval_results.py summary         # 快速摘要")
+        print("  python analyze_eval_results.py report          # 生成完整报告")
+        print("  python analyze_eval_results.py bad-cases       # 导出Bad Case")
+        print("  python analyze_eval_results.py layer-perf      # 各层性能分析")
+        print("  python analyze_eval_results.py recommendations # 优化建议")
+
+
+if __name__ == "__main__":
+    main()

evaluation/clean_and_export_sft_data.py

@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+"""
+SFT 数据清洗与导出脚本
+
+功能:
+1. 从 eval_results.jsonl 读取原始评估数据
+2. 应用严格的质量过滤规则
+3. 转换为标准 SFT 训练格式
+4. 导出为可直接用于训练的数据集
+
+Author: Dexter
+Date: 2026-01-28
+"""
+
+import json
+import os
+from datetime import datetime
+from typing import Dict, List, Tuple
+from pathlib import Path
+
+from evaluation.utils import is_chatty_query, has_code_indicators
+
+
+# ============================================================================
+# 配置
+# ============================================================================
+
+class CleaningConfig:
+    """数据清洗配置"""
+    # 质量阈值
+    MIN_OVERALL_SCORE = 0.7          # 最低综合分
+    MIN_FAITHFULNESS = 0.6           # 最低 faithfulness
+    MIN_ANSWER_RELEVANCE = 0.6       # 最低 answer_relevance
+    
+    # 长度阈值
+    MIN_QUERY_LENGTH = 10            # 最短 query
+    MIN_ANSWER_LENGTH = 100          # 最短 answer
+    MIN_CONTEXT_LENGTH = 50          # 最短 context
+    MAX_CONTEXT_LENGTH = 4000        # 最长 context（截断）
+    
+    # 必须条件
+    REQUIRE_REPO_URL = True          # 必须有仓库 URL
+    REQUIRE_CODE_IN_CONTEXT = True   # 上下文必须包含代码
+    
+    # 输出配置
+    OUTPUT_DIR = "evaluation/sft_data/cleaned"
+
+
+# ============================================================================
+# 数据清洗逻辑
+# ============================================================================
+
+def validate_sample(sample: Dict, config: CleaningConfig) -> Tuple[bool, str]:
+    """
+    验证单个样本是否符合质量标准
+    
+    Returns:
+        (is_valid, rejection_reason)
+    """
+    # 1. 检查基本字段存在
+    if not sample.get("query"):
+        return False, "missing_query"
+    
+    if not sample.get("generation"):
+        return False, "missing_generation"
+    
+    gen = sample["generation"]
+    
+    # 2. 检查 repo_url
+    if config.REQUIRE_REPO_URL and not sample.get("repo_url"):
+        return False, "missing_repo_url"
+    
+    # 3. 检查质量分数
+    overall_score = sample.get("overall_score", 0)
+    if overall_score < config.MIN_OVERALL_SCORE:
+        return False, f"low_score:{overall_score:.2f}"
+    
+    faithfulness = gen.get("faithfulness", 0)
+    if faithfulness < config.MIN_FAITHFULNESS:
+        return False, f"low_faithfulness:{faithfulness:.2f}"
+    
+    answer_relevance = gen.get("answer_relevance", 0)
+    if answer_relevance < config.MIN_ANSWER_RELEVANCE:
+        return False, f"low_relevance:{answer_relevance:.2f}"
+    
+    # 4. 检查长度
+    query = sample.get("query", "")
+    if len(query) < config.MIN_QUERY_LENGTH:
+        return False, f"short_query:{len(query)}"
+    
+    answer = gen.get("generated_answer", "")
+    if len(answer) < config.MIN_ANSWER_LENGTH:
+        return False, f"short_answer:{len(answer)}"
+    
+    context = gen.get("retrieved_context", "")
+    if len(context) < config.MIN_CONTEXT_LENGTH:
+        return False, f"short_context:{len(context)}"
+    
+    # 5. 检查闲聊
+    if is_chatty_query(query):
+        return False, "chatty_query"
+    
+    # 6. 检查代码存在
+    if config.REQUIRE_CODE_IN_CONTEXT and not has_code_indicators(context):
+        return False, "no_code_in_context"
+    
+    return True, "passed"
+
+
+def transform_to_sft_format(sample: Dict, config: CleaningConfig) -> Dict:
+    """
+    将原始评估数据转换为标准 SFT 格式
+    """
+    gen = sample["generation"]
+    
+    # 清理和截断 context
+    context = gen.get("retrieved_context", "")
+    if len(context) > config.MAX_CONTEXT_LENGTH:
+        context = context[:config.MAX_CONTEXT_LENGTH] + "\n... [truncated]"
+    
+    # 构建标准 SFT 格式
+    sft_sample = {
+        # === 核心训练字段 ===
+        "instruction": "你是一个专业的GitHub代码仓库分析助手。根据提供的代码上下文，准确回答用户关于代码实现、架构设计、功能逻辑等问题。回答时应该：1) 直接引用相关代码 2) 解释代码的工作原理 3) 如有必要，提供代码示例。",
+        "input": f"[用户问题]\n{sample['query']}\n\n[代码上下文]\n{context}",
+        "output": gen.get("generated_answer", ""),
+        
+        # === 元数据 ===
+        "metadata": {
+            "query": sample["query"],
+            "repo_url": sample.get("repo_url", ""),
+            "language": sample.get("language", "en"),
+            "session_id": sample.get("session_id", ""),
+            "timestamp": sample.get("timestamp", ""),
+            "quality_tier": sample.get("data_quality_tier", ""),
+            "overall_score": sample.get("overall_score", 0),
+            "faithfulness": gen.get("faithfulness", 0),
+            "answer_relevance": gen.get("answer_relevance", 0),
+            "answer_completeness": gen.get("answer_completeness", 0),
+            "code_correctness": gen.get("code_correctness", 0),
+        }
+    }
+    
+    return sft_sample
+
+
+def clean_and_export(
+    input_file: str = "evaluation/sft_data/eval_results.jsonl",
+    config: CleaningConfig = None
+) -> Dict:
+    """
+    清洗数据并导出
+    
+    Returns:
+        统计信息
+    """
+    config = config or CleaningConfig()
+    
+    # 创建输出目录
+    output_dir = Path(config.OUTPUT_DIR)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # 统计
+    stats = {
+        "total_read": 0,
+        "passed": 0,
+        "rejected": 0,
+        "rejection_reasons": {},
+        "quality_distribution": {"gold": 0, "silver": 0, "bronze": 0}
+    }
+    
+    # 输出文件
+    output_file = output_dir / f"sft_train_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jsonl"
+    rejected_file = output_dir / f"rejected_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jsonl"
+    
+    print("=" * 60)
+    print("🧹 SFT 数据清洗与导出")
+    print("=" * 60)
+    print(f"输入文件: {input_file}")
+    print(f"输出目录: {output_dir}")
+    print(f"质量阈值: score >= {config.MIN_OVERALL_SCORE}")
+    print()
+    
+    if not os.path.exists(input_file):
+        print(f"❌ 输入文件不存在: {input_file}")
+        return stats
+    
+    passed_samples = []
+    rejected_samples = []
+    
+    # 读取并处理
+    with open(input_file, 'r', encoding='utf-8') as f:
+        for line_num, line in enumerate(f, 1):
+            try:
+                sample = json.loads(line)
+                stats["total_read"] += 1
+                
+                # 验证
+                is_valid, reason = validate_sample(sample, config)
+                
+                if is_valid:
+                    # 转换格式
+                    sft_sample = transform_to_sft_format(sample, config)
+                    passed_samples.append(sft_sample)
+                    stats["passed"] += 1
+                    
+                    # 统计质量分布
+                    score = sample.get("overall_score", 0)
+                    if score > 0.9:
+                        stats["quality_distribution"]["gold"] += 1
+                    elif score > 0.7:
+                        stats["quality_distribution"]["silver"] += 1
+                    else:
+                        stats["quality_distribution"]["bronze"] += 1
+                else:
+                    rejected_samples.append({
+                        "reason": reason,
+                        "query": sample.get("query", "")[:50],
+                        "score": sample.get("overall_score", 0)
+                    })
+                    stats["rejected"] += 1
+                    stats["rejection_reasons"][reason] = stats["rejection_reasons"].get(reason, 0) + 1
+                    
+            except json.JSONDecodeError as e:
+                print(f"  ⚠️ 第 {line_num} 行 JSON 解析错误: {e}")
+                continue
+    
+    # 写入通过的样本
+    if passed_samples:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            for sample in passed_samples:
+                f.write(json.dumps(sample, ensure_ascii=False) + '\n')
+        print(f"✅ 已导出 {len(passed_samples)} 条高质量样本到: {output_file}")
+    
+    # 写入拒绝的样本（用于分析）
+    if rejected_samples:
+        with open(rejected_file, 'w', encoding='utf-8') as f:
+            for sample in rejected_samples:
+                f.write(json.dumps(sample, ensure_ascii=False) + '\n')
+        print(f"📝 已记录 {len(rejected_samples)} 条被拒绝样本到: {rejected_file}")
+    
+    # 打印统计
+    print()
+    print("=" * 60)
+    print("📊 统计报告")
+    print("=" * 60)
+    print(f"总读取: {stats['total_read']}")
+    print(f"通过:   {stats['passed']} ({stats['passed']/max(stats['total_read'],1)*100:.1f}%)")
+    print(f"拒绝:   {stats['rejected']} ({stats['rejected']/max(stats['total_read'],1)*100:.1f}%)")
+    print()
+    print("质量分布:")
+    print(f"  🥇 Gold (>0.9):   {stats['quality_distribution']['gold']}")
+    print(f"  🥈 Silver (>0.7): {stats['quality_distribution']['silver']}")
+    print(f"  🥉 Bronze (>0.5): {stats['quality_distribution']['bronze']}")
+    print()
+    
+    if stats["rejection_reasons"]:
+        print("拒绝原因分布:")
+        for reason, count in sorted(stats["rejection_reasons"].items(), key=lambda x: -x[1]):
+            print(f"  - {reason}: {count}")
+    
+    print()
+    print("=" * 60)
+    
+    return stats
+
+
+def export_for_training(
+    input_file: str,
+    output_file: str,
+    format_type: str = "alpaca"
+) -> int:
+    """
+    将清洗后的数据导出为特定训练格式
+    
+    Args:
+        input_file: 清洗后的 JSONL 文件
+        output_file: 输出文件
+        format_type: 格式类型 (alpaca, sharegpt, messages)
+    
+    Returns:
+        导出的样本数量
+    """
+    samples = []
+    
+    with open(input_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            sample = json.loads(line)
+            
+            if format_type == "alpaca":
+                # Alpaca 格式（适用于 LLaMA-Factory 等）
+                formatted = {
+                    "instruction": sample["instruction"],
+                    "input": sample["input"],
+                    "output": sample["output"]
+                }
+            
+            elif format_type == "sharegpt":
+                # ShareGPT 格式
+                formatted = {
+                    "conversations": [
+                        {"from": "system", "value": sample["instruction"]},
+                        {"from": "human", "value": sample["input"]},
+                        {"from": "gpt", "value": sample["output"]}
+                    ]
+                }
+            
+            elif format_type == "messages":
+                # OpenAI messages 格式
+                formatted = {
+                    "messages": [
+                        {"role": "system", "content": sample["instruction"]},
+                        {"role": "user", "content": sample["input"]},
+                        {"role": "assistant", "content": sample["output"]}
+                    ]
+                }
+            
+            else:
+                formatted = sample
+            
+            samples.append(formatted)
+    
+    # 写入
+    with open(output_file, 'w', encoding='utf-8') as f:
+        if output_file.endswith('.json'):
+            json.dump(samples, f, ensure_ascii=False, indent=2)
+        else:
+            for sample in samples:
+                f.write(json.dumps(sample, ensure_ascii=False) + '\n')
+    
+    print(f"✅ 已导出 {len(samples)} 条样本为 {format_type} 格式: {output_file}")
+    return len(samples)
+
+
+# ============================================================================
+# 主函数
+# ============================================================================
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="SFT 数据清洗与导出工具")
+    parser.add_argument("--input", "-i", default="evaluation/sft_data/eval_results.jsonl",
+                       help="输入文件路径")
+    parser.add_argument("--min-score", "-s", type=float, default=0.7,
+                       help="最低质量分数 (默认: 0.7)")
+    parser.add_argument("--format", "-f", choices=["alpaca", "sharegpt", "messages"],
+                       default="alpaca", help="导出格式 (默认: alpaca)")
+    parser.add_argument("--export", "-e", action="store_true",
+                       help="同时导出为训练格式")
+    
+    args = parser.parse_args()
+    
+    # 配置
+    config = CleaningConfig()
+    config.MIN_OVERALL_SCORE = args.min_score
+    
+    # 清洗
+    stats = clean_and_export(args.input, config)
+    
+    # 导出为训练格式
+    if args.export and stats["passed"] > 0:
+        # 找到最新的清洗文件
+        output_dir = Path(config.OUTPUT_DIR)
+        cleaned_files = sorted(output_dir.glob("sft_train_*.jsonl"), reverse=True)
+        if cleaned_files:
+            latest_file = cleaned_files[0]
+            export_file = output_dir / f"train_{args.format}.jsonl"
+            export_for_training(str(latest_file), str(export_file), args.format)

evaluation/data_router.py

@@ -0,0 +1,222 @@
+# 文件路径: evaluation/data_router.py
+"""
+数据路由引擎 - 负责 SFT 数据管理和路由
+
+根据评估结果将样本路由到不同的数据集
+"""
+
+import json
+import os
+from typing import Dict, List, Any
+
+from evaluation.models import EvaluationResult, DataQualityTier
+from evaluation.utils import smart_truncate, SFTLengthConfig
+
+
+class DataRoutingEngine:
+    """评估驱动的数据路由引擎"""
+    
+    # SFT 训练提示词
+    SFT_INSTRUCTION = (
+        "你是一个专业的GitHub代码仓库分析助手。根据提供的代码上下文，"
+        "准确回答用户关于代码实现、架构设计、功能逻辑等问题。"
+        "回答时应该：1) 直接引用相关代码 2) 解释代码的工作原理 3) 如有必要，提供代码示例。"
+    )
+    
+    def __init__(self, output_dir: str = "evaluation/sft_data"):
+        self.output_dir = output_dir
+        os.makedirs(output_dir, exist_ok=True)
+        
+        self.positive_samples_file = os.path.join(output_dir, "positive_samples.jsonl")
+        self.negative_samples_file = os.path.join(output_dir, "negative_samples.jsonl")
+        self.dpo_pairs_file = os.path.join(output_dir, "dpo_pairs.jsonl")
+        self.eval_results_file = os.path.join(output_dir, "eval_results.jsonl")
+    
+    def route_sample(self, eval_result: EvaluationResult) -> str:
+        """路由单个样本，返回数据质量等级"""
+        if eval_result.overall_score == 0.0:
+            eval_result.compute_overall_score()
+        
+        self.route_data(eval_result)
+        return eval_result.data_quality_tier.value
+    
+    def route_data(self, eval_result: EvaluationResult) -> None:
+        """
+        根据评估结果路由数据
+        
+        路由规则:
+        - score > 0.9  → Gold   → positive_samples.jsonl
+        - score > 0.6  → Silver → positive_samples.jsonl  
+        - score > 0.4  → Bronze → negative_samples.jsonl
+        - score <= 0.4 → Rejected (不应到达此处，在 auto_eval 中已过滤)
+        
+        注意: eval_results.jsonl 记录所有通过验证的样本，用于分析和审计
+        """
+        # 记录所有评估结果（完整审计日志）
+        self._append_jsonl(self.eval_results_file, eval_result.to_dict())
+        
+        # 根据质量分级路由到不同的 SFT 数据文件
+        if eval_result.overall_score > 0.9:
+            # Gold: 高质量正样本
+            sft_sample = self._build_sft_sample(eval_result)
+            self._append_jsonl(self.positive_samples_file, sft_sample)
+        
+        elif eval_result.overall_score > 0.6:
+            # Silver: 可用正样本
+            sft_sample = self._build_sft_sample(eval_result)
+            self._append_jsonl(self.positive_samples_file, sft_sample)
+        
+        elif eval_result.overall_score > 0.4:
+            # Bronze: 负样本，可用于 DPO 或人工修正
+            sft_sample = self._build_sft_sample(eval_result, negative=True)
+            self._append_jsonl(self.negative_samples_file, sft_sample)
+        
+        # <= 0.4: 不写入任何 SFT 文件（已在 auto_eval 中被拒绝）
+    
+    def _build_sft_sample(self, eval_result: EvaluationResult, negative: bool = False) -> Dict:
+        """
+        构建 SFT 训练样本
+        
+        长度限制（基于 SFTLengthConfig）:
+        - Context: 最大 2500 字符 (~800 tokens)
+        - Answer: 最大 3000 字符 (~1000 tokens)
+        - 总计: ~2000 tokens，适合 4096 max_length 训练
+        """
+        if eval_result.generation_metrics is None:
+            return {}
+        
+        cfg = SFTLengthConfig
+        
+        # 1. 截断 Query
+        query = eval_result.query
+        if len(query) > cfg.MAX_QUERY_CHARS:
+            query = query[:cfg.MAX_QUERY_CHARS] + "..."
+        
+        # 2. 智能截断 Context（保留开头 70% + 结尾 30%）
+        context = eval_result.generation_metrics.retrieved_context
+        context = smart_truncate(context, cfg.MAX_CONTEXT_CHARS, keep_ratio=0.7)
+        
+        # 3. 截断 Answer（保留开头，通常结论在开头）
+        answer = eval_result.generation_metrics.generated_answer
+        if len(answer) > cfg.MAX_ANSWER_CHARS:
+            answer = answer[:cfg.MAX_ANSWER_CHARS] + "\n\n... [回答过长，已截断]"
+        
+        # 4. 构建 input 并检查总长度
+        input_text = f"[用户问题]\n{query}\n\n[代码上下文]\n{context}"
+        
+        # 如果总长度仍超限，进一步压缩 context
+        total_len = len(self.SFT_INSTRUCTION) + len(input_text) + len(answer)
+        if total_len > cfg.MAX_TOTAL_CHARS:
+            excess = total_len - cfg.MAX_TOTAL_CHARS
+            new_context_len = max(500, len(context) - excess)  # 至少保留 500 字符
+            context = smart_truncate(
+                eval_result.generation_metrics.retrieved_context, 
+                new_context_len, 
+                keep_ratio=0.7
+            )
+            input_text = f"[用户问题]\n{query}\n\n[代码上下文]\n{context}"
+        
+        return {
+            "instruction": self.SFT_INSTRUCTION,
+            "input": input_text,
+            "output": answer,
+            "metadata": {
+                "query": eval_result.query[:200],  # metadata 中也截断，节省空间
+                "repo_url": eval_result.repo_url,
+                "language": eval_result.language,
+                "session_id": eval_result.session_id,
+                "timestamp": eval_result.timestamp.isoformat(),
+                "quality_tier": eval_result.data_quality_tier.value,
+                "overall_score": eval_result.overall_score,
+                "faithfulness": eval_result.generation_metrics.faithfulness,
+                "answer_relevance": eval_result.generation_metrics.answer_relevance,
+                "answer_completeness": eval_result.generation_metrics.answer_completeness,
+                "code_correctness": eval_result.generation_metrics.code_correctness,
+                "is_negative": negative,
+                "sft_ready": eval_result.sft_ready,
+                # 记录原始长度，便于分析
+                "original_context_len": len(eval_result.generation_metrics.retrieved_context),
+                "original_answer_len": len(eval_result.generation_metrics.generated_answer),
+                "truncated": len(eval_result.generation_metrics.retrieved_context) > cfg.MAX_CONTEXT_CHARS
+                          or len(eval_result.generation_metrics.generated_answer) > cfg.MAX_ANSWER_CHARS,
+            }
+        }
+    
+    def _append_jsonl(self, filepath: str, data: Dict) -> None:
+        """追加数据到 JSONL 文件"""
+        with open(filepath, 'a', encoding='utf-8') as f:
+            f.write(json.dumps(data, ensure_ascii=False) + '\n')
+    
+    def get_statistics(self) -> Dict[str, int]:
+        """获取当前数据统计"""
+        stats = {}
+        for name, filepath in [
+            ("positive", self.positive_samples_file),
+            ("negative", self.negative_samples_file),
+            ("dpo_pairs", self.dpo_pairs_file),
+        ]:
+            if os.path.exists(filepath):
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    stats[name] = sum(1 for _ in f)
+            else:
+                stats[name] = 0
+        return stats
+    
+    def get_distribution(self) -> Dict[str, int]:
+        """获取评估结果的质量分布"""
+        distribution = {"gold": 0, "silver": 0, "bronze": 0, "rejected": 0, "corrected": 0}
+        
+        if not os.path.exists(self.eval_results_file):
+            return distribution
+        
+        try:
+            with open(self.eval_results_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    try:
+                        result = json.loads(line)
+                        tier = result.get("data_quality_tier", "bronze")
+                        if tier in distribution:
+                            distribution[tier] += 1
+                    except json.JSONDecodeError:
+                        continue
+        except Exception as e:
+            print(f"⚠️ Error reading eval results: {e}")
+        
+        return distribution
+    
+    def get_bad_samples(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """获取低质量样本用于人工审核"""
+        bad_samples = []
+        
+        if not os.path.exists(self.eval_results_file):
+            return bad_samples
+        
+        try:
+            with open(self.eval_results_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    try:
+                        result = json.loads(line)
+                        if result.get("overall_score", 0) < 0.5:
+                            sample = {
+                                "query": result.get("query", ""),
+                                "score": result.get("overall_score", 0),
+                                "issue": result.get("error_message", "Low quality"),
+                                "quality_tier": result.get("data_quality_tier", "rejected"),
+                                "timestamp": result.get("timestamp", "")
+                            }
+                            if result.get("generation"):
+                                gen = result["generation"]
+                                sample.update({
+                                    "faithfulness": gen.get("faithfulness", 0),
+                                    "answer_relevance": gen.get("answer_relevance", 0),
+                                    "answer_completeness": gen.get("answer_completeness", 0),
+                                })
+                            bad_samples.append(sample)
+                            if len(bad_samples) >= limit:
+                                break
+                    except json.JSONDecodeError:
+                        continue
+        except Exception as e:
+            print(f"⚠️ Error reading bad samples: {e}")
+        
+        return sorted(bad_samples, key=lambda x: x["score"])[:limit]

evaluation/evaluation_framework.py

@@ -0,0 +1,512 @@
+# 文件路径: evaluation/evaluation_framework.py
+"""
+GitHub Agent 完整评估框架
+四层评估架构 + 数据路由引擎
+
+Author: Dexter
+Date: 2025-01-27
+
+注意: 数据模型已拆分到 models.py，数据路由已拆分到 data_router.py
+      此文件保留核心评估引擎逻辑，并重新导出所有符号保持向后兼容
+"""
+
+import json
+import os
+import re
+from typing import List, Dict, Any
+from datetime import datetime
+
+# 重新导出所有模型（保持向后兼容）
+from evaluation.models import (
+    EvaluationLayer,
+    DataQualityTier,
+    QueryRewriteMetrics,
+    RetrievalMetrics,
+    GenerationMetrics,
+    AgenticMetrics,
+    EvaluationResult,
+)
+from evaluation.data_router import DataRoutingEngine
+
+
+# ============================================================================
+# 评估引擎核心逻辑
+# ============================================================================
+
+class EvaluationEngine:
+    """评估引擎 - 负责多层面打分"""
+    
+    def __init__(
+        self, 
+        llm_client=None, 
+        golden_dataset_path: str = "evaluation/golden_dataset.json",
+        model_name: str = None
+    ):
+        self.llm_client = llm_client
+        self.model_name = model_name or "gpt-4o-mini"  # 默认使用轻量模型
+        self.golden_dataset = self._load_golden_dataset(golden_dataset_path)
+    
+    def _load_golden_dataset(self, path: str) -> List[Dict]:
+        """加载黄金数据集"""
+        if not os.path.exists(path):
+            print(f"⚠️ Golden dataset not found at {path}")
+            return []
+        
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    
+    async def evaluate_query_rewrite(
+        self,
+        original_query: str,
+        rewritten_query: str,
+        language_detected: str
+    ) -> QueryRewriteMetrics:
+        """
+        评估查询重写质量
+        
+        指标:
+        - keyword_coverage: 重写后的关键词是否覆盖了原Query的核心概念?
+        - semantic_preservation: 语义是否保留?
+        - diversity_score: 关键词多样性
+        """
+        
+        # 简化版: 使用关键词匹配
+        original_tokens = set(original_query.lower().split())
+        rewritten_tokens = set(rewritten_query.lower().split())
+        
+        # 关键词覆盖度: 原Query的关键词有多少在重写中保留
+        if original_tokens:
+            coverage = len(original_tokens & rewritten_tokens) / len(original_tokens)
+        else:
+            coverage = 0.0
+        
+        # 多样性: 重写后的关键词数量越多、越不重复，分数越高
+        unique_ratio = len(rewritten_tokens) / max(len(original_tokens), 1)
+        diversity = min(1.0, unique_ratio)
+        
+        # 语义保留度 (简化版本: 假设如果覆盖度高就认为语义保留良好)
+        semantic_preservation = min(1.0, coverage + 0.2)  # 基础分+覆盖度加分
+        
+        return QueryRewriteMetrics(
+            original_query=original_query,
+            rewritten_query=rewritten_query,
+            language_detected=language_detected,
+            keyword_coverage=coverage,
+            semantic_preservation=semantic_preservation,
+            diversity_score=diversity
+        )
+    
+    async def evaluate_retrieval(
+        self,
+        query: str,
+        retrieved_files: List[str],
+        ground_truth_files: List[str],
+        top_k: int = 5,
+        retrieval_latency_ms: float = 0,
+        vector_scores: List[float] = None,
+        bm25_scores: List[float] = None
+    ) -> RetrievalMetrics:
+        """
+        评估检索层质量
+        
+        指标:
+        - hit_rate: 是否找到了任何正确的文件?
+        - recall_at_k: 前K个中有多少是正确的?
+        - precision_at_k: 返回的文件中有多少是正确的?
+        - mrr: 第一个正确结果的排名倒数
+        """
+        
+        retrieved_set = set(retrieved_files[:top_k])
+        ground_truth_set = set(ground_truth_files)
+        
+        # Hit rate: 是否有交集
+        hit_rate = 1.0 if retrieved_set & ground_truth_set else 0.0
+        
+        # Recall@K: 找到的正确结果数 / 正确结果总数
+        correct_count = len(retrieved_set & ground_truth_set)
+        recall = correct_count / len(ground_truth_set) if ground_truth_set else 0.0
+        
+        # Precision@K: 找到的正确结果数 / 返回的结果总数
+        precision = correct_count / len(retrieved_set) if retrieved_set else 0.0
+        
+        # MRR: 第一个正确结果的倒数排名
+        mrr = 0.0
+        for i, file in enumerate(retrieved_files[:top_k], 1):
+            if file in ground_truth_set:
+                mrr = 1.0 / i
+                break
+        
+        # Context Relevance: 简化版 - 假设Precision反映了相关性
+        context_relevance = precision
+        
+        # Chunk Integrity: 简化版 - 假设没有太多文件就认为完���度高
+        chunk_integrity = min(1.0, 1.0 / len(retrieved_set)) if retrieved_set else 0.0
+        
+        vector_avg = sum(vector_scores) / len(vector_scores) if vector_scores else 0.0
+        bm25_avg = sum(bm25_scores) / len(bm25_scores) if bm25_scores else 0.0
+        
+        return RetrievalMetrics(
+            query=query,
+            top_k=top_k,
+            hit_rate=hit_rate,
+            recall_at_k=recall,
+            precision_at_k=precision,
+            mrr=mrr,
+            context_relevance=context_relevance,
+            chunk_integrity=chunk_integrity,
+            retrieval_latency_ms=retrieval_latency_ms,
+            vector_score_avg=vector_avg,
+            bm25_score_avg=bm25_avg,
+            retrieved_files=retrieved_files,
+            ground_truth_files=ground_truth_files
+        )
+    
+    async def evaluate_generation(
+        self,
+        query: str,
+        retrieved_context: str,
+        generated_answer: str,
+        ground_truth_answer: str = "",
+        generation_latency_ms: float = 0,
+        token_usage: Dict[str, int] = None
+    ) -> GenerationMetrics:
+        """
+        评估生成层质量
+        
+        指标:
+        - faithfulness: 回答是否严格基于Context?
+        - answer_relevance: 回答是否回答了问题?
+        - answer_completeness: 回答是否足够完整?
+        - code_correctness: 生成的代码是否正确?
+        """
+        
+        # 1. Faithfulness: 使用LLM-as-Judge进行幻觉检测
+        faithfulness = await self._judge_faithfulness(
+            retrieved_context,
+            generated_answer
+        )
+        
+        # 2. Answer Relevance: 回答和问题的相似度
+        answer_relevance = await self._judge_answer_relevance(
+            query,
+            generated_answer
+        )
+        
+        # 3. Answer Completeness: 简化版 - 通过长度和结构判断
+        completeness = self._judge_completeness(
+            generated_answer,
+            ground_truth_answer
+        )
+        
+        # 4. Code Correctness: 使用AST检查代码块
+        code_samples = self._extract_code_blocks(generated_answer)
+        code_correctness = self._check_code_correctness(code_samples)
+        
+        metrics = GenerationMetrics(
+            query=query,
+            retrieved_context=retrieved_context,
+            generated_answer=generated_answer,
+            ground_truth_answer=ground_truth_answer,
+            faithfulness=faithfulness,
+            answer_relevance=answer_relevance,
+            answer_completeness=completeness,
+            code_correctness=code_correctness,
+            generated_code_samples=code_samples,
+            generation_latency_ms=generation_latency_ms,
+            token_usage=token_usage or {"input": 0, "output": 0}
+        )
+        
+        return metrics
+    
+    async def _judge_faithfulness(self, context: str, answer: str) -> float:
+        """
+        LLM-as-Judge: 判断回答是否由Context支撑
+        返回 0-1 的分数
+        
+        注意：Faithfulness 判断的是"回答中的信息是否能从 Context 中找到依据"
+        而不是"回答是否完全复制 Context 内容"
+        """
+        if not self.llm_client:
+            # 简化版: 如果没有LLM客户端，使用启发式方法
+            # 统计Answer中的关键词有多少出现在Context中
+            context_lower = context.lower()
+            answer_words = set(answer.lower().split())
+            # 过滤掉常见停用词
+            stop_words = {'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 
+                         'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will',
+                         'would', 'could', 'should', 'may', 'might', 'must', 'shall',
+                         'can', 'need', 'dare', 'ought', 'used', 'to', 'of', 'in',
+                         'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'that',
+                         'which', 'who', 'whom', 'this', 'these', 'those', 'it', 'its'}
+            meaningful_words = answer_words - stop_words
+            if not meaningful_words:
+                return 0.7  # 没有有意义的词，给默认分
+            # 计算答案中有多少有意义的词出现在Context中
+            found_count = sum(1 for word in meaningful_words if word in context_lower)
+            overlap = found_count / len(meaningful_words)
+            return min(1.0, overlap + 0.2)  # 给一定的基础分
+        
+        # 智能截取 Context：提取与 Answer 相关的部分
+        # 如果 Context 太长，优先包含 Answer 中提到的关键词附近的内容
+        max_context_len = 6000  # 增加到 6000 字符
+        if len(context) > max_context_len:
+            # 尝试找到 Answer 中提到的关键文件/函数名
+            import re
+            # 提取 Answer 中可能的文件路径或函数名
+            patterns = re.findall(r'[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*', answer[:500])
+            important_terms = [p for p in patterns if len(p) > 3][:5]  # 取前5个重要词
+            
+            # 优先截取包含这些词的部分
+            context_parts = []
+            remaining = max_context_len
+            for term in important_terms:
+                idx = context.find(term)
+                if idx != -1 and remaining > 0:
+                    start = max(0, idx - 300)
+                    end = min(len(context), idx + 700)
+                    snippet = context[start:end]
+                    if snippet not in ''.join(context_parts):
+                        context_parts.append(snippet)
+                        remaining -= len(snippet)
+            
+            # 如果没找到相关部分，还是用前 6000 字符
+            if context_parts:
+                truncated_context = "\n...\n".join(context_parts)
+            else:
+                truncated_context = context[:max_context_len]
+        else:
+            truncated_context = context
+        
+        # 改进的 Prompt：更明确定义 Faithfulness
+        prompt = f"""Evaluate the FAITHFULNESS of the answer to the given context.
+
+FAITHFULNESS means: The claims and information in the answer can be verified from or are consistent with the context. 
+- Score HIGH (0.7-1.0) if the answer correctly identifies or explains concepts that ARE in the context
+- Score MEDIUM (0.4-0.7) if the answer is partially supported but makes some unsupported claims  
+- Score LOW (0.0-0.4) if the answer contradicts the context or makes completely unsupported claims
+
+NOTE: If the answer says "X is not in the context" and X is indeed not shown, that's a FAITHFUL statement (score 0.7+)
+NOTE: If the answer correctly identifies WHERE something is defined based on imports/references in context, that's FAITHFUL
+
+[Context]
+{truncated_context}
+
+[Answer]
+{answer[:1500]}
+
+SCORE (0.0-1.0):"""
+        
+        try:
+            response = await self.llm_client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.1,
+                max_tokens=10
+            )
+            score_str = response.choices[0].message.content.strip()
+            # 提取数字（处理可能的额外文本）
+            import re
+            match = re.search(r'(\d+\.?\d*)', score_str)
+            if match:
+                score = float(match.group(1))
+            else:
+                score = float(score_str)
+            return min(1.0, max(0.0, score))
+        except Exception as e:
+            print(f"⚠️ Faithfulness judgment failed: {e}")
+            return 0.5
+    
+    async def _judge_answer_relevance(self, query: str, answer: str) -> float:
+        """判断回答与问题的相关性"""
+        if not self.llm_client:
+            # 简化版: 使用关键词重叠度
+            query_words = set(query.lower().split())
+            answer_words = set(answer.lower().split())
+            overlap = len(query_words & answer_words) / max(len(query_words), 1)
+            return min(1.0, overlap + 0.3)  # 基础分0.3+重叠度
+        
+        prompt = f"""
+        Does the answer address the query?
+        
+        [Query]
+        {query}
+        
+        [Answer]
+        {answer[:1000]}
+        
+        Score (0.0-1.0):
+        """
+        
+        try:
+            response = await self.llm_client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.1,
+                max_tokens=10
+            )
+            score = float(response.choices[0].message.content.strip())
+            return min(1.0, max(0.0, score))
+        except:
+            return 0.5
+    
+    def _judge_completeness(self, generated_answer: str, ground_truth: str = "") -> float:
+        """判断回答的完整性"""
+        # 简化版: 根据长度和结构
+        if len(generated_answer) < 50:
+            return 0.3
+        elif len(generated_answer) < 200:
+            return 0.6
+        else:
+            return 0.9
+    
+    def _extract_code_blocks(self, text: str) -> List[str]:
+        """从文本中提取代码块"""
+        import re
+        code_pattern = r'```[\w]*\n(.*?)\n```'
+        matches = re.findall(code_pattern, text, re.DOTALL)
+        return matches
+    
+    def _check_code_correctness(self, code_samples: List[str]) -> float:
+        """检查代码是否有语法错误"""
+        if not code_samples:
+            return 1.0  # 没有代码就认为正确
+        
+        import ast
+        correct_count = 0
+        for code in code_samples:
+            try:
+                ast.parse(code)
+                correct_count += 1
+            except SyntaxError:
+                pass
+        
+        return correct_count / len(code_samples)
+    
+    async def evaluate_agentic(
+        self,
+        query: str,
+        tool_calls: List[Dict[str, Any]],
+        success: bool,
+        steps_taken: int = 0,
+        end_to_end_latency_ms: float = 0
+    ) -> AgenticMetrics:
+        """
+        评估Agent的决策和行为
+        """
+        
+        # Tool Selection Accuracy: 工具选择是否正确?
+        tool_selection_accuracy = 1.0 if success else 0.5
+        
+        # Tool Parameter Correctness: 参数是否正确传递?
+        tool_param_correctness = 1.0 if all(
+            tc.get("success", False) for tc in tool_calls
+        ) else 0.5
+        
+        # 计算冗余步骤
+        unnecessary_steps = 0
+        backtrack_count = 0
+        
+        # 简化版: 如果有重复的工具调用则视为冗余
+        tool_call_signatures = [tc.get("name", "") for tc in tool_calls]
+        for i, sig in enumerate(tool_call_signatures):
+            if i > 0 and sig == tool_call_signatures[i-1]:
+                unnecessary_steps += 1
+        
+        return AgenticMetrics(
+            query=query,
+            tool_calls=tool_calls,
+            tool_selection_accuracy=tool_selection_accuracy,
+            tool_parameter_correctness=tool_param_correctness,
+            steps_taken=steps_taken,
+            unnecessary_steps=unnecessary_steps,
+            backtrack_count=backtrack_count,
+            success=success,
+            end_to_end_latency_ms=end_to_end_latency_ms
+        )
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        获取评估统计信息
+        
+        Returns:
+            包含 total_evaluations, average_score, quality_distribution, top_issues 的字典
+        """
+        # 从 eval_results.jsonl 读取评估结果
+        eval_results_path = "evaluation/sft_data/eval_results.jsonl"
+        
+        stats = {
+            "total_evaluations": 0,
+            "average_score": 0.0,
+            "quality_distribution": {
+                "gold": 0,
+                "silver": 0,
+                "bronze": 0,
+                "rejected": 0
+            },
+            "top_issues": []
+        }
+        
+        if not os.path.exists(eval_results_path):
+            return stats
+        
+        # 读取和分析评估结果
+        scores = []
+        issues = {}
+        
+        try:
+            with open(eval_results_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    try:
+                        result = json.loads(line)
+                        stats["total_evaluations"] += 1
+                        
+                        # 收集得分
+                        score = result.get("overall_score", 0)
+                        scores.append(score)
+                        
+                        # 统计质量分布
+                        tier = result.get("data_quality_tier", "bronze")
+                        if tier in stats["quality_distribution"]:
+                            stats["quality_distribution"][tier] += 1
+                        
+                        # 收集常见问题 (假设记录在 notes 或 error_message 中)
+                        note = result.get("notes", "") or result.get("error_message", "")
+                        if note:
+                            issues[note] = issues.get(note, 0) + 1
+                    except json.JSONDecodeError:
+                        continue
+        except Exception as e:
+            print(f"⚠️ Error reading eval results: {e}")
+        
+        # 计算平均分
+        if scores:
+            stats["average_score"] = sum(scores) / len(scores)
+        
+        # 获取前5个常见问题
+        if issues:
+            stats["top_issues"] = [
+                {"issue": issue, "count": count}
+                for issue, count in sorted(issues.items(), key=lambda x: x[1], reverse=True)[:5]
+            ]
+        
+        return stats
+
+
+# ============================================================================
+# __all__ 导出列表（保持向后兼容）
+# ============================================================================
+
+__all__ = [
+    # 枚举
+    "EvaluationLayer",
+    "DataQualityTier",
+    # 数据模型
+    "QueryRewriteMetrics",
+    "RetrievalMetrics",
+    "GenerationMetrics",
+    "AgenticMetrics",
+    "EvaluationResult",
+    # 引擎
+    "EvaluationEngine",
+    "DataRoutingEngine",
+]

evaluation/golden_dataset_builder.py

@@ -0,0 +1,414 @@
+# 文件路径: evaluation/golden_dataset_builder.py
+"""
+黄金数据集构建工具
+用于快速构建评估所需的标注数据集
+
+使用场景:
+1. 初始化: 为新项目快速创建 50 条测试用例
+2. 扩展: 定期添加新的问题和标注
+3. 验证: 自动验证数据集的完整性
+
+Author: Dexter
+Date: 2025-01-27
+"""
+
+import json
+import os
+from typing import List, Dict, Optional
+from dataclasses import dataclass, asdict
+from datetime import datetime
+
+
+@dataclass
+class GoldenSample:
+    """黄金数据集样本"""
+    id: str                           # 唯一ID
+    description: str                  # 问题描述 (用于标注人员理解问题类型)
+    query: str                        # 用户查询
+    expected_files: List[str]         # 标准答案: 应该返回的文件列表
+    expected_answer: str = ""         # 标准答案: 预期回答 (可选)
+    difficulty: str = "medium"        # 难度: easy/medium/hard
+    category: str = "general"         # 类别: general/code_finding/architecture/workflow
+    language: str = "en"              # 语言: en/zh
+    created_at: str = ""
+    
+    def __post_init__(self):
+        if not self.created_at:
+            self.created_at = datetime.now().isoformat()
+
+
+class GoldenDatasetBuilder:
+    """黄金数据集构建器"""
+    
+    def __init__(self, filepath: str = "evaluation/golden_dataset.json"):
+        self.filepath = filepath
+        self.samples: List[GoldenSample] = []
+        self.load()
+    
+    def load(self):
+        """加载现有数据集"""
+        if os.path.exists(self.filepath):
+            with open(self.filepath, 'r', encoding='utf-8') as f:
+                try:
+                    raw_data = json.load(f)
+                    # 兼容旧格式 (直接是字典列表)
+                    if isinstance(raw_data, list):
+                        self.samples = [
+                            GoldenSample(**item) if isinstance(item, dict) and "id" in item
+                            else GoldenSample(
+                                id=str(len(self.samples)),
+                                description=item.get("description", ""),
+                                query=item.get("query", ""),
+                                expected_files=[item.get("answer_file", "")] if item.get("answer_file") else []
+                            )
+                            for item in raw_data
+                        ]
+                except:
+                    self.samples = []
+    
+    def save(self):
+        """保存数据集"""
+        os.makedirs(os.path.dirname(self.filepath), exist_ok=True)
+        data = [asdict(s) for s in self.samples]
+        with open(self.filepath, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    
+    def add_sample(self, sample: GoldenSample):
+        """添加样本"""
+        sample.id = f"sample_{len(self.samples):04d}"
+        self.samples.append(sample)
+    
+    def add_samples_batch(self, samples: List[GoldenSample]):
+        """批量添加样本"""
+        for sample in samples:
+            self.add_sample(sample)
+    
+    def get_samples_by_category(self, category: str) -> List[GoldenSample]:
+        """按类别筛选"""
+        return [s for s in self.samples if s.category == category]
+    
+    def get_samples_by_difficulty(self, difficulty: str) -> List[GoldenSample]:
+        """按难度筛选"""
+        return [s for s in self.samples if s.difficulty == difficulty]
+    
+    def get_statistics(self) -> Dict:
+        """获取统计信息"""
+        stats = {
+            "total": len(self.samples),
+            "by_category": {},
+            "by_difficulty": {},
+            "by_language": {}
+        }
+        
+        for s in self.samples:
+            stats["by_category"][s.category] = stats["by_category"].get(s.category, 0) + 1
+            stats["by_difficulty"][s.difficulty] = stats["by_difficulty"].get(s.difficulty, 0) + 1
+            stats["by_language"][s.language] = stats["by_language"].get(s.language, 0) + 1
+        
+        return stats
+
+
+# ============================================================================
+# 预定义的通用问题模板
+# ============================================================================
+
+# 针对 FastAPI 项目的初始数据集 (参考你现有的 golden_dataset.json)
+FASTAPI_GOLDEN_SAMPLES = [
+    # Easy: 代码位置查找
+    GoldenSample(
+        id="",
+        description="简单函数查找",
+        query="Where is the 'serialize_response' function?",
+        expected_files=["fastapi/routing.py"],
+        difficulty="easy",
+        category="code_finding"
+    ),
+    
+    # Medium: 理解数据流
+    GoldenSample(
+        id="",
+        description="理解核心模块职责",
+        query="How does dependency injection work in FastAPI?",
+        expected_files=["fastapi/dependencies/utils.py", "fastapi/depends.py"],
+        difficulty="medium",
+        category="architecture"
+    ),
+    
+    # Hard: 跨文件理解工作流
+    GoldenSample(
+        id="",
+        description="完整工作流理解",
+        query="Show me the complete flow from request to response in FastAPI",
+        expected_files=["fastapi/routing.py", "fastapi/applications.py", "fastapi/dependencies/utils.py"],
+        difficulty="hard",
+        category="workflow"
+    ),
+]
+
+# GitHub Agent 项目的初始数据集
+GITHUB_AGENT_GOLDEN_SAMPLES = [
+    GoldenSample(
+        id="",
+        description="检索核心逻辑",
+        query="How is chunk_file method implemented?",
+        expected_files=["app/services/chunking_service.py"],
+        expected_answer="The chunk_file method is implemented in chunking_service.py. It takes content and file_path as parameters and uses AST parsing for Python files to intelligently chunk the code.",
+        difficulty="easy",
+        category="code_finding",
+        language="en"
+    ),
+    
+    GoldenSample(
+        id="",
+        description="向量搜索机制",
+        query="What vector database is used for retrieval?",
+        expected_files=["app/services/vector_service.py"],
+        difficulty="medium",
+        category="architecture",
+        language="en"
+    ),
+    
+    GoldenSample(
+        id="",
+        description="完整分析流程",
+        query="How does the agent analyze a GitHub repository?",
+        expected_files=["app/services/agent_service.py", "app/services/chunking_service.py", "app/services/vector_service.py"],
+        difficulty="hard",
+        category="workflow",
+        language="en"
+    ),
+]
+
+
+# ============================================================================
+# 交互式数据集构建工具
+# ============================================================================
+
+def interactive_builder():
+    """交互式构建黄金数据集"""
+    builder = GoldenDatasetBuilder()
+    
+    print("=" * 60)
+    print("🛠️  黄金数据集构建工具")
+    print("=" * 60)
+    
+    while True:
+        print("\n请选择操作:")
+        print("1. 添加新样本")
+        print("2. 查看现有样本")
+        print("3. 按类别筛选")
+        print("4. 统计信息")
+        print("5. 保存并退出")
+        print("0. 退出(不保存)")
+        
+        choice = input("请输入选项 (0-5): ").strip()
+        
+        if choice == "1":
+            sample = GoldenSample(
+                id="",
+                description=input("📝 描述 (问题类型): "),
+                query=input("❓ 查询/问题: "),
+                expected_files=input("📁 预期文件 (逗号分隔): ").split(","),
+                expected_answer=input("📄 标准答案 (可选): "),
+                difficulty=input("⭐ 难度 (easy/medium/hard) [medium]: ") or "medium",
+                category=input("🏷️  类别 (code_finding/architecture/workflow/general) [general]: ") or "general",
+                language=input("🌍 语言 (en/zh) [en]: ") or "en"
+            )
+            builder.add_sample(sample)
+            print("✅ 样本已添加")
+        
+        elif choice == "2":
+            print(f"\n总共 {len(builder.samples)} 个样本:")
+            for s in builder.samples[-10:]:  # 显示最后10个
+                print(f"  - [{s.difficulty}] {s.query[:50]}")
+        
+        elif choice == "3":
+            category = input("输入类别: ")
+            samples = builder.get_samples_by_category(category)
+            print(f"\n找到 {len(samples)} 个 '{category}' 类别的样本:")
+            for s in samples:
+                print(f"  - {s.query}")
+        
+        elif choice == "4":
+            stats = builder.get_statistics()
+            print(f"\n📊 数据集统计:")
+            print(f"  总样本数: {stats['total']}")
+            print(f"  按类别: {stats['by_category']}")
+            print(f"  按难度: {stats['by_difficulty']}")
+            print(f"  按语言: {stats['by_language']}")
+        
+        elif choice == "5":
+            builder.save()
+            print("✅ 数据集已保存")
+            break
+        
+        elif choice == "0":
+            print("⚠️ 未保存,退出")
+            break
+
+
+# ============================================================================
+# 自动评估数据集的完整性
+# ============================================================================
+
+def validate_golden_dataset(filepath: str = "evaluation/golden_dataset.json") -> Dict:
+    """验证黄金数据集的完整性"""
+    
+    builder = GoldenDatasetBuilder(filepath)
+    issues = {
+        "missing_fields": [],
+        "empty_queries": [],
+        "empty_files": [],
+        "duplicates": []
+    }
+    
+    seen_queries = set()
+    
+    for i, sample in enumerate(builder.samples):
+        # 检查必填字段
+        if not sample.query:
+            issues["empty_queries"].append(f"Sample {i}: query is empty")
+        
+        if not sample.expected_files or all(not f for f in sample.expected_files):
+            issues["empty_files"].append(f"Sample {i}: expected_files is empty")
+        
+        # 检查重复
+        if sample.query in seen_queries:
+            issues["duplicates"].append(f"Sample {i}: duplicate query")
+        seen_queries.add(sample.query)
+    
+    return {
+        "valid": len(issues) == 0 or not any(issues.values()),
+        "total_samples": len(builder.samples),
+        "issues": issues,
+        "stats": builder.get_statistics()
+    }
+
+
+# ============================================================================
+# 快速初始化脚本
+# ============================================================================
+
+def init_github_agent_dataset():
+    """快速初始化 GitHub Agent 项目的数据集"""
+    builder = GoldenDatasetBuilder("evaluation/golden_dataset.json")
+    
+    # 清空现有 (可选)
+    # builder.samples = []
+    
+    # 添加初始样本
+    builder.add_samples_batch(GITHUB_AGENT_GOLDEN_SAMPLES)
+    
+    # 额外添加更多样本 (扩展到30+)
+    extra_samples = [
+        GoldenSample(
+            id="",
+            description="向量检索质量",
+            query="What retrieval metrics are tracked?",
+            expected_files=["evaluation/evaluation_framework.py"],
+            difficulty="medium",
+            category="architecture"
+        ),
+        GoldenSample(
+            id="",
+            description="Agent决策过程",
+            query="How does the agent decide which files to read?",
+            expected_files=["app/services/agent_service.py"],
+            difficulty="hard",
+            category="workflow"
+        ),
+        GoldenSample(
+            id="",
+            description="错误处理",
+            query="Where are network timeout errors handled?",
+            expected_files=["app/services/agent_service.py", "app/services/chat_service.py"],
+            difficulty="medium",
+            category="code_finding"
+        ),
+    ]
+    builder.add_samples_batch(extra_samples)
+    builder.save()
+    
+    print(f"✅ 初始化完成: {len(builder.samples)} 个样本")
+    print(f"📊 {builder.get_statistics()}")
+
+
+# ============================================================================
+# 导出为 Ragas 格式
+# ============================================================================
+
+def export_to_ragas_format(golden_filepath: str, output_filepath: str = "evaluation/ragas_eval_dataset.json"):
+    """
+    将黄金数据集导出为 Ragas 评估框架所需的格式
+    
+    Ragas 格式:
+    {
+        "questions": [...],
+        "contexts": [...],
+        "ground_truths": [...]
+    }
+    """
+    builder = GoldenDatasetBuilder(golden_filepath)
+    
+    ragas_data = {
+        "questions": [],
+        "contexts": [],
+        "ground_truths": [],
+        "metadata": []
+    }
+    
+    for sample in builder.samples:
+        ragas_data["questions"].append(sample.query)
+        ragas_data["ground_truths"].append({
+            "answer": sample.expected_answer,
+            "files": sample.expected_files
+        })
+        ragas_data["contexts"].append("\n".join(sample.expected_files))
+        ragas_data["metadata"].append({
+            "difficulty": sample.difficulty,
+            "category": sample.category,
+            "description": sample.description
+        })
+    
+    os.makedirs(os.path.dirname(output_filepath), exist_ok=True)
+    with open(output_filepath, 'w', encoding='utf-8') as f:
+        json.dump(ragas_data, f, ensure_ascii=False, indent=2)
+    
+    print(f"✅ Exported to {output_filepath}")
+    print(f"   Questions: {len(ragas_data['questions'])}")
+
+
+# ============================================================================
+# 命令行接口
+# ============================================================================
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "init":
+            init_github_agent_dataset()
+        
+        elif command == "validate":
+            result = validate_golden_dataset()
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        
+        elif command == "export-ragas":
+            export_to_ragas_format("evaluation/golden_dataset.json")
+        
+        elif command == "interactive":
+            interactive_builder()
+        
+        else:
+            print(f"Unknown command: {command}")
+    
+    else:
+        print("黄金数据集构建工具")
+        print()
+        print("用法:")
+        print("  python golden_dataset_builder.py init              # 快速初始化")
+        print("  python golden_dataset_builder.py validate          # 验证数据集")
+        print("  python golden_dataset_builder.py export-ragas      # 导出为Ragas格式")
+        print("  python golden_dataset_builder.py interactive       # 交互式构建")

evaluation/models.py

@@ -0,0 +1,244 @@
+# 文件路径: evaluation/models.py
+"""
+评估数据模型定义
+
+将所有数据类和枚举集中管理，保持代码职责清晰
+"""
+
+from dataclasses import dataclass, field, asdict
+from typing import List, Dict, Optional, Any
+from enum import Enum
+from datetime import datetime
+
+
+class EvaluationLayer(Enum):
+    """评估层次分类"""
+    QUERY_REWRITE = "query_rewrite"
+    RETRIEVAL = "retrieval"
+    GENERATION = "generation"
+    AGENTIC = "agentic"
+
+
+class DataQualityTier(Enum):
+    """数据质量分级 (用于SFT数据路由)"""
+    GOLD = "gold"          # 完美样本 (score > 0.9)
+    SILVER = "silver"      # 优质样本 (score 0.7-0.9)
+    BRONZE = "bronze"      # 可用样本 (score 0.5-0.7)
+    REJECTED = "rejected"  # 拒绝 (score < 0.5)
+    CORRECTED = "corrected"  # 自纠正后的样本 (用于DPO)
+
+
+# ============================================================================
+# 各层评估指标
+# ============================================================================
+
+@dataclass
+class QueryRewriteMetrics:
+    """查询重写评估指标"""
+    original_query: str
+    rewritten_query: str
+    language_detected: str
+    keyword_coverage: float       # 0-1
+    semantic_preservation: float  # 0-1
+    diversity_score: float        # 0-1
+    
+    def overall_score(self) -> float:
+        return (
+            self.keyword_coverage * 0.4 +
+            self.semantic_preservation * 0.4 +
+            self.diversity_score * 0.2
+        )
+
+
+@dataclass
+class RetrievalMetrics:
+    """检索层评估指标"""
+    query: str
+    top_k: int
+    
+    # 核心指标
+    hit_rate: float
+    recall_at_k: float
+    precision_at_k: float
+    mrr: float  # Mean Reciprocal Rank
+    
+    # 高级指标
+    context_relevance: float
+    chunk_integrity: float
+    retrieval_latency_ms: float
+    
+    # 混合检索
+    vector_score_avg: float
+    bm25_score_avg: float
+    
+    retrieved_files: List[str] = field(default_factory=list)
+    ground_truth_files: List[str] = field(default_factory=list)
+    
+    def overall_score(self) -> float:
+        return (
+            self.recall_at_k * 0.3 +
+            self.precision_at_k * 0.3 +
+            self.context_relevance * 0.25 +
+            self.chunk_integrity * 0.15
+        )
+
+
+@dataclass
+class GenerationMetrics:
+    """生成层评估指标"""
+    query: str
+    retrieved_context: str
+    generated_answer: str
+    
+    # 核心指标
+    faithfulness: float
+    answer_relevance: float
+    answer_completeness: float
+    code_correctness: float
+    
+    # 可选
+    ground_truth_answer: str = ""
+    hallucination_count: int = 0
+    unsupported_claims: List[str] = field(default_factory=list)
+    generated_code_samples: List[str] = field(default_factory=list)
+    generation_latency_ms: float = 0
+    token_usage: Dict[str, int] = field(default_factory=lambda: {"input": 0, "output": 0})
+    
+    def overall_score(self) -> float:
+        base_score = (
+            self.faithfulness * 0.35 +
+            self.answer_relevance * 0.35 +
+            self.answer_completeness * 0.2 +
+            self.code_correctness * 0.1
+        )
+        penalty = self.hallucination_count * 0.1
+        return max(0, base_score - penalty)
+
+
+@dataclass
+class AgenticMetrics:
+    """Agent行为评估指标"""
+    query: str
+    tool_selection_accuracy: float
+    tool_parameter_correctness: float
+    
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    steps_taken: int = 0
+    unnecessary_steps: int = 0
+    backtrack_count: int = 0
+    success: bool = True
+    early_termination: bool = False
+    end_to_end_latency_ms: float = 0
+    
+    def efficiency_score(self) -> float:
+        if self.steps_taken == 0:
+            return 0
+        redundancy_ratio = self.unnecessary_steps / self.steps_taken
+        return max(0, min(1, 1 - redundancy_ratio - self.backtrack_count * 0.1))
+    
+    def overall_score(self) -> float:
+        return (
+            self.tool_selection_accuracy * 0.4 +
+            self.tool_parameter_correctness * 0.3 +
+            self.efficiency_score() * 0.2 +
+            (1.0 if self.success else 0.0) * 0.1
+        )
+
+
+# ============================================================================
+# 综合评估结果
+# ============================================================================
+
+@dataclass
+class EvaluationResult:
+    """单次评估完整结果"""
+    session_id: str
+    query: str
+    repo_url: str
+    timestamp: datetime
+    language: str = "en"
+    
+    # 各层评估结果
+    query_rewrite_metrics: Optional[QueryRewriteMetrics] = None
+    retrieval_metrics: Optional[RetrievalMetrics] = None
+    generation_metrics: Optional[GenerationMetrics] = None
+    agentic_metrics: Optional[AgenticMetrics] = None
+    
+    # 综合评分
+    overall_score: float = 0.0
+    data_quality_tier: DataQualityTier = DataQualityTier.BRONZE
+    
+    # SFT标注
+    sft_ready: bool = False
+    dpo_candidate: bool = False
+    
+    # 元数据
+    error_message: Optional[str] = None
+    notes: str = ""
+    
+    def compute_overall_score(self) -> float:
+        """计算加权综合得分"""
+        scores, weights = [], []
+        
+        if self.query_rewrite_metrics:
+            scores.append(self.query_rewrite_metrics.overall_score())
+            weights.append(0.15)
+        
+        if self.retrieval_metrics:
+            scores.append(self.retrieval_metrics.overall_score())
+            weights.append(0.35)
+        
+        if self.generation_metrics:
+            scores.append(self.generation_metrics.overall_score())
+            weights.append(0.4)
+        
+        if self.agentic_metrics:
+            scores.append(self.agentic_metrics.overall_score())
+            weights.append(0.1)
+        
+        if not scores:
+            return 0.0
+        
+        total_weight = sum(weights)
+        self.overall_score = sum(s * w for s, w in zip(scores, weights)) / total_weight
+        
+        # 分级
+        if self.overall_score > 0.9:
+            self.data_quality_tier = DataQualityTier.GOLD
+            self.sft_ready = True
+        elif self.overall_score > 0.7:
+            self.data_quality_tier = DataQualityTier.SILVER
+            self.sft_ready = True
+        elif self.overall_score > 0.5:
+            self.data_quality_tier = DataQualityTier.BRONZE
+        else:
+            self.data_quality_tier = DataQualityTier.REJECTED
+        
+        return self.overall_score
+    
+    def to_dict(self) -> Dict:
+        """转换为字典供存储"""
+        result = {
+            "session_id": self.session_id,
+            "query": self.query,
+            "repo_url": self.repo_url,
+            "timestamp": self.timestamp.isoformat(),
+            "language": self.language,
+            "overall_score": self.overall_score,
+            "data_quality_tier": self.data_quality_tier.value,
+            "sft_ready": self.sft_ready,
+            "dpo_candidate": self.dpo_candidate,
+            "error_message": self.error_message,
+            "notes": self.notes,
+        }
+        
+        if self.query_rewrite_metrics:
+            result["query_rewrite"] = asdict(self.query_rewrite_metrics)
+        if self.retrieval_metrics:
+            result["retrieval"] = asdict(self.retrieval_metrics)
+        if self.generation_metrics:
+            result["generation"] = asdict(self.generation_metrics)
+        if self.agentic_metrics:
+            result["agentic"] = asdict(self.agentic_metrics)
+        
+        return result

evaluation/test_retrieval.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+"""
+检索系统离线评估脚本
+
+用于测试 chunking 和检索策略的准确率。
+使用 golden_dataset.json 中的标注数据作为 ground truth。
+
+使用方法:
+    python evaluation/test_retrieval.py --repo https://github.com/tiangolo/fastapi
+    python evaluation/test_retrieval.py --repo https://github.com/tiangolo/fastapi --top-k 5
+    python evaluation/test_retrieval.py --repo https://github.com/tiangolo/fastapi --verbose
+
+Author: Dexter
+Date: 2026-01-28
+"""
+
+import json
+import os
+import sys
+import asyncio
+import argparse
+from typing import List, Dict, Tuple
+from dataclasses import dataclass, field
+from datetime import datetime
+
+# 添加项目根目录到 path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.services.vector_service import store_manager
+from app.services.github_service import get_repo_structure
+
+
+@dataclass
+class RetrievalTestResult:
+    """单个测试用例的结果"""
+    query: str
+    expected_files: List[str]
+    retrieved_files: List[str]
+    hit: bool                      # 是否命中任意一个预期文件
+    recall: float                  # 召回率: 命中的预期文件 / 总预期文件
+    precision: float               # 精确率: 命中的预期文件 / 检索结果数
+    reciprocal_rank: float         # 倒数排名: 1 / 第一个命中的位置
+    difficulty: str = ""
+    category: str = ""
+
+
+@dataclass
+class EvaluationReport:
+    """完整评估报告"""
+    repo_url: str
+    top_k: int
+    total_queries: int
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+    
+    # 聚合指标
+    hit_rate: float = 0.0          # 命中率: 至少命中一个的查询比例
+    mean_recall: float = 0.0       # 平均召回率
+    mean_precision: float = 0.0    # 平均精确率
+    mrr: float = 0.0               # Mean Reciprocal Rank
+    
+    # 按难度分组
+    by_difficulty: Dict[str, Dict] = field(default_factory=dict)
+    
+    # 详细结果
+    results: List[RetrievalTestResult] = field(default_factory=list)
+    failed_cases: List[Dict] = field(default_factory=list)
+
+
+class RetrievalEvaluator:
+    """检索系统评估器"""
+    
+    def __init__(self, golden_dataset_path: str = "evaluation/golden_dataset.json"):
+        self.golden_dataset = self._load_golden_dataset(golden_dataset_path)
+        print(f"📊 Loaded {len(self.golden_dataset)} test cases from golden dataset")
+    
+    def _load_golden_dataset(self, path: str) -> List[Dict]:
+        """加载黄金数据集"""
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Golden dataset not found: {path}")
+        
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    
+    async def evaluate(
+        self,
+        repo_url: str,
+        session_id: str = "eval_test",
+        top_k: int = 5,
+        verbose: bool = False
+    ) -> EvaluationReport:
+        """
+        运行完整的检索评估
+        
+        Args:
+            repo_url: 要评估的仓库 URL
+            session_id: 会话 ID
+            top_k: 每次检索返回的文件数
+            verbose: 是否打印详细信息
+        """
+        print(f"\n{'='*60}")
+        print(f"🔍 Retrieval Evaluation")
+        print(f"{'='*60}")
+        print(f"Repository: {repo_url}")
+        print(f"Top-K: {top_k}")
+        print(f"Test Cases: {len(self.golden_dataset)}")
+        print(f"{'='*60}\n")
+        
+        # 获取仓库文件列表
+        print("📂 Fetching repository structure...")
+        file_list = get_repo_structure(repo_url)  # 同步函数，不需要 await
+        print(f"   Found {len(file_list)} files")
+        
+        # 获取向量存储
+        store = store_manager.get_store(session_id)
+        chunk_count = store.collection.count()  # 使用 collection.count()
+        if chunk_count == 0:
+            print("\n⚠️  Vector store is empty!")
+            print("   Please run the agent first to index the repository.")
+            print("   Example: Access http://localhost:8000 and analyze the repo first.")
+            return None
+        print(f"   Vector store has {chunk_count} chunks")
+        
+        # 运行评估
+        report = EvaluationReport(
+            repo_url=repo_url,
+            top_k=top_k,
+            total_queries=len(self.golden_dataset)
+        )
+        
+        hits = 0
+        recalls = []
+        precisions = []
+        reciprocal_ranks = []
+        
+        difficulty_stats = {}
+        
+        for i, sample in enumerate(self.golden_dataset):
+            query = sample.get("query", "")
+            expected_files = sample.get("expected_files", [])
+            difficulty = sample.get("difficulty", "medium")
+            category = sample.get("category", "general")
+            
+            if not query or not expected_files:
+                continue
+            
+            # 执行检索 (使用 hybrid search)
+            try:
+                results = await store.search_hybrid(query, top_k=top_k)
+            except Exception as e:
+                if verbose:
+                    print(f"  [ERR] Search failed: {e}")
+                continue
+            
+            # 提取检索到的文件路径
+            retrieved_files = []
+            for doc in results:
+                if isinstance(doc, dict):
+                    file_path = doc.get("file", "")
+                    if file_path and file_path not in retrieved_files:
+                        retrieved_files.append(file_path)
+            
+            # 计算指标
+            expected_set = set(expected_files)
+            retrieved_set = set(retrieved_files[:top_k])
+            
+            # 命中的文件
+            hits_set = expected_set & retrieved_set
+            
+            # Hit: 是否命中任意一个
+            hit = len(hits_set) > 0
+            if hit:
+                hits += 1
+            
+            # Recall: 命中的 / 期望的
+            recall = len(hits_set) / len(expected_set) if expected_set else 0
+            recalls.append(recall)
+            
+            # Precision: 命中的 / 检索的
+            precision = len(hits_set) / min(len(retrieved_files), top_k) if retrieved_files else 0
+            precisions.append(precision)
+            
+            # Reciprocal Rank: 1 / 第一个命中的位置
+            rr = 0.0
+            for rank, file in enumerate(retrieved_files[:top_k], 1):
+                if file in expected_set:
+                    rr = 1.0 / rank
+                    break
+            reciprocal_ranks.append(rr)
+            
+            # 记录结果
+            result = RetrievalTestResult(
+                query=query,
+                expected_files=expected_files,
+                retrieved_files=retrieved_files[:top_k],
+                hit=hit,
+                recall=recall,
+                precision=precision,
+                reciprocal_rank=rr,
+                difficulty=difficulty,
+                category=category
+            )
+            report.results.append(result)
+            
+            # 按难度统计
+            if difficulty not in difficulty_stats:
+                difficulty_stats[difficulty] = {"hits": 0, "total": 0, "recalls": [], "precisions": []}
+            difficulty_stats[difficulty]["total"] += 1
+            if hit:
+                difficulty_stats[difficulty]["hits"] += 1
+            difficulty_stats[difficulty]["recalls"].append(recall)
+            difficulty_stats[difficulty]["precisions"].append(precision)
+            
+            # 记录失败案例
+            if not hit:
+                report.failed_cases.append({
+                    "query": query,
+                    "expected": expected_files,
+                    "retrieved": retrieved_files[:top_k],
+                    "difficulty": difficulty
+                })
+            
+            # 打印进度
+            if verbose:
+                status = "✅" if hit else "❌"
+                print(f"  [{i+1:3d}] {status} Recall={recall:.2f} | {query[:50]}...")
+            else:
+                print(f"\r  Progress: {i+1}/{len(self.golden_dataset)}", end="")
+        
+        print("\n")
+        
+        # 计算聚合指标
+        report.hit_rate = hits / len(self.golden_dataset) if self.golden_dataset else 0
+        report.mean_recall = sum(recalls) / len(recalls) if recalls else 0
+        report.mean_precision = sum(precisions) / len(precisions) if precisions else 0
+        report.mrr = sum(reciprocal_ranks) / len(reciprocal_ranks) if reciprocal_ranks else 0
+        
+        # 按难度汇总
+        for diff, stats in difficulty_stats.items():
+            report.by_difficulty[diff] = {
+                "hit_rate": stats["hits"] / stats["total"] if stats["total"] else 0,
+                "mean_recall": sum(stats["recalls"]) / len(stats["recalls"]) if stats["recalls"] else 0,
+                "mean_precision": sum(stats["precisions"]) / len(stats["precisions"]) if stats["precisions"] else 0,
+                "total": stats["total"]
+            }
+        
+        return report
+    
+    def print_report(self, report: EvaluationReport):
+        """打印评估报告"""
+        print(f"\n{'='*60}")
+        print(f"📊 RETRIEVAL EVALUATION REPORT")
+        print(f"{'='*60}")
+        print(f"Repository: {report.repo_url}")
+        print(f"Top-K: {report.top_k}")
+        print(f"Total Queries: {report.total_queries}")
+        print(f"Timestamp: {report.timestamp}")
+        print(f"{'='*60}\n")
+        
+        print("📈 OVERALL METRICS")
+        print(f"   Hit Rate:       {report.hit_rate:.1%}")
+        print(f"   Mean Recall:    {report.mean_recall:.1%}")
+        print(f"   Mean Precision: {report.mean_precision:.1%}")
+        print(f"   MRR:            {report.mrr:.3f}")
+        
+        print(f"\n📊 BY DIFFICULTY")
+        for diff, stats in sorted(report.by_difficulty.items()):
+            print(f"   {diff.upper():8s} | Hit: {stats['hit_rate']:.1%} | Recall: {stats['mean_recall']:.1%} | n={stats['total']}")
+        
+        if report.failed_cases:
+            print(f"\n❌ FAILED CASES ({len(report.failed_cases)} total)")
+            for case in report.failed_cases[:5]:  # 只显示前5个
+                print(f"   Query: {case['query'][:60]}...")
+                print(f"   Expected: {case['expected']}")
+                print(f"   Got: {case['retrieved'][:3]}...")
+                print()
+        
+        print(f"{'='*60}")
+    
+    def save_report(self, report: EvaluationReport, output_path: str = "evaluation/retrieval_report.json"):
+        """保存报告到文件"""
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        # 转换为可序列化格式
+        data = {
+            "repo_url": report.repo_url,
+            "top_k": report.top_k,
+            "total_queries": report.total_queries,
+            "timestamp": report.timestamp,
+            "metrics": {
+                "hit_rate": report.hit_rate,
+                "mean_recall": report.mean_recall,
+                "mean_precision": report.mean_precision,
+                "mrr": report.mrr
+            },
+            "by_difficulty": report.by_difficulty,
+            "failed_cases": report.failed_cases
+        }
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        
+        print(f"\n💾 Report saved to: {output_path}")
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Evaluate retrieval system using golden dataset")
+    parser.add_argument("--repo", required=True, help="GitHub repository URL to evaluate")
+    parser.add_argument("--top-k", type=int, default=5, help="Number of results to retrieve (default: 5)")
+    parser.add_argument("--session", default="eval_test", help="Session ID for vector store")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Print detailed results")
+    parser.add_argument("--save", action="store_true", help="Save report to file")
+    
+    args = parser.parse_args()
+    
+    evaluator = RetrievalEvaluator()
+    report = await evaluator.evaluate(
+        repo_url=args.repo,
+        session_id=args.session,
+        top_k=args.top_k,
+        verbose=args.verbose
+    )
+    
+    if report:
+        evaluator.print_report(report)
+        if args.save:
+            evaluator.save_report(report)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

evaluation/utils.py

@@ -0,0 +1,196 @@
+# 文件路径: evaluation/utils.py
+"""
+评估模块公共工具函数和常量
+
+将重复的逻辑抽取到这里，保持代码 DRY (Don't Repeat Yourself)
+"""
+
+from typing import List
+
+
+# ============================================================================
+# 闲聊/无效 Query 检测
+# ============================================================================
+
+CHATTY_PATTERNS: List[str] = [
+    # 中文闲聊
+    "你好", "您好", "嗨", "在吗", "在不在", "谢谢", "多谢", "再见", "拜拜",
+    "什么是", "你是谁", "你叫什么", "帮帮我", "教教我",
+    # 英文闲聊
+    "hello", "hi", "hey", "thanks", "thank you", "bye", "goodbye",
+    "what is", "who are you", "help me", "can you",
+    # 单词/简短
+    "test", "测试", "ok", "yes", "no",
+]
+
+# 代码语言指示符
+CODE_INDICATORS: List[str] = [
+    # Python
+    "def ", "class ", "import ", "from ",
+    # JavaScript/TypeScript  
+    "function ", "const ", "let ", "var ",
+    # Java/C#
+    "public ", "private ", "void ",
+    # Go
+    "func ", "package ",
+    # 通用
+    "```",  # Markdown 代码块
+]
+
+
+def is_chatty_query(query: str, min_length: int = 5) -> bool:
+    """
+    检测是否为闲聊/无效 query
+    
+    Args:
+        query: 用户查询
+        min_length: 最小有效长度，低于此值视为无效
+        
+    Returns:
+        True 如果是闲聊/无效查询
+    """
+    if not query:
+        return True
+    
+    query_lower = query.lower().strip()
+    
+    # 长度检查
+    if len(query_lower) < min_length:
+        return True
+    
+    # 模式匹配
+    for pattern in CHATTY_PATTERNS:
+        if query_lower == pattern or query_lower.startswith(pattern + " "):
+            return True
+    
+    return False
+
+
+def has_code_indicators(text: str) -> bool:
+    """
+    检查文本是否包含代码指示符
+    
+    Args:
+        text: 要检查的文本
+        
+    Returns:
+        True 如果包含代码特征
+    """
+    if not text:
+        return False
+    
+    for indicator in CODE_INDICATORS:
+        if indicator in text:
+            return True
+    
+    return False
+
+
+# ============================================================================
+# 文件操作工具
+# ============================================================================
+
+def append_jsonl(filepath: str, data: dict) -> None:
+    """
+    追加一行 JSON 到 JSONL 文件
+    
+    Args:
+        filepath: 文件路径
+        data: 要追加的数据字典
+    """
+    import json
+    with open(filepath, 'a', encoding='utf-8') as f:
+        f.write(json.dumps(data, ensure_ascii=False) + '\n')
+
+
+def read_jsonl(filepath: str) -> list:
+    """
+    读取 JSONL 文件
+    
+    Args:
+        filepath: 文件路径
+        
+    Returns:
+        数据列表
+    """
+    import json
+    import os
+    
+    if not os.path.exists(filepath):
+        return []
+    
+    results = []
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line in f:
+            try:
+                results.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    return results
+
+
+def safe_truncate(text: str, max_length: int, suffix: str = "\n... [truncated]") -> str:
+    """
+    安全截断文本
+    
+    Args:
+        text: 原始文本
+        max_length: 最大长度
+        suffix: 截断后缀
+        
+    Returns:
+        截断后的文本
+    """
+    if not text or len(text) <= max_length:
+        return text
+    return text[:max_length] + suffix
+
+
+def smart_truncate(text: str, max_length: int, keep_ratio: float = 0.7) -> str:
+    """
+    智能截断：保留开头大部分 + 结尾小部分，适合代码上下文
+    
+    Args:
+        text: 原始文本
+        max_length: 最大长度
+        keep_ratio: 开头保留比例（默认 70% 开头，30% 结尾）
+        
+    Returns:
+        截断后的文本，保留首尾关键内容
+    """
+    if not text or len(text) <= max_length:
+        return text
+    
+    separator = "\n\n... [中间内容已省略] ...\n\n"
+    available = max_length - len(separator)
+    
+    if available <= 0:
+        return text[:max_length]
+    
+    head_len = int(available * keep_ratio)
+    tail_len = available - head_len
+    
+    return text[:head_len] + separator + text[-tail_len:]
+
+
+# ============================================================================
+# SFT 数据长度配置
+# ============================================================================
+
+class SFTLengthConfig:
+    """SFT 训练数据长度配置"""
+    
+    # Context 限制（检索到的代码上下文）
+    MAX_CONTEXT_CHARS = 2500          # 最大字符数 (~800 tokens)
+    
+    # Answer 限制（模型生成的回答）
+    MAX_ANSWER_CHARS = 3000           # 最大字符数 (~1000 tokens)
+    
+    # Query 限制
+    MAX_QUERY_CHARS = 500             # 最大字符数
+    
+    # 总体限制
+    MAX_TOTAL_CHARS = 6000            # 总字符数上限 (~2000 tokens)
+    
+    # Token 估算（中英文混合，保守估计）
+    CHARS_PER_TOKEN = 3               # 平均每 token 的字符数

frontend-dist/assets/Tableau10-B-NsZVaP.js

@@ -0,0 +1 @@
+function o(e){for(var c=e.length/6|0,n=new Array(c),a=0;a<c;)n[a]="#"+e.slice(a*6,++a*6);return n}const r=o("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");export{r as s};

frontend-dist/assets/arc-BscbqCCW.js

@@ -0,0 +1 @@
+import{w as ln,c as I}from"./path-CbwjOpE9.js";import{av as an,aw as j,ax as D,ay as rn,az as y,V as on,aA as K,aB as _,aC as un,aD as t,aE as tn,aF as sn,aG as fn}from"./index-BCNM9-Ly.js";function cn(l){return l.innerRadius}function yn(l){return l.outerRadius}function gn(l){return l.startAngle}function mn(l){return l.endAngle}function pn(l){return l&&l.padAngle}function xn(l,h,z,E,v,A,O,a){var B=z-l,i=E-h,n=O-v,m=a-A,r=m*B-n*i;if(!(r*r<y))return r=(n*(h-A)-m*(l-v))/r,[l+r*B,h+r*i]}function W(l,h,z,E,v,A,O){var a=l-z,B=h-E,i=(O?A:-A)/K(a*a+B*B),n=i*B,m=-i*a,r=l+n,s=h+m,f=z+n,c=E+m,S=(r+f)/2,o=(s+c)/2,p=f-r,g=c-s,R=p*p+g*g,T=v-A,w=r*c-f*s,C=(g<0?-1:1)*K(tn(0,T*T*R-w*w)),F=(w*g-p*C)/R,G=(-w*p-g*C)/R,P=(w*g+p*C)/R,x=(-w*p+g*C)/R,d=F-S,e=G-o,u=P-S,V=x-o;return d*d+e*e>u*u+V*V&&(F=P,G=x),{cx:F,cy:G,x01:-n,y01:-m,x11:F*(v/T-1),y11:G*(v/T-1)}}function vn(){var l=cn,h=yn,z=I(0),E=null,v=gn,A=mn,O=pn,a=null,B=ln(i);function i(){var n,m,r=+l.apply(this,arguments),s=+h.apply(this,arguments),f=v.apply(this,arguments)-rn,c=A.apply(this,arguments)-rn,S=un(c-f),o=c>f;if(a||(a=n=B()),s<r&&(m=s,s=r,r=m),!(s>y))a.moveTo(0,0);else if(S>on-y)a.moveTo(s*j(f),s*D(f)),a.arc(0,0,s,f,c,!o),r>y&&(a.moveTo(r*j(c),r*D(c)),a.arc(0,0,r,c,f,o));else{var p=f,g=c,R=f,T=c,w=S,C=S,F=O.apply(this,arguments)/2,G=F>y&&(E?+E.apply(this,arguments):K(r*r+s*s)),P=_(un(s-r)/2,+z.apply(this,arguments)),x=P,d=P,e,u;if(G>y){var V=sn(G/r*D(F)),L=sn(G/s*D(F));(w-=V*2)>y?(V*=o?1:-1,R+=V,T-=V):(w=0,R=T=(f+c)/2),(C-=L*2)>y?(L*=o?1:-1,p+=L,g-=L):(C=0,p=g=(f+c)/2)}var H=s*j(p),J=s*D(p),M=r*j(T),N=r*D(T);if(P>y){var Q=s*j(g),U=s*D(g),X=r*j(R),Y=r*D(R),q;if(S<an)if(q=xn(H,J,X,Y,Q,U,M,N)){var Z=H-q[0],$=J-q[1],k=Q-q[0],b=U-q[1],nn=1/D(fn((Z*k+$*b)/(K(Z*Z+$*$)*K(k*k+b*b)))/2),en=K(q[0]*q[0]+q[1]*q[1]);x=_(P,(r-en)/(nn-1)),d=_(P,(s-en)/(nn+1))}else x=d=0}C>y?d>y?(e=W(X,Y,H,J,s,d,o),u=W(Q,U,M,N,s,d,o),a.moveTo(e.cx+e.x01,e.cy+e.y01),d<P?a.arc(e.cx,e.cy,d,t(e.y01,e.x01),t(u.y01,u.x01),!o):(a.arc(e.cx,e.cy,d,t(e.y01,e.x01),t(e.y11,e.x11),!o),a.arc(0,0,s,t(e.cy+e.y11,e.cx+e.x11),t(u.cy+u.y11,u.cx+u.x11),!o),a.arc(u.cx,u.cy,d,t(u.y11,u.x11),t(u.y01,u.x01),!o))):(a.moveTo(H,J),a.arc(0,0,s,p,g,!o)):a.moveTo(H,J),!(r>y)||!(w>y)?a.lineTo(M,N):x>y?(e=W(M,N,Q,U,r,-x,o),u=W(H,J,X,Y,r,-x,o),a.lineTo(e.cx+e.x01,e.cy+e.y01),x<P?a.arc(e.cx,e.cy,x,t(e.y01,e.x01),t(u.y01,u.x01),!o):(a.arc(e.cx,e.cy,x,t(e.y01,e.x01),t(e.y11,e.x11),!o),a.arc(0,0,r,t(e.cy+e.y11,e.cx+e.x11),t(u.cy+u.y11,u.cx+u.x11),o),a.arc(u.cx,u.cy,x,t(u.y11,u.x11),t(u.y01,u.x01),!o))):a.arc(0,0,r,T,R,o)}if(a.closePath(),n)return a=null,n+""||null}return i.centroid=function(){var n=(+l.apply(this,arguments)+ +h.apply(this,arguments))/2,m=(+v.apply(this,arguments)+ +A.apply(this,arguments))/2-an/2;return[j(m)*n,D(m)*n]},i.innerRadius=function(n){return arguments.length?(l=typeof n=="function"?n:I(+n),i):l},i.outerRadius=function(n){return arguments.length?(h=typeof n=="function"?n:I(+n),i):h},i.cornerRadius=function(n){return arguments.length?(z=typeof n=="function"?n:I(+n),i):z},i.padRadius=function(n){return arguments.length?(E=n==null?null:typeof n=="function"?n:I(+n),i):E},i.startAngle=function(n){return arguments.length?(v=typeof n=="function"?n:I(+n),i):v},i.endAngle=function(n){return arguments.length?(A=typeof n=="function"?n:I(+n),i):A},i.padAngle=function(n){return arguments.length?(O=typeof n=="function"?n:I(+n),i):O},i.context=function(n){return arguments.length?(a=n??null,i):a},i}export{vn as a};

frontend-dist/assets/array-BKyUJesY.js

@@ -0,0 +1 @@
+function t(r){return typeof r=="object"&&"length"in r?r:Array.from(r)}export{t as a};

frontend-dist/assets/blockDiagram-c4efeb88-CL85BYG9.js

@@ -0,0 +1,118 @@
+import{_ as se,d as H,e as ye,l as S,E as Ee,B as we,k as De,c as he,p as ve}from"./index-BCNM9-Ly.js";import{c as Ne}from"./clone-C4pHamD7.js";import{i as ke,c as Ie,b as Oe,d as Te,a as ge,p as ze}from"./edges-96097737-CqpaF4BI.js";import{G as Ce}from"./graph-CY8eBbAS.js";import{o as Ae}from"./ordinal-Cboi1Yqb.js";import{c as Re}from"./channel-DsKT-zfZ.js";import{s as Be}from"./Tableau10-B-NsZVaP.js";import"./createText-1719965b-BZ0xZVnk.js";import"./line-DdWeXrJe.js";import"./array-BKyUJesY.js";import"./path-CbwjOpE9.js";import"./init-Gi6I4Gst.js";var le,oe,ee=function(){var e=function(D,o,s,i){for(s=s||{},i=D.length;i--;s[D[i]]=o);return s},a=[1,7],d=[1,13],c=[1,14],n=[1,15],g=[1,19],l=[1,16],f=[1,17],b=[1,18],p=[8,30],x=[8,21,28,29,30,31,32,40,44,47],y=[1,23],T=[1,24],v=[8,15,16,21,28,29,30,31,32,40,44,47],N=[8,15,16,21,27,28,29,30,31,32,40,44,47],E=[1,49],L={trace:function(){},yy:{},symbols_:{error:2,spaceLines:3,SPACELINE:4,NL:5,separator:6,SPACE:7,EOF:8,start:9,BLOCK_DIAGRAM_KEY:10,document:11,stop:12,statement:13,link:14,LINK:15,START_LINK:16,LINK_LABEL:17,STR:18,nodeStatement:19,columnsStatement:20,SPACE_BLOCK:21,blockStatement:22,classDefStatement:23,cssClassStatement:24,styleStatement:25,node:26,SIZE:27,COLUMNS:28,"id-block":29,end:30,block:31,NODE_ID:32,nodeShapeNLabel:33,dirList:34,DIR:35,NODE_DSTART:36,NODE_DEND:37,BLOCK_ARROW_START:38,BLOCK_ARROW_END:39,classDef:40,CLASSDEF_ID:41,CLASSDEF_STYLEOPTS:42,DEFAULT:43,class:44,CLASSENTITY_IDS:45,STYLECLASS:46,style:47,STYLE_ENTITY_IDS:48,STYLE_DEFINITION_DATA:49,$accept:0,$end:1},terminals_:{2:"error",4:"SPACELINE",5:"NL",7:"SPACE",8:"EOF",10:"BLOCK_DIAGRAM_KEY",15:"LINK",16:"START_LINK",17:"LINK_LABEL",18:"STR",21:"SPACE_BLOCK",27:"SIZE",28:"COLUMNS",29:"id-block",30:"end",31:"block",32:"NODE_ID",35:"DIR",36:"NODE_DSTART",37:"NODE_DEND",38:"BLOCK_ARROW_START",39:"BLOCK_ARROW_END",40:"classDef",41:"CLASSDEF_ID",42:"CLASSDEF_STYLEOPTS",43:"DEFAULT",44:"class",45:"CLASSENTITY_IDS",46:"STYLECLASS",47:"style",48:"STYLE_ENTITY_IDS",49:"STYLE_DEFINITION_DATA"},productions_:[0,[3,1],[3,2],[3,2],[6,1],[6,1],[6,1],[9,3],[12,1],[12,1],[12,2],[12,2],[11,1],[11,2],[14,1],[14,4],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[13,1],[19,3],[19,2],[19,1],[20,1],[22,4],[22,3],[26,1],[26,2],[34,1],[34,2],[33,3],[33,4],[23,3],[23,3],[24,3],[25,3]],performAction:function(o,s,i,u,h,t,m){var r=t.length-1;switch(h){case 4:u.getLogger().debug("Rule: separator (NL) ");break;case 5:u.getLogger().debug("Rule: separator (Space) ");break;case 6:u.getLogger().debug("Rule: separator (EOF) ");break;case 7:u.getLogger().debug("Rule: hierarchy: ",t[r-1]),u.setHierarchy(t[r-1]);break;case 8:u.getLogger().debug("Stop NL ");break;case 9:u.getLogger().debug("Stop EOF ");break;case 10:u.getLogger().debug("Stop NL2 ");break;case 11:u.getLogger().debug("Stop EOF2 ");break;case 12:u.getLogger().debug("Rule: statement: ",t[r]),typeof t[r].length=="number"?this.$=t[r]:this.$=[t[r]];break;case 13:u.getLogger().debug("Rule: statement #2: ",t[r-1]),this.$=[t[r-1]].concat(t[r]);break;case 14:u.getLogger().debug("Rule: link: ",t[r],o),this.$={edgeTypeStr:t[r],label:""};break;case 15:u.getLogger().debug("Rule: LABEL link: ",t[r-3],t[r-1],t[r]),this.$={edgeTypeStr:t[r],label:t[r-1]};break;case 18:const R=parseInt(t[r]),Y=u.generateId();this.$={id:Y,type:"space",label:"",width:R,children:[]};break;case 23:u.getLogger().debug("Rule: (nodeStatement link node) ",t[r-2],t[r-1],t[r]," typestr: ",t[r-1].edgeTypeStr);const F=u.edgeStrToEdgeData(t[r-1].edgeTypeStr);this.$=[{id:t[r-2].id,label:t[r-2].label,type:t[r-2].type,directions:t[r-2].directions},{id:t[r-2].id+"-"+t[r].id,start:t[r-2].id,end:t[r].id,label:t[r-1].label,type:"edge",directions:t[r].directions,arrowTypeEnd:F,arrowTypeStart:"arrow_open"},{id:t[r].id,label:t[r].label,type:u.typeStr2Type(t[r].typeStr),directions:t[r].directions}];break;case 24:u.getLogger().debug("Rule: nodeStatement (abc88 node size) ",t[r-1],t[r]),this.$={id:t[r-1].id,label:t[r-1].label,type:u.typeStr2Type(t[r-1].typeStr),directions:t[r-1].directions,widthInColumns:parseInt(t[r],10)};break;case 25:u.getLogger().debug("Rule: nodeStatement (node) ",t[r]),this.$={id:t[r].id,label:t[r].label,type:u.typeStr2Type(t[r].typeStr),directions:t[r].directions,widthInColumns:1};break;case 26:u.getLogger().debug("APA123",this?this:"na"),u.getLogger().debug("COLUMNS: ",t[r]),this.$={type:"column-setting",columns:t[r]==="auto"?-1:parseInt(t[r])};break;case 27:u.getLogger().debug("Rule: id-block statement : ",t[r-2],t[r-1]),u.generateId(),this.$={...t[r-2],type:"composite",children:t[r-1]};break;case 28:u.getLogger().debug("Rule: blockStatement : ",t[r-2],t[r-1],t[r]);const C=u.generateId();this.$={id:C,type:"composite",label:"",children:t[r-1]};break;case 29:u.getLogger().debug("Rule: node (NODE_ID separator): ",t[r]),this.$={id:t[r]};break;case 30:u.getLogger().debug("Rule: node (NODE_ID nodeShapeNLabel separator): ",t[r-1],t[r]),this.$={id:t[r-1],label:t[r].label,typeStr:t[r].typeStr,directions:t[r].directions};break;case 31:u.getLogger().debug("Rule: dirList: ",t[r]),this.$=[t[r]];break;case 32:u.getLogger().debug("Rule: dirList: ",t[r-1],t[r]),this.$=[t[r-1]].concat(t[r]);break;case 33:u.getLogger().debug("Rule: nodeShapeNLabel: ",t[r-2],t[r-1],t[r]),this.$={typeStr:t[r-2]+t[r],label:t[r-1]};break;case 34:u.getLogger().debug("Rule: BLOCK_ARROW nodeShapeNLabel: ",t[r-3],t[r-2]," #3:",t[r-1],t[r]),this.$={typeStr:t[r-3]+t[r],label:t[r-2],directions:t[r-1]};break;case 35:case 36:this.$={type:"classDef",id:t[r-1].trim(),css:t[r].trim()};break;case 37:this.$={type:"applyClass",id:t[r-1].trim(),styleClass:t[r].trim()};break;case 38:this.$={type:"applyStyles",id:t[r-1].trim(),stylesStr:t[r].trim()};break}},table:[{9:1,10:[1,2]},{1:[3]},{11:3,13:4,19:5,20:6,21:a,22:8,23:9,24:10,25:11,26:12,28:d,29:c,31:n,32:g,40:l,44:f,47:b},{8:[1,20]},e(p,[2,12],{13:4,19:5,20:6,22:8,23:9,24:10,25:11,26:12,11:21,21:a,28:d,29:c,31:n,32:g,40:l,44:f,47:b}),e(x,[2,16],{14:22,15:y,16:T}),e(x,[2,17]),e(x,[2,18]),e(x,[2,19]),e(x,[2,20]),e(x,[2,21]),e(x,[2,22]),e(v,[2,25],{27:[1,25]}),e(x,[2,26]),{19:26,26:12,32:g},{11:27,13:4,19:5,20:6,21:a,22:8,23:9,24:10,25:11,26:12,28:d,29:c,31:n,32:g,40:l,44:f,47:b},{41:[1,28],43:[1,29]},{45:[1,30]},{48:[1,31]},e(N,[2,29],{33:32,36:[1,33],38:[1,34]}),{1:[2,7]},e(p,[2,13]),{26:35,32:g},{32:[2,14]},{17:[1,36]},e(v,[2,24]),{11:37,13:4,14:22,15:y,16:T,19:5,20:6,21:a,22:8,23:9,24:10,25:11,26:12,28:d,29:c,31:n,32:g,40:l,44:f,47:b},{30:[1,38]},{42:[1,39]},{42:[1,40]},{46:[1,41]},{49:[1,42]},e(N,[2,30]),{18:[1,43]},{18:[1,44]},e(v,[2,23]),{18:[1,45]},{30:[1,46]},e(x,[2,28]),e(x,[2,35]),e(x,[2,36]),e(x,[2,37]),e(x,[2,38]),{37:[1,47]},{34:48,35:E},{15:[1,50]},e(x,[2,27]),e(N,[2,33]),{39:[1,51]},{34:52,35:E,39:[2,31]},{32:[2,15]},e(N,[2,34]),{39:[2,32]}],defaultActions:{20:[2,7],23:[2,14],50:[2,15],52:[2,32]},parseError:function(o,s){if(s.recoverable)this.trace(o);else{var i=new Error(o);throw i.hash=s,i}},parse:function(o){var s=this,i=[0],u=[],h=[null],t=[],m=this.table,r="",R=0,Y=0,F=2,C=1,Le=t.slice.call(arguments,1),w=Object.create(this.lexer),K={yy:{}};for(var Z in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Z)&&(K.yy[Z]=this.yy[Z]);w.setInput(o,K.yy),K.yy.lexer=w,K.yy.parser=this,typeof w.yylloc>"u"&&(w.yylloc={});var J=w.yylloc;t.push(J);var me=w.options&&w.options.ranges;typeof K.yy.parseError=="function"?this.parseError=K.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function _e(){var P;return P=u.pop()||w.lex()||C,typeof P!="number"&&(P instanceof Array&&(u=P,P=u.pop()),P=s.symbols_[P]||P),P}for(var I,M,z,Q,W={},X,B,ae,G;;){if(M=i[i.length-1],this.defaultActions[M]?z=this.defaultActions[M]:((I===null||typeof I>"u")&&(I=_e()),z=m[M]&&m[M][I]),typeof z>"u"||!z.length||!z[0]){var $="";G=[];for(X in m[M])this.terminals_[X]&&X>F&&G.push("'"+this.terminals_[X]+"'");w.showPosition?$="Parse error on line "+(R+1)+`:
+`+w.showPosition()+`
+Expecting `+G.join(", ")+", got '"+(this.terminals_[I]||I)+"'":$="Parse error on line "+(R+1)+": Unexpected "+(I==C?"end of input":"'"+(this.terminals_[I]||I)+"'"),this.parseError($,{text:w.match,token:this.terminals_[I]||I,line:w.yylineno,loc:J,expected:G})}if(z[0]instanceof Array&&z.length>1)throw new Error("Parse Error: multiple actions possible at state: "+M+", token: "+I);switch(z[0]){case 1:i.push(I),h.push(w.yytext),t.push(w.yylloc),i.push(z[1]),I=null,Y=w.yyleng,r=w.yytext,R=w.yylineno,J=w.yylloc;break;case 2:if(B=this.productions_[z[1]][1],W.$=h[h.length-B],W._$={first_line:t[t.length-(B||1)].first_line,last_line:t[t.length-1].last_line,first_column:t[t.length-(B||1)].first_column,last_column:t[t.length-1].last_column},me&&(W._$.range=[t[t.length-(B||1)].range[0],t[t.length-1].range[1]]),Q=this.performAction.apply(W,[r,Y,R,K.yy,z[1],h,t].concat(Le)),typeof Q<"u")return Q;B&&(i=i.slice(0,-1*B*2),h=h.slice(0,-1*B),t=t.slice(0,-1*B)),i.push(this.productions_[z[1]][0]),h.push(W.$),t.push(W._$),ae=m[i[i.length-2]][i[i.length-1]],i.push(ae);break;case 3:return!0}}return!0}},A=function(){var D={EOF:1,parseError:function(s,i){if(this.yy.parser)this.yy.parser.parseError(s,i);else throw new Error(s)},setInput:function(o,s){return this.yy=s||this.yy||{},this._input=o,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},input:function(){var o=this._input[0];this.yytext+=o,this.yyleng++,this.offset++,this.match+=o,this.matched+=o;var s=o.match(/(?:\r\n?|\n).*/g);return s?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),o},unput:function(o){var s=o.length,i=o.split(/(?:\r\n?|\n)/g);this._input=o+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-s),this.offset-=s;var u=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),i.length-1&&(this.yylineno-=i.length-1);var h=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:i?(i.length===u.length?this.yylloc.first_column:0)+u[u.length-i.length].length-i[0].length:this.yylloc.first_column-s},this.options.ranges&&(this.yylloc.range=[h[0],h[0]+this.yyleng-s]),this.yyleng=this.yytext.length,this},more:function(){return this._more=!0,this},reject:function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},less:function(o){this.unput(this.match.slice(o))},pastInput:function(){var o=this.matched.substr(0,this.matched.length-this.match.length);return(o.length>20?"...":"")+o.substr(-20).replace(/\n/g,"")},upcomingInput:function(){var o=this.match;return o.length<20&&(o+=this._input.substr(0,20-o.length)),(o.substr(0,20)+(o.length>20?"...":"")).replace(/\n/g,"")},showPosition:function(){var o=this.pastInput(),s=new Array(o.length+1).join("-");return o+this.upcomingInput()+`
+`+s+"^"},test_match:function(o,s){var i,u,h;if(this.options.backtrack_lexer&&(h={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(h.yylloc.range=this.yylloc.range.slice(0))),u=o[0].match(/(?:\r\n?|\n).*/g),u&&(this.yylineno+=u.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:u?u[u.length-1].length-u[u.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+o[0].length},this.yytext+=o[0],this.match+=o[0],this.matches=o,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(o[0].length),this.matched+=o[0],i=this.performAction.call(this,this.yy,this,s,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),i)return i;if(this._backtrack){for(var t in h)this[t]=h[t];return!1}return!1},next:function(){if(this.done)return this.EOF;this._input||(this.done=!0);var o,s,i,u;this._more||(this.yytext="",this.match="");for(var h=this._currentRules(),t=0;t<h.length;t++)if(i=this._input.match(this.rules[h[t]]),i&&(!s||i[0].length>s[0].length)){if(s=i,u=t,this.options.backtrack_lexer){if(o=this.test_match(i,h[t]),o!==!1)return o;if(this._backtrack){s=!1;continue}else return!1}else if(!this.options.flex)break}return s?(o=this.test_match(s,h[u]),o!==!1?o:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text.
+`+this.showPosition(),{text:"",token:null,line:this.yylineno})},lex:function(){var s=this.next();return s||this.lex()},begin:function(s){this.conditionStack.push(s)},popState:function(){var s=this.conditionStack.length-1;return s>0?this.conditionStack.pop():this.conditionStack[0]},_currentRules:function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},topState:function(s){return s=this.conditionStack.length-1-Math.abs(s||0),s>=0?this.conditionStack[s]:"INITIAL"},pushState:function(s){this.begin(s)},stateStackSize:function(){return this.conditionStack.length},options:{},performAction:function(s,i,u,h){switch(u){case 0:return 10;case 1:return s.getLogger().debug("Found space-block"),31;case 2:return s.getLogger().debug("Found nl-block"),31;case 3:return s.getLogger().debug("Found space-block"),29;case 4:s.getLogger().debug(".",i.yytext);break;case 5:s.getLogger().debug("_",i.yytext);break;case 6:return 5;case 7:return i.yytext=-1,28;case 8:return i.yytext=i.yytext.replace(/columns\s+/,""),s.getLogger().debug("COLUMNS (LEX)",i.yytext),28;case 9:this.pushState("md_string");break;case 10:return"MD_STR";case 11:this.popState();break;case 12:this.pushState("string");break;case 13:s.getLogger().debug("LEX: POPPING STR:",i.yytext),this.popState();break;case 14:return s.getLogger().debug("LEX: STR end:",i.yytext),"STR";case 15:return i.yytext=i.yytext.replace(/space\:/,""),s.getLogger().debug("SPACE NUM (LEX)",i.yytext),21;case 16:return i.yytext="1",s.getLogger().debug("COLUMNS (LEX)",i.yytext),21;case 17:return 43;case 18:return"LINKSTYLE";case 19:return"INTERPOLATE";case 20:return this.pushState("CLASSDEF"),40;case 21:return this.popState(),this.pushState("CLASSDEFID"),"DEFAULT_CLASSDEF_ID";case 22:return this.popState(),this.pushState("CLASSDEFID"),41;case 23:return this.popState(),42;case 24:return this.pushState("CLASS"),44;case 25:return this.popState(),this.pushState("CLASS_STYLE"),45;case 26:return this.popState(),46;case 27:return this.pushState("STYLE_STMNT"),47;case 28:return this.popState(),this.pushState("STYLE_DEFINITION"),48;case 29:return this.popState(),49;case 30:return this.pushState("acc_title"),"acc_title";case 31:return this.popState(),"acc_title_value";case 32:return this.pushState("acc_descr"),"acc_descr";case 33:return this.popState(),"acc_descr_value";case 34:this.pushState("acc_descr_multiline");break;case 35:this.popState();break;case 36:return"acc_descr_multiline_value";case 37:return 30;case 38:return this.popState(),s.getLogger().debug("Lex: (("),"NODE_DEND";case 39:return this.popState(),s.getLogger().debug("Lex: (("),"NODE_DEND";case 40:return this.popState(),s.getLogger().debug("Lex: ))"),"NODE_DEND";case 41:return this.popState(),s.getLogger().debug("Lex: (("),"NODE_DEND";case 42:return this.popState(),s.getLogger().debug("Lex: (("),"NODE_DEND";case 43:return this.popState(),s.getLogger().debug("Lex: (-"),"NODE_DEND";case 44:return this.popState(),s.getLogger().debug("Lex: -)"),"NODE_DEND";case 45:return this.popState(),s.getLogger().debug("Lex: (("),"NODE_DEND";case 46:return this.popState(),s.getLogger().debug("Lex: ]]"),"NODE_DEND";case 47:return this.popState(),s.getLogger().debug("Lex: ("),"NODE_DEND";case 48:return this.popState(),s.getLogger().debug("Lex: ])"),"NODE_DEND";case 49:return this.popState(),s.getLogger().debug("Lex: /]"),"NODE_DEND";case 50:return this.popState(),s.getLogger().debug("Lex: /]"),"NODE_DEND";case 51:return this.popState(),s.getLogger().debug("Lex: )]"),"NODE_DEND";case 52:return this.popState(),s.getLogger().debug("Lex: )"),"NODE_DEND";case 53:return this.popState(),s.getLogger().debug("Lex: ]>"),"NODE_DEND";case 54:return this.popState(),s.getLogger().debug("Lex: ]"),"NODE_DEND";case 55:return s.getLogger().debug("Lexa: -)"),this.pushState("NODE"),36;case 56:return s.getLogger().debug("Lexa: (-"),this.pushState("NODE"),36;case 57:return s.getLogger().debug("Lexa: ))"),this.pushState("NODE"),36;case 58:return s.getLogger().debug("Lexa: )"),this.pushState("NODE"),36;case 59:return s.getLogger().debug("Lex: ((("),this.pushState("NODE"),36;case 60:return s.getLogger().debug("Lexa: )"),this.pushState("NODE"),36;case 61:return s.getLogger().debug("Lexa: )"),this.pushState("NODE"),36;case 62:return s.getLogger().debug("Lexa: )"),this.pushState("NODE"),36;case 63:return s.getLogger().debug("Lexc: >"),this.pushState("NODE"),36;case 64:return s.getLogger().debug("Lexa: (["),this.pushState("NODE"),36;case 65:return s.getLogger().debug("Lexa: )"),this.pushState("NODE"),36;case 66:return this.pushState("NODE"),36;case 67:return this.pushState("NODE"),36;case 68:return this.pushState("NODE"),36;case 69:return this.pushState("NODE"),36;case 70:return this.pushState("NODE"),36;case 71:return this.pushState("NODE"),36;case 72:return this.pushState("NODE"),36;case 73:return s.getLogger().debug("Lexa: ["),this.pushState("NODE"),36;case 74:return this.pushState("BLOCK_ARROW"),s.getLogger().debug("LEX ARR START"),38;case 75:return s.getLogger().debug("Lex: NODE_ID",i.yytext),32;case 76:return s.getLogger().debug("Lex: EOF",i.yytext),8;case 77:this.pushState("md_string");break;case 78:this.pushState("md_string");break;case 79:return"NODE_DESCR";case 80:this.popState();break;case 81:s.getLogger().debug("Lex: Starting string"),this.pushState("string");break;case 82:s.getLogger().debug("LEX ARR: Starting string"),this.pushState("string");break;case 83:return s.getLogger().debug("LEX: NODE_DESCR:",i.yytext),"NODE_DESCR";case 84:s.getLogger().debug("LEX POPPING"),this.popState();break;case 85:s.getLogger().debug("Lex: =>BAE"),this.pushState("ARROW_DIR");break;case 86:return i.yytext=i.yytext.replace(/^,\s*/,""),s.getLogger().debug("Lex (right): dir:",i.yytext),"DIR";case 87:return i.yytext=i.yytext.replace(/^,\s*/,""),s.getLogger().debug("Lex (left):",i.yytext),"DIR";case 88:return i.yytext=i.yytext.replace(/^,\s*/,""),s.getLogger().debug("Lex (x):",i.yytext),"DIR";case 89:return i.yytext=i.yytext.replace(/^,\s*/,""),s.getLogger().debug("Lex (y):",i.yytext),"DIR";case 90:return i.yytext=i.yytext.replace(/^,\s*/,""),s.getLogger().debug("Lex (up):",i.yytext),"DIR";case 91:return i.yytext=i.yytext.replace(/^,\s*/,""),s.getLogger().debug("Lex (down):",i.yytext),"DIR";case 92:return i.yytext="]>",s.getLogger().debug("Lex (ARROW_DIR end):",i.yytext),this.popState(),this.popState(),"BLOCK_ARROW_END";case 93:return s.getLogger().debug("Lex: LINK","#"+i.yytext+"#"),15;case 94:return s.getLogger().debug("Lex: LINK",i.yytext),15;case 95:return s.getLogger().debug("Lex: LINK",i.yytext),15;case 96:return s.getLogger().debug("Lex: LINK",i.yytext),15;case 97:return s.getLogger().debug("Lex: START_LINK",i.yytext),this.pushState("LLABEL"),16;case 98:return s.getLogger().debug("Lex: START_LINK",i.yytext),this.pushState("LLABEL"),16;case 99:return s.getLogger().debug("Lex: START_LINK",i.yytext),this.pushState("LLABEL"),16;case 100:this.pushState("md_string");break;case 101:return s.getLogger().debug("Lex: Starting string"),this.pushState("string"),"LINK_LABEL";case 102:return this.popState(),s.getLogger().debug("Lex: LINK","#"+i.yytext+"#"),15;case 103:return this.popState(),s.getLogger().debug("Lex: LINK",i.yytext),15;case 104:return this.popState(),s.getLogger().debug("Lex: LINK",i.yytext),15;case 105:return s.getLogger().debug("Lex: COLON",i.yytext),i.yytext=i.yytext.slice(1),27}},rules:[/^(?:block-beta\b)/,/^(?:block\s+)/,/^(?:block\n+)/,/^(?:block:)/,/^(?:[\s]+)/,/^(?:[\n]+)/,/^(?:((\u000D\u000A)|(\u000A)))/,/^(?:columns\s+auto\b)/,/^(?:columns\s+[\d]+)/,/^(?:["][`])/,/^(?:[^`"]+)/,/^(?:[`]["])/,/^(?:["])/,/^(?:["])/,/^(?:[^"]*)/,/^(?:space[:]\d+)/,/^(?:space\b)/,/^(?:default\b)/,/^(?:linkStyle\b)/,/^(?:interpolate\b)/,/^(?:classDef\s+)/,/^(?:DEFAULT\s+)/,/^(?:\w+\s+)/,/^(?:[^\n]*)/,/^(?:class\s+)/,/^(?:(\w+)+((,\s*\w+)*))/,/^(?:[^\n]*)/,/^(?:style\s+)/,/^(?:(\w+)+((,\s*\w+)*))/,/^(?:[^\n]*)/,/^(?:accTitle\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*\{\s*)/,/^(?:[\}])/,/^(?:[^\}]*)/,/^(?:end\b\s*)/,/^(?:\(\(\()/,/^(?:\)\)\))/,/^(?:[\)]\))/,/^(?:\}\})/,/^(?:\})/,/^(?:\(-)/,/^(?:-\))/,/^(?:\(\()/,/^(?:\]\])/,/^(?:\()/,/^(?:\]\))/,/^(?:\\\])/,/^(?:\/\])/,/^(?:\)\])/,/^(?:[\)])/,/^(?:\]>)/,/^(?:[\]])/,/^(?:-\))/,/^(?:\(-)/,/^(?:\)\))/,/^(?:\))/,/^(?:\(\(\()/,/^(?:\(\()/,/^(?:\{\{)/,/^(?:\{)/,/^(?:>)/,/^(?:\(\[)/,/^(?:\()/,/^(?:\[\[)/,/^(?:\[\|)/,/^(?:\[\()/,/^(?:\)\)\))/,/^(?:\[\\)/,/^(?:\[\/)/,/^(?:\[\\)/,/^(?:\[)/,/^(?:<\[)/,/^(?:[^\(\[\n\-\)\{\}\s\<\>:]+)/,/^(?:$)/,/^(?:["][`])/,/^(?:["][`])/,/^(?:[^`"]+)/,/^(?:[`]["])/,/^(?:["])/,/^(?:["])/,/^(?:[^"]+)/,/^(?:["])/,/^(?:\]>\s*\()/,/^(?:,?\s*right\s*)/,/^(?:,?\s*left\s*)/,/^(?:,?\s*x\s*)/,/^(?:,?\s*y\s*)/,/^(?:,?\s*up\s*)/,/^(?:,?\s*down\s*)/,/^(?:\)\s*)/,/^(?:\s*[xo<]?--+[-xo>]\s*)/,/^(?:\s*[xo<]?==+[=xo>]\s*)/,/^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,/^(?:\s*~~[\~]+\s*)/,/^(?:\s*[xo<]?--\s*)/,/^(?:\s*[xo<]?==\s*)/,/^(?:\s*[xo<]?-\.\s*)/,/^(?:["][`])/,/^(?:["])/,/^(?:\s*[xo<]?--+[-xo>]\s*)/,/^(?:\s*[xo<]?==+[=xo>]\s*)/,/^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,/^(?::\d+)/],conditions:{STYLE_DEFINITION:{rules:[29],inclusive:!1},STYLE_STMNT:{rules:[28],inclusive:!1},CLASSDEFID:{rules:[23],inclusive:!1},CLASSDEF:{rules:[21,22],inclusive:!1},CLASS_STYLE:{rules:[26],inclusive:!1},CLASS:{rules:[25],inclusive:!1},LLABEL:{rules:[100,101,102,103,104],inclusive:!1},ARROW_DIR:{rules:[86,87,88,89,90,91,92],inclusive:!1},BLOCK_ARROW:{rules:[77,82,85],inclusive:!1},NODE:{rules:[38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,78,81],inclusive:!1},md_string:{rules:[10,11,79,80],inclusive:!1},space:{rules:[],inclusive:!1},string:{rules:[13,14,83,84],inclusive:!1},acc_descr_multiline:{rules:[35,36],inclusive:!1},acc_descr:{rules:[33],inclusive:!1},acc_title:{rules:[31],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,7,8,9,12,15,16,17,18,19,20,24,27,30,32,34,37,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,93,94,95,96,97,98,99,105],inclusive:!0}}};return D}();L.lexer=A;function k(){this.yy={}}return k.prototype=L,L.Parser=k,new k}();ee.parser=ee;const Pe=ee;let O={},ie=[],V={};const ce="color",ue="fill",Fe="bgFill",pe=",",Ke=he();let j={};const Me=e=>De.sanitizeText(e,Ke),Ye=function(e,a=""){j[e]===void 0&&(j[e]={id:e,styles:[],textStyles:[]});const d=j[e];a!=null&&a.split(pe).forEach(c=>{const n=c.replace(/([^;]*);/,"$1").trim();if(c.match(ce)){const l=n.replace(ue,Fe).replace(ce,ue);d.textStyles.push(l)}d.styles.push(n)})},We=function(e,a=""){const d=O[e];a!=null&&(d.styles=a.split(pe))},Ve=function(e,a){e.split(",").forEach(function(d){let c=O[d];if(c===void 0){const n=d.trim();O[n]={id:n,type:"na",children:[]},c=O[n]}c.classes||(c.classes=[]),c.classes.push(a)})},fe=(e,a)=>{const d=e.flat(),c=[];for(const n of d){if(n.label&&(n.label=Me(n.label)),n.type==="classDef"){Ye(n.id,n.css);continue}if(n.type==="applyClass"){Ve(n.id,(n==null?void 0:n.styleClass)||"");continue}if(n.type==="applyStyles"){n!=null&&n.stylesStr&&We(n.id,n==null?void 0:n.stylesStr);continue}if(n.type==="column-setting")a.columns=n.columns||-1;else if(n.type==="edge")V[n.id]?V[n.id]++:V[n.id]=1,n.id=V[n.id]+"-"+n.id,ie.push(n);else{n.label||(n.type==="composite"?n.label="":n.label=n.id);const g=!O[n.id];if(g?O[n.id]=n:(n.type!=="na"&&(O[n.id].type=n.type),n.label!==n.id&&(O[n.id].label=n.label)),n.children&&fe(n.children,n),n.type==="space"){const l=n.width||1;for(let f=0;f<l;f++){const b=Ne(n);b.id=b.id+"-"+f,O[b.id]=b,c.push(b)}}else g&&c.push(n)}}a.children=c};let re=[],U={id:"root",type:"composite",children:[],columns:-1};const je=()=>{S.debug("Clear called"),Ee(),U={id:"root",type:"composite",children:[],columns:-1},O={root:U},re=[],j={},ie=[],V={}};function Ue(e){switch(S.debug("typeStr2Type",e),e){case"[]":return"square";case"()":return S.debug("we have a round"),"round";case"(())":return"circle";case">]":return"rect_left_inv_arrow";case"{}":return"diamond";case"{{}}":return"hexagon";case"([])":return"stadium";case"[[]]":return"subroutine";case"[()]":return"cylinder";case"((()))":return"doublecircle";case"[//]":return"lean_right";case"[\\\\]":return"lean_left";case"[/\\]":return"trapezoid";case"[\\/]":return"inv_trapezoid";case"<[]>":return"block_arrow";default:return"na"}}function Xe(e){switch(S.debug("typeStr2Type",e),e){case"==":return"thick";default:return"normal"}}function Ge(e){switch(e.trim()){case"--x":return"arrow_cross";case"--o":return"arrow_circle";default:return"arrow_point"}}let de=0;const He=()=>(de++,"id-"+Math.random().toString(36).substr(2,12)+"-"+de),qe=e=>{U.children=e,fe(e,U),re=U.children},Ze=e=>{const a=O[e];return a?a.columns?a.columns:a.children?a.children.length:-1:-1},Je=()=>[...Object.values(O)],Qe=()=>re||[],$e=()=>ie,et=e=>O[e],tt=e=>{O[e.id]=e},st=()=>console,it=function(){return j},rt={getConfig:()=>se().block,typeStr2Type:Ue,edgeTypeStr2Type:Xe,edgeStrToEdgeData:Ge,getLogger:st,getBlocksFlat:Je,getBlocks:Qe,getEdges:$e,setHierarchy:qe,getBlock:et,setBlock:tt,getColumns:Ze,getClasses:it,clear:je,generateId:He},nt=rt,q=(e,a)=>{const d=Re,c=d(e,"r"),n=d(e,"g"),g=d(e,"b");return we(c,n,g,a)},at=e=>`.label {
+    font-family: ${e.fontFamily};
+    color: ${e.nodeTextColor||e.textColor};
+  }
+  .cluster-label text {
+    fill: ${e.titleColor};
+  }
+  .cluster-label span,p {
+    color: ${e.titleColor};
+  }
+
+
+
+  .label text,span,p {
+    fill: ${e.nodeTextColor||e.textColor};
+    color: ${e.nodeTextColor||e.textColor};
+  }
+
+  .node rect,
+  .node circle,
+  .node ellipse,
+  .node polygon,
+  .node path {
+    fill: ${e.mainBkg};
+    stroke: ${e.nodeBorder};
+    stroke-width: 1px;
+  }
+  .flowchart-label text {
+    text-anchor: middle;
+  }
+  // .flowchart-label .text-outer-tspan {
+  //   text-anchor: middle;
+  // }
+  // .flowchart-label .text-inner-tspan {
+  //   text-anchor: start;
+  // }
+
+  .node .label {
+    text-align: center;
+  }
+  .node.clickable {
+    cursor: pointer;
+  }
+
+  .arrowheadPath {
+    fill: ${e.arrowheadColor};
+  }
+
+  .edgePath .path {
+    stroke: ${e.lineColor};
+    stroke-width: 2.0px;
+  }
+
+  .flowchart-link {
+    stroke: ${e.lineColor};
+    fill: none;
+  }
+
+  .edgeLabel {
+    background-color: ${e.edgeLabelBackground};
+    rect {
+      opacity: 0.5;
+      background-color: ${e.edgeLabelBackground};
+      fill: ${e.edgeLabelBackground};
+    }
+    text-align: center;
+  }
+
+  /* For html labels only */
+  .labelBkg {
+    background-color: ${q(e.edgeLabelBackground,.5)};
+    // background-color:
+  }
+
+  .node .cluster {
+    // fill: ${q(e.mainBkg,.5)};
+    fill: ${q(e.clusterBkg,.5)};
+    stroke: ${q(e.clusterBorder,.2)};
+    box-shadow: rgba(50, 50, 93, 0.25) 0px 13px 27px -5px, rgba(0, 0, 0, 0.3) 0px 8px 16px -8px;
+    stroke-width: 1px;
+  }
+
+  .cluster text {
+    fill: ${e.titleColor};
+  }
+
+  .cluster span,p {
+    color: ${e.titleColor};
+  }
+  /* .cluster div {
+    color: ${e.titleColor};
+  } */
+
+  div.mermaidTooltip {
+    position: absolute;
+    text-align: center;
+    max-width: 200px;
+    padding: 2px;
+    font-family: ${e.fontFamily};
+    font-size: 12px;
+    background: ${e.tertiaryColor};
+    border: 1px solid ${e.border2};
+    border-radius: 2px;
+    pointer-events: none;
+    z-index: 100;
+  }
+
+  .flowchartTitleText {
+    text-anchor: middle;
+    font-size: 18px;
+    fill: ${e.textColor};
+  }
+`,lt=at;function be(e,a,d=!1){var c,n,g;const l=e;let f="default";(((c=l==null?void 0:l.classes)==null?void 0:c.length)||0)>0&&(f=((l==null?void 0:l.classes)||[]).join(" ")),f=f+" flowchart-label";let b=0,p="",x;switch(l.type){case"round":b=5,p="rect";break;case"composite":b=0,p="composite",x=0;break;case"square":p="rect";break;case"diamond":p="question";break;case"hexagon":p="hexagon";break;case"block_arrow":p="block_arrow";break;case"odd":p="rect_left_inv_arrow";break;case"lean_right":p="lean_right";break;case"lean_left":p="lean_left";break;case"trapezoid":p="trapezoid";break;case"inv_trapezoid":p="inv_trapezoid";break;case"rect_left_inv_arrow":p="rect_left_inv_arrow";break;case"circle":p="circle";break;case"ellipse":p="ellipse";break;case"stadium":p="stadium";break;case"subroutine":p="subroutine";break;case"cylinder":p="cylinder";break;case"group":p="rect";break;case"doublecircle":p="doublecircle";break;default:p="rect"}const y=ve((l==null?void 0:l.styles)||[]),T=l.label,v=l.size||{width:0,height:0,x:0,y:0};return{labelStyle:y.labelStyle,shape:p,labelText:T,rx:b,ry:b,class:f,style:y.style,id:l.id,directions:l.directions,width:v.width,height:v.height,x:v.x,y:v.y,positioned:d,intersect:void 0,type:l.type,padding:x??(((g=(n=se())==null?void 0:n.block)==null?void 0:g.padding)||0)}}async function ot(e,a,d){const c=be(a,d,!1);if(c.type==="group")return;const n=await ge(e,c),g=n.node().getBBox(),l=d.getBlock(c.id);l.size={width:g.width,height:g.height,x:0,y:0,node:n},d.setBlock(l),n.remove()}async function ct(e,a,d){const c=be(a,d,!0);d.getBlock(c.id).type!=="space"&&(await ge(e,c),a.intersect=c==null?void 0:c.intersect,ze(c))}async function ne(e,a,d,c){for(const n of a)await c(e,n,d),n.children&&await ne(e,n.children,d,c)}async function ut(e,a,d){await ne(e,a,d,ot)}async function dt(e,a,d){await ne(e,a,d,ct)}async function ht(e,a,d,c,n){const g=new Ce({multigraph:!0,compound:!0});g.setGraph({rankdir:"TB",nodesep:10,ranksep:10,marginx:8,marginy:8});for(const l of d)l.size&&g.setNode(l.id,{width:l.size.width,height:l.size.height,intersect:l.intersect});for(const l of a)if(l.start&&l.end){const f=c.getBlock(l.start),b=c.getBlock(l.end);if(f!=null&&f.size&&(b!=null&&b.size)){const p=f.size,x=b.size,y=[{x:p.x,y:p.y},{x:p.x+(x.x-p.x)/2,y:p.y+(x.y-p.y)/2},{x:x.x,y:x.y}];await Ie(e,{v:l.start,w:l.end,name:l.id},{...l,arrowTypeEnd:l.arrowTypeEnd,arrowTypeStart:l.arrowTypeStart,points:y,classes:"edge-thickness-normal edge-pattern-solid flowchart-link LS-a1 LE-b1"},void 0,"block",g,n),l.label&&(await Oe(e,{...l,label:l.label,labelStyle:"stroke: #333; stroke-width: 1.5px;fill:none;",arrowTypeEnd:l.arrowTypeEnd,arrowTypeStart:l.arrowTypeStart}),await Te({...l,x:y[1].x,y:y[1].y},{originalPath:y}))}}}const _=((oe=(le=he())==null?void 0:le.block)==null?void 0:oe.padding)||8;function gt(e,a){if(e===0||!Number.isInteger(e))throw new Error("Columns must be an integer !== 0.");if(a<0||!Number.isInteger(a))throw new Error("Position must be a non-negative integer."+a);if(e<0)return{px:a,py:0};if(e===1)return{px:0,py:a};const d=a%e,c=Math.floor(a/e);return{px:d,py:c}}const pt=e=>{let a=0,d=0;for(const c of e.children){const{width:n,height:g,x:l,y:f}=c.size||{width:0,height:0,x:0,y:0};S.debug("getMaxChildSize abc95 child:",c.id,"width:",n,"height:",g,"x:",l,"y:",f,c.type),c.type!=="space"&&(n>a&&(a=n/(e.widthInColumns||1)),g>d&&(d=g))}return{width:a,height:d}};function te(e,a,d=0,c=0){var n,g,l,f,b,p,x,y,T,v,N;S.debug("setBlockSizes abc95 (start)",e.id,(n=e==null?void 0:e.size)==null?void 0:n.x,"block width =",e==null?void 0:e.size,"sieblingWidth",d),(g=e==null?void 0:e.size)!=null&&g.width||(e.size={width:d,height:c,x:0,y:0});let E=0,L=0;if(((l=e.children)==null?void 0:l.length)>0){for(const h of e.children)te(h,a);const A=pt(e);E=A.width,L=A.height,S.debug("setBlockSizes abc95 maxWidth of",e.id,":s children is ",E,L);for(const h of e.children)h.size&&(S.debug(`abc95 Setting size of children of ${e.id} id=${h.id} ${E} ${L} ${h.size}`),h.size.width=E*(h.widthInColumns||1)+_*((h.widthInColumns||1)-1),h.size.height=L,h.size.x=0,h.size.y=0,S.debug(`abc95 updating size of ${e.id} children child:${h.id} maxWidth:${E} maxHeight:${L}`));for(const h of e.children)te(h,a,E,L);const k=e.columns||-1;let D=0;for(const h of e.children)D+=h.widthInColumns||1;let o=e.children.length;k>0&&k<D&&(o=k),e.widthInColumns;const s=Math.ceil(D/o);let i=o*(E+_)+_,u=s*(L+_)+_;if(i<d){S.debug(`Detected to small siebling: abc95 ${e.id} sieblingWidth ${d} sieblingHeight ${c} width ${i}`),i=d,u=c;const h=(d-o*_-_)/o,t=(c-s*_-_)/s;S.debug("Size indata abc88",e.id,"childWidth",h,"maxWidth",E),S.debug("Size indata abc88",e.id,"childHeight",t,"maxHeight",L),S.debug("Size indata abc88 xSize",o,"padding",_);for(const m of e.children)m.size&&(m.size.width=h,m.size.height=t,m.size.x=0,m.size.y=0)}if(S.debug(`abc95 (finale calc) ${e.id} xSize ${o} ySize ${s} columns ${k}${e.children.length} width=${Math.max(i,((f=e.size)==null?void 0:f.width)||0)}`),i<(((b=e==null?void 0:e.size)==null?void 0:b.width)||0)){i=((p=e==null?void 0:e.size)==null?void 0:p.width)||0;const h=k>0?Math.min(e.children.length,k):e.children.length;if(h>0){const t=(i-h*_-_)/h;S.debug("abc95 (growing to fit) width",e.id,i,(x=e.size)==null?void 0:x.width,t);for(const m of e.children)m.size&&(m.size.width=t)}}e.size={width:i,height:u,x:0,y:0}}S.debug("setBlockSizes abc94 (done)",e.id,(y=e==null?void 0:e.size)==null?void 0:y.x,(T=e==null?void 0:e.size)==null?void 0:T.width,(v=e==null?void 0:e.size)==null?void 0:v.y,(N=e==null?void 0:e.size)==null?void 0:N.height)}function xe(e,a){var d,c,n,g,l,f,b,p,x,y,T,v,N,E,L,A,k;S.debug(`abc85 layout blocks (=>layoutBlocks) ${e.id} x: ${(d=e==null?void 0:e.size)==null?void 0:d.x} y: ${(c=e==null?void 0:e.size)==null?void 0:c.y} width: ${(n=e==null?void 0:e.size)==null?void 0:n.width}`);const D=e.columns||-1;if(S.debug("layoutBlocks columns abc95",e.id,"=>",D,e),e.children&&e.children.length>0){const o=((l=(g=e==null?void 0:e.children[0])==null?void 0:g.size)==null?void 0:l.width)||0,s=e.children.length*o+(e.children.length-1)*_;S.debug("widthOfChildren 88",s,"posX");let i=0;S.debug("abc91 block?.size?.x",e.id,(f=e==null?void 0:e.size)==null?void 0:f.x);let u=(b=e==null?void 0:e.size)!=null&&b.x?((p=e==null?void 0:e.size)==null?void 0:p.x)+(-((x=e==null?void 0:e.size)==null?void 0:x.width)/2||0):-_,h=0;for(const t of e.children){const m=e;if(!t.size)continue;const{width:r,height:R}=t.size,{px:Y,py:F}=gt(D,i);if(F!=h&&(h=F,u=(y=e==null?void 0:e.size)!=null&&y.x?((T=e==null?void 0:e.size)==null?void 0:T.x)+(-((v=e==null?void 0:e.size)==null?void 0:v.width)/2||0):-_,S.debug("New row in layout for block",e.id," and child ",t.id,h)),S.debug(`abc89 layout blocks (child) id: ${t.id} Pos: ${i} (px, py) ${Y},${F} (${(N=m==null?void 0:m.size)==null?void 0:N.x},${(E=m==null?void 0:m.size)==null?void 0:E.y}) parent: ${m.id} width: ${r}${_}`),m.size){const C=r/2;t.size.x=u+_+C,S.debug(`abc91 layout blocks (calc) px, pyid:${t.id} startingPos=X${u} new startingPosX${t.size.x} ${C} padding=${_} width=${r} halfWidth=${C} => x:${t.size.x} y:${t.size.y} ${t.widthInColumns} (width * (child?.w || 1)) / 2 ${r*((t==null?void 0:t.widthInColumns)||1)/2}`),u=t.size.x+C,t.size.y=m.size.y-m.size.height/2+F*(R+_)+R/2+_,S.debug(`abc88 layout blocks (calc) px, pyid:${t.id}startingPosX${u}${_}${C}=>x:${t.size.x}y:${t.size.y}${t.widthInColumns}(width * (child?.w || 1)) / 2${r*((t==null?void 0:t.widthInColumns)||1)/2}`)}t.children&&xe(t),i+=(t==null?void 0:t.widthInColumns)||1,S.debug("abc88 columnsPos",t,i)}}S.debug(`layout blocks (<==layoutBlocks) ${e.id} x: ${(L=e==null?void 0:e.size)==null?void 0:L.x} y: ${(A=e==null?void 0:e.size)==null?void 0:A.y} width: ${(k=e==null?void 0:e.size)==null?void 0:k.width}`)}function Se(e,{minX:a,minY:d,maxX:c,maxY:n}={minX:0,minY:0,maxX:0,maxY:0}){if(e.size&&e.id!=="root"){const{x:g,y:l,width:f,height:b}=e.size;g-f/2<a&&(a=g-f/2),l-b/2<d&&(d=l-b/2),g+f/2>c&&(c=g+f/2),l+b/2>n&&(n=l+b/2)}if(e.children)for(const g of e.children)({minX:a,minY:d,maxX:c,maxY:n}=Se(g,{minX:a,minY:d,maxX:c,maxY:n}));return{minX:a,minY:d,maxX:c,maxY:n}}function ft(e){const a=e.getBlock("root");if(!a)return;te(a,e,0,0),xe(a),S.debug("getBlocks",JSON.stringify(a,null,2));const{minX:d,minY:c,maxX:n,maxY:g}=Se(a),l=g-c,f=n-d;return{x:d,y:c,width:f,height:l}}const bt=function(e,a){return a.db.getClasses()},xt=async function(e,a,d,c){const{securityLevel:n,block:g}=se(),l=c.db;let f;n==="sandbox"&&(f=H("#i"+a));const b=n==="sandbox"?H(f.nodes()[0].contentDocument.body):H("body"),p=n==="sandbox"?b.select(`[id="${a}"]`):H(`[id="${a}"]`);ke(p,["point","circle","cross"],c.type,a);const y=l.getBlocks(),T=l.getBlocksFlat(),v=l.getEdges(),N=p.insert("g").attr("class","block");await ut(N,y,l);const E=ft(l);if(await dt(N,y,l),await ht(N,v,T,l,a),E){const L=E,A=Math.max(1,Math.round(.125*(L.width/L.height))),k=L.height+A+10,D=L.width+10,{useMaxWidth:o}=g;ye(p,k,D,!!o),S.debug("Here Bounds",E,L),p.attr("viewBox",`${L.x-5} ${L.y-5} ${L.width+10} ${L.height+10}`)}Ae(Be)},St={draw:xt,getClasses:bt},Tt={parser:Pe,db:nt,renderer:St,styles:lt};export{Tt as diagram};

frontend-dist/assets/c4Diagram-c83219d4-Dwk4T9_E.js

@@ -0,0 +1,10 @@
+import{s as we,g as Oe,a as Te,b as Re,c as Dt,d as Nt,l as le,e as De,f as Se,h as wt,i as ue,j as Pe,w as Me,k as Kt,m as oe}from"./index-BCNM9-Ly.js";import{d as Le,g as Ne}from"./svgDrawCommon-b86b1483-KNrWL8cU.js";var Yt=function(){var e=function(bt,_,x,m){for(x=x||{},m=bt.length;m--;x[bt[m]]=_);return x},t=[1,24],a=[1,25],o=[1,26],l=[1,27],i=[1,28],s=[1,63],r=[1,64],n=[1,65],h=[1,66],f=[1,67],d=[1,68],p=[1,69],E=[1,29],O=[1,30],R=[1,31],S=[1,32],L=[1,33],Y=[1,34],Q=[1,35],H=[1,36],q=[1,37],G=[1,38],K=[1,39],J=[1,40],Z=[1,41],$=[1,42],tt=[1,43],et=[1,44],it=[1,45],nt=[1,46],st=[1,47],at=[1,48],rt=[1,50],lt=[1,51],ot=[1,52],ct=[1,53],ht=[1,54],ut=[1,55],dt=[1,56],ft=[1,57],pt=[1,58],yt=[1,59],gt=[1,60],At=[14,42],Vt=[14,34,36,37,38,39,40,41,42,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74],Ot=[12,14,34,36,37,38,39,40,41,42,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74],v=[1,82],k=[1,83],A=[1,84],C=[1,85],w=[12,14,42],ne=[12,14,33,42],Pt=[12,14,33,42,76,77,79,80],mt=[12,33],zt=[34,36,37,38,39,40,41,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74],Xt={trace:function(){},yy:{},symbols_:{error:2,start:3,mermaidDoc:4,direction:5,direction_tb:6,direction_bt:7,direction_rl:8,direction_lr:9,graphConfig:10,C4_CONTEXT:11,NEWLINE:12,statements:13,EOF:14,C4_CONTAINER:15,C4_COMPONENT:16,C4_DYNAMIC:17,C4_DEPLOYMENT:18,otherStatements:19,diagramStatements:20,otherStatement:21,title:22,accDescription:23,acc_title:24,acc_title_value:25,acc_descr:26,acc_descr_value:27,acc_descr_multiline_value:28,boundaryStatement:29,boundaryStartStatement:30,boundaryStopStatement:31,boundaryStart:32,LBRACE:33,ENTERPRISE_BOUNDARY:34,attributes:35,SYSTEM_BOUNDARY:36,BOUNDARY:37,CONTAINER_BOUNDARY:38,NODE:39,NODE_L:40,NODE_R:41,RBRACE:42,diagramStatement:43,PERSON:44,PERSON_EXT:45,SYSTEM:46,SYSTEM_DB:47,SYSTEM_QUEUE:48,SYSTEM_EXT:49,SYSTEM_EXT_DB:50,SYSTEM_EXT_QUEUE:51,CONTAINER:52,CONTAINER_DB:53,CONTAINER_QUEUE:54,CONTAINER_EXT:55,CONTAINER_EXT_DB:56,CONTAINER_EXT_QUEUE:57,COMPONENT:58,COMPONENT_DB:59,COMPONENT_QUEUE:60,COMPONENT_EXT:61,COMPONENT_EXT_DB:62,COMPONENT_EXT_QUEUE:63,REL:64,BIREL:65,REL_U:66,REL_D:67,REL_L:68,REL_R:69,REL_B:70,REL_INDEX:71,UPDATE_EL_STYLE:72,UPDATE_REL_STYLE:73,UPDATE_LAYOUT_CONFIG:74,attribute:75,STR:76,STR_KEY:77,STR_VALUE:78,ATTRIBUTE:79,ATTRIBUTE_EMPTY:80,$accept:0,$end:1},terminals_:{2:"error",6:"direction_tb",7:"direction_bt",8:"direction_rl",9:"direction_lr",11:"C4_CONTEXT",12:"NEWLINE",14:"EOF",15:"C4_CONTAINER",16:"C4_COMPONENT",17:"C4_DYNAMIC",18:"C4_DEPLOYMENT",22:"title",23:"accDescription",24:"acc_title",25:"acc_title_value",26:"acc_descr",27:"acc_descr_value",28:"acc_descr_multiline_value",33:"LBRACE",34:"ENTERPRISE_BOUNDARY",36:"SYSTEM_BOUNDARY",37:"BOUNDARY",38:"CONTAINER_BOUNDARY",39:"NODE",40:"NODE_L",41:"NODE_R",42:"RBRACE",44:"PERSON",45:"PERSON_EXT",46:"SYSTEM",47:"SYSTEM_DB",48:"SYSTEM_QUEUE",49:"SYSTEM_EXT",50:"SYSTEM_EXT_DB",51:"SYSTEM_EXT_QUEUE",52:"CONTAINER",53:"CONTAINER_DB",54:"CONTAINER_QUEUE",55:"CONTAINER_EXT",56:"CONTAINER_EXT_DB",57:"CONTAINER_EXT_QUEUE",58:"COMPONENT",59:"COMPONENT_DB",60:"COMPONENT_QUEUE",61:"COMPONENT_EXT",62:"COMPONENT_EXT_DB",63:"COMPONENT_EXT_QUEUE",64:"REL",65:"BIREL",66:"REL_U",67:"REL_D",68:"REL_L",69:"REL_R",70:"REL_B",71:"REL_INDEX",72:"UPDATE_EL_STYLE",73:"UPDATE_REL_STYLE",74:"UPDATE_LAYOUT_CONFIG",76:"STR",77:"STR_KEY",78:"STR_VALUE",79:"ATTRIBUTE",80:"ATTRIBUTE_EMPTY"},productions_:[0,[3,1],[3,1],[5,1],[5,1],[5,1],[5,1],[4,1],[10,4],[10,4],[10,4],[10,4],[10,4],[13,1],[13,1],[13,2],[19,1],[19,2],[19,3],[21,1],[21,1],[21,2],[21,2],[21,1],[29,3],[30,3],[30,3],[30,4],[32,2],[32,2],[32,2],[32,2],[32,2],[32,2],[32,2],[31,1],[20,1],[20,2],[20,3],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,1],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[43,2],[35,1],[35,2],[75,1],[75,2],[75,1],[75,1]],performAction:function(_,x,m,g,T,u,Tt){var y=u.length-1;switch(T){case 3:g.setDirection("TB");break;case 4:g.setDirection("BT");break;case 5:g.setDirection("RL");break;case 6:g.setDirection("LR");break;case 8:case 9:case 10:case 11:case 12:g.setC4Type(u[y-3]);break;case 19:g.setTitle(u[y].substring(6)),this.$=u[y].substring(6);break;case 20:g.setAccDescription(u[y].substring(15)),this.$=u[y].substring(15);break;case 21:this.$=u[y].trim(),g.setTitle(this.$);break;case 22:case 23:this.$=u[y].trim(),g.setAccDescription(this.$);break;case 28:case 29:u[y].splice(2,0,"ENTERPRISE"),g.addPersonOrSystemBoundary(...u[y]),this.$=u[y];break;case 30:g.addPersonOrSystemBoundary(...u[y]),this.$=u[y];break;case 31:u[y].splice(2,0,"CONTAINER"),g.addContainerBoundary(...u[y]),this.$=u[y];break;case 32:g.addDeploymentNode("node",...u[y]),this.$=u[y];break;case 33:g.addDeploymentNode("nodeL",...u[y]),this.$=u[y];break;case 34:g.addDeploymentNode("nodeR",...u[y]),this.$=u[y];break;case 35:g.popBoundaryParseStack();break;case 39:g.addPersonOrSystem("person",...u[y]),this.$=u[y];break;case 40:g.addPersonOrSystem("external_person",...u[y]),this.$=u[y];break;case 41:g.addPersonOrSystem("system",...u[y]),this.$=u[y];break;case 42:g.addPersonOrSystem("system_db",...u[y]),this.$=u[y];break;case 43:g.addPersonOrSystem("system_queue",...u[y]),this.$=u[y];break;case 44:g.addPersonOrSystem("external_system",...u[y]),this.$=u[y];break;case 45:g.addPersonOrSystem("external_system_db",...u[y]),this.$=u[y];break;case 46:g.addPersonOrSystem("external_system_queue",...u[y]),this.$=u[y];break;case 47:g.addContainer("container",...u[y]),this.$=u[y];break;case 48:g.addContainer("container_db",...u[y]),this.$=u[y];break;case 49:g.addContainer("container_queue",...u[y]),this.$=u[y];break;case 50:g.addContainer("external_container",...u[y]),this.$=u[y];break;case 51:g.addContainer("external_container_db",...u[y]),this.$=u[y];break;case 52:g.addContainer("external_container_queue",...u[y]),this.$=u[y];break;case 53:g.addComponent("component",...u[y]),this.$=u[y];break;case 54:g.addComponent("component_db",...u[y]),this.$=u[y];break;case 55:g.addComponent("component_queue",...u[y]),this.$=u[y];break;case 56:g.addComponent("external_component",...u[y]),this.$=u[y];break;case 57:g.addComponent("external_component_db",...u[y]),this.$=u[y];break;case 58:g.addComponent("external_component_queue",...u[y]),this.$=u[y];break;case 60:g.addRel("rel",...u[y]),this.$=u[y];break;case 61:g.addRel("birel",...u[y]),this.$=u[y];break;case 62:g.addRel("rel_u",...u[y]),this.$=u[y];break;case 63:g.addRel("rel_d",...u[y]),this.$=u[y];break;case 64:g.addRel("rel_l",...u[y]),this.$=u[y];break;case 65:g.addRel("rel_r",...u[y]),this.$=u[y];break;case 66:g.addRel("rel_b",...u[y]),this.$=u[y];break;case 67:u[y].splice(0,1),g.addRel("rel",...u[y]),this.$=u[y];break;case 68:g.updateElStyle("update_el_style",...u[y]),this.$=u[y];break;case 69:g.updateRelStyle("update_rel_style",...u[y]),this.$=u[y];break;case 70:g.updateLayoutConfig("update_layout_config",...u[y]),this.$=u[y];break;case 71:this.$=[u[y]];break;case 72:u[y].unshift(u[y-1]),this.$=u[y];break;case 73:case 75:this.$=u[y].trim();break;case 74:let Et={};Et[u[y-1].trim()]=u[y].trim(),this.$=Et;break;case 76:this.$="";break}},table:[{3:1,4:2,5:3,6:[1,5],7:[1,6],8:[1,7],9:[1,8],10:4,11:[1,9],15:[1,10],16:[1,11],17:[1,12],18:[1,13]},{1:[3]},{1:[2,1]},{1:[2,2]},{1:[2,7]},{1:[2,3]},{1:[2,4]},{1:[2,5]},{1:[2,6]},{12:[1,14]},{12:[1,15]},{12:[1,16]},{12:[1,17]},{12:[1,18]},{13:19,19:20,20:21,21:22,22:t,23:a,24:o,26:l,28:i,29:49,30:61,32:62,34:s,36:r,37:n,38:h,39:f,40:d,41:p,43:23,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt},{13:70,19:20,20:21,21:22,22:t,23:a,24:o,26:l,28:i,29:49,30:61,32:62,34:s,36:r,37:n,38:h,39:f,40:d,41:p,43:23,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt},{13:71,19:20,20:21,21:22,22:t,23:a,24:o,26:l,28:i,29:49,30:61,32:62,34:s,36:r,37:n,38:h,39:f,40:d,41:p,43:23,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt},{13:72,19:20,20:21,21:22,22:t,23:a,24:o,26:l,28:i,29:49,30:61,32:62,34:s,36:r,37:n,38:h,39:f,40:d,41:p,43:23,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt},{13:73,19:20,20:21,21:22,22:t,23:a,24:o,26:l,28:i,29:49,30:61,32:62,34:s,36:r,37:n,38:h,39:f,40:d,41:p,43:23,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt},{14:[1,74]},e(At,[2,13],{43:23,29:49,30:61,32:62,20:75,34:s,36:r,37:n,38:h,39:f,40:d,41:p,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt}),e(At,[2,14]),e(Vt,[2,16],{12:[1,76]}),e(At,[2,36],{12:[1,77]}),e(Ot,[2,19]),e(Ot,[2,20]),{25:[1,78]},{27:[1,79]},e(Ot,[2,23]),{35:80,75:81,76:v,77:k,79:A,80:C},{35:86,75:81,76:v,77:k,79:A,80:C},{35:87,75:81,76:v,77:k,79:A,80:C},{35:88,75:81,76:v,77:k,79:A,80:C},{35:89,75:81,76:v,77:k,79:A,80:C},{35:90,75:81,76:v,77:k,79:A,80:C},{35:91,75:81,76:v,77:k,79:A,80:C},{35:92,75:81,76:v,77:k,79:A,80:C},{35:93,75:81,76:v,77:k,79:A,80:C},{35:94,75:81,76:v,77:k,79:A,80:C},{35:95,75:81,76:v,77:k,79:A,80:C},{35:96,75:81,76:v,77:k,79:A,80:C},{35:97,75:81,76:v,77:k,79:A,80:C},{35:98,75:81,76:v,77:k,79:A,80:C},{35:99,75:81,76:v,77:k,79:A,80:C},{35:100,75:81,76:v,77:k,79:A,80:C},{35:101,75:81,76:v,77:k,79:A,80:C},{35:102,75:81,76:v,77:k,79:A,80:C},{35:103,75:81,76:v,77:k,79:A,80:C},{35:104,75:81,76:v,77:k,79:A,80:C},e(w,[2,59]),{35:105,75:81,76:v,77:k,79:A,80:C},{35:106,75:81,76:v,77:k,79:A,80:C},{35:107,75:81,76:v,77:k,79:A,80:C},{35:108,75:81,76:v,77:k,79:A,80:C},{35:109,75:81,76:v,77:k,79:A,80:C},{35:110,75:81,76:v,77:k,79:A,80:C},{35:111,75:81,76:v,77:k,79:A,80:C},{35:112,75:81,76:v,77:k,79:A,80:C},{35:113,75:81,76:v,77:k,79:A,80:C},{35:114,75:81,76:v,77:k,79:A,80:C},{35:115,75:81,76:v,77:k,79:A,80:C},{20:116,29:49,30:61,32:62,34:s,36:r,37:n,38:h,39:f,40:d,41:p,43:23,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt},{12:[1,118],33:[1,117]},{35:119,75:81,76:v,77:k,79:A,80:C},{35:120,75:81,76:v,77:k,79:A,80:C},{35:121,75:81,76:v,77:k,79:A,80:C},{35:122,75:81,76:v,77:k,79:A,80:C},{35:123,75:81,76:v,77:k,79:A,80:C},{35:124,75:81,76:v,77:k,79:A,80:C},{35:125,75:81,76:v,77:k,79:A,80:C},{14:[1,126]},{14:[1,127]},{14:[1,128]},{14:[1,129]},{1:[2,8]},e(At,[2,15]),e(Vt,[2,17],{21:22,19:130,22:t,23:a,24:o,26:l,28:i}),e(At,[2,37],{19:20,20:21,21:22,43:23,29:49,30:61,32:62,13:131,22:t,23:a,24:o,26:l,28:i,34:s,36:r,37:n,38:h,39:f,40:d,41:p,44:E,45:O,46:R,47:S,48:L,49:Y,50:Q,51:H,52:q,53:G,54:K,55:J,56:Z,57:$,58:tt,59:et,60:it,61:nt,62:st,63:at,64:rt,65:lt,66:ot,67:ct,68:ht,69:ut,70:dt,71:ft,72:pt,73:yt,74:gt}),e(Ot,[2,21]),e(Ot,[2,22]),e(w,[2,39]),e(ne,[2,71],{75:81,35:132,76:v,77:k,79:A,80:C}),e(Pt,[2,73]),{78:[1,133]},e(Pt,[2,75]),e(Pt,[2,76]),e(w,[2,40]),e(w,[2,41]),e(w,[2,42]),e(w,[2,43]),e(w,[2,44]),e(w,[2,45]),e(w,[2,46]),e(w,[2,47]),e(w,[2,48]),e(w,[2,49]),e(w,[2,50]),e(w,[2,51]),e(w,[2,52]),e(w,[2,53]),e(w,[2,54]),e(w,[2,55]),e(w,[2,56]),e(w,[2,57]),e(w,[2,58]),e(w,[2,60]),e(w,[2,61]),e(w,[2,62]),e(w,[2,63]),e(w,[2,64]),e(w,[2,65]),e(w,[2,66]),e(w,[2,67]),e(w,[2,68]),e(w,[2,69]),e(w,[2,70]),{31:134,42:[1,135]},{12:[1,136]},{33:[1,137]},e(mt,[2,28]),e(mt,[2,29]),e(mt,[2,30]),e(mt,[2,31]),e(mt,[2,32]),e(mt,[2,33]),e(mt,[2,34]),{1:[2,9]},{1:[2,10]},{1:[2,11]},{1:[2,12]},e(Vt,[2,18]),e(At,[2,38]),e(ne,[2,72]),e(Pt,[2,74]),e(w,[2,24]),e(w,[2,35]),e(zt,[2,25]),e(zt,[2,26],{12:[1,138]}),e(zt,[2,27])],defaultActions:{2:[2,1],3:[2,2],4:[2,7],5:[2,3],6:[2,4],7:[2,5],8:[2,6],74:[2,8],126:[2,9],127:[2,10],128:[2,11],129:[2,12]},parseError:function(_,x){if(x.recoverable)this.trace(_);else{var m=new Error(_);throw m.hash=x,m}},parse:function(_){var x=this,m=[0],g=[],T=[null],u=[],Tt=this.table,y="",Et=0,se=0,ve=2,ae=1,ke=u.slice.call(arguments,1),D=Object.create(this.lexer),vt={yy:{}};for(var Qt in this.yy)Object.prototype.hasOwnProperty.call(this.yy,Qt)&&(vt.yy[Qt]=this.yy[Qt]);D.setInput(_,vt.yy),vt.yy.lexer=D,vt.yy.parser=this,typeof D.yylloc>"u"&&(D.yylloc={});var Ht=D.yylloc;u.push(Ht);var Ae=D.options&&D.options.ranges;typeof vt.yy.parseError=="function"?this.parseError=vt.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function Ce(){var X;return X=g.pop()||D.lex()||ae,typeof X!="number"&&(X instanceof Array&&(g=X,X=g.pop()),X=x.symbols_[X]||X),X}for(var M,kt,N,qt,Ct={},Mt,z,re,Lt;;){if(kt=m[m.length-1],this.defaultActions[kt]?N=this.defaultActions[kt]:((M===null||typeof M>"u")&&(M=Ce()),N=Tt[kt]&&Tt[kt][M]),typeof N>"u"||!N.length||!N[0]){var Gt="";Lt=[];for(Mt in Tt[kt])this.terminals_[Mt]&&Mt>ve&&Lt.push("'"+this.terminals_[Mt]+"'");D.showPosition?Gt="Parse error on line "+(Et+1)+`:
+`+D.showPosition()+`
+Expecting `+Lt.join(", ")+", got '"+(this.terminals_[M]||M)+"'":Gt="Parse error on line "+(Et+1)+": Unexpected "+(M==ae?"end of input":"'"+(this.terminals_[M]||M)+"'"),this.parseError(Gt,{text:D.match,token:this.terminals_[M]||M,line:D.yylineno,loc:Ht,expected:Lt})}if(N[0]instanceof Array&&N.length>1)throw new Error("Parse Error: multiple actions possible at state: "+kt+", token: "+M);switch(N[0]){case 1:m.push(M),T.push(D.yytext),u.push(D.yylloc),m.push(N[1]),M=null,se=D.yyleng,y=D.yytext,Et=D.yylineno,Ht=D.yylloc;break;case 2:if(z=this.productions_[N[1]][1],Ct.$=T[T.length-z],Ct._$={first_line:u[u.length-(z||1)].first_line,last_line:u[u.length-1].last_line,first_column:u[u.length-(z||1)].first_column,last_column:u[u.length-1].last_column},Ae&&(Ct._$.range=[u[u.length-(z||1)].range[0],u[u.length-1].range[1]]),qt=this.performAction.apply(Ct,[y,se,Et,vt.yy,N[1],T,u].concat(ke)),typeof qt<"u")return qt;z&&(m=m.slice(0,-1*z*2),T=T.slice(0,-1*z),u=u.slice(0,-1*z)),m.push(this.productions_[N[1]][0]),T.push(Ct.$),u.push(Ct._$),re=Tt[m[m.length-2]][m[m.length-1]],m.push(re);break;case 3:return!0}}return!0}},Ee=function(){var bt={EOF:1,parseError:function(x,m){if(this.yy.parser)this.yy.parser.parseError(x,m);else throw new Error(x)},setInput:function(_,x){return this.yy=x||this.yy||{},this._input=_,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},input:function(){var _=this._input[0];this.yytext+=_,this.yyleng++,this.offset++,this.match+=_,this.matched+=_;var x=_.match(/(?:\r\n?|\n).*/g);return x?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),_},unput:function(_){var x=_.length,m=_.split(/(?:\r\n?|\n)/g);this._input=_+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-x),this.offset-=x;var g=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),m.length-1&&(this.yylineno-=m.length-1);var T=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:m?(m.length===g.length?this.yylloc.first_column:0)+g[g.length-m.length].length-m[0].length:this.yylloc.first_column-x},this.options.ranges&&(this.yylloc.range=[T[0],T[0]+this.yyleng-x]),this.yyleng=this.yytext.length,this},more:function(){return this._more=!0,this},reject:function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},less:function(_){this.unput(this.match.slice(_))},pastInput:function(){var _=this.matched.substr(0,this.matched.length-this.match.length);return(_.length>20?"...":"")+_.substr(-20).replace(/\n/g,"")},upcomingInput:function(){var _=this.match;return _.length<20&&(_+=this._input.substr(0,20-_.length)),(_.substr(0,20)+(_.length>20?"...":"")).replace(/\n/g,"")},showPosition:function(){var _=this.pastInput(),x=new Array(_.length+1).join("-");return _+this.upcomingInput()+`
+`+x+"^"},test_match:function(_,x){var m,g,T;if(this.options.backtrack_lexer&&(T={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(T.yylloc.range=this.yylloc.range.slice(0))),g=_[0].match(/(?:\r\n?|\n).*/g),g&&(this.yylineno+=g.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:g?g[g.length-1].length-g[g.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+_[0].length},this.yytext+=_[0],this.match+=_[0],this.matches=_,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(_[0].length),this.matched+=_[0],m=this.performAction.call(this,this.yy,this,x,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),m)return m;if(this._backtrack){for(var u in T)this[u]=T[u];return!1}return!1},next:function(){if(this.done)return this.EOF;this._input||(this.done=!0);var _,x,m,g;this._more||(this.yytext="",this.match="");for(var T=this._currentRules(),u=0;u<T.length;u++)if(m=this._input.match(this.rules[T[u]]),m&&(!x||m[0].length>x[0].length)){if(x=m,g=u,this.options.backtrack_lexer){if(_=this.test_match(m,T[u]),_!==!1)return _;if(this._backtrack){x=!1;continue}else return!1}else if(!this.options.flex)break}return x?(_=this.test_match(x,T[g]),_!==!1?_:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text.
+`+this.showPosition(),{text:"",token:null,line:this.yylineno})},lex:function(){var x=this.next();return x||this.lex()},begin:function(x){this.conditionStack.push(x)},popState:function(){var x=this.conditionStack.length-1;return x>0?this.conditionStack.pop():this.conditionStack[0]},_currentRules:function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},topState:function(x){return x=this.conditionStack.length-1-Math.abs(x||0),x>=0?this.conditionStack[x]:"INITIAL"},pushState:function(x){this.begin(x)},stateStackSize:function(){return this.conditionStack.length},options:{},performAction:function(x,m,g,T){switch(g){case 0:return 6;case 1:return 7;case 2:return 8;case 3:return 9;case 4:return 22;case 5:return 23;case 6:return this.begin("acc_title"),24;case 7:return this.popState(),"acc_title_value";case 8:return this.begin("acc_descr"),26;case 9:return this.popState(),"acc_descr_value";case 10:this.begin("acc_descr_multiline");break;case 11:this.popState();break;case 12:return"acc_descr_multiline_value";case 13:break;case 14:c;break;case 15:return 12;case 16:break;case 17:return 11;case 18:return 15;case 19:return 16;case 20:return 17;case 21:return 18;case 22:return this.begin("person_ext"),45;case 23:return this.begin("person"),44;case 24:return this.begin("system_ext_queue"),51;case 25:return this.begin("system_ext_db"),50;case 26:return this.begin("system_ext"),49;case 27:return this.begin("system_queue"),48;case 28:return this.begin("system_db"),47;case 29:return this.begin("system"),46;case 30:return this.begin("boundary"),37;case 31:return this.begin("enterprise_boundary"),34;case 32:return this.begin("system_boundary"),36;case 33:return this.begin("container_ext_queue"),57;case 34:return this.begin("container_ext_db"),56;case 35:return this.begin("container_ext"),55;case 36:return this.begin("container_queue"),54;case 37:return this.begin("container_db"),53;case 38:return this.begin("container"),52;case 39:return this.begin("container_boundary"),38;case 40:return this.begin("component_ext_queue"),63;case 41:return this.begin("component_ext_db"),62;case 42:return this.begin("component_ext"),61;case 43:return this.begin("component_queue"),60;case 44:return this.begin("component_db"),59;case 45:return this.begin("component"),58;case 46:return this.begin("node"),39;case 47:return this.begin("node"),39;case 48:return this.begin("node_l"),40;case 49:return this.begin("node_r"),41;case 50:return this.begin("rel"),64;case 51:return this.begin("birel"),65;case 52:return this.begin("rel_u"),66;case 53:return this.begin("rel_u"),66;case 54:return this.begin("rel_d"),67;case 55:return this.begin("rel_d"),67;case 56:return this.begin("rel_l"),68;case 57:return this.begin("rel_l"),68;case 58:return this.begin("rel_r"),69;case 59:return this.begin("rel_r"),69;case 60:return this.begin("rel_b"),70;case 61:return this.begin("rel_index"),71;case 62:return this.begin("update_el_style"),72;case 63:return this.begin("update_rel_style"),73;case 64:return this.begin("update_layout_config"),74;case 65:return"EOF_IN_STRUCT";case 66:return this.begin("attribute"),"ATTRIBUTE_EMPTY";case 67:this.begin("attribute");break;case 68:this.popState(),this.popState();break;case 69:return 80;case 70:break;case 71:return 80;case 72:this.begin("string");break;case 73:this.popState();break;case 74:return"STR";case 75:this.begin("string_kv");break;case 76:return this.begin("string_kv_key"),"STR_KEY";case 77:this.popState(),this.begin("string_kv_value");break;case 78:return"STR_VALUE";case 79:this.popState(),this.popState();break;case 80:return"STR";case 81:return"LBRACE";case 82:return"RBRACE";case 83:return"SPACE";case 84:return"EOL";case 85:return 14}},rules:[/^(?:.*direction\s+TB[^\n]*)/,/^(?:.*direction\s+BT[^\n]*)/,/^(?:.*direction\s+RL[^\n]*)/,/^(?:.*direction\s+LR[^\n]*)/,/^(?:title\s[^#\n;]+)/,/^(?:accDescription\s[^#\n;]+)/,/^(?:accTitle\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*\{\s*)/,/^(?:[\}])/,/^(?:[^\}]*)/,/^(?:%%(?!\{)*[^\n]*(\r?\n?)+)/,/^(?:%%[^\n]*(\r?\n)*)/,/^(?:\s*(\r?\n)+)/,/^(?:\s+)/,/^(?:C4Context\b)/,/^(?:C4Container\b)/,/^(?:C4Component\b)/,/^(?:C4Dynamic\b)/,/^(?:C4Deployment\b)/,/^(?:Person_Ext\b)/,/^(?:Person\b)/,/^(?:SystemQueue_Ext\b)/,/^(?:SystemDb_Ext\b)/,/^(?:System_Ext\b)/,/^(?:SystemQueue\b)/,/^(?:SystemDb\b)/,/^(?:System\b)/,/^(?:Boundary\b)/,/^(?:Enterprise_Boundary\b)/,/^(?:System_Boundary\b)/,/^(?:ContainerQueue_Ext\b)/,/^(?:ContainerDb_Ext\b)/,/^(?:Container_Ext\b)/,/^(?:ContainerQueue\b)/,/^(?:ContainerDb\b)/,/^(?:Container\b)/,/^(?:Container_Boundary\b)/,/^(?:ComponentQueue_Ext\b)/,/^(?:ComponentDb_Ext\b)/,/^(?:Component_Ext\b)/,/^(?:ComponentQueue\b)/,/^(?:ComponentDb\b)/,/^(?:Component\b)/,/^(?:Deployment_Node\b)/,/^(?:Node\b)/,/^(?:Node_L\b)/,/^(?:Node_R\b)/,/^(?:Rel\b)/,/^(?:BiRel\b)/,/^(?:Rel_Up\b)/,/^(?:Rel_U\b)/,/^(?:Rel_Down\b)/,/^(?:Rel_D\b)/,/^(?:Rel_Left\b)/,/^(?:Rel_L\b)/,/^(?:Rel_Right\b)/,/^(?:Rel_R\b)/,/^(?:Rel_Back\b)/,/^(?:RelIndex\b)/,/^(?:UpdateElementStyle\b)/,/^(?:UpdateRelStyle\b)/,/^(?:UpdateLayoutConfig\b)/,/^(?:$)/,/^(?:[(][ ]*[,])/,/^(?:[(])/,/^(?:[)])/,/^(?:,,)/,/^(?:,)/,/^(?:[ ]*["]["])/,/^(?:[ ]*["])/,/^(?:["])/,/^(?:[^"]*)/,/^(?:[ ]*[\$])/,/^(?:[^=]*)/,/^(?:[=][ ]*["])/,/^(?:[^"]+)/,/^(?:["])/,/^(?:[^,]+)/,/^(?:\{)/,/^(?:\})/,/^(?:[\s]+)/,/^(?:[\n\r]+)/,/^(?:$)/],conditions:{acc_descr_multiline:{rules:[11,12],inclusive:!1},acc_descr:{rules:[9],inclusive:!1},acc_title:{rules:[7],inclusive:!1},string_kv_value:{rules:[78,79],inclusive:!1},string_kv_key:{rules:[77],inclusive:!1},string_kv:{rules:[76],inclusive:!1},string:{rules:[73,74],inclusive:!1},attribute:{rules:[68,69,70,71,72,75,80],inclusive:!1},update_layout_config:{rules:[65,66,67,68],inclusive:!1},update_rel_style:{rules:[65,66,67,68],inclusive:!1},update_el_style:{rules:[65,66,67,68],inclusive:!1},rel_b:{rules:[65,66,67,68],inclusive:!1},rel_r:{rules:[65,66,67,68],inclusive:!1},rel_l:{rules:[65,66,67,68],inclusive:!1},rel_d:{rules:[65,66,67,68],inclusive:!1},rel_u:{rules:[65,66,67,68],inclusive:!1},rel_bi:{rules:[],inclusive:!1},rel:{rules:[65,66,67,68],inclusive:!1},node_r:{rules:[65,66,67,68],inclusive:!1},node_l:{rules:[65,66,67,68],inclusive:!1},node:{rules:[65,66,67,68],inclusive:!1},index:{rules:[],inclusive:!1},rel_index:{rules:[65,66,67,68],inclusive:!1},component_ext_queue:{rules:[],inclusive:!1},component_ext_db:{rules:[65,66,67,68],inclusive:!1},component_ext:{rules:[65,66,67,68],inclusive:!1},component_queue:{rules:[65,66,67,68],inclusive:!1},component_db:{rules:[65,66,67,68],inclusive:!1},component:{rules:[65,66,67,68],inclusive:!1},container_boundary:{rules:[65,66,67,68],inclusive:!1},container_ext_queue:{rules:[65,66,67,68],inclusive:!1},container_ext_db:{rules:[65,66,67,68],inclusive:!1},container_ext:{rules:[65,66,67,68],inclusive:!1},container_queue:{rules:[65,66,67,68],inclusive:!1},container_db:{rules:[65,66,67,68],inclusive:!1},container:{rules:[65,66,67,68],inclusive:!1},birel:{rules:[65,66,67,68],inclusive:!1},system_boundary:{rules:[65,66,67,68],inclusive:!1},enterprise_boundary:{rules:[65,66,67,68],inclusive:!1},boundary:{rules:[65,66,67,68],inclusive:!1},system_ext_queue:{rules:[65,66,67,68],inclusive:!1},system_ext_db:{rules:[65,66,67,68],inclusive:!1},system_ext:{rules:[65,66,67,68],inclusive:!1},system_queue:{rules:[65,66,67,68],inclusive:!1},system_db:{rules:[65,66,67,68],inclusive:!1},system:{rules:[65,66,67,68],inclusive:!1},person_ext:{rules:[65,66,67,68],inclusive:!1},person:{rules:[65,66,67,68],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,8,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,81,82,83,84,85],inclusive:!0}}};return bt}();Xt.lexer=Ee;function Wt(){this.yy={}}return Wt.prototype=Xt,Xt.Parser=Wt,new Wt}();Yt.parser=Yt;const Be=Yt;let U=[],_t=[""],P="global",j="",V=[{alias:"global",label:{text:"global"},type:{text:"global"},tags:null,link:null,parentBoundary:""}],St=[],te="",ee=!1,It=4,jt=2;var de;const Ye=function(){return de},Ie=function(e){de=ue(e,Dt())},je=function(e,t,a,o,l,i,s,r,n){if(e==null||t===void 0||t===null||a===void 0||a===null||o===void 0||o===null)return;let h={};const f=St.find(d=>d.from===t&&d.to===a);if(f?h=f:St.push(h),h.type=e,h.from=t,h.to=a,h.label={text:o},l==null)h.techn={text:""};else if(typeof l=="object"){let[d,p]=Object.entries(l)[0];h[d]={text:p}}else h.techn={text:l};if(i==null)h.descr={text:""};else if(typeof i=="object"){let[d,p]=Object.entries(i)[0];h[d]={text:p}}else h.descr={text:i};if(typeof s=="object"){let[d,p]=Object.entries(s)[0];h[d]=p}else h.sprite=s;if(typeof r=="object"){let[d,p]=Object.entries(r)[0];h[d]=p}else h.tags=r;if(typeof n=="object"){let[d,p]=Object.entries(n)[0];h[d]=p}else h.link=n;h.wrap=xt()},Ue=function(e,t,a,o,l,i,s){if(t===null||a===null)return;let r={};const n=U.find(h=>h.alias===t);if(n&&t===n.alias?r=n:(r.alias=t,U.push(r)),a==null?r.label={text:""}:r.label={text:a},o==null)r.descr={text:""};else if(typeof o=="object"){let[h,f]=Object.entries(o)[0];r[h]={text:f}}else r.descr={text:o};if(typeof l=="object"){let[h,f]=Object.entries(l)[0];r[h]=f}else r.sprite=l;if(typeof i=="object"){let[h,f]=Object.entries(i)[0];r[h]=f}else r.tags=i;if(typeof s=="object"){let[h,f]=Object.entries(s)[0];r[h]=f}else r.link=s;r.typeC4Shape={text:e},r.parentBoundary=P,r.wrap=xt()},Fe=function(e,t,a,o,l,i,s,r){if(t===null||a===null)return;let n={};const h=U.find(f=>f.alias===t);if(h&&t===h.alias?n=h:(n.alias=t,U.push(n)),a==null?n.label={text:""}:n.label={text:a},o==null)n.techn={text:""};else if(typeof o=="object"){let[f,d]=Object.entries(o)[0];n[f]={text:d}}else n.techn={text:o};if(l==null)n.descr={text:""};else if(typeof l=="object"){let[f,d]=Object.entries(l)[0];n[f]={text:d}}else n.descr={text:l};if(typeof i=="object"){let[f,d]=Object.entries(i)[0];n[f]=d}else n.sprite=i;if(typeof s=="object"){let[f,d]=Object.entries(s)[0];n[f]=d}else n.tags=s;if(typeof r=="object"){let[f,d]=Object.entries(r)[0];n[f]=d}else n.link=r;n.wrap=xt(),n.typeC4Shape={text:e},n.parentBoundary=P},Ve=function(e,t,a,o,l,i,s,r){if(t===null||a===null)return;let n={};const h=U.find(f=>f.alias===t);if(h&&t===h.alias?n=h:(n.alias=t,U.push(n)),a==null?n.label={text:""}:n.label={text:a},o==null)n.techn={text:""};else if(typeof o=="object"){let[f,d]=Object.entries(o)[0];n[f]={text:d}}else n.techn={text:o};if(l==null)n.descr={text:""};else if(typeof l=="object"){let[f,d]=Object.entries(l)[0];n[f]={text:d}}else n.descr={text:l};if(typeof i=="object"){let[f,d]=Object.entries(i)[0];n[f]=d}else n.sprite=i;if(typeof s=="object"){let[f,d]=Object.entries(s)[0];n[f]=d}else n.tags=s;if(typeof r=="object"){let[f,d]=Object.entries(r)[0];n[f]=d}else n.link=r;n.wrap=xt(),n.typeC4Shape={text:e},n.parentBoundary=P},ze=function(e,t,a,o,l){if(e===null||t===null)return;let i={};const s=V.find(r=>r.alias===e);if(s&&e===s.alias?i=s:(i.alias=e,V.push(i)),t==null?i.label={text:""}:i.label={text:t},a==null)i.type={text:"system"};else if(typeof a=="object"){let[r,n]=Object.entries(a)[0];i[r]={text:n}}else i.type={text:a};if(typeof o=="object"){let[r,n]=Object.entries(o)[0];i[r]=n}else i.tags=o;if(typeof l=="object"){let[r,n]=Object.entries(l)[0];i[r]=n}else i.link=l;i.parentBoundary=P,i.wrap=xt(),j=P,P=e,_t.push(j)},Xe=function(e,t,a,o,l){if(e===null||t===null)return;let i={};const s=V.find(r=>r.alias===e);if(s&&e===s.alias?i=s:(i.alias=e,V.push(i)),t==null?i.label={text:""}:i.label={text:t},a==null)i.type={text:"container"};else if(typeof a=="object"){let[r,n]=Object.entries(a)[0];i[r]={text:n}}else i.type={text:a};if(typeof o=="object"){let[r,n]=Object.entries(o)[0];i[r]=n}else i.tags=o;if(typeof l=="object"){let[r,n]=Object.entries(l)[0];i[r]=n}else i.link=l;i.parentBoundary=P,i.wrap=xt(),j=P,P=e,_t.push(j)},We=function(e,t,a,o,l,i,s,r){if(t===null||a===null)return;let n={};const h=V.find(f=>f.alias===t);if(h&&t===h.alias?n=h:(n.alias=t,V.push(n)),a==null?n.label={text:""}:n.label={text:a},o==null)n.type={text:"node"};else if(typeof o=="object"){let[f,d]=Object.entries(o)[0];n[f]={text:d}}else n.type={text:o};if(l==null)n.descr={text:""};else if(typeof l=="object"){let[f,d]=Object.entries(l)[0];n[f]={text:d}}else n.descr={text:l};if(typeof s=="object"){let[f,d]=Object.entries(s)[0];n[f]=d}else n.tags=s;if(typeof r=="object"){let[f,d]=Object.entries(r)[0];n[f]=d}else n.link=r;n.nodeType=e,n.parentBoundary=P,n.wrap=xt(),j=P,P=t,_t.push(j)},Qe=function(){P=j,_t.pop(),j=_t.pop(),_t.push(j)},He=function(e,t,a,o,l,i,s,r,n,h,f){let d=U.find(p=>p.alias===t);if(!(d===void 0&&(d=V.find(p=>p.alias===t),d===void 0))){if(a!=null)if(typeof a=="object"){let[p,E]=Object.entries(a)[0];d[p]=E}else d.bgColor=a;if(o!=null)if(typeof o=="object"){let[p,E]=Object.entries(o)[0];d[p]=E}else d.fontColor=o;if(l!=null)if(typeof l=="object"){let[p,E]=Object.entries(l)[0];d[p]=E}else d.borderColor=l;if(i!=null)if(typeof i=="object"){let[p,E]=Object.entries(i)[0];d[p]=E}else d.shadowing=i;if(s!=null)if(typeof s=="object"){let[p,E]=Object.entries(s)[0];d[p]=E}else d.shape=s;if(r!=null)if(typeof r=="object"){let[p,E]=Object.entries(r)[0];d[p]=E}else d.sprite=r;if(n!=null)if(typeof n=="object"){let[p,E]=Object.entries(n)[0];d[p]=E}else d.techn=n;if(h!=null)if(typeof h=="object"){let[p,E]=Object.entries(h)[0];d[p]=E}else d.legendText=h;if(f!=null)if(typeof f=="object"){let[p,E]=Object.entries(f)[0];d[p]=E}else d.legendSprite=f}},qe=function(e,t,a,o,l,i,s){const r=St.find(n=>n.from===t&&n.to===a);if(r!==void 0){if(o!=null)if(typeof o=="object"){let[n,h]=Object.entries(o)[0];r[n]=h}else r.textColor=o;if(l!=null)if(typeof l=="object"){let[n,h]=Object.entries(l)[0];r[n]=h}else r.lineColor=l;if(i!=null)if(typeof i=="object"){let[n,h]=Object.entries(i)[0];r[n]=parseInt(h)}else r.offsetX=parseInt(i);if(s!=null)if(typeof s=="object"){let[n,h]=Object.entries(s)[0];r[n]=parseInt(h)}else r.offsetY=parseInt(s)}},Ge=function(e,t,a){let o=It,l=jt;if(typeof t=="object"){const i=Object.values(t)[0];o=parseInt(i)}else o=parseInt(t);if(typeof a=="object"){const i=Object.values(a)[0];l=parseInt(i)}else l=parseInt(a);o>=1&&(It=o),l>=1&&(jt=l)},Ke=function(){return It},Je=function(){return jt},Ze=function(){return P},$e=function(){return j},fe=function(e){return e==null?U:U.filter(t=>t.parentBoundary===e)},t0=function(e){return U.find(t=>t.alias===e)},e0=function(e){return Object.keys(fe(e))},pe=function(e){return e==null?V:V.filter(t=>t.parentBoundary===e)},i0=pe,n0=function(){return St},s0=function(){return te},a0=function(e){ee=e},xt=function(){return ee},r0=function(){U=[],V=[{alias:"global",label:{text:"global"},type:{text:"global"},tags:null,link:null,parentBoundary:""}],j="",P="global",_t=[""],St=[],_t=[""],te="",ee=!1,It=4,jt=2},l0={SOLID:0,DOTTED:1,NOTE:2,SOLID_CROSS:3,DOTTED_CROSS:4,SOLID_OPEN:5,DOTTED_OPEN:6,LOOP_START:10,LOOP_END:11,ALT_START:12,ALT_ELSE:13,ALT_END:14,OPT_START:15,OPT_END:16,ACTIVE_START:17,ACTIVE_END:18,PAR_START:19,PAR_AND:20,PAR_END:21,RECT_START:22,RECT_END:23,SOLID_POINT:24,DOTTED_POINT:25},o0={FILLED:0,OPEN:1},c0={LEFTOF:0,RIGHTOF:1,OVER:2},h0=function(e){te=ue(e,Dt())},Jt={addPersonOrSystem:Ue,addPersonOrSystemBoundary:ze,addContainer:Fe,addContainerBoundary:Xe,addComponent:Ve,addDeploymentNode:We,popBoundaryParseStack:Qe,addRel:je,updateElStyle:He,updateRelStyle:qe,updateLayoutConfig:Ge,autoWrap:xt,setWrap:a0,getC4ShapeArray:fe,getC4Shape:t0,getC4ShapeKeys:e0,getBoundaries:pe,getBoundarys:i0,getCurrentBoundaryParse:Ze,getParentBoundaryParse:$e,getRels:n0,getTitle:s0,getC4Type:Ye,getC4ShapeInRow:Ke,getC4BoundaryInRow:Je,setAccTitle:Re,getAccTitle:Te,getAccDescription:Oe,setAccDescription:we,getConfig:()=>Dt().c4,clear:r0,LINETYPE:l0,ARROWTYPE:o0,PLACEMENT:c0,setTitle:h0,setC4Type:Ie},ie=function(e,t){return Le(e,t)},ye=function(e,t,a,o,l,i){const s=e.append("image");s.attr("width",t),s.attr("height",a),s.attr("x",o),s.attr("y",l);let r=i.startsWith("data:image/png;base64")?i:Pe.sanitizeUrl(i);s.attr("xlink:href",r)},u0=(e,t,a)=>{const o=e.append("g");let l=0;for(let i of t){let s=i.textColor?i.textColor:"#444444",r=i.lineColor?i.lineColor:"#444444",n=i.offsetX?parseInt(i.offsetX):0,h=i.offsetY?parseInt(i.offsetY):0,f="";if(l===0){let p=o.append("line");p.attr("x1",i.startPoint.x),p.attr("y1",i.startPoint.y),p.attr("x2",i.endPoint.x),p.attr("y2",i.endPoint.y),p.attr("stroke-width","1"),p.attr("stroke",r),p.style("fill","none"),i.type!=="rel_b"&&p.attr("marker-end","url("+f+"#arrowhead)"),(i.type==="birel"||i.type==="rel_b")&&p.attr("marker-start","url("+f+"#arrowend)"),l=-1}else{let p=o.append("path");p.attr("fill","none").attr("stroke-width","1").attr("stroke",r).attr("d","Mstartx,starty Qcontrolx,controly stopx,stopy ".replaceAll("startx",i.startPoint.x).replaceAll("starty",i.startPoint.y).replaceAll("controlx",i.startPoint.x+(i.endPoint.x-i.startPoint.x)/2-(i.endPoint.x-i.startPoint.x)/4).replaceAll("controly",i.startPoint.y+(i.endPoint.y-i.startPoint.y)/2).replaceAll("stopx",i.endPoint.x).replaceAll("stopy",i.endPoint.y)),i.type!=="rel_b"&&p.attr("marker-end","url("+f+"#arrowhead)"),(i.type==="birel"||i.type==="rel_b")&&p.attr("marker-start","url("+f+"#arrowend)")}let d=a.messageFont();W(a)(i.label.text,o,Math.min(i.startPoint.x,i.endPoint.x)+Math.abs(i.endPoint.x-i.startPoint.x)/2+n,Math.min(i.startPoint.y,i.endPoint.y)+Math.abs(i.endPoint.y-i.startPoint.y)/2+h,i.label.width,i.label.height,{fill:s},d),i.techn&&i.techn.text!==""&&(d=a.messageFont(),W(a)("["+i.techn.text+"]",o,Math.min(i.startPoint.x,i.endPoint.x)+Math.abs(i.endPoint.x-i.startPoint.x)/2+n,Math.min(i.startPoint.y,i.endPoint.y)+Math.abs(i.endPoint.y-i.startPoint.y)/2+a.messageFontSize+5+h,Math.max(i.label.width,i.techn.width),i.techn.height,{fill:s,"font-style":"italic"},d))}},d0=function(e,t,a){const o=e.append("g");let l=t.bgColor?t.bgColor:"none",i=t.borderColor?t.borderColor:"#444444",s=t.fontColor?t.fontColor:"black",r={"stroke-width":1,"stroke-dasharray":"7.0,7.0"};t.nodeType&&(r={"stroke-width":1});let n={x:t.x,y:t.y,fill:l,stroke:i,width:t.width,height:t.height,rx:2.5,ry:2.5,attrs:r};ie(o,n);let h=a.boundaryFont();h.fontWeight="bold",h.fontSize=h.fontSize+2,h.fontColor=s,W(a)(t.label.text,o,t.x,t.y+t.label.Y,t.width,t.height,{fill:"#444444"},h),t.type&&t.type.text!==""&&(h=a.boundaryFont(),h.fontColor=s,W(a)(t.type.text,o,t.x,t.y+t.type.Y,t.width,t.height,{fill:"#444444"},h)),t.descr&&t.descr.text!==""&&(h=a.boundaryFont(),h.fontSize=h.fontSize-2,h.fontColor=s,W(a)(t.descr.text,o,t.x,t.y+t.descr.Y,t.width,t.height,{fill:"#444444"},h))},f0=function(e,t,a){var o;let l=t.bgColor?t.bgColor:a[t.typeC4Shape.text+"_bg_color"],i=t.borderColor?t.borderColor:a[t.typeC4Shape.text+"_border_color"],s=t.fontColor?t.fontColor:"#FFFFFF",r="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAIAAADYYG7QAAACD0lEQVR4Xu2YoU4EMRCGT+4j8Ai8AhaH4QHgAUjQuFMECUgMIUgwJAgMhgQsAYUiJCiQIBBY+EITsjfTdme6V24v4c8vyGbb+ZjOtN0bNcvjQXmkH83WvYBWto6PLm6v7p7uH1/w2fXD+PBycX1Pv2l3IdDm/vn7x+dXQiAubRzoURa7gRZWd0iGRIiJbOnhnfYBQZNJjNbuyY2eJG8fkDE3bbG4ep6MHUAsgYxmE3nVs6VsBWJSGccsOlFPmLIViMzLOB7pCVO2AtHJMohH7Fh6zqitQK7m0rJvAVYgGcEpe//PLdDz65sM4pF9N7ICcXDKIB5Nv6j7tD0NoSdM2QrU9Gg0ewE1LqBhHR3BBdvj2vapnidjHxD/q6vd7Pvhr31AwcY8eXMTXAKECZZJFXuEq27aLgQK5uLMohCenGGuGewOxSjBvYBqeG6B+Nqiblggdjnc+ZXDy+FNFpFzw76O3UBAROuXh6FoiAcf5g9eTvUgzy0nWg6I8cXHRUpg5bOVBCo+KDpFajOf23GgPme7RSQ+lacIENUgJ6gg1k6HjgOlqnLqip4tEuhv0hNEMXUD0clyXE3p6pZA0S2nnvTlXwLJEZWlb7cTQH1+USgTN4VhAenm/wea1OCAOmqo6fE1WCb9WSKBah+rbUWPWAmE2Rvk0ApiB45eOyNAzU8xcTvj8KvkKEoOaIYeHNA3ZuygAvFMUO0AAAAASUVORK5CYII=";switch(t.typeC4Shape.text){case"person":r="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAIAAADYYG7QAAACD0lEQVR4Xu2YoU4EMRCGT+4j8Ai8AhaH4QHgAUjQuFMECUgMIUgwJAgMhgQsAYUiJCiQIBBY+EITsjfTdme6V24v4c8vyGbb+ZjOtN0bNcvjQXmkH83WvYBWto6PLm6v7p7uH1/w2fXD+PBycX1Pv2l3IdDm/vn7x+dXQiAubRzoURa7gRZWd0iGRIiJbOnhnfYBQZNJjNbuyY2eJG8fkDE3bbG4ep6MHUAsgYxmE3nVs6VsBWJSGccsOlFPmLIViMzLOB7pCVO2AtHJMohH7Fh6zqitQK7m0rJvAVYgGcEpe//PLdDz65sM4pF9N7ICcXDKIB5Nv6j7tD0NoSdM2QrU9Gg0ewE1LqBhHR3BBdvj2vapnidjHxD/q6vd7Pvhr31AwcY8eXMTXAKECZZJFXuEq27aLgQK5uLMohCenGGuGewOxSjBvYBqeG6B+Nqiblggdjnc+ZXDy+FNFpFzw76O3UBAROuXh6FoiAcf5g9eTvUgzy0nWg6I8cXHRUpg5bOVBCo+KDpFajOf23GgPme7RSQ+lacIENUgJ6gg1k6HjgOlqnLqip4tEuhv0hNEMXUD0clyXE3p6pZA0S2nnvTlXwLJEZWlb7cTQH1+USgTN4VhAenm/wea1OCAOmqo6fE1WCb9WSKBah+rbUWPWAmE2Rvk0ApiB45eOyNAzU8xcTvj8KvkKEoOaIYeHNA3ZuygAvFMUO0AAAAASUVORK5CYII=";break;case"external_person":r="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAIAAADYYG7QAAAB6ElEQVR4Xu2YLY+EMBCG9+dWr0aj0Wg0Go1Go0+j8Xdv2uTCvv1gpt0ebHKPuhDaeW4605Z9mJvx4AdXUyTUdd08z+u6flmWZRnHsWkafk9DptAwDPu+f0eAYtu2PEaGWuj5fCIZrBAC2eLBAnRCsEkkxmeaJp7iDJ2QMDdHsLg8SxKFEJaAo8lAXnmuOFIhTMpxxKATebo4UiFknuNo4OniSIXQyRxEA3YsnjGCVEjVXD7yLUAqxBGUyPv/Y4W2beMgGuS7kVQIBycH0fD+oi5pezQETxdHKmQKGk1eQEYldK+jw5GxPfZ9z7Mk0Qnhf1W1m3w//EUn5BDmSZsbR44QQLBEqrBHqOrmSKaQAxdnLArCrxZcM7A7ZKs4ioRq8LFC+NpC3WCBJsvpVw5edm9iEXFuyNfxXAgSwfrFQ1c0iNda8AdejvUgnktOtJQQxmcfFzGglc5WVCj7oDgFqU18boeFSs52CUh8LE8BIVQDT1ABrB0HtgSEYlX5doJnCwv9TXocKCaKbnwhdDKPq4lf3SwU3HLq4V/+WYhHVMa/3b4IlfyikAduCkcBc7mQ3/z/Qq/cTuikhkzB12Ae/mcJC9U+Vo8Ej1gWAtgbeGgFsAMHr50BIWOLCbezvhpBFUdY6EJuJ/QDW0XoMX60zZ0AAAAASUVORK5CYII=";break}const n=e.append("g");n.attr("class","person-man");const h=Ne();switch(t.typeC4Shape.text){case"person":case"external_person":case"system":case"external_system":case"container":case"external_container":case"component":case"external_component":h.x=t.x,h.y=t.y,h.fill=l,h.width=t.width,h.height=t.height,h.stroke=i,h.rx=2.5,h.ry=2.5,h.attrs={"stroke-width":.5},ie(n,h);break;case"system_db":case"external_system_db":case"container_db":case"external_container_db":case"component_db":case"external_component_db":n.append("path").attr("fill",l).attr("stroke-width","0.5").attr("stroke",i).attr("d","Mstartx,startyc0,-10 half,-10 half,-10c0,0 half,0 half,10l0,heightc0,10 -half,10 -half,10c0,0 -half,0 -half,-10l0,-height".replaceAll("startx",t.x).replaceAll("starty",t.y).replaceAll("half",t.width/2).replaceAll("height",t.height)),n.append("path").attr("fill","none").attr("stroke-width","0.5").attr("stroke",i).attr("d","Mstartx,startyc0,10 half,10 half,10c0,0 half,0 half,-10".replaceAll("startx",t.x).replaceAll("starty",t.y).replaceAll("half",t.width/2));break;case"system_queue":case"external_system_queue":case"container_queue":case"external_container_queue":case"component_queue":case"external_component_queue":n.append("path").attr("fill",l).attr("stroke-width","0.5").attr("stroke",i).attr("d","Mstartx,startylwidth,0c5,0 5,half 5,halfc0,0 0,half -5,halfl-width,0c-5,0 -5,-half -5,-halfc0,0 0,-half 5,-half".replaceAll("startx",t.x).replaceAll("starty",t.y).replaceAll("width",t.width).replaceAll("half",t.height/2)),n.append("path").attr("fill","none").attr("stroke-width","0.5").attr("stroke",i).attr("d","Mstartx,startyc-5,0 -5,half -5,halfc0,half 5,half 5,half".replaceAll("startx",t.x+t.width).replaceAll("starty",t.y).replaceAll("half",t.height/2));break}let f=v0(a,t.typeC4Shape.text);switch(n.append("text").attr("fill",s).attr("font-family",f.fontFamily).attr("font-size",f.fontSize-2).attr("font-style","italic").attr("lengthAdjust","spacing").attr("textLength",t.typeC4Shape.width).attr("x",t.x+t.width/2-t.typeC4Shape.width/2).attr("y",t.y+t.typeC4Shape.Y).text("<<"+t.typeC4Shape.text+">>"),t.typeC4Shape.text){case"person":case"external_person":ye(n,48,48,t.x+t.width/2-24,t.y+t.image.Y,r);break}let d=a[t.typeC4Shape.text+"Font"]();return d.fontWeight="bold",d.fontSize=d.fontSize+2,d.fontColor=s,W(a)(t.label.text,n,t.x,t.y+t.label.Y,t.width,t.height,{fill:s},d),d=a[t.typeC4Shape.text+"Font"](),d.fontColor=s,t.techn&&((o=t.techn)==null?void 0:o.text)!==""?W(a)(t.techn.text,n,t.x,t.y+t.techn.Y,t.width,t.height,{fill:s,"font-style":"italic"},d):t.type&&t.type.text!==""&&W(a)(t.type.text,n,t.x,t.y+t.type.Y,t.width,t.height,{fill:s,"font-style":"italic"},d),t.descr&&t.descr.text!==""&&(d=a.personFont(),d.fontColor=s,W(a)(t.descr.text,n,t.x,t.y+t.descr.Y,t.width,t.height,{fill:s},d)),t.height},p0=function(e){e.append("defs").append("symbol").attr("id","database").attr("fill-rule","evenodd").attr("clip-rule","evenodd").append("path").attr("transform","scale(.5)").attr("d","M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z")},y0=function(e){e.append("defs").append("symbol").attr("id","computer").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z")},g0=function(e){e.append("defs").append("symbol").attr("id","clock").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z")},b0=function(e){e.append("defs").append("marker").attr("id","arrowhead").attr("refX",9).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 0 0 L 10 5 L 0 10 z")},_0=function(e){e.append("defs").append("marker").attr("id","arrowend").attr("refX",1).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 10 0 L 0 5 L 10 10 z")},x0=function(e){e.append("defs").append("marker").attr("id","filled-head").attr("refX",18).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L14,7 L9,1 Z")},m0=function(e){e.append("defs").append("marker").attr("id","sequencenumber").attr("refX",15).attr("refY",15).attr("markerWidth",60).attr("markerHeight",40).attr("orient","auto").append("circle").attr("cx",15).attr("cy",15).attr("r",6)},E0=function(e){const a=e.append("defs").append("marker").attr("id","crosshead").attr("markerWidth",15).attr("markerHeight",8).attr("orient","auto").attr("refX",16).attr("refY",4);a.append("path").attr("fill","black").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1px").attr("d","M 9,2 V 6 L16,4 Z"),a.append("path").attr("fill","none").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1px").attr("d","M 0,1 L 6,7 M 6,1 L 0,7")},v0=(e,t)=>({fontFamily:e[t+"FontFamily"],fontSize:e[t+"FontSize"],fontWeight:e[t+"FontWeight"]}),W=function(){function e(l,i,s,r,n,h,f){const d=i.append("text").attr("x",s+n/2).attr("y",r+h/2+5).style("text-anchor","middle").text(l);o(d,f)}function t(l,i,s,r,n,h,f,d){const{fontSize:p,fontFamily:E,fontWeight:O}=d,R=l.split(Kt.lineBreakRegex);for(let S=0;S<R.length;S++){const L=S*p-p*(R.length-1)/2,Y=i.append("text").attr("x",s+n/2).attr("y",r).style("text-anchor","middle").attr("dominant-baseline","middle").style("font-size",p).style("font-weight",O).style("font-family",E);Y.append("tspan").attr("dy",L).text(R[S]).attr("alignment-baseline","mathematical"),o(Y,f)}}function a(l,i,s,r,n,h,f,d){const p=i.append("switch"),O=p.append("foreignObject").attr("x",s).attr("y",r).attr("width",n).attr("height",h).append("xhtml:div").style("display","table").style("height","100%").style("width","100%");O.append("div").style("display","table-cell").style("text-align","center").style("vertical-align","middle").text(l),t(l,p,s,r,n,h,f,d),o(O,f)}function o(l,i){for(const s in i)i.hasOwnProperty(s)&&l.attr(s,i[s])}return function(l){return l.textPlacement==="fo"?a:l.textPlacement==="old"?e:t}}(),F={drawRect:ie,drawBoundary:d0,drawC4Shape:f0,drawRels:u0,drawImage:ye,insertArrowHead:b0,insertArrowEnd:_0,insertArrowFilledHead:x0,insertDynamicNumber:m0,insertArrowCrossHead:E0,insertDatabaseIcon:p0,insertComputerIcon:y0,insertClockIcon:g0};let Ut=0,Ft=0,ge=4,Zt=2;Yt.yy=Jt;let b={};class be{constructor(t){this.name="",this.data={},this.data.startx=void 0,this.data.stopx=void 0,this.data.starty=void 0,this.data.stopy=void 0,this.data.widthLimit=void 0,this.nextData={},this.nextData.startx=void 0,this.nextData.stopx=void 0,this.nextData.starty=void 0,this.nextData.stopy=void 0,this.nextData.cnt=0,$t(t.db.getConfig())}setData(t,a,o,l){this.nextData.startx=this.data.startx=t,this.nextData.stopx=this.data.stopx=a,this.nextData.starty=this.data.starty=o,this.nextData.stopy=this.data.stopy=l}updateVal(t,a,o,l){t[a]===void 0?t[a]=o:t[a]=l(o,t[a])}insert(t){this.nextData.cnt=this.nextData.cnt+1;let a=this.nextData.startx===this.nextData.stopx?this.nextData.stopx+t.margin:this.nextData.stopx+t.margin*2,o=a+t.width,l=this.nextData.starty+t.margin*2,i=l+t.height;(a>=this.data.widthLimit||o>=this.data.widthLimit||this.nextData.cnt>ge)&&(a=this.nextData.startx+t.margin+b.nextLinePaddingX,l=this.nextData.stopy+t.margin*2,this.nextData.stopx=o=a+t.width,this.nextData.starty=this.nextData.stopy,this.nextData.stopy=i=l+t.height,this.nextData.cnt=1),t.x=a,t.y=l,this.updateVal(this.data,"startx",a,Math.min),this.updateVal(this.data,"starty",l,Math.min),this.updateVal(this.data,"stopx",o,Math.max),this.updateVal(this.data,"stopy",i,Math.max),this.updateVal(this.nextData,"startx",a,Math.min),this.updateVal(this.nextData,"starty",l,Math.min),this.updateVal(this.nextData,"stopx",o,Math.max),this.updateVal(this.nextData,"stopy",i,Math.max)}init(t){this.name="",this.data={startx:void 0,stopx:void 0,starty:void 0,stopy:void 0,widthLimit:void 0},this.nextData={startx:void 0,stopx:void 0,starty:void 0,stopy:void 0,cnt:0},$t(t.db.getConfig())}bumpLastMargin(t){this.data.stopx+=t,this.data.stopy+=t}}const $t=function(e){Se(b,e),e.fontFamily&&(b.personFontFamily=b.systemFontFamily=b.messageFontFamily=e.fontFamily),e.fontSize&&(b.personFontSize=b.systemFontSize=b.messageFontSize=e.fontSize),e.fontWeight&&(b.personFontWeight=b.systemFontWeight=b.messageFontWeight=e.fontWeight)},Rt=(e,t)=>({fontFamily:e[t+"FontFamily"],fontSize:e[t+"FontSize"],fontWeight:e[t+"FontWeight"]}),Bt=e=>({fontFamily:e.boundaryFontFamily,fontSize:e.boundaryFontSize,fontWeight:e.boundaryFontWeight}),k0=e=>({fontFamily:e.messageFontFamily,fontSize:e.messageFontSize,fontWeight:e.messageFontWeight});function I(e,t,a,o,l){if(!t[e].width)if(a)t[e].text=Me(t[e].text,l,o),t[e].textLines=t[e].text.split(Kt.lineBreakRegex).length,t[e].width=l,t[e].height=oe(t[e].text,o);else{let i=t[e].text.split(Kt.lineBreakRegex);t[e].textLines=i.length;let s=0;t[e].height=0,t[e].width=0;for(const r of i)t[e].width=Math.max(wt(r,o),t[e].width),s=oe(r,o),t[e].height=t[e].height+s}}const _e=function(e,t,a){t.x=a.data.startx,t.y=a.data.starty,t.width=a.data.stopx-a.data.startx,t.height=a.data.stopy-a.data.starty,t.label.y=b.c4ShapeMargin-35;let o=t.wrap&&b.wrap,l=Bt(b);l.fontSize=l.fontSize+2,l.fontWeight="bold";let i=wt(t.label.text,l);I("label",t,o,l,i),F.drawBoundary(e,t,b)},xe=function(e,t,a,o){let l=0;for(const i of o){l=0;const s=a[i];let r=Rt(b,s.typeC4Shape.text);switch(r.fontSize=r.fontSize-2,s.typeC4Shape.width=wt("«"+s.typeC4Shape.text+"»",r),s.typeC4Shape.height=r.fontSize+2,s.typeC4Shape.Y=b.c4ShapePadding,l=s.typeC4Shape.Y+s.typeC4Shape.height-4,s.image={width:0,height:0,Y:0},s.typeC4Shape.text){case"person":case"external_person":s.image.width=48,s.image.height=48,s.image.Y=l,l=s.image.Y+s.image.height;break}s.sprite&&(s.image.width=48,s.image.height=48,s.image.Y=l,l=s.image.Y+s.image.height);let n=s.wrap&&b.wrap,h=b.width-b.c4ShapePadding*2,f=Rt(b,s.typeC4Shape.text);if(f.fontSize=f.fontSize+2,f.fontWeight="bold",I("label",s,n,f,h),s.label.Y=l+8,l=s.label.Y+s.label.height,s.type&&s.type.text!==""){s.type.text="["+s.type.text+"]";let E=Rt(b,s.typeC4Shape.text);I("type",s,n,E,h),s.type.Y=l+5,l=s.type.Y+s.type.height}else if(s.techn&&s.techn.text!==""){s.techn.text="["+s.techn.text+"]";let E=Rt(b,s.techn.text);I("techn",s,n,E,h),s.techn.Y=l+5,l=s.techn.Y+s.techn.height}let d=l,p=s.label.width;if(s.descr&&s.descr.text!==""){let E=Rt(b,s.typeC4Shape.text);I("descr",s,n,E,h),s.descr.Y=l+20,l=s.descr.Y+s.descr.height,p=Math.max(s.label.width,s.descr.width),d=l-s.descr.textLines*5}p=p+b.c4ShapePadding,s.width=Math.max(s.width||b.width,p,b.width),s.height=Math.max(s.height||b.height,d,b.height),s.margin=s.margin||b.c4ShapeMargin,e.insert(s),F.drawC4Shape(t,s,b)}e.bumpLastMargin(b.c4ShapeMargin)};class B{constructor(t,a){this.x=t,this.y=a}}let ce=function(e,t){let a=e.x,o=e.y,l=t.x,i=t.y,s=a+e.width/2,r=o+e.height/2,n=Math.abs(a-l),h=Math.abs(o-i),f=h/n,d=e.height/e.width,p=null;return o==i&&a<l?p=new B(a+e.width,r):o==i&&a>l?p=new B(a,r):a==l&&o<i?p=new B(s,o+e.height):a==l&&o>i&&(p=new B(s,o)),a>l&&o<i?d>=f?p=new B(a,r+f*e.width/2):p=new B(s-n/h*e.height/2,o+e.height):a<l&&o<i?d>=f?p=new B(a+e.width,r+f*e.width/2):p=new B(s+n/h*e.height/2,o+e.height):a<l&&o>i?d>=f?p=new B(a+e.width,r-f*e.width/2):p=new B(s+e.height/2*n/h,o):a>l&&o>i&&(d>=f?p=new B(a,r-e.width/2*f):p=new B(s-e.height/2*n/h,o)),p},A0=function(e,t){let a={x:0,y:0};a.x=t.x+t.width/2,a.y=t.y+t.height/2;let o=ce(e,a);a.x=e.x+e.width/2,a.y=e.y+e.height/2;let l=ce(t,a);return{startPoint:o,endPoint:l}};const C0=function(e,t,a,o){let l=0;for(let i of t){l=l+1;let s=i.wrap&&b.wrap,r=k0(b);o.db.getC4Type()==="C4Dynamic"&&(i.label.text=l+": "+i.label.text);let h=wt(i.label.text,r);I("label",i,s,r,h),i.techn&&i.techn.text!==""&&(h=wt(i.techn.text,r),I("techn",i,s,r,h)),i.descr&&i.descr.text!==""&&(h=wt(i.descr.text,r),I("descr",i,s,r,h));let f=a(i.from),d=a(i.to),p=A0(f,d);i.startPoint=p.startPoint,i.endPoint=p.endPoint}F.drawRels(e,t,b)};function me(e,t,a,o,l){let i=new be(l);i.data.widthLimit=a.data.widthLimit/Math.min(Zt,o.length);for(let[s,r]of o.entries()){let n=0;r.image={width:0,height:0,Y:0},r.sprite&&(r.image.width=48,r.image.height=48,r.image.Y=n,n=r.image.Y+r.image.height);let h=r.wrap&&b.wrap,f=Bt(b);if(f.fontSize=f.fontSize+2,f.fontWeight="bold",I("label",r,h,f,i.data.widthLimit),r.label.Y=n+8,n=r.label.Y+r.label.height,r.type&&r.type.text!==""){r.type.text="["+r.type.text+"]";let O=Bt(b);I("type",r,h,O,i.data.widthLimit),r.type.Y=n+5,n=r.type.Y+r.type.height}if(r.descr&&r.descr.text!==""){let O=Bt(b);O.fontSize=O.fontSize-2,I("descr",r,h,O,i.data.widthLimit),r.descr.Y=n+20,n=r.descr.Y+r.descr.height}if(s==0||s%Zt===0){let O=a.data.startx+b.diagramMarginX,R=a.data.stopy+b.diagramMarginY+n;i.setData(O,O,R,R)}else{let O=i.data.stopx!==i.data.startx?i.data.stopx+b.diagramMarginX:i.data.startx,R=i.data.starty;i.setData(O,O,R,R)}i.name=r.alias;let d=l.db.getC4ShapeArray(r.alias),p=l.db.getC4ShapeKeys(r.alias);p.length>0&&xe(i,e,d,p),t=r.alias;let E=l.db.getBoundarys(t);E.length>0&&me(e,t,i,E,l),r.alias!=="global"&&_e(e,r,i),a.data.stopy=Math.max(i.data.stopy+b.c4ShapeMargin,a.data.stopy),a.data.stopx=Math.max(i.data.stopx+b.c4ShapeMargin,a.data.stopx),Ut=Math.max(Ut,a.data.stopx),Ft=Math.max(Ft,a.data.stopy)}}const w0=function(e,t,a,o){b=Dt().c4;const l=Dt().securityLevel;let i;l==="sandbox"&&(i=Nt("#i"+t));const s=l==="sandbox"?Nt(i.nodes()[0].contentDocument.body):Nt("body");let r=o.db;o.db.setWrap(b.wrap),ge=r.getC4ShapeInRow(),Zt=r.getC4BoundaryInRow(),le.debug(`C:${JSON.stringify(b,null,2)}`);const n=l==="sandbox"?s.select(`[id="${t}"]`):Nt(`[id="${t}"]`);F.insertComputerIcon(n),F.insertDatabaseIcon(n),F.insertClockIcon(n);let h=new be(o);h.setData(b.diagramMarginX,b.diagramMarginX,b.diagramMarginY,b.diagramMarginY),h.data.widthLimit=screen.availWidth,Ut=b.diagramMarginX,Ft=b.diagramMarginY;const f=o.db.getTitle();let d=o.db.getBoundarys("");me(n,"",h,d,o),F.insertArrowHead(n),F.insertArrowEnd(n),F.insertArrowCrossHead(n),F.insertArrowFilledHead(n),C0(n,o.db.getRels(),o.db.getC4Shape,o),h.data.stopx=Ut,h.data.stopy=Ft;const p=h.data;let O=p.stopy-p.starty+2*b.diagramMarginY;const S=p.stopx-p.startx+2*b.diagramMarginX;f&&n.append("text").text(f).attr("x",(p.stopx-p.startx)/2-4*b.diagramMarginX).attr("y",p.starty+b.diagramMarginY),De(n,O,S,b.useMaxWidth);const L=f?60:0;n.attr("viewBox",p.startx-b.diagramMarginX+" -"+(b.diagramMarginY+L)+" "+S+" "+(O+L)),le.debug("models:",p)},he={drawPersonOrSystemArray:xe,drawBoundary:_e,setConf:$t,draw:w0},O0=e=>`.person {
+    stroke: ${e.personBorder};
+    fill: ${e.personBkg};
+  }
+`,T0=O0,S0={parser:Be,db:Jt,renderer:he,styles:T0,init:({c4:e,wrap:t})=>{he.setConf(e),Jt.setWrap(t)}};export{S0 as diagram};

frontend-dist/assets/channel-DsKT-zfZ.js

@@ -0,0 +1 @@
+import{aH as o,aI as n}from"./index-BCNM9-Ly.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

frontend-dist/assets/classDiagram-beda092f-wmkRqnN2.js

@@ -0,0 +1,2 @@
+import{s as A,d as S,p as G}from"./styles-b4e223ce-CtHeUc7h.js";import{c as v,l as y,d as B,e as W,F as $,A as M,G as I}from"./index-BCNM9-Ly.js";import{G as O}from"./graph-CY8eBbAS.js";import{l as P}from"./layout-CUwpW5wl.js";import{l as X}from"./line-DdWeXrJe.js";import"./array-BKyUJesY.js";import"./path-CbwjOpE9.js";let H=0;const Y=function(i,a,t,o,p){const g=function(e){switch(e){case p.db.relationType.AGGREGATION:return"aggregation";case p.db.relationType.EXTENSION:return"extension";case p.db.relationType.COMPOSITION:return"composition";case p.db.relationType.DEPENDENCY:return"dependency";case p.db.relationType.LOLLIPOP:return"lollipop"}};a.points=a.points.filter(e=>!Number.isNaN(e.y));const s=a.points,c=X().x(function(e){return e.x}).y(function(e){return e.y}).curve($),n=i.append("path").attr("d",c(s)).attr("id","edge"+H).attr("class","relation");let r="";o.arrowMarkerAbsolute&&(r=window.location.protocol+"//"+window.location.host+window.location.pathname+window.location.search,r=r.replace(/\(/g,"\\("),r=r.replace(/\)/g,"\\)")),t.relation.lineType==1&&n.attr("class","relation dashed-line"),t.relation.lineType==10&&n.attr("class","relation dotted-line"),t.relation.type1!=="none"&&n.attr("marker-start","url("+r+"#"+g(t.relation.type1)+"Start)"),t.relation.type2!=="none"&&n.attr("marker-end","url("+r+"#"+g(t.relation.type2)+"End)");let f,h;const x=a.points.length;let b=M.calcLabelPosition(a.points);f=b.x,h=b.y;let u,m,w,k;if(x%2!==0&&x>1){let e=M.calcCardinalityPosition(t.relation.type1!=="none",a.points,a.points[0]),d=M.calcCardinalityPosition(t.relation.type2!=="none",a.points,a.points[x-1]);y.debug("cardinality_1_point "+JSON.stringify(e)),y.debug("cardinality_2_point "+JSON.stringify(d)),u=e.x,m=e.y,w=d.x,k=d.y}if(t.title!==void 0){const e=i.append("g").attr("class","classLabel"),d=e.append("text").attr("class","label").attr("x",f).attr("y",h).attr("fill","red").attr("text-anchor","middle").text(t.title);window.label=d;const l=d.node().getBBox();e.insert("rect",":first-child").attr("class","box").attr("x",l.x-o.padding/2).attr("y",l.y-o.padding/2).attr("width",l.width+o.padding).attr("height",l.height+o.padding)}y.info("Rendering relation "+JSON.stringify(t)),t.relationTitle1!==void 0&&t.relationTitle1!=="none"&&i.append("g").attr("class","cardinality").append("text").attr("class","type1").attr("x",u).attr("y",m).attr("fill","black").attr("font-size","6").text(t.relationTitle1),t.relationTitle2!==void 0&&t.relationTitle2!=="none"&&i.append("g").attr("class","cardinality").append("text").attr("class","type2").attr("x",w).attr("y",k).attr("fill","black").attr("font-size","6").text(t.relationTitle2),H++},J=function(i,a,t,o){y.debug("Rendering class ",a,t);const p=a.id,g={id:p,label:a.id,width:0,height:0},s=i.append("g").attr("id",o.db.lookUpDomId(p)).attr("class","classGroup");let c;a.link?c=s.append("svg:a").attr("xlink:href",a.link).attr("target",a.linkTarget).append("text").attr("y",t.textHeight+t.padding).attr("x",0):c=s.append("text").attr("y",t.textHeight+t.padding).attr("x",0);let n=!0;a.annotations.forEach(function(d){const l=c.append("tspan").text("«"+d+"»");n||l.attr("dy",t.textHeight),n=!1});let r=C(a);const f=c.append("tspan").text(r).attr("class","title");n||f.attr("dy",t.textHeight);const h=c.node().getBBox().height;let x,b,u;if(a.members.length>0){x=s.append("line").attr("x1",0).attr("y1",t.padding+h+t.dividerMargin/2).attr("y2",t.padding+h+t.dividerMargin/2);const d=s.append("text").attr("x",t.padding).attr("y",h+t.dividerMargin+t.textHeight).attr("fill","white").attr("class","classText");n=!0,a.members.forEach(function(l){_(d,l,n,t),n=!1}),b=d.node().getBBox()}if(a.methods.length>0){u=s.append("line").attr("x1",0).attr("y1",t.padding+h+t.dividerMargin+b.height).attr("y2",t.padding+h+t.dividerMargin+b.height);const d=s.append("text").attr("x",t.padding).attr("y",h+2*t.dividerMargin+b.height+t.textHeight).attr("fill","white").attr("class","classText");n=!0,a.methods.forEach(function(l){_(d,l,n,t),n=!1})}const m=s.node().getBBox();var w=" ";a.cssClasses.length>0&&(w=w+a.cssClasses.join(" "));const e=s.insert("rect",":first-child").attr("x",0).attr("y",0).attr("width",m.width+2*t.padding).attr("height",m.height+t.padding+.5*t.dividerMargin).attr("class",w).node().getBBox().width;return c.node().childNodes.forEach(function(d){d.setAttribute("x",(e-d.getBBox().width)/2)}),a.tooltip&&c.insert("title").text(a.tooltip),x&&x.attr("x2",e),u&&u.attr("x2",e),g.width=e,g.height=m.height+t.padding+.5*t.dividerMargin,g},C=function(i){let a=i.id;return i.type&&(a+="<"+I(i.type)+">"),a},Z=function(i,a,t,o){y.debug("Rendering note ",a,t);const p=a.id,g={id:p,text:a.text,width:0,height:0},s=i.append("g").attr("id",p).attr("class","classGroup");let c=s.append("text").attr("y",t.textHeight+t.padding).attr("x",0);const n=JSON.parse(`"${a.text}"`).split(`
+`);n.forEach(function(x){y.debug(`Adding line: ${x}`),c.append("tspan").text(x).attr("class","title").attr("dy",t.textHeight)});const r=s.node().getBBox(),h=s.insert("rect",":first-child").attr("x",0).attr("y",0).attr("width",r.width+2*t.padding).attr("height",r.height+n.length*t.textHeight+t.padding+.5*t.dividerMargin).node().getBBox().width;return c.node().childNodes.forEach(function(x){x.setAttribute("x",(h-x.getBBox().width)/2)}),g.width=h,g.height=r.height+n.length*t.textHeight+t.padding+.5*t.dividerMargin,g},_=function(i,a,t,o){const{displayText:p,cssStyle:g}=a.getDisplayDetails(),s=i.append("tspan").attr("x",o.padding).text(p);g!==""&&s.attr("style",a.cssStyle),t||s.attr("dy",o.textHeight)},N={getClassTitleString:C,drawClass:J,drawEdge:Y,drawNote:Z};let T={};const E=20,L=function(i){const a=Object.entries(T).find(t=>t[1].label===i);if(a)return a[0]},R=function(i){i.append("defs").append("marker").attr("id","extensionStart").attr("class","extension").attr("refX",0).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").append("path").attr("d","M 1,7 L18,13 V 1 Z"),i.append("defs").append("marker").attr("id","extensionEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 1,1 V 13 L18,7 Z"),i.append("defs").append("marker").attr("id","compositionStart").attr("class","extension").attr("refX",0).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),i.append("defs").append("marker").attr("id","compositionEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),i.append("defs").append("marker").attr("id","aggregationStart").attr("class","extension").attr("refX",0).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),i.append("defs").append("marker").attr("id","aggregationEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L1,7 L9,1 Z"),i.append("defs").append("marker").attr("id","dependencyStart").attr("class","extension").attr("refX",0).attr("refY",7).attr("markerWidth",190).attr("markerHeight",240).attr("orient","auto").append("path").attr("d","M 5,7 L9,13 L1,7 L9,1 Z"),i.append("defs").append("marker").attr("id","dependencyEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L14,7 L9,1 Z")},F=function(i,a,t,o){const p=v().class;T={},y.info("Rendering diagram "+i);const g=v().securityLevel;let s;g==="sandbox"&&(s=B("#i"+a));const c=g==="sandbox"?B(s.nodes()[0].contentDocument.body):B("body"),n=c.select(`[id='${a}']`);R(n);const r=new O({multigraph:!0});r.setGraph({isMultiGraph:!0}),r.setDefaultEdgeLabel(function(){return{}});const f=o.db.getClasses(),h=Object.keys(f);for(const e of h){const d=f[e],l=N.drawClass(n,d,p,o);T[l.id]=l,r.setNode(l.id,l),y.info("Org height: "+l.height)}o.db.getRelations().forEach(function(e){y.info("tjoho"+L(e.id1)+L(e.id2)+JSON.stringify(e)),r.setEdge(L(e.id1),L(e.id2),{relation:e},e.title||"DEFAULT")}),o.db.getNotes().forEach(function(e){y.debug(`Adding note: ${JSON.stringify(e)}`);const d=N.drawNote(n,e,p,o);T[d.id]=d,r.setNode(d.id,d),e.class&&e.class in f&&r.setEdge(e.id,L(e.class),{relation:{id1:e.id,id2:e.class,relation:{type1:"none",type2:"none",lineType:10}}},"DEFAULT")}),P(r),r.nodes().forEach(function(e){e!==void 0&&r.node(e)!==void 0&&(y.debug("Node "+e+": "+JSON.stringify(r.node(e))),c.select("#"+(o.db.lookUpDomId(e)||e)).attr("transform","translate("+(r.node(e).x-r.node(e).width/2)+","+(r.node(e).y-r.node(e).height/2)+" )"))}),r.edges().forEach(function(e){e!==void 0&&r.edge(e)!==void 0&&(y.debug("Edge "+e.v+" -> "+e.w+": "+JSON.stringify(r.edge(e))),N.drawEdge(n,r.edge(e),r.edge(e).relation,p,o))});const u=n.node().getBBox(),m=u.width+E*2,w=u.height+E*2;W(n,w,m,p.useMaxWidth);const k=`${u.x-E} ${u.y-E} ${m} ${w}`;y.debug(`viewBox ${k}`),n.attr("viewBox",k)},U={draw:F},tt={parser:G,db:S,renderer:U,styles:A,init:i=>{i.class||(i.class={}),i.class.arrowMarkerAbsolute=i.arrowMarkerAbsolute,S.clear()}};export{tt as diagram};