precis-cli 0.1.5__tar.gz → 0.1.7__tar.gz

{precis_cli-0.1.5 → precis_cli-0.1.7}/MANIFEST.in

@@ -1,3 +1,2 @@
 include README.md
 include pyproject.toml
-recursive-include app *.yaml

{precis_cli-0.1.5 → precis_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: precis-cli
-Version: 0.1.5
+Version: 0.1.7
 Summary: Precis - 可配置数据校验工具 CLI（校验 CSV/Excel/JSON 数据质量）
 Author: Precis Team
 License: Apache-2.0

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/api/routers/ai/providers.py

@@ -58,8 +58,10 @@ def _is_configured(p: AIProvider) -> bool:
     """判断 Provider 是否已配置。
 
     loader.load() 已完成 env-var 覆盖，直接检查 api_key 即可。
-    本地 Provider（Ollama）不需要 API Key。
+    本地 Provider（Ollama）不需要 API Key；fake 是确定性测试 Provider，永不依赖 key。
     """
+    if p.type == ProviderType.FAKE:
+        return True
     if p.deployment == DeploymentType.LOCAL:
         return bool(p.base_url)
     return bool(p.api_key and p.api_key.strip())
@@ -141,7 +143,7 @@ providers:
     type: openai
     base_url: https://api.deepseek.com
     api_key: ${DEEPSEEK_API_KEY}
-    model: deepseek-v4-pro
+    model: deepseek-flash
 
   # 本地 Ollama（无需 API Key）
   - id: ollama-local
@@ -391,7 +393,10 @@ async def create_provider(req: CreateProviderRequest) -> ProviderResponse:
     try:
         provider_type = ProviderType(req.type)
     except ValueError:
-        raise HTTPException(400, detail=f"不支持的 AI 服务类型「{req.type}」，目前仅支持 openai、ollama 两种接入方式")
+        raise HTTPException(
+            400,
+            detail=f"不支持的 AI 服务类型「{req.type}」，目前支持 openai、ollama 两种接入方式（fake 仅用于测试演练）",
+        )
 
     _validate_base_url(req.base_url)  # SSRF 防护
 

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shared_services/config_ops.py

@@ -41,6 +41,7 @@
 from __future__ import annotations
 
 import logging
+import math
 import os
 import tempfile
 from collections.abc import Iterator
@@ -207,6 +208,10 @@ def resolve_config_file(project_path: str, filename: str | None) -> tuple[str |
 def get_by_dotpath(data: dict, key_path: str) -> tuple[bool, Any]:
     """按点号路径从字典中查找值。
 
+    YAML 键可为非字符串（如 ``2024:`` 解析为 int、``true:`` 解析为 bool）——
+    路径段除精确匹配外也按字符串形态匹配非字符串键，防止"键存在却查不到"
+    进而被 set 侧写出同形态影子键。
+
     Args:
         data: 配置字典
         key_path: 点号路径，如 "project.name"
@@ -217,8 +222,16 @@ def get_by_dotpath(data: dict, key_path: str) -> tuple[bool, Any]:
     keys = key_path.split(".")
     value: Any = data
     for key in keys:
-        if isinstance(value, dict) and key in value:
-            value = value[key]
+        if isinstance(value, dict):
+            if key in value:
+                value = value[key]
+                continue
+            for k, v in value.items():
+                if not isinstance(k, str) and str(k) == key:
+                    value = v
+                    break
+            else:
+                return False, None
         else:
             return False, None
     return True, value
@@ -227,7 +240,8 @@ def get_by_dotpath(data: dict, key_path: str) -> tuple[bool, Any]:
 def set_by_dotpath(data: dict, key_path: str, value: Any) -> dict:
     """按点号路径写入值，返回新 data（不改原 dict）。
 
-    中间层级不存在时自动创建空字典。
+    中间层级不存在时自动创建空字典；路径段与既有非字符串键（如 int ``2024``）
+    字符串形态相同时复用原键，防止写出同形态影子键并存。
 
     Args:
         data: 原配置字典（不会被修改）
@@ -244,10 +258,21 @@ def set_by_dotpath(data: dict, key_path: str, value: Any) -> dict:
     keys = key_path.split(".")
     current = new_data
     for key in keys[:-1]:
-        if key not in current or not isinstance(current[key], dict):
-            current[key] = {}
-        current = current[key]
-    current[keys[-1]] = value
+        existing = current.get(key)
+        if isinstance(existing, dict):
+            current = existing
+            continue
+        # 同形态非字符串键复用（写原键而非另建字符串影子键）
+        non_str_key = next((k for k in current if not isinstance(k, str) and str(k) == key), None)
+        if non_str_key is not None and isinstance(current[non_str_key], dict):
+            current = current[non_str_key]
+            continue
+        target = non_str_key if non_str_key is not None else key
+        current[target] = {}
+        current = current[target]
+    leaf = keys[-1]
+    leaf_key = next((k for k in current if not isinstance(k, str) and str(k) == leaf), leaf)
+    current[leaf_key] = value
     return new_data
 
 
@@ -267,8 +292,9 @@ def parse_config_value(value_str: str) -> tuple[bool, Any, str]:
         value_str: 原始字符串值
 
     Returns:
-        (成功, 转换后的值, 错误信息)；本实现始终成功，错误信息为空字符串。
-        保留 tuple 三元组以匹配接口契约，便于未来扩展严格模式。
+        (成功, 转换后的值, 错误信息)；毒化字面量（inf/nan/下划线整数等
+        无法被下游安全消费的数值形态）返回 (False, None, 错误信息)，
+        调用方应拒绝落盘。
     """
     # 尝试布尔值
     if value_str.lower() == "true":
@@ -278,17 +304,24 @@ def parse_config_value(value_str: str) -> tuple[bool, Any, str]:
     if value_str.lower() == "null" or value_str.lower() == "none":
         return True, None, ""
 
-    # 尝试整数
-    try:
-        return True, int(value_str), ""
-    except ValueError:
-        pass
+    # 尝试整数：拒绝 Python 下划线字面量（'1_0' 静默变 10 会毒化下游数值读取）
+    if "_" not in value_str:
+        try:
+            return True, int(value_str), ""
+        except ValueError:
+            pass
 
-    # 尝试浮点数
-    try:
-        return True, float(value_str), ""
-    except ValueError:
-        pass
+    # 尝试浮点数：拒绝非有限值（inf/nan/溢出 1e999）与下划线字面量——
+    # timeout_seconds: .inf 落盘后 validate 侧 int(inf) 抛 OverflowError，项目从此无法校验
+    if "_" not in value_str:
+        try:
+            parsed_float = float(value_str)
+        except ValueError:
+            parsed_float = None
+        if parsed_float is not None:
+            if not math.isfinite(parsed_float):
+                return False, None, f"不接受非有限数值: {value_str}（inf/nan 落盘会使项目无法校验）"
+            return True, parsed_float, ""
 
     # 去除引号
     if (value_str.startswith('"') and value_str.endswith('"')) or (

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shared_services/generation_ops.py

@@ -36,6 +36,7 @@ from __future__ import annotations
 import glob
 import logging
 import os
+import re
 from pathlib import Path
 from typing import Any
 
@@ -46,6 +47,25 @@ logger = logging.getLogger(__name__)
 # 支持的文件扩展名（generate/migrate 共用）
 SUPPORTED_EXTENSIONS = (".xlsx", ".xls", ".csv", ".json", ".jsonl")
 
+# 实体 id 安全白名单：字母/数字/下划线/连字符（H10——LLM 生成的 id 未消毒即拼盘
+# 路径时，`../../evil` 类路径成分可越项目写文件/建目录，写盘前须拒绝）
+_SAFE_ENTITY_ID_RE = re.compile(r"[A-Za-z0-9_-]+")
+
+
+def _filter_safe_entity_ids(entities: dict[str, Any], kind: str) -> dict[str, Any]:
+    """过滤掉含路径成分或非法字符的实体 id，记录错误日志（H10）。
+
+    Returns:
+        仅保留安全 id 的实体字典；非法 id 整体跳过（不写盘、不进 manifest 引用）
+    """
+    safe: dict[str, Any] = {}
+    for eid, body in entities.items():
+        if isinstance(eid, str) and _SAFE_ENTITY_ID_RE.fullmatch(eid):
+            safe[eid] = body
+        else:
+            logger.error("跳过非法实体 id（含路径成分或非法字符，kind=%s）: %r", kind, eid)
+    return safe
+
 
 def scan_data_files(patterns: list[str], project_path: str) -> list[str]:
     """展开数据文件路径（支持通配符、相对路径、data/ 目录扫描）。
@@ -91,8 +111,9 @@ def scan_data_files(patterns: list[str], project_path: str) -> list[str]:
 def apply_generated_config(result: dict[str, Any], project_path: str) -> list[str]:
     """将生成的配置写入项目目录。
 
-    会保留现有 project.precis.yaml 中的 transforms/manual_data 等引用，
-    覆盖写入 schemas、constraints、regex_nodes。
+    保留策略为并集（R6）：生成 manifest 未携带的既有顶层键（project/settings/
+    templates/data_sources 等）一律保留，防止空/局部 manifest 清空既有配置；
+    schemas、constraints、regex_nodes 引用则始终按生成结果覆盖写入。
 
     Args:
         result: ConfigGenerationService / ConfigMigrationService 返回的配置字典
@@ -111,16 +132,24 @@ def apply_generated_config(result: dict[str, Any], project_path: str) -> list[st
         except Exception:
             logger.warning("读取现有 manifest 失败，将覆盖写入", exc_info=True)
 
-    manifest = result.get("manifest") or {"version": 2, "project": {"id": "", "name": ""}}
-
-    # 保留现有 manifest 中生成未覆盖的引用
-    for key in ("transforms", "manual_data"):
-        if key in existing_manifest and key not in manifest:
-            manifest[key] = existing_manifest[key]
-
-    schemas = result.get("schemas", {})
-    constraints = result.get("constraints", {})
-    regex_nodes = result.get("regex_nodes", {})
+    generated_manifest = result.get("manifest")
+    if generated_manifest:
+        manifest = dict(generated_manifest)
+    else:
+        # LLM 未返回 manifest：以现有 manifest 为底仅补最小骨架，
+        # 不再制造空 project 兜底清空既有 project.id/settings（R6）
+        manifest = dict(existing_manifest)
+        manifest.setdefault("version", 2)
+        manifest.setdefault("project", {"id": "", "name": ""})
+
+    # 保留策略并集（R6）：生成 manifest 未携带的既有键一律保留
+    for key, value in existing_manifest.items():
+        if key not in manifest:
+            manifest[key] = value
+
+    schemas = _filter_safe_entity_ids(result.get("schemas", {}) or {}, "schema")
+    constraints = _filter_safe_entity_ids(result.get("constraints", {}) or {}, "constraint")
+    regex_nodes = _filter_safe_entity_ids(result.get("regex_nodes", {}) or {}, "regex")
 
     # 确保目录存在
     (Path(project_path) / "schemas").mkdir(exist_ok=True)

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shared_services/project_ops.py

@@ -51,10 +51,25 @@ HISTORY_FILE = os.path.expanduser("~/.precis_project_history")
 MAX_HISTORY = 10
 
 
+def _backup_corrupt_history() -> None:
+    """把损坏的历史文件改名备份（.corrupt.bak），失败仅记日志。
+
+    原实现在 JSON 损坏后静默按空历史继续——下次保存直接覆盖，
+    用户历史不可恢复；备份保留现场供手工抢救。
+    """
+    try:
+        backup = f"{HISTORY_FILE}.corrupt.bak"
+        os.replace(HISTORY_FILE, backup)
+        logger.warning("项目历史文件损坏，已备份到 %s 并从空历史继续", backup)
+    except OSError:
+        logger.error("备份损坏的项目历史文件失败: %s", HISTORY_FILE, exc_info=True)
+
+
 def load_history() -> list[dict]:
     """加载项目打开历史。
 
     从 HISTORY_FILE 读取历史记录。文件不存在、格式损坏或权限不足时返回空列表。
+    JSON 损坏时先把原文件备份为 ``*.corrupt.bak`` 再按空历史继续（不静默清零）。
 
     Returns:
         历史记录列表，每个元素为包含 path 和 last_opened 的字典
@@ -78,7 +93,8 @@ def load_history() -> list[dict]:
                 return valid
             return []
     except json.JSONDecodeError:
-        # JSON 格式损坏，返回空列表
+        # JSON 格式损坏：备份后按空历史继续
+        _backup_corrupt_history()
         return []
     except PermissionError:
         # 无权限读取，返回空列表
@@ -91,7 +107,8 @@ def load_history() -> list[dict]:
 def _save_history(history: list[dict]) -> None:
     """保存项目打开历史。
 
-    将历史记录写入 HISTORY_FILE。保存失败仅记录日志，不阻断主流程。
+    原子写（临时文件 + os.replace）：进程中断不会留下半截 JSON——
+    半截文件在下次 load 即被判损坏。保存失败仅记录日志，不阻断主流程。
 
     Args:
         history: 历史记录列表
@@ -99,8 +116,10 @@ def _save_history(history: list[dict]) -> None:
     try:
         # 确保目录存在（用户主目录）
         os.makedirs(os.path.dirname(HISTORY_FILE), exist_ok=True)
-        with open(HISTORY_FILE, "w", encoding="utf-8") as f:
+        tmp_file = f"{HISTORY_FILE}.tmp"
+        with open(tmp_file, "w", encoding="utf-8") as f:
             json.dump(history, f, ensure_ascii=False, indent=2)
+        os.replace(tmp_file, HISTORY_FILE)
     except (PermissionError, OSError):
         # 保存失败时记录错误日志，但不阻断主流程
         logger.error("保存项目历史记录失败", exc_info=True)

precis_cli-0.1.7/app/cli/shell/commands/ai/agent_interaction.py

@@ -0,0 +1,210 @@
+# 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 Agent 模式终端交互适配器（CLI）
+
+为 CLI `ai chat`（默认 agent 模式）提供 apply_actions 两阶段确认与 ask_user
+交互问答的终端实现，解开非流式环境的 fail-closed 写盘/提问闸门。
+
+机制与 GUI 流式路径同源：回调在事件循环协程内触发（on_apply_pending /
+on_user_input_requested），此处打印摘要后在独立 daemon 线程阻塞读终端输入，
+经 pending interaction store 线程安全 resolve 唤醒挂起的 await_decision() /
+await_response()。超时（5 分钟）由 controller 兜底自动 reject/skip。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+from typing import Any
+
+from app.cli.shell.commands.ai.executor_utils import SpinnerController
+from app.cli.shell.formatter import Formatter
+from app.shared.services.ai.agent.chat_tools.apply_actions import ApplyCallbacks
+from app.shared.services.ai.agent.chat_tools.ask_user import AskCallbacks
+
+logger = logging.getLogger(__name__)
+
+# 终端 diff 展示上限：超长 diff 只显示前 N 行，避免刷屏（完整内容在 dry-run 文件里）
+_MAX_DIFF_LINES = 30
+
+
+def build_agent_interaction(spinner: SpinnerController | None) -> tuple[ApplyCallbacks, AskCallbacks]:
+    """构建 CLI 终端的 apply/ask 回调集合。
+
+    参数:
+        spinner: CLI 交互模式的 spinner 控制器（None 表示无动画，静默模式）
+
+    返回:
+        (ApplyCallbacks, AskCallbacks)，注入 ChatOptions 后经 ChatAgentRunner 生效
+    """
+
+    def on_apply_pending(payload: dict[str, Any]) -> None:
+        # 回调在事件循环协程内同步触发，捕获运行中的 loop 供工作线程 resolve
+        loop = asyncio.get_running_loop()
+        apply_id = payload.get("apply_id", "")
+        if spinner:
+            spinner.pause()
+        _print_apply_summary(payload)
+
+        def _worker() -> None:
+            decision = _read_apply_decision()
+            try:
+                future = asyncio.run_coroutine_threadsafe(_resolve_apply(apply_id, decision), loop)
+                future.result(timeout=10)
+            except Exception:
+                logger.exception("[agent-confirm] 终端确认 resolve 失败: apply_id=%s", apply_id)
+            finally:
+                if spinner:
+                    spinner.resume()
+
+        threading.Thread(target=_worker, daemon=True, name="agent-apply-confirm").start()
+
+    def on_user_input_requested(payload: dict[str, Any]) -> None:
+        loop = asyncio.get_running_loop()
+        ask_id = payload.get("ask_id", "")
+        if spinner:
+            spinner.pause()
+        _print_ask_question(payload)
+
+        def _worker() -> None:
+            response = _read_ask_response(payload)
+            try:
+                future = asyncio.run_coroutine_threadsafe(_resolve_ask(ask_id, response), loop)
+                future.result(timeout=10)
+            except Exception:
+                logger.exception("[agent-ask] 终端问答 resolve 失败: ask_id=%s", ask_id)
+            finally:
+                if spinner:
+                    spinner.resume()
+
+        threading.Thread(target=_worker, daemon=True, name="agent-ask-input").start()
+
+    apply_callbacks = ApplyCallbacks(on_apply_pending=on_apply_pending)
+    ask_callbacks = AskCallbacks(on_user_input_requested=on_user_input_requested)
+    return apply_callbacks, ask_callbacks
+
+
+async def _resolve_apply(apply_id: str, decision: str) -> None:
+    """按 apply_id 从全局 store 取 controller 并写入决策（幂等）。"""
+    # 延迟导入与 apply_actions._run_two_phase 一致（避免 streaming 包初始化链循环导入）
+    from app.shared.services.ai.streaming.pending_interaction_store import (
+        ConfirmController,
+        get_global_pending_interaction_store,
+    )
+
+    controller = get_global_pending_interaction_store().get(apply_id)
+    if isinstance(controller, ConfirmController):
+        await controller.resolve(decision)
+
+
+async def _resolve_ask(ask_id: str, response: dict[str, Any]) -> None:
+    from app.shared.services.ai.streaming.pending_interaction_store import (
+        InteractionController,
+        get_global_pending_interaction_store,
+    )
+
+    controller = get_global_pending_interaction_store().get(ask_id)
+    if isinstance(controller, InteractionController):
+        await controller.resolve(response)
+
+
+def _print_apply_summary(payload: dict[str, Any]) -> None:
+    """打印写盘计划摘要：文件清单 + 状态 + 截断 diff + 汇总行。"""
+    files = payload.get("files") or []
+    print(Formatter.warning(f"\nAI 请求写入 {len(files)} 个文件："))
+    for f in files:
+        status = f.get("status", "?")
+        path = f.get("path", "?")
+        print(f"  [{status}] {path}")
+        diff = (f.get("diff") or "").strip()
+        if diff:
+            diff_lines = diff.splitlines()
+            shown = diff_lines[:_MAX_DIFF_LINES]
+            for line in shown:
+                print(f"      {line}")
+            if len(diff_lines) > _MAX_DIFF_LINES:
+                print(f"      ...（共 {len(diff_lines)} 行，已截断）")
+    summary = payload.get("summary")
+    if summary:
+        print(Formatter.info(f"  摘要: {summary}"))
+
+
+def _read_apply_decision() -> str:
+    """读取 y/n 决策；空输入与非 y 输入一律 reject（写盘默认保守）。"""
+    try:
+        raw = input(Formatter.warning("确认写入以上变更？[y/N]: ")).strip().lower()
+    except EOFError:
+        return "reject"
+    return "confirm" if raw in ("y", "yes", "是") else "reject"
+
+
+def _print_ask_question(payload: dict[str, Any]) -> None:
+    print(Formatter.warning(f"\nAI 提问: {payload.get('prompt', '')}"))
+    options = payload.get("options")
+    if isinstance(options, list) and options:
+        for idx, opt in enumerate(options, start=1):
+            print(f"  {idx}. {opt}")
+    if payload.get("optional"):
+        print(Formatter.info("  （直接回车跳过此问题）"))
+
+
+def _read_ask_response(payload: dict[str, Any]) -> dict[str, Any]:
+    """按 question_type 读取终端回答，构造 AskResponseBody 形态。
+
+    形态与前端 AskUserCard 一致：{answer: str|num|bool|str[]} / {skipped: true, reason}。
+    """
+    question_type = payload.get("question_type", "free_text")
+    optional = bool(payload.get("optional"))
+    try:
+        if question_type == "confirm":
+            raw = input("[y/N]: ").strip().lower()
+            return {"answer": raw in ("y", "yes", "是")}
+        if question_type == "choice":
+            options = payload.get("options") or []
+            raw = input(("(多选，逗号分隔) " if payload.get("multiple") else "") + "选项编号: ").strip()
+            if not raw and optional:
+                return {"skipped": True, "reason": "user_skipped"}
+            indexes = [part.strip() for part in raw.split(",") if part.strip()]
+            picked: list[str] = []
+            for part in indexes:
+                if part.isdigit() and 1 <= int(part) <= len(options):
+                    picked.append(str(options[int(part) - 1]))
+                else:
+                    picked.append(part)
+            if payload.get("multiple"):
+                return {"answer": picked}
+            return {"answer": picked[0] if picked else ""}
+        if question_type == "value":
+            value_type = payload.get("value_type", "string")
+            raw = input(f"输入值({value_type}): ").strip()
+            if not raw and optional:
+                return {"skipped": True, "reason": "user_skipped"}
+            if value_type in ("integer", "float"):
+                try:
+                    return {"answer": float(raw) if value_type == "float" else int(raw)}
+                except ValueError:
+                    return {"answer": raw}
+            if value_type == "boolean":
+                return {"answer": raw.lower() in ("y", "yes", "true", "1", "是")}
+            return {"answer": raw}
+        # free_text
+        raw = input("回答: ").strip()
+        if not raw and optional:
+            return {"skipped": True, "reason": "user_skipped"}
+        return {"answer": raw}
+    except EOFError:
+        return {"skipped": True, "reason": "eof"}

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shell/commands/ai/chat.py

@@ -258,8 +258,6 @@ AI 助手帮助
   qq           - 直接退出整个程序（全局可用）
 
 启动选项:
-    --stream         - 启用流式输出
-    --no-stream      - 禁用流式输出（默认，显示 loading spinner）
     --no-agent-mode  - 关闭 Agent 深度模式（降级为旧 JSON actions 路径）
 
 你可以用自然语言描述你的需求，例如:
@@ -277,6 +275,8 @@ AI 助手帮助
   - ForeignKey: 外键约束 (如: "关联到 orders 表的 user_id 列")
   - Conditional: 条件约束 (如: "如果 type 等于 A 则值为 B")
   - DateLogic: 日期逻辑约束 (如: "日期晚于 2023-01-01")
+  - Charset: 字符集约束 (如: "该列只能包含中文")
+  - Composite: 复合约束 (如: "该列必须非空且唯一")
         """
         print(Formatter.info(help_text))
 

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shell/commands/ai/executor.py

@@ -125,6 +125,15 @@ def execute_ai_chat(
     context_window = resolve_context_window(provider_config)
     max_history_tokens, _output_budget = compute_token_budgets(context_window)
 
+    # Agent 模式终端交互：注入 apply/ask 回调解开 fail-closed 写盘/提问闸门
+    # （非交互或 legacy JSON 路径不需要——legacy 走 confirm_callback 确认门）
+    agent_apply_callbacks = None
+    agent_ask_callbacks = None
+    if interactive and agent_mode:
+        from app.cli.shell.commands.ai.agent_interaction import build_agent_interaction
+
+        agent_apply_callbacks, agent_ask_callbacks = build_agent_interaction(spinner)
+
     # 配置对话选项
     options = ChatOptions(
         history=history or [],
@@ -137,6 +146,9 @@ def execute_ai_chat(
         agent_mode=agent_mode,
         max_agent_iterations=5,
         canvas_nodes=[],
+        apply_callbacks=agent_apply_callbacks,
+        ask_callbacks=agent_ask_callbacks,
+        dry_run_enabled=agent_apply_callbacks is not None,
     )
 
     try:

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shell/commands/ai/generate.py

@@ -53,6 +53,7 @@ from app.cli.shared_services.generation_ops import (
 )
 from app.cli.shell.commands.base import Command, CommandResult, ProjectContext
 from app.cli.shell.formatter import Formatter
+from app.shared.core.utils.path_utils import display_relpath
 from app.shared.services.llm.generation import (
     ConfigGenerationService,
     GenerationOptions,
@@ -200,7 +201,7 @@ class AIGenerateCommand(Command):
         print(Formatter.info(f"迭代次数: {max_iterations}"))
         print(Formatter.info("数据文件:"))
         for p in file_paths:
-            print(f"  - {os.path.relpath(p, project_path)}")
+            print(f"  - {display_relpath(p, project_path)}")
 
         def progress_callback(stage: str, progress: float, extra: dict[str, Any] | None = None) -> None:
             """终端进度回调。"""

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shell/commands/ai/migrate.py

@@ -51,6 +51,7 @@ from app.cli.shared_services.generation_ops import (
 )
 from app.cli.shell.commands.base import Command, CommandResult, ProjectContext
 from app.cli.shell.formatter import Formatter
+from app.shared.core.utils.path_utils import display_relpath
 from app.shared.services.ai.migrate_service import ConfigMigrationService
 from app.shared.services.llm.generation import (
     GenerationOptions,
@@ -72,6 +73,10 @@ def _infer_language(file_path: str) -> str:
     return "natural_language"
 
 
+# --language 可选值（与 usage 声明一致）
+_SUPPORTED_LANGUAGES = ("python", "sql", "excel_formula", "natural_language")
+
+
 class AIMigrateCommand(Command):
     """AI 配置迁移命令。
 
@@ -171,6 +176,9 @@ class AIMigrateCommand(Command):
 
         if language is None:
             language = _infer_language(script_path)
+        elif language not in _SUPPORTED_LANGUAGES:
+            # 枚举校验：非法值前置拒绝（usage 已声明可选值），不透传下游晦涩报错
+            return CommandResult.error(f"--language 仅支持 {'|'.join(_SUPPORTED_LANGUAGES)}，收到: {language}")
 
         try:
             with open(script_path, encoding="utf-8") as f:
@@ -202,10 +210,10 @@ class AIMigrateCommand(Command):
 
         print(Formatter.header("\nAI 配置迁移"))
         print(Formatter.info(f"项目: {project_name}"))
-        print(Formatter.info(f"脚本: {os.path.relpath(script_path, project_path)} ({language})"))
+        print(Formatter.info(f"脚本: {display_relpath(script_path, project_path)} ({language})"))
         print(Formatter.info("数据文件:"))
         for p in file_paths:
-            print(f"  - {os.path.relpath(p, project_path)}")
+            print(f"  - {display_relpath(p, project_path)}")
 
         def progress_callback(stage: str, progress: float, extra: dict[str, Any] | None = None) -> None:
             """终端进度回调。"""

{precis_cli-0.1.5 → precis_cli-0.1.7}/app/cli/shell/commands/ai/switch.py

@@ -58,19 +58,20 @@ class AISwitchCommand(Command):
 
     @property
     def usage(self) -> str:
-        return "ai switch <provider_id>"
+        return "ai switch [provider_id]"
 
     @property
     def help_text(self) -> str:
         return """
-用法: ai switch <provider_id>
+用法: ai switch [provider_id]
 
 示例:
-  ai switch openai   # 切换到 OpenAI
-  ai switch kimi     # 切换到 Kimi
+  ai switch             # 交互式选择 Provider（方向键导航）
+  ai switch openai      # 切换到 OpenAI
+  ai switch kimi        # 切换到 Kimi
 
 说明:
-  切换到已配置的 Provider。
+  缺省参数时进入交互式选择；传入 provider_id 时直接切换（大小写不敏感）。
   使用 'ai status' 查看可用的 Provider。
         """.strip()