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

{precis_cli-0.1.6/precis_cli.egg-info → precis_cli-0.1.7}/PKG-INFO

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

{precis_cli-0.1.6 → 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.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.6 → precis_cli-0.1.7}/app/cli/shell/commands/ai/chat.py

@@ -275,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.6 → 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.6 → precis_cli-0.1.7}/app/cli/shell/commands/provider.py

@@ -576,7 +576,7 @@ providers:
     type: openai
     base_url: https://api.deepseek.com
     api_key: sk-xxx
-    model: deepseek-v4-flash
+    model: deepseek-flash
 
   # 本地 Ollama（无需 API Key）
   - id: ollama-local

{precis_cli-0.1.6 → precis_cli-0.1.7}/app/cli/shell/commands/validate.py

@@ -111,6 +111,39 @@ def _parse_standalone_args(args: list[str]) -> dict:
     return result
 
 
+def _extract_settings(project_config: dict | None) -> tuple[dict, dict]:
+    """从清单 dump 中提取 (validation, script_security) 设置。
+
+    兼容两种形态：标准清单 dump（settings 嵌套在 "settings" 键下，open 命令
+    的 project_config 即此形态）与直接以 settings 内容为顶层的形态。
+    旧实现读顶层 "validation"/"script_security" 在标准形态下恒 miss。
+    """
+    if not project_config:
+        return {}, {}
+    settings = project_config.get("settings")
+    if isinstance(settings, dict):
+        return settings.get("validation") or {}, settings.get("script_security") or {}
+    return project_config.get("validation") or {}, project_config.get("script_security") or {}
+
+
+def _load_manifest_settings(manifest_path: str) -> tuple[dict, dict]:
+    """轻量读取清单 YAML 的 settings 段，供 standalone 模式使用。
+
+    不做完整模型加载（executor 内部自会加载并报告真正的解析错误）；
+    文件不可读/非 dict 结构时静默回退默认设置。
+    """
+    try:
+        import yaml
+
+        with open(manifest_path, encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+    except Exception:
+        return {}, {}
+    if not isinstance(data, dict):
+        return {}, {}
+    return _extract_settings(data)
+
+
 def _find_dangling_option(args: list[str]) -> str | None:
     """检测缺值的 standalone 选项（尾部悬挂或值位置是下一个选项）。
 
@@ -236,9 +269,9 @@ class ValidateCommand(Command):
         manifest_path = os.path.join(project_path, "project.precis.yaml")
         data_dir = project_path
 
-        # 从项目配置中读取设置
-        validation_settings = context.project_config.get("validation", {}) if context.project_config else {}
-        script_security = context.project_config.get("script_security", {}) if context.project_config else {}
+        # 从项目配置中读取设置（settings 嵌套在清单 dump 的 "settings" 键下；
+        # 旧实现读顶层 "validation" 恒 miss，REPL 模式的 timeout/error_handling 实际从未生效）
+        validation_settings, script_security = _extract_settings(context.project_config)
 
         return self._run_validation(
             manifest_path,
@@ -255,7 +288,8 @@ class ValidateCommand(Command):
         """Standalone 模式执行校验。
 
         直接从命令行参数获取路径，不依赖项目上下文。
-        使用默认设置（timeout=30, 安全沙箱）。
+        读取清单内 settings（validation/script_security），缺省回退默认值
+        （timeout=30 / continue / 安全沙箱）。
 
         Args:
             parsed: 解析后的参数字典，包含 manifest/data_directory/table/format/report
@@ -294,8 +328,14 @@ class ValidateCommand(Command):
 
         table_name = parsed["table"]
 
-        # standalone 模式使用默认设置
-        return self._run_validation(manifest_path, data_dir, table_name, {}, {}, output_format, parsed["report"])
+        # standalone 模式同样读取清单内的 settings（插件/CI 场景改 YAML 的
+        # timeout/error_handling 由此生效；旧实现传空 settings 导致配置被忽略，
+        # 与 SKILL.md "调整超时/错误处理" 的指引矛盾）。清单不可读时退回默认值，
+        # 真正的解析错误由 executor 加载阶段报告。
+        validation_settings, script_security = _load_manifest_settings(manifest_path)
+        return self._run_validation(
+            manifest_path, data_dir, table_name, validation_settings, script_security, output_format, parsed["report"]
+        )
 
     def _run_validation(
         self,

{precis_cli-0.1.6 → precis_cli-0.1.7}/app/shared/services/ai/chat_agent_runner.py

@@ -201,16 +201,19 @@ actionType 可选值（{ACTION_COUNT}种）：
 constraintSpec.params 按类型填充对应字段：
 
 - **NotNull**: 非空约束。参数：无。
-- **Unique**: 唯一约束。参数：无。
+- **Unique**: 唯一约束。单列无需参数；多列联合唯一用 constraintSpec.targetColumns（列名数组，如 ["order_id", "line_no"]）。
 - **AllowedValues**: 允许值约束。参数：`allowedValues` (List[Any])。
-- **Range**: 范围约束。参数：`min` (float/int), `max` (float/int)。
+- **Range**: 范围约束。参数：`min` (float/int), `max` (float/int)（至少一个），`boundaryMode` ("inclusive" 闭区间 / "exclusive" 开区间，默认 inclusive)。
 - **Scripted**: 脚本/正则约束。二选一：`expression` (str, 代码表达式) 或 `pattern` (str, 正则)。
 - **ForeignKey**: 外键约束。参数：`toTableId` (str), `toColumnId` (str)。
-- **Conditional**: 条件约束。参数：`ifConditions` (List), `thenValue` (Any)。
-  - `ifConditions` 结构：`[{{"ifColumnId": "列名", "operator": "eq/ne/gt/lt/in", "value": "比较值"}}]`
-- **DateLogic**: 日期逻辑约束。参数：`logicMode` ("compare"/"calculation"), `compareOp` ("gt/lt/eq/gte/lte/range"), `referenceDate` (str, "YYYY-MM-DD"), `referenceColumn` (str)。当 `compareOp` 为 "range" 时，必须同时提供 `referenceDateEnd` 或 `referenceColumnEnd`。
-- **Charset**: 字符集约束。
-- **Composite**: 组合约束（多列联合）。
+- **Conditional**: 条件约束。参数：`ifConditions` (List), `thenCondition` (Object 或 str，必填)。
+  - `ifConditions` 结构：`[{{"ifColumnId": "列名", "operator": "eq/neq/in/not_null/greater_than/less_than", "value": "比较值", "values": 列表(in 时可选)}}]`
+  - `thenCondition` 两种形态：DSL 对象 `{{"operator": "not_null/greater_than/less_than/in/eq/neq", "value": 比较值, "values": 列表(in 时), "refColumn": "同表参考列(可选，与该列比较)"}}`；或字符串（已注册条件函数名，如 "is_not_empty"）。旧字段 thenValue 已废弃，不要再使用。
+- **DateLogic**: 日期逻辑约束。参数：`logicMode` ("compare"/"calculation")。
+  - compare 模式：`compareOp` ("gt/gte/lt/lte/eq/range"), `referenceDate` (str, "YYYY-MM-DD", 固定日期) 或 `referenceColumn` (str, 参考列，二选一)；`compareOp` 为 "range" 时必须同时提供 `referenceDateEnd` 或 `referenceColumnEnd`（与起点同形态）。
+  - calculation 模式：`calculationType` ("age"/"days_diff"), `targetValue` (数值，必填)；days_diff 另需 `targetColumn` (str, 天数差比较的目标列)。
+- **Charset**: 字符集约束。参数：`charsetMode` ("ascii"/"chinese"/"chinese_mixed"，必填——缺省会创建失败而非默认 ascii)。
+- **Composite**: 复合约束（把多条子约束按逻辑聚合为一条，如"非空且唯一"）。参数：`logic` ("all"/"any"/"none"，默认 all), `subConstraints` (List, 必填，每项 {{"type": 约束类型, "targetColumn": "列名", "params": {{该子约束的参数}}}})；不允许嵌套 Composite。
 
 ## 字段解析约定
 

{precis_cli-0.1.6 → precis_cli-0.1.7}/app/shared/services/ai/chat_orchestrator.py

@@ -26,7 +26,7 @@ import asyncio
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol
 
 from app.shared.services.ai.failure_messages import describe_ai_failure
 from app.shared.services.llm.actions.action_parser import (
@@ -39,6 +39,10 @@ from app.shared.services.llm.chat.response_parser import ActionParser
 from app.shared.services.llm.config.models import AIProvider
 from app.shared.services.llm.providers.base import ChatMessage, ChatRequest
 
+if TYPE_CHECKING:
+    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__)
 
 
@@ -95,6 +99,10 @@ class ChatOptions:
     max_agent_iterations: int = 5
     # 画布节点快照（前端请求体携带，供 read_canvas 工具查询画布真实状态）
     canvas_nodes: list[dict[str, Any]] = field(default_factory=list)
+    # Agent 模式两阶段确认/交互问答回调（CLI 终端注入；HTTP 非流式缺省 → fail-closed 保持）
+    apply_callbacks: ApplyCallbacks | None = None
+    ask_callbacks: AskCallbacks | None = None
+    dry_run_enabled: bool = False
 
 
 @dataclass
@@ -454,6 +462,11 @@ class AIChatOrchestrator:
                 max_iterations=options.max_agent_iterations,
                 max_history_tokens=options.max_history_tokens,
                 canvas_nodes=options.canvas_nodes,
+                # CLI 终端环境经 ChatOptions 注入确认回调后解锁写盘/提问；
+                # HTTP 非流式缺省 None/False → apply_actions/ask_user 保持 fail-closed
+                apply_callbacks=options.apply_callbacks,
+                ask_callbacks=options.ask_callbacks,
+                dry_run_enabled=options.dry_run_enabled,
             )
         except Exception as e:
             logger.error(f"Agent 模式初始化失败: {e}")

{precis_cli-0.1.6 → precis_cli-0.1.7}/app/shared/services/llm/actions/_constraint_validator.py

@@ -103,6 +103,31 @@ def validate_constraint_action(
 
     # 2. 验证字段存在
     column_name = spec.get("targetColumn")
+    multi_columns = spec.get("targetColumns") or spec.get("targetColumnIds") or []
+    if not column_name and isinstance(multi_columns, list) and multi_columns:
+        # 多列联合唯一：targetColumns 携带全部列引用，逐列校验存在性；
+        # 后续单列流程（类型兼容性等）以首列继续
+        for mc in multi_columns:
+            mc_name = str(mc)
+            mc_found = any(
+                col_id == mc_name or col_data["name"] == mc_name for col_id, col_data in table_info["columns"].items()
+            )
+            if not mc_found:
+                suggestion = suggest_similar_column(mc_name, table_info)
+                errors.append(
+                    ValidationError(
+                        action_index=index,
+                        action_type=action_type,
+                        error_type="column_not_found",
+                        message=f"字段 '{mc_name}' 在表 '{table_info['name']}' 中不存在",
+                        suggestion=suggestion,
+                        auto_fixable=False,
+                    )
+                )
+        if errors:
+            return errors
+        column_name = str(multi_columns[0])
+
     if not column_name:
         errors.append(
             ValidationError(
@@ -260,7 +285,7 @@ def validate_constraint_params(
     errors = []
     params = spec.get("params", {})
 
-    # DateLogic range 模式参数完整性检查（不依赖 required_params）
+    # DateLogic 参数完整性检查（不依赖 required_params）
     if constraint_type == "DateLogic":
         logic_mode = params.get("logicMode", "compare")
         compare_op = params.get("compareOp", "gt")
@@ -279,6 +304,42 @@ def validate_constraint_params(
                         suggestion="请添加 params.referenceDateEnd / params.referenceColumnEnd",
                     )
                 )
+        if logic_mode == "calculation":
+            # calculation 模式（age/days_diff）参数完整性：写盘侧同样 fail-fast，此处提前拦截
+            calc = params.get("calculationType") or params.get("calculation_type")
+            if calc not in ("age", "days_diff"):
+                errors.append(
+                    ValidationError(
+                        action_index=index,
+                        action_type=action_type,
+                        error_type="missing_required_param",
+                        message="DateLogic calculation 模式需要 params.calculationType（age/days_diff）",
+                        suggestion="请添加 params.calculationType",
+                    )
+                )
+            else:
+                target_column = params.get("targetColumn") or params.get("target_column")
+                target_value = params.get("targetValue", params.get("target_value"))
+                if calc == "days_diff" and not target_column:
+                    errors.append(
+                        ValidationError(
+                            action_index=index,
+                            action_type=action_type,
+                            error_type="missing_required_param",
+                            message="DateLogic days_diff 需要 params.targetColumn（天数差比较的目标列）",
+                            suggestion="请添加 params.targetColumn",
+                        )
+                    )
+                if target_value is None:
+                    errors.append(
+                        ValidationError(
+                            action_index=index,
+                            action_type=action_type,
+                            error_type="missing_required_param",
+                            message="DateLogic calculation 模式需要 params.targetValue（比较目标值）",
+                            suggestion="请添加 params.targetValue",
+                        )
+                    )
 
     required = required_params.get(constraint_type, [])
     if required:

{precis_cli-0.1.6 → precis_cli-0.1.7}/app/shared/services/llm/actions/action_handlers.py

@@ -53,6 +53,7 @@ from app.shared.services.llm.constraints.constraint_builder import (
     CONSTRAINT_TYPE_MAP,
     _build_constraint_params,
     _build_constraint_refs,
+    _build_inline_constraint_item,
 )
 from app.shared.services.llm.constraints.constraint_deletion import delete_constraint_file
 from app.shared.services.llm.constraints.constraint_id import _generate_constraint_id
@@ -225,18 +226,22 @@ def update_yaml_config(action: dict[str, Any], workspace_path: str) -> tuple[boo
     target_node_id = constraint_spec.get("targetNodeId", "")
     target_column_id = constraint_spec.get("targetColumnId", "")
     is_inline = constraint_spec.get("isInline", False)
+    # 多列联合唯一：targetColumns（列名/ID 数组）可作为 targetColumn 的替代
+    target_columns = constraint_spec.get("targetColumnIds") or constraint_spec.get("targetColumns") or []
 
     # 统一转换类型名
     std_type = CONSTRAINT_TYPE_MAP.get(constraint_type, constraint_type)
 
-    if not std_type or not target_column:
+    if not std_type or (not target_column and not target_columns):
         error_msg = f"无效的约束规格: constraint_type={constraint_type}, std_type={std_type}, table_name={table_name}, target_column={target_column}"
         logger.error(f"[updateYamlConfig] {error_msg}")
         return False, error_msg
 
     # 确定用于文件名的表标识符 (优先使用可读的名称)
     filename_table = table_name or target_node_id or "unknown"
-    filename_column = target_column or target_column_id or "unknown"
+    filename_column = (
+        target_column or target_column_id or ("_".join(str(c) for c in target_columns) if target_columns else "unknown")
+    )
 
     # DELETE 动作必须先于 is_inline 分支处理：删除语义与存储形态无关，
     # 旧实现 isInline=true 时先命中内联"添加"分支，只增不删还误报 success。
@@ -307,26 +312,36 @@ def update_yaml_config(action: dict[str, Any], workspace_path: str) -> tuple[boo
                             column_id = col.get("id")
                             break
 
-                if not column_id:
+                # 多列联合唯一：单列引用可缺省（targetColumns 携带全部列引用，由共用构建器解析）
+                is_multi_unique = std_type == "Unique" and isinstance(target_columns, list) and len(target_columns) > 1
+                if not column_id and not is_multi_unique:
                     # 目标列不存在时必须返回失败，否则会静默成功（与 process_inline_batch 对齐）。
                     error_msg = f"未找到列: {target_column}"
                     logger.warning(f"[updateYamlConfig] {error_msg}")
                     return False, error_msg
 
-                # 构建内联约束结构
-                inline_constraint = {
-                    "id": constraint_id,
-                    "column": column_id,
-                    "type": std_type,
-                }
-                params = _build_constraint_params(std_type, constraint_spec)
-                if params:
-                    inline_constraint["params"] = params
-
-                # 检查是否已存在相同列和类型的约束
+                # 构建内联约束结构（共用构建器：Conditional 引用入 params、FK 目标入顶层字段、
+                # 多列 Unique 用 columns 列表，三种特殊形态与 process_inline_batch 收敛到同一实现）
+                inline_constraint = _build_inline_constraint_item(
+                    std_type,
+                    constraint_spec,
+                    column_id or "",
+                    columns,
+                    table_name,
+                    target_column,
+                    workspace_path,
+                    constraint_id,
+                )
+
+                # 检查是否已存在相同列（或列组合）和类型的约束
                 existing_idx = None
                 for idx, existing in enumerate(schema_data["constraints"]):
-                    if existing.get("column") == column_id and existing.get("type") == std_type:
+                    same_target = (
+                        existing.get("columns") == inline_constraint.get("columns")
+                        if "columns" in inline_constraint
+                        else existing.get("column") == inline_constraint.get("column")
+                    )
+                    if same_target and existing.get("type") == std_type:
                         existing_idx = idx
                         break
 
@@ -377,7 +392,9 @@ def update_yaml_config(action: dict[str, Any], workspace_path: str) -> tuple[boo
                 enabled=True,
                 description=None,
                 refs=_build_constraint_refs(std_type, table_name, target_column, constraint_spec, workspace_path),
-                params=_build_constraint_params(std_type, constraint_spec),
+                params=_build_constraint_params(
+                    std_type, constraint_spec, table_name, target_column, workspace_path, constraint_id
+                ),
                 input_from_node=None,
                 input_column=None,
             )

{precis_cli-0.1.6 → precis_cli-0.1.7}/app/shared/services/llm/actions/registry.py

@@ -79,10 +79,14 @@ ALL_CONSTRAINT_TYPES: frozenset[str] = CONSTRAINT_TYPES | frozenset(CONSTRAINT_T
 # 需要特定参数的约束类型（供参数完整性校验）
 # 注意：Range 的 min/max 实际允许"至少一个"（见 _constraint_validator 特殊处理），
 # 此处仅声明"需要关注的参数键"，具体宽松度由 validator 决定。
+# Charset 必填 charsetMode：缺省时写盘侧不再静默默认 ascii（中文约束误判为 ascii 约束）；
+# Composite 必填 subConstraints：空子约束在引擎侧恒真（no-op 假通过）。
 CONSTRAINT_REQUIRED_PARAMS: dict[str, list[str]] = {
     "Range": ["min", "max"],
     "AllowedValues": ["allowedValues"],
     "ForeignKey": ["toTableId", "toColumnId"],
+    "Charset": ["charsetMode"],
+    "Composite": ["subConstraints"],
 }
 
 # 转换子类型白名单（22种）——原 response_parser(21条) 与 transform_handlers(22条) 不一致，