precis-cli 0.1.3__py3-none-any.whl

app/api/routers/ai/stream.py

@@ -0,0 +1,281 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""@fileoverview AI 流式 SSE 端点
+
+把后端流式内核(StreamingOrchestrator + EventJournal + sse_event_stream)
+暴露为 HTTP SSE 端点。
+
+端点:
+- POST /ai/chat/stream: 聊天流式,包装 ChatAgentRunner
+- POST /ai/jobs/{job_id}/cancel: 取消正在运行的 job(软取消)
+
+设计要点:
+- 每个流式请求: 创建 job_id → 启动 orchestrator 后台 task → 返回 SSE StreamingResponse
+- 取消信号: 内存中 _cancel_events 字典(job_id → asyncio.Event)
+- Last-Event-ID: 仅作为本连接内 journal 回放的起始游标（§2.8）；不支持跨连接断线续传——
+  每次请求都新建 job_id 与 journal,重连等价于重新发起会话(真续传需 job 持久化+按 job_id 重连端点,属未来 feature)
+- 资源清理: orchestrator 结束后注销 cancel_event,防止内存泄漏
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+import uuid
+from collections.abc import AsyncIterator
+from typing import Any
+
+from fastapi import Header, HTTPException
+from fastapi.responses import StreamingResponse
+
+from app.shared.services.ai.streaming.event_journal import EventJournal
+from app.shared.services.ai.streaming.orchestrator import StreamingOrchestrator
+from app.shared.services.ai.streaming.pending_interaction_store import (
+    ConfirmController,
+    InteractionController,
+    get_global_pending_interaction_store,
+)
+from app.shared.services.ai.streaming.sse_response import sse_event_stream
+from app.shared.services.llm.config import loader
+from app.shared.services.llm.providers.registry import create
+
+from .models import AiChatConfirmRequest, AiChatRequest, AiChatRespondRequest
+from .router import router
+
+logger = logging.getLogger(__name__)
+
+# 内存中保存运行中 job 的取消信号: job_id → asyncio.Event
+# orchestrator 结束后通过 _unregister_cancel_event 移除,防止内存泄漏
+_cancel_events: dict[str, asyncio.Event] = {}
+_cancel_events_lock = threading.Lock()
+
+# 后台 orchestrator task 的强引用集合：防止 task 被 GC 回收（Python asyncio 已知行为）
+# task 完成后通过 add_done_callback 自动从集合移除
+_background_tasks: set[asyncio.Task[None]] = set()
+
+# journal 存储目录基础(按项目 config_path 分片),复用 AgentJobStorage 的 .precis 约定
+# 实际路径在端点中按 project_path 拼接
+
+
+def _unregister_cancel_event(job_id: str) -> None:
+    """@methoddesc 从 _cancel_events 移除已完成 job 的取消信号(防内存泄漏)。"""
+    with _cancel_events_lock:
+        _cancel_events.pop(job_id, None)
+
+
+def _journal_dir_for(project_path: str | None) -> str:
+    """@methoddesc 根据项目路径返回 journal 目录(复用项目本地 .precis 约定)。
+
+    无 project_path 时回退到用户级 ~/.precis。
+    """
+    import os
+
+    if project_path:
+        return os.path.join(project_path, ".precis", "stream_jobs")
+    return os.path.join(os.path.expanduser("~"), ".precis", "stream_jobs")
+
+
+@router.post("/chat/stream", summary="AI 聊天流式接口(SSE)")
+async def chat_stream(
+    request: AiChatRequest,
+    x_project_config_path: str | None = Header(None),
+    last_event_id: int = Header(default=0, alias="Last-Event-ID"),
+) -> StreamingResponse:
+    """@methoddesc 聊天流式端点
+
+    流程:
+    1. 加载 Provider 配置并实例化
+    2. 创建 job_id、EventJournal、cancel_event、event_queue
+    3. 启动后台 orchestrator task(并发执行 run_chat)
+    4. 返回 SSE StreamingResponse,从 journal 回放(本连接内) + 实时推送队列
+
+    参数:
+        request: AiChatRequest(复用现有聊天请求模型)
+        x_project_config_path: 项目配置路径 header
+        last_event_id: 本连接内 journal 回放的起始事件号(非断线续传,见 §2.8 声明)
+
+    返回:
+        StreamingResponse(media_type=text/event-stream)
+    """
+    config = loader.load()
+
+    # 校验项目路径（修复 #10：防止 X-Project-Config-Path 任意目录读写）
+    from .utils import validate_project_path
+
+    safe_project_path = validate_project_path(x_project_config_path)
+
+    # 获取默认 provider(与 /chat 端点逻辑一致)
+    provider_id = config.defaults.get("chat")
+    if not provider_id:
+        raise HTTPException(400, detail="尚未设置默认的 AI 模型，请先在设置中选择一个 AI 模型")
+
+    provider_cfg = next((p for p in config.providers if p.id == provider_id), None)
+    if not provider_cfg:
+        raise HTTPException(404, detail=f"未找到对应的 AI 模型配置，可能已被删除（ID: {provider_id}）")
+
+    # 实例化 provider
+    try:
+        provider = create(provider_cfg)
+    except ImportError as e:
+        raise HTTPException(502, detail=f"AI 服务初始化失败，请检查模型配置是否正确（{e}）") from e
+
+    # 创建 job 资源
+    job_id = f"stream_{uuid.uuid4().hex[:12]}"
+    journal_dir = _journal_dir_for(safe_project_path)
+    journal = EventJournal(job_id=job_id, journal_dir=journal_dir)
+
+    cancel_event = asyncio.Event()
+    with _cancel_events_lock:
+        _cancel_events[job_id] = cancel_event
+
+    # 上下文节点与历史转换(与 /chat 端点一致)
+    context_nodes = [node.model_dump() for node in request.context.selectedNodes]
+    # 画布节点快照（供 read_canvas 工具查询画布真实状态）
+    canvas_nodes = [node.model_dump() for node in request.context.canvasNodes]
+    history = [{"role": h.role, "content": h.content} for h in (request.history or [])]
+
+    # 实时事件队列: orchestrator emit 时推入, sse_event_stream 消费
+    event_queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+
+    orchestrator = StreamingOrchestrator(
+        job_id=job_id,
+        journal=journal,
+        cancel_event=cancel_event,
+        event_queue=event_queue,
+    )
+
+    async def _run_orchestrator() -> None:
+        """后台执行 run_chat,结束后注销 cancel_event。"""
+        try:
+            await orchestrator.run_chat(
+                message=request.message,
+                history=history,
+                provider=provider,
+                project_path=safe_project_path,
+                context_nodes=context_nodes,
+                canvas_nodes=canvas_nodes,
+            )
+        finally:
+            _unregister_cancel_event(job_id)
+
+    # 启动后台 task：持有强引用防 GC，完成回调中移除
+    task = asyncio.create_task(_run_orchestrator())
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
+
+    # 返回 SSE 流: 先回放 journal(本连接内,自 last_event_id 起), 再实时推送队列
+    async def _sse_generator() -> AsyncIterator[str]:
+        try:
+            async for frame in sse_event_stream(
+                journal=journal,
+                last_event_id=last_event_id,
+                event_queue=event_queue,
+            ):
+                yield frame
+        finally:
+            # 客户端断连时（StreamingResponse 被取消），通知后台 task 停止
+            # 这让 executor 在下一个取消检查点中断，避免后台 task 泄漏
+            cancel_event.set()
+
+    return StreamingResponse(_sse_generator(), media_type="text/event-stream")
+
+
+@router.post("/jobs/{job_id}/cancel", summary="取消正在运行的 AI job(软取消)")
+async def cancel_job(job_id: str) -> dict[str, str]:
+    """@methoddesc 取消端点(软取消)
+
+    设置 cancel_event 后,orchestrator/executor 在下一个检查点(turn 开始/chunk 间)中断。
+    已落盘的 apply_actions 改动保留,前端轨迹如实显示已执行步数。
+    同步 resolve 挂起的 apply_actions 确认门为 reject。
+
+    参数:
+        job_id: 任务 ID
+
+    返回:
+        {"status": "cancelling"} 或 {"status": "not_found"}
+    """
+    with _cancel_events_lock:
+        ev = _cancel_events.get(job_id)
+    if ev is not None:
+        ev.set()
+        # 同步 resolve 该 job 下所有挂起的交互门（apply→reject, ask→skipped）。
+        # store 同时持有两类 controller，resolve 签名不同，按 isinstance 分别处理。
+        pending_store = get_global_pending_interaction_store()
+        for controller in pending_store.pop_by_job_prefix(job_id):
+            if not controller.is_resolved:
+                if isinstance(controller, ConfirmController):
+                    await controller.resolve("reject")
+                elif isinstance(controller, InteractionController):
+                    await controller.resolve({"skipped": True, "reason": "cancelled"})
+        return {"status": "cancelling"}
+    return {"status": "not_found"}
+
+
+@router.post("/chat/{job_id}/confirm", summary="确认/拒绝挂起的 apply_actions 改动")
+async def confirm_apply(job_id: str, request: AiChatConfirmRequest) -> dict[str, str]:
+    """@methoddesc 确认端点
+
+    用户在前端点击"确认"或"拒绝"后调用。
+    decide 后 resolve ConfirmController 唤醒挂起的 apply_actions 协程。
+
+    参数:
+        job_id: 任务 ID
+        request: 含 decision 字段("confirm" 或 "reject")
+
+    返回:
+        {"status": "resolved", "decision": "confirm"} 或 404
+    """
+    pending_store = get_global_pending_interaction_store()
+    # 优先用 apply_id 精确查找；为空时回退到 job 维度（兼容单 apply 场景）
+    lookup_key = request.apply_id if request.apply_id else job_id
+    controller = pending_store.get(lookup_key)
+    if controller is None:
+        raise HTTPException(404, detail="无挂起的改动(可能已决策或任务已结束)")
+    # /confirm 只处理 apply 确认（ConfirmController）；若拿到 InteractionController 说明 key 冲突，拒绝
+    if not isinstance(controller, ConfirmController):
+        raise HTTPException(409, detail="该交互不是 apply 确认类型，无法用 /confirm 处理")
+    if controller.is_resolved:
+        return {"status": "already_resolved", "decision": controller.decision or "unknown"}
+    await controller.resolve(request.decision)
+    return {"status": "resolved", "decision": request.decision}
+
+
+@router.post("/chat/{job_id}/respond", summary="回答 agent 的 ask_user 提问")
+async def respond_to_ask(job_id: str, request: AiChatRespondRequest) -> dict[str, Any]:
+    """@methoddesc 回答端点
+
+    用户在前端 AskUserCard 提交回答后调用。
+    resolve InteractionController 唤醒挂起的 ask_user 协程。
+
+    参数:
+        job_id: 任务 ID
+        request: 含 ask_id 和 response 字段
+
+    返回:
+        {"ok": true, "already_resolved": false} 或 404（ask_id 不存在）/ 409（类型不符）
+    """
+    pending_store = get_global_pending_interaction_store()
+    controller = pending_store.get(request.ask_id)
+    if controller is None:
+        raise HTTPException(404, detail="提问已过期或不存在(可能已回答或任务已结束)")
+    # /respond 只处理 ask 交互（InteractionController）；若拿到 ConfirmController 说明 key 冲突，拒绝
+    if not isinstance(controller, InteractionController):
+        raise HTTPException(409, detail="该交互不是 ask 提问类型，无法用 /respond 处理")
+    if controller.is_resolved:
+        return {"ok": True, "already_resolved": True}
+    await controller.resolve(request.response)
+    return {"ok": True, "already_resolved": False}

