congsh/MineNasAI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
23bf2cfaef0a8ff459fee40697c3d7aaf558d99c
MineNasAI/PoC验证.md

1091 lines
28 KiB
Markdown
Raw Normal View History

feat: 添加项目规则、环境配置示例及开发文档
2026-02-04 18:49:38 +08:00
# MineNASAI - PoC 验证计划
**创建日期**: 2025-02-04
**目标**: 验证3个关键技术的可行性
**预计时间**: 2-3天
---
## 验证目标
### 为什么需要 PoC？
在投入大量时间开发之前，我们需要验证以下关键技术的可行性：
1. **Claude Code CLI 集成** (最高优先级)
- 风险：子进程管理、输出解析复杂
- 影响：这是核心功能，如果不可行需要重新设计
2. **智能路由算法**
- 风险：路由准确度不足
- 影响：影响用户体验和资源利用率
3. **MCP Server 加载**
- 风险：MCP协议不熟悉、进程通信复杂
- 影响：工具扩展能力的基础
---
## PoC 1: Claude Code CLI 集成
### 目标
验证可以通过 Python 子进程调用 Claude Code CLI，并正确解析其输出。
### 验证内容
- [ ] 子进程启动和管理
- [ ] 实时输出流捕获
- [ ] ANSI 转义序列处理
- [ ] 交互式输入处理
- [ ] 超时和资源限制
- [ ] 错误处理和恢复
### 实施步骤
#### 步骤1: 环境准备
```bash
# 1. 确保已安装 Claude Code CLI
# 如果没有,访问: https://docs.anthropic.com/claude/docs/claude-code
# 2. 验证 CLI 可用
claude --version
# 3. 测试基本调用
claude "print hello world in python"
# 4. 创建 PoC 工作目录
mkdir -p poc/claude_cli_test
cd poc/claude_cli_test
```
#### 步骤2: 基础子进程调用 (poc_1_basic.py)
```python
"""PoC 1.1: Basic Claude CLI subprocess call."""
import subprocess
import sys
def test_basic_call():
"""测试基本的 CLI 调用."""
print("=== PoC 1.1: Basic CLI Call ===\n")
# 简单命令
cmd = ["claude", "print hello world in python"]
print(f"执行命令: {' '.join(cmd)}")
print("-" * 60)
try:
# 使用 subprocess.run
result = subprocess.run(
cmd,
capture_output=True,
text=True,
timeout=30,
)
print("STDOUT:")
print(result.stdout)
print("\nSTDERR:")
print(result.stderr)
print(f"\n退出码: {result.returncode}")
if result.returncode == 0:
print("\n✅ 基础调用成功!")
return True
else:
print("\n❌ 命令执行失败")
return False
except subprocess.TimeoutExpired:
print("\n❌ 命令超时")
return False
except Exception as e:
print(f"\n❌ 异常: {e}")
return False
if __name__ == "__main__":
success = test_basic_call()
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] 脚本可以成功调用 Claude CLI
- [ ] 可以捕获完整输出
- [ ] 超时机制生效
**运行测试**:
```bash
python poc_1_basic.py
```
---
#### 步骤3: 实时输出流捕获 (poc_1_streaming.py)
```python
"""PoC 1.2: Real-time output streaming."""
import subprocess
import sys
import select
import os
def test_streaming_output():
"""测试实时输出流捕获."""
print("=== PoC 1.2: Streaming Output ===\n")
cmd = ["claude", "count to 10 with 1 second delays in python"]
print(f"执行命令: {' '.join(cmd)}")
print("-" * 60)
try:
# 使用 Popen 进行流式输出
process = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
bufsize=1, # 行缓冲
)
print("实时输出:")
# 实时读取输出
while True:
# 检查进程是否结束
if process.poll() is not None:
break
# 读取一行输出
line = process.stdout.readline()
if line:
print(f"[OUT] {line.rstrip()}")
# 读取错误输出
# 注意: stderr 需要非阻塞读取或使用 select
# 获取剩余输出
remaining_out, remaining_err = process.communicate()
if remaining_out:
print(remaining_out)
print(f"\n退出码: {process.returncode}")
if process.returncode == 0:
print("\n✅ 流式输出捕获成功!")
return True
else:
print("\n❌ 进程执行失败")
return False
except Exception as e:
print(f"\n❌ 异常: {e}")
return False
if __name__ == "__main__":
success = test_streaming_output()
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] 可以实时捕获输出（不是等待结束）
- [ ] 输出不会丢失
- [ ] 可以正确检测进程结束
**运行测试**:
```bash
python poc_1_streaming.py
```
---
#### 步骤4: PTY 伪终端处理 (poc_1_pty.py)
```python
"""PoC 1.3: PTY pseudo-terminal for interactive handling."""
import pty
import os
import sys
import select
import subprocess
def test_pty_terminal():
"""测试 PTY 伪终端处理."""
print("=== PoC 1.3: PTY Terminal ===\n")
cmd = ["claude", "create a simple python calculator"]
print(f"执行命令: {' '.join(cmd)}")
print("-" * 60)
try:
# 创建 PTY
master, slave = pty.openpty()
# 启动进程
process = subprocess.Popen(
cmd,
stdin=slave,
stdout=slave,
stderr=slave,
close_fds=True,
)
os.close(slave) # 子进程已继承，关闭父进程的副本
print("实时输出 (PTY):")
output_buffer = []
# 读取输出
while True:
# 检查进程是否结束
if process.poll() is not None:
break
# 使用 select 进行非阻塞读取
r, w, e = select.select([master], [], [], 0.1)
if master in r:
try:
data = os.read(master, 1024)
if data:
text = data.decode('utf-8', errors='replace')
print(text, end='')
output_buffer.append(text)
except OSError:
break
os.close(master)
print(f"\n\n退出码: {process.returncode}")
print(f"总输出长度: {len(''.join(output_buffer))} 字符")
if process.returncode == 0:
print("\n✅ PTY 终端处理成功!")
return True
else:
print("\n❌ 进程执行失败")
return False
except Exception as e:
print(f"\n❌ 异常: {e}")
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
success = test_pty_terminal()
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] PTY 可以正确创建
- [ ] 可以处理交互式输出
- [ ] ANSI 转义序列正确显示
**运行测试**:
```bash
python poc_1_pty.py
```
---
#### 步骤5: 完整集成示例 (poc_1_full.py)
```python
"""PoC 1.4: Full Claude CLI integration."""
import asyncio
import pty
import os
import select
import subprocess
from dataclasses import dataclass
from typing import Optional
@dataclass
class CLIResult:
"""CLI execution result."""
exit_code: int
output: str
error: Optional[str] = None
duration_ms: int = 0
class ClaudeCLI:
"""Claude CLI wrapper."""
def __init__(self, timeout: int = 300):
"""Initialize CLI wrapper."""
self.timeout = timeout
async def execute(self, prompt: str, workspace: str = ".") -> CLIResult:
"""
Execute Claude CLI command.
Args:
prompt: 任务提示
workspace: 工作目录
Returns:
CLIResult with output
"""
import time
start_time = time.time()
cmd = ["claude", prompt]
try:
# 创建 PTY
master, slave = pty.openpty()
# 启动进程
process = subprocess.Popen(
cmd,
stdin=slave,
stdout=slave,
stderr=slave,
cwd=workspace,
close_fds=True,
)
os.close(slave)
# 收集输出
output_buffer = []
# 读取输出 (带超时)
timeout_time = start_time + self.timeout
while True:
# 检查超时
if time.time() > timeout_time:
process.kill()
raise TimeoutError(f"Command timeout after {self.timeout}s")
# 检查进程是否结束
if process.poll() is not None:
break
# 非阻塞读取
r, w, e = select.select([master], [], [], 0.1)
if master in r:
try:
data = os.read(master, 4096)
if data:
text = data.decode('utf-8', errors='replace')
output_buffer.append(text)
except OSError:
break
os.close(master)
duration_ms = int((time.time() - start_time) * 1000)
output = ''.join(output_buffer)
return CLIResult(
exit_code=process.returncode,
output=output,
duration_ms=duration_ms,
)
except TimeoutError as e:
return CLIResult(
exit_code=-1,
output=''.join(output_buffer),
error=str(e),
duration_ms=int((time.time() - start_time) * 1000),
)
except Exception as e:
return CLIResult(
exit_code=-1,
output='',
error=str(e),
duration_ms=int((time.time() - start_time) * 1000),
)
async def test_full_integration():
"""测试完整集成."""
print("=== PoC 1.4: Full Integration ===\n")
cli = ClaudeCLI(timeout=60)
# 测试用例1: 简单任务
print("测试1: 简单Python脚本")
print("-" * 60)
result = await cli.execute("create a hello world python script")
print(f"输出:\n{result.output}")
print(f"\n退出码: {result.exit_code}")
print(f"耗时: {result.duration_ms}ms")
if result.exit_code == 0:
print("✅ 测试1通过")
else:
print(f"❌ 测试1失败: {result.error}")
return False
# 测试用例2: 需要多步骤的任务
print("\n\n测试2: 多步骤任务")
print("-" * 60)
result = await cli.execute(
"create a simple REST API with FastAPI that has a hello endpoint"
)
print(f"输出:\n{result.output[:500]}...") # 只显示前500字符
print(f"\n退出码: {result.exit_code}")
print(f"耗时: {result.duration_ms}ms")
if result.exit_code == 0:
print("✅ 测试2通过")
else:
print(f"❌ 测试2失败: {result.error}")
return False
print("\n" + "=" * 60)
print("✅ 完整集成验证通过!")
print("=" * 60)
return True
if __name__ == "__main__":
success = asyncio.run(test_full_integration())
import sys
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] 封装类可以正常工作
- [ ] 支持异步调用
- [ ] 超时控制有效
- [ ] 错误处理完善
- [ ] 可以处理简单和复杂任务
**运行测试**:
```bash
python poc_1_full.py
```
---
### PoC 1 总结
完成上述5个步骤后，填写以下清单：
**验证结果**:
- [ ] 基础调用可行
- [ ] 流式输出捕获可行
- [ ] PTY终端处理可行
- [ ] 完整集成验证通过
- [ ] 性能可接受 (大多数任务 < 1分钟)
**发现的问题**:
1.
2.
3.
**需要的改进**:
1.
2.
3.
**结论**:
- [ ] ✅ 可行，建议使用 PTY + asyncio 方案
- [ ] ⚠️ 部分可行，需要调整设计
- [ ] ❌ 不可行，需要备选方案
---
## PoC 2: 智能路由算法
### 目标
验证路由算法可以合理地将任务分类为 fast/medium/deep 三种模式。
### 验证内容
- [ ] 启发式规则准确度
- [ ] LLM-based 路由可行性
- [ ] 用户指令覆盖
- [ ] 路由性能 (响应时间)
### 实施步骤
#### 步骤1: 启发式规则测试 (poc_2_heuristic.py)
```python
"""PoC 2.1: Heuristic routing rules."""
from dataclasses import dataclass
from typing import Literal
@dataclass
class RoutingDecision:
"""Routing decision."""
mode: Literal["fast", "medium", "deep"]
reason: str
confidence: float # 0.0 - 1.0
class HeuristicRouter:
"""Heuristic-based router."""
def __init__(self):
"""Initialize rules."""
self.rules = {
"fast_keywords": ["状态", "查询", "搜索", "是什么", "?", "？"],
"deep_keywords": ["实现", "开发", "编写", "重构", "优化", "设计", "创建"],
"medium_keywords": ["修改", "更新", "添加", "删除"],
}
def evaluate(self, message: str) -> RoutingDecision:
"""Evaluate routing decision."""
message_lower = message.lower()
length = len(message)
# 规则1: 短消息 + 查询关键词 -> fast
if length < 50 and any(kw in message_lower for kw in self.rules["fast_keywords"]):
return RoutingDecision(
mode="fast",
reason="短消息且包含查询关键词",
confidence=0.9,
)
# 规则2: 包含开发关键词 -> deep
deep_count = sum(1 for kw in self.rules["deep_keywords"] if kw in message_lower)
if deep_count >= 1:
return RoutingDecision(
mode="deep",
reason=f"包含 {deep_count} 个开发关键词",
confidence=0.7 + min(deep_count * 0.1, 0.2),
)
# 规则3: 中等长度 + 修改关键词 -> medium
if 50 <= length <= 200 and any(kw in message_lower for kw in self.rules["medium_keywords"]):
return RoutingDecision(
mode="medium",
reason="中等长度且包含修改关键词",
confidence=0.6,
)
# 规则4: 长消息 -> medium/deep
if length > 200:
return RoutingDecision(
mode="medium",
reason="消息较长，可能需要多步处理",
confidence=0.5,
)
# 默认: medium
return RoutingDecision(
mode="medium",
reason="默认中等复杂度",
confidence=0.4,
)
def test_heuristic_router():
"""测试启发式路由."""
print("=== PoC 2.1: Heuristic Router ===\n")
router = HeuristicRouter()
# 测试用例
test_cases = [
("NAS状态?", "fast"),
("搜索最新的Python教程", "fast"),
("实现一个Web服务", "deep"),
("重构这个模块", "deep"),
("修改配置文件中的端口", "medium"),
("添加一个新的API端点", "medium"),
("这是一段很长的描述，我需要你帮我分析一下这个系统的架构，然后给出优化建议，包括性能、安全性和可维护性等多个方面", "medium"),
]
correct = 0
total = len(test_cases)
print(f"测试用例数: {total}\n")
for i, (message, expected) in enumerate(test_cases, 1):
decision = router.evaluate(message)
is_correct = decision.mode == expected
correct += is_correct
status = "✅" if is_correct else "❌"
print(f"{status} 用例 {i}:")
print(f" 消息: {message}")
print(f" 预期: {expected}")
print(f" 实际: {decision.mode} (置信度: {decision.confidence:.2f})")
print(f" 理由: {decision.reason}")
print()
accuracy = correct / total
print("=" * 60)
print(f"准确率: {accuracy:.1%} ({correct}/{total})")
print("=" * 60)
if accuracy >= 0.7:
print("\n✅ 启发式规则准确度可接受 (>= 70%)")
return True
else:
print(f"\n⚠️ 准确度较低 ({accuracy:.1%}), 建议优化规则或使用LLM")
return False
if __name__ == "__main__":
import sys
success = test_heuristic_router()
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] 准确率 >= 70%
- [ ] 置信度评分合理
- [ ] 响应时间 < 10ms
**运行测试**:
```bash
python poc_2_heuristic.py
```
---
#### 步骤2: LLM 路由测试 (poc_2_llm.py)
```python
"""PoC 2.2: LLM-based routing."""
import asyncio
import os
from anthropic import AsyncAnthropic
class LLMRouter:
"""LLM-based router using Claude Haiku."""
def __init__(self, api_key: str):
"""Initialize with API key."""
self.client = AsyncAnthropic(api_key=api_key)
self.model = "claude-3-5-haiku-20241022"
async def evaluate(self, message: str) -> dict:
"""Evaluate using Claude Haiku."""
system_prompt = """
你是一个智能路由助手。分析用户消息，判断任务复杂度:
- **fast**: 简单查询，不需要复杂工具 (<1000 tokens)
例如: "NAS状态?", "搜索xxx", "是什么"
- **medium**: 中等任务，需要少量工具调用 (<5000 tokens)
例如: "修改配置", "添加功能", "更新文档"
- **deep**: 复杂任务，需要编程或多步骤处理 (>5000 tokens)
例如: "实现xxx", "重构xxx", "设计xxx"
返回 JSON 格式:
{
"mode": "fast|medium|deep",
"reason": "判断理由",
"confidence": 0.0-1.0
}
"""
try:
response = await self.client.messages.create(
model=self.model,
max_tokens=200,
system=system_prompt,
messages=[
{"role": "user", "content": f"分析这个任务: {message}"}
]
)
# 解析响应
import json
text = response.content[0].text
# 尝试提取JSON
if "{" in text and "}" in text:
json_str = text[text.find("{"):text.rfind("}")+1]
result = json.loads(json_str)
return result
else:
# 降级到启发式
return {"mode": "medium", "reason": "LLM解析失败", "confidence": 0.5}
except Exception as e:
print(f"LLM路由失败: {e}")
return {"mode": "medium", "reason": f"错误: {e}", "confidence": 0.0}
async def test_llm_router():
"""测试LLM路由."""
print("=== PoC 2.2: LLM Router ===\n")
# 检查API密钥
api_key = os.getenv("ANTHROPIC_API_KEY")
if not api_key:
print("⚠️ 未设置 ANTHROPIC_API_KEY，跳过LLM测试")
return True
router = LLMRouter(api_key)
# 测试用例
test_cases = [
("NAS状态?", "fast"),
("实现一个Web服务", "deep"),
("修改配置文件中的端口", "medium"),
]
print(f"测试用例数: {len(test_cases)}\n")
for i, (message, expected) in enumerate(test_cases, 1):
print(f"用例 {i}: {message}")
result = await router.evaluate(message)
is_correct = result["mode"] == expected
status = "✅" if is_correct else "❌"
print(f" {status} 预期: {expected}, 实际: {result['mode']}")
print(f" 理由: {result.get('reason', 'N/A')}")
print(f" 置信度: {result.get('confidence', 0):.2f}")
print()
print("✅ LLM路由可行（需要API费用）")
return True
if __name__ == "__main__":
success = asyncio.run(test_llm_router())
import sys
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] LLM可以正确分类
- [ ] 响应时间可接受 (< 2秒)
- [ ] API费用在预算内
**运行测试**:
```bash
export ANTHROPIC_API_KEY="your-api-key"
python poc_2_llm.py
```
---
### PoC 2 总结
**验证结果**:
- [ ] 启发式规则准确度: ____%
- [ ] LLM路由准确度: ____%
- [ ] LLM平均响应时间: ___ ms
- [ ] 单次LLM路由成本: $_____
**结论**:
- [ ] ✅ 启发式规则足够，先用规则
- [ ] ✅ 启发式 + LLM混合（低置信度时调用LLM）
- [ ] ⚠️ 仅使用LLM（成本和延迟较高）
---
## PoC 3: MCP Server 加载
### 目标
验证可以动态加载和调用 MCP Server。
### 验证内容
- [ ] MCP Server 发现和启动
- [ ] MCP 协议通信 (stdio/sse)
- [ ] 工具调用和结果解析
- [ ] 进程生命周期管理
### 实施步骤
#### 步骤1: 基础MCP连接 (poc_3_basic.py)
```python
"""PoC 3.1: Basic MCP server connection."""
import asyncio
import subprocess
import json
async def test_mcp_connection():
"""测试 MCP Server 连接."""
print("=== PoC 3.1: MCP Connection ===\n")
# 使用官方 filesystem MCP server
cmd = ["npx", "-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
print(f"启动 MCP Server: {' '.join(cmd)}")
print("-" * 60)
try:
# 启动进程
process = subprocess.Popen(
cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
# 发送 initialize 请求
initialize_request = {
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "0.1.0",
"capabilities": {},
"clientInfo": {
"name": "poc-test",
"version": "0.1.0"
}
}
}
print("发送 initialize 请求...")
process.stdin.write(json.dumps(initialize_request) + "\n")
process.stdin.flush()
# 读取响应
response_line = process.stdout.readline()
response = json.loads(response_line)
print(f"收到响应: {json.dumps(response, indent=2)}")
if "result" in response:
print("\n✅ MCP 连接成功!")
print(f"Server capabilities: {response['result'].get('capabilities', {})}")
# 清理
process.terminate()
process.wait(timeout=5)
return True
else:
print(f"\n❌ 初始化失败: {response.get('error')}")
process.terminate()
return False
except Exception as e:
print(f"\n❌ 异常: {e}")
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
success = asyncio.run(test_mcp_connection())
import sys
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] MCP Server可以启动
- [ ] initialize握手成功
- [ ] 可以正确解析响应
**运行测试**:
```bash
python poc_3_basic.py
```
---
#### 步骤2: 工具调用测试 (poc_3_tools.py)
```python
"""PoC 3.2: MCP tool calling."""
import asyncio
import subprocess
import json
async def test_mcp_tools():
"""测试 MCP 工具调用."""
print("=== PoC 3.2: MCP Tools ===\n")
cmd = ["npx", "-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
try:
process = subprocess.Popen(
cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
# Initialize
initialize_request = {
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "0.1.0",
"capabilities": {},
"clientInfo": {"name": "poc-test", "version": "0.1.0"}
}
}
process.stdin.write(json.dumps(initialize_request) + "\n")
process.stdin.flush()
response = json.loads(process.stdout.readline())
print(f"✓ Initialized")
# List tools
list_tools_request = {
"jsonrpc": "2.0",
"id": 2,
"method": "tools/list",
"params": {}
}
print("\n列出可用工具...")
process.stdin.write(json.dumps(list_tools_request) + "\n")
process.stdin.flush()
response = json.loads(process.stdout.readline())
if "result" in response:
tools = response["result"].get("tools", [])
print(f"✓ 找到 {len(tools)} 个工具:")
for tool in tools:
print(f" - {tool['name']}: {tool.get('description', 'N/A')}")
# 测试调用一个工具 (read_file)
if tools:
print("\n测试调用工具...")
# 创建测试文件
test_file = "/tmp/mcp_test.txt"
with open(test_file, "w") as f:
f.write("Hello MCP!")
call_tool_request = {
"jsonrpc": "2.0",
"id": 3,
"method": "tools/call",
"params": {
"name": "read_file",
"arguments": {"path": test_file}
}
}
process.stdin.write(json.dumps(call_tool_request) + "\n")
process.stdin.flush()
response = json.loads(process.stdout.readline())
if "result" in response:
print(f"✓ 工具调用成功: {response['result']}")
print("\n✅ MCP 工具调用验证通过!")
process.terminate()
return True
else:
print(f"❌ 工具调用失败: {response.get('error')}")
process.terminate()
return False
except Exception as e:
print(f"\n❌ 异常: {e}")
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
success = asyncio.run(test_mcp_tools())
import sys
sys.exit(0 if success else 1)
```
**验收标准**:
- [ ] 可以列出工具
- [ ] 可以调用工具
- [ ] 结果解析正确
**运行测试**:
```bash
python poc_3_tools.py
```
---
### PoC 3 总结
**验证结果**:
- [ ] MCP Server 可以启动
- [ ] 协议通信正常
- [ ] 工具调用成功
- [ ] 进程管理可控
**发现的问题**:
1.
2.
**结论**:
- [ ] ✅ MCP 集成可行
- [ ] ⚠️ 需要解决的问题:
- [ ] ❌ 不可行，需要替代方案
---
## 总体结论
完成所有 PoC 后，填写总体评估：
### PoC 验证总结
| PoC | 状态 | 结论 | 备注 |
|-----|------|------|------|
| Claude CLI 集成 | ⏸️ | - | - |
| 智能路由算法 | ⏸️ | - | - |
| MCP Server 加载 | ⏸️ | - | - |
### 风险评估更新
原有风险的验证结果:
1. **Claude CLI集成复杂** (原风险等级: 高)
- PoC 结果: ____
- 新风险等级: ____
- 建议: ____
2. **智能路由效果不佳** (原风险等级: 中)
- PoC 结果: ____
- 新风险等级: ____
- 建议: ____
3. **MCP Server不稳定** (原风险等级: 中)
- PoC 结果: ____
- 新风险等级: ____
- 建议: ____
### 下一步建议
基于 PoC 结果:
- [ ] ✅ 所有验证通过，可以开始 Phase 0 正式开发
- [ ] ⚠️ 部分通过，需要调整设计后开发
- [ ] ❌ 关键技术不可行，需要重新规划
具体行动:
1.
2.
3.
---
**文档结束**
Reference in New Issue Copy Permalink