app/api/routers/ai/utils.py

@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview AI 路由通用工具端点模块
+
+功能概述:
+- 提供路径展开工具，支持目录递归、通配符、相对路径解析
+- 用于 AI 配置生成前批量收集数据文件路径
+- 支持基于 X-Project-Config-Path 解析相对路径
+
+架构设计:
+- 纯工具函数，不依赖具体 AI 业务逻辑
+- 自动过滤隐藏目录和常见非数据目录
+- 支持的数据文件类型：.xlsx, .xls, .csv, .json, .jsonl
+
+输入示例:
+    POST /ai/utils/expand-paths
+    ["data/", "*.csv", "./users.xlsx"]
+
+输出示例:
+    [
+        "D:/project/data/users.xlsx",
+        "D:/project/data/orders.csv"
+    ]
+"""
+
+import os
+
+from fastapi import Header
+
+from .router import router
+
+# 支持的数据文件扩展名
+_DATA_EXTENSIONS = {".xlsx", ".xls", ".csv", ".json", ".jsonl"}
+
+# 递归遍历时跳过的目录
+_SKIP_DIRS = {"node_modules", "__pycache__", ".git", ".venv", "venv", ".idea"}
+
+
+def validate_project_path(raw_path: str | None) -> str:
+    """校验 X-Project-Config-Path Header 值是否为合法 Precis 项目根。
+
+    B-sec3: 现委托 app.api.dependencies._validate_project_root（单一事实源），
+    与通用依赖 get_project_config_path 共用同一套校验，消除双套不一致。
+
+    参数:
+        raw_path: Header 原始值
+
+    返回:
+        规范化后的绝对路径
+
+    抛出:
+        HTTPException(400): 校验失败
+    """
+    from app.api.dependencies import _validate_project_root
+
+    return _validate_project_root(raw_path)
+
+
+_MAX_DEPTH = 5
+_MAX_FILES = 1000
+
+
+def _expand_directory(dir_path: str, max_depth: int = _MAX_DEPTH) -> list[str]:
+    """递归展开目录，收集所有数据文件路径
+
+    :param dir_path: 目录绝对路径
+    :param max_depth: 最大递归深度
+    :return: 数据文件路径列表（去重、排序）
+    """
+    result = []
+    for root, dirs, files in os.walk(dir_path):
+        depth = root[len(dir_path) :].count(os.sep)
+        if depth >= max_depth:
+            dirs[:] = []
+            continue
+        dirs[:] = [d for d in dirs if not d.startswith(".") and d not in _SKIP_DIRS]
+        for fname in files:
+            ext = os.path.splitext(fname)[1].lower()
+            if ext in _DATA_EXTENSIONS:
+                result.append(os.path.join(root, fname))
+                if len(result) >= _MAX_FILES:
+                    return result
+    return sorted(result)
+
+
+def _resolve_path(path: str, config_path: str | None) -> str:
+    """解析路径：如果为相对路径，则基于项目配置目录拼接
+
+    :param path: 原始路径（可能是相对或绝对）
+    :param config_path: 项目配置目录（绝对路径），用于解析相对路径
+    :return: 绝对路径
+    """
+    # 如果已经是绝对路径，直接返回
+    if os.path.isabs(path):
+        return path
+
+    # 如果有配置路径，基于配置路径解析相对路径
+    if config_path:
+        base = os.path.dirname(config_path) if os.path.isfile(config_path) else config_path
+        return os.path.normpath(os.path.join(base, path))
+
+    # 兜底：返回原路径
+    return path
+
+
+@router.post(
+    "/utils/expand-paths",
+    response_model=list[str],
+    summary="展开路径列表",
+    responses={
+        500: {"description": "服务器内部错误"},
+    },
+)
+def expand_paths(
+    paths: list[str],
+    x_project_config_path: str | None = Header(None, alias="X-Project-Config-Path"),
+) -> list[str]:
+    """展开路径列表
+
+    支持以下展开方式：
+    - 目录递归展开：自动遍历目录及其子目录，收集所有数据文件
+    - 通配符展开：支持 * 和 ? 通配符
+    - 相对路径解析：基于 X-Project-Config-Path 解析相对路径
+
+    数据文件类型：.xlsx, .xls, .csv, .json, .jsonl
+    """
+    result = []
+    seen = set()
+
+    for raw_path in paths:
+        # 1. 解析为绝对路径
+        path = _resolve_path(raw_path, x_project_config_path)
+
+        # 2. 如果是目录，递归展开
+        if os.path.isdir(path):
+            for file_path in _expand_directory(path):
+                norm = os.path.normpath(file_path)
+                if norm not in seen:
+                    seen.add(norm)
+                    result.append(norm)
+            continue
+
+        # 3. 如果是具体文件，直接保留
+        if os.path.isfile(path):
+            norm = os.path.normpath(path)
+            if norm not in seen:
+                seen.add(norm)
+                result.append(norm)
+            continue
+
+        # 4. 通配符展开
+        if "*" in raw_path or "?" in raw_path:
+            import glob
+
+            for matched in glob.glob(path):
+                if os.path.isfile(matched):
+                    norm = os.path.normpath(matched)
+                    if norm not in seen:
+                        seen.add(norm)
+                        result.append(norm)
+                elif os.path.isdir(matched):
+                    for file_path in _expand_directory(matched):
+                        norm = os.path.normpath(file_path)
+                        if norm not in seen:
+                            seen.add(norm)
+                            result.append(norm)
+
+    return result

app/api/routers/core/__init__.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 核心路由模块包入口
+
+功能概述:
+- 标记 backend/app/api/routers/core 目录为 Python 包
+- 聚合正则工具、报告通知、白名单管理、工作区配置等核心路由
+
+架构设计:
+- 各子模块独立定义 APIRouter 实例
+- 通过 api/routers/__init__.py 统一导入并注册到主应用
+- 核心路由提供不依赖具体项目配置的基础服务能力
+
+输入示例:
+    from app.api.routers.core.regex import router as regex_router
+    from app.api.routers.core.reporting import router as reporting_router
+
+输出示例:
+    无直接输出，仅作为包标记
+"""

app/api/routers/core/connection_rules.py

@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 连接规则 API 路由模块
+
+功能概述:
+- 提供节点连接规则的读取、保存和重置接口
+- 定义节点类型和 handles 之间的允许连接关系
+- 支持 strict（严格）和 loose（宽松）两种验证模式
+
+架构设计:
+- 规则持久化在项目根目录的 connection-rules.precis.yaml
+- 使用 Pydantic 模型验证规则结构和字段
+- 不存在的规则文件返回空规则列表
+
+输入示例:
+    PUT /connection-rules
+    {
+        "version": "1.0",
+        "rules": [
+            {
+                "id": "schema_to_constraint",
+                "name": "Schema -> Constraint",
+                "source": {"node_types": ["SchemaNode"]},
+                "target": {"node_types": ["ConstraintNode"]}
+            }
+        ]
+    }
+
+输出示例:
+    {"message": "连接规则已成功保存！"}
+"""
+
+import logging
+import os
+from pathlib import Path
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from app.api.dependencies import get_project_config_path
+from app.api.models import StandardResponse
+from app.api.models.connection_rules import ConnectionRulesModel
+from app.shared.core.io.yaml import read_yaml, write_yaml_atomic
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    prefix="/api/latest/connection-rules",
+    tags=["Connection Rules"],
+)
+
+CONNECTION_RULES_FILENAME = "connection-rules.precis.yaml"
+
+
+def _rules_path(config_path: str) -> str:
+    return os.path.join(config_path, CONNECTION_RULES_FILENAME)
+
+
+@router.get(
+    "",
+    response_model=ConnectionRulesModel,
+    summary="获取当前项目的连接规则",
+    responses={
+        500: {"description": "加载连接规则失败"},
+    },
+)
+def get_connection_rules(config_path: str = Depends(get_project_config_path)) -> ConnectionRulesModel:
+    """
+    获取当前项目的连接规则。
+
+    使用场景：
+    - 前端初始化画布时加载连接规则，用于限制节点间允许的连接关系
+    - 用户自定义连接规则后重新加载
+
+    副作用：
+    - 如果规则文件不存在，返回默认空规则列表（不报错），保证前端始终能拿到有效数据
+    - 如果解析失败，返回 500 错误并附带详细原因
+
+    参数:
+        config_path: 项目配置根目录（通过 Depends 注入）
+
+    返回:
+        ConnectionRulesModel: 连接规则集合，包含版本号和规则列表
+    """
+    rules_file_path = _rules_path(config_path)
+
+    if not os.path.isfile(rules_file_path):
+        return ConnectionRulesModel(version="1.0", rules=[])
+
+    try:
+        data = read_yaml(Path(rules_file_path))
+        if not data:
+            return ConnectionRulesModel(version="1.0", rules=[])
+
+        return ConnectionRulesModel(**data)
+    except Exception as e:
+        logger.error(f"加载连接规则失败: {e}")
+        raise HTTPException(status_code=500, detail=f"加载连接规则失败: {str(e)}")
+
+
+@router.put(
+    "",
+    response_model=StandardResponse,
+    summary="保存当前项目的连接规则",
+    responses={
+        500: {"description": "保存连接规则失败"},
+    },
+)
+def save_connection_rules(
+    rules: ConnectionRulesModel, config_path: str = Depends(get_project_config_path)
+) -> dict[str, str]:
+    """
+    保存当前项目的连接规则。
+
+    使用场景：
+    - 用户在设置面板中修改连接规则后保存
+    - 前端通过可视化编辑器调整节点连接限制后持久化
+
+    副作用：
+    - 直接覆盖写入 connection-rules.precis.yaml 文件
+    - 使用 exclude_unset=True 避免将未设置的字段写入文件，保持 YAML 整洁
+
+    参数:
+        rules: 新的连接规则集合
+        config_path: 项目配置根目录（通过 Depends 注入）
+
+    返回:
+        StandardResponse: 操作结果消息
+    """
+    rules_file_path = _rules_path(config_path)
+
+    try:
+        data = rules.model_dump(exclude_unset=True)
+        write_yaml_atomic(Path(rules_file_path), data)
+        return {"message": "连接规则已成功保存！"}
+    except Exception as e:
+        logger.error(f"保存连接规则失败: {e}")
+        raise HTTPException(status_code=500, detail=f"保存连接规则失败: {str(e)}")
+
+
+@router.post(
+    "/reset",
+    response_model=StandardResponse,
+    summary="重置连接规则为默认值",
+    responses={
+        500: {"description": "重置连接规则失败"},
+    },
+)
+def reset_connection_rules(config_path: str = Depends(get_project_config_path)) -> dict[str, str]:
+    """
+    重置连接规则为默认值。
+
+    使用场景：
+    - 用户自定义规则后出现问题，需要恢复系统默认的连接规则
+    - 清理项目中的连接规则配置
+
+    副作用：
+    - 删除项目根目录下的 connection-rules.precis.yaml 文件
+    - 删除后，前端应回退到内置的默认连接规则
+
+    参数:
+        config_path: 项目配置根目录（通过 Depends 注入）
+
+    返回:
+        StandardResponse: 操作结果消息
+    """
+    rules_file_path = _rules_path(config_path)
+
+    try:
+        if os.path.isfile(rules_file_path):
+            os.remove(rules_file_path)
+        return {"message": "连接规则已重置为默认值"}
+    except Exception as e:
+        logger.error(f"重置连接规则失败: {e}")
+        raise HTTPException(status_code=500, detail=f"重置连接规则失败: {str(e)}")