precis-cli 0.1.3__py3-none-any.whl

app/cli/__init__.py

@@ -0,0 +1,18 @@
+# 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 CLI 模块入口
+"""

app/cli/__main__.py

@@ -0,0 +1,30 @@
+# 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.
+# backend/app/cli/__main__.py
+"""
+@fileoverview CLI 入口启动模块
+
+功能概述:
+- 作为 python -m app.cli 的入口点启动交互式 CLI
+- 委托给 shell.main.main 执行主循环
+"""
+
+import sys
+
+from app.cli.shell.main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

app/cli/shared_services/__init__.py

@@ -0,0 +1,42 @@
+# 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.
+# backend/app/cli/shared_services/__init__.py
+"""
+@fileoverview CLI/TUI 共享薄壳层（Layer 2）
+
+功能概述:
+- 收敛 CLI 与 TUI 共用的非核心业务逻辑，确保「改一处即可」
+- 三个子模块：project_ops（项目操作）、config_ops（配置操作）、generation_ops（生成/迁移落盘）
+
+架构设计:
+- 本包只含纯逻辑与文件 IO，不含任何 UI/交互
+- CLI 的 execute() 与 TUI 的 service 都从这里 import，不再复制业务规则
+- 核心业务逻辑仍在 app.shared.*（Layer 1），本层只收口「不该复制但不属于核心」的薄壳
+
+接口契约（P0b 冻结，P1/P3/P5 直接 import 不修改）:
+    project_ops:     load_history / add_to_history / find_manifest /
+                     load_manifest_config / resolve_project_label / open_project / OpenResult
+    config_ops:      find_config_file / get_by_dotpath / set_by_dotpath /
+                     parse_config_value / list_config_files / load_config_content /
+                     check_yaml_syntax / ConfigFileInfo / YamlCheckResult
+    generation_ops:  apply_generated_config / scan_data_files / SUPPORTED_EXTENSIONS
+"""
+
+from __future__ import annotations
+
+from app.cli.shared_services import config_ops, generation_ops, project_ops
+
+__all__ = ["config_ops", "generation_ops", "project_ops"]

app/cli/shared_services/config_ops.py

@@ -0,0 +1,581 @@
+# 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.
+# backend/app/cli/shared_services/config_ops.py
+"""
+@fileoverview 配置操作共享逻辑（CLI/TUI 同源）
+
+功能概述:
+- 收敛 config show/get/set/list/check 共用的纯业务逻辑：
+  配置文件定位、点号路径读写、值类型解析、YAML 语法检查
+- 供 CLI 的 config 子命令与未来 TUI 的 config 屏共同调用，确保「改一处即可」
+
+架构设计:
+- 本模块只含纯逻辑与文件 IO，不含任何 UI/渲染
+- check_yaml_syntax 只负责「检查 + 收集错误位置/上下文/建议」，rich.Syntax 渲染留在各 UI 层
+- find_config_file 含路径穿越防护（原 config/base.py 逻辑）
+
+接口契约（P0b 冻结）:
+    def find_config_file(project_path: str, name: str | None) -> str | None
+    def resolve_config_file(project_path: str, name: str | None) -> tuple[str | None, str | None]
+    def get_by_dotpath(data: dict, key_path: str) -> tuple[bool, Any]
+    def set_by_dotpath(data: dict, key_path: str, value: Any) -> dict
+    def parse_config_value(value_str: str) -> tuple[bool, Any, str]
+    def list_config_files(project_path: str) -> list[ConfigFileInfo]
+    def load_config_content(project_path: str, filename: str) -> dict | str
+    def check_yaml_syntax(content: str, filename: str) -> YamlCheckResult
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+from ruamel.yaml import YAML
+from ruamel.yaml.comments import CommentedMap
+from ruamel.yaml.error import YAMLError as RuamelYAMLError
+
+from app.shared.core.utils.path_utils import paths_equal
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ConfigFileInfo:
+    """单个配置文件的信息（list 子命令用）。
+
+    Attributes:
+        name: 相对项目根的显示名（根目录文件为文件名，子目录文件为相对路径）
+        size: 文件大小（字节）
+        path: 文件绝对路径
+    """
+
+    name: str
+    size: int
+    path: str
+
+
+@dataclass
+class YamlCheckResult:
+    """YAML 语法检查结果（check 子命令用，纯逻辑，不含渲染）。
+
+    Attributes:
+        file: 文件名
+        valid: 是否通过语法检查
+        line_no: 错误所在行号（1-based）；无位置信息或通过时为 None
+        snippet: 错误附近的代码片段（纯文本，无高亮）；无则 None
+        problem: 简化后的问题描述；无则 None
+        hint: 修复建议；无则 None
+    """
+
+    file: str
+    valid: bool
+    line_no: int | None
+    snippet: str | None
+    problem: str | None
+    hint: str | None
+
+
+def find_config_file(project_path: str, filename: str | None) -> str | None:
+    """查找配置文件。
+
+    首先尝试直接拼接路径，如果失败则在项目目录下递归查找
+    （先精确相对路径匹配，再按文件名模糊回退）。
+
+    Args:
+        project_path: 项目根目录路径
+        filename: 文件名（可能包含子目录）；为 None 或空时返回 None
+
+    Returns:
+        文件的完整路径，如果未找到则返回 None
+
+    Security:
+        - 验证 project_path 是合法目录
+        - 验证 filename 不包含路径分隔符或父目录引用
+        - 解析后的文件路径必须在 project_path 范围内
+    """
+    path, _match_kind = resolve_config_file(project_path, filename)
+    return path
+
+
+# 路径匹配方式（resolve_config_file 返回值第二元素）
+MATCH_DIRECT = "direct"  # 直接路径命中（project_path/filename 存在）
+MATCH_EXACT = "exact"  # 递归查找中精确相对路径命中（rel_path == filename）
+MATCH_BASENAME = "basename"  # 按文件名模糊回退命中（仅当直接/精确均未命中时）
+
+
+def resolve_config_file(project_path: str, filename: str | None) -> tuple[str | None, str | None]:
+    """查找配置文件，返回 (路径, 匹配方式)。
+
+    与 find_config_file 的定位逻辑一致，额外返回匹配方式以便调用方
+    区分"精确命中"与"文件名模糊回退"——后者命中时必须向用户披露实际
+    写入的解析路径（如 config set 的成功提示）。
+
+    匹配优先级：直接路径 > 精确相对路径（递归）> 文件名模糊回退（递归）。
+    精确匹配整轮优先于模糊回退：输入 "schemas/x.yaml" 而 schemas/ 下不存在
+    该文件时，若 regex/ 下存在同名文件，模糊回退仍命中 regex/x.yaml，
+    但任何目录下的精确相对路径命中都先于模糊回退返回。
+
+    Args:
+        project_path: 项目根目录路径
+        filename: 文件名（可能包含子目录）；为 None 或空时返回 (None, None)
+
+    Returns:
+        (文件的完整路径, 匹配方式)；未找到时返回 (None, None)。
+        匹配方式取值为 MATCH_DIRECT / MATCH_EXACT / MATCH_BASENAME。
+
+    Security:
+        - 验证 project_path 是合法目录
+        - 验证 filename 不包含路径分隔符或父目录引用
+        - 解析后的文件路径必须在 project_path 范围内
+    """
+    # 验证 project_path 是合法目录
+    if not project_path or not isinstance(project_path, str):
+        return None, None
+
+    project_path = os.path.realpath(project_path)
+    if not os.path.isdir(project_path):
+        return None, None
+
+    # 验证 filename 不包含危险字符（路径穿越防护）
+    if not filename or not isinstance(filename, str):
+        return None, None
+
+    # 禁止绝对路径和父目录引用
+    if os.path.isabs(filename):
+        return None, None
+    # 父目录引用按路径段检查（子串检查会误伤 "my..data.yaml" 这类合法文件名）
+    if any(seg == ".." for seg in Path(filename).parts) or filename.startswith("~"):
+        return None, None
+
+    # 首先尝试直接路径
+    direct_path = os.path.normpath(os.path.join(project_path, filename))
+
+    # 确保解析后的路径在项目目录范围内
+    if not direct_path.startswith(project_path):
+        return None, None
+
+    if os.path.isfile(direct_path):
+        return direct_path, MATCH_DIRECT
+
+    # 递归查找（跳过隐藏目录）
+    def _walk_visible() -> Iterator[tuple[str, list[str]]]:
+        for root, _, files in os.walk(project_path):
+            if any(part.startswith(".") for part in root.split(os.sep)):
+                continue
+            yield root, files
+
+    # 第一遍：精确相对路径匹配（如 "schemas/x.yaml" 必须命中 schemas/ 下的该文件）
+    for root, files in _walk_visible():
+        for f in files:
+            rel_path = os.path.relpath(os.path.join(root, f), project_path)
+            if paths_equal(rel_path, filename):
+                full_path = os.path.join(root, f)
+                # 验证找到的完整路径在项目范围内
+                if os.path.realpath(full_path).startswith(project_path):
+                    return full_path, MATCH_EXACT
+
+    # 第二遍：文件名模糊回退（仅当直接路径与精确相对路径均未命中时）
+    for root, files in _walk_visible():
+        if os.path.basename(filename) in files:
+            full_path = os.path.join(root, os.path.basename(filename))
+            # 验证找到的完整路径在项目范围内
+            if os.path.realpath(full_path).startswith(project_path):
+                return full_path, MATCH_BASENAME
+
+    return None, None
+
+
+def get_by_dotpath(data: dict, key_path: str) -> tuple[bool, Any]:
+    """按点号路径从字典中查找值。
+
+    Args:
+        data: 配置字典
+        key_path: 点号路径，如 "project.name"
+
+    Returns:
+        (找到, 值)；未找到时返回 (False, None)
+    """
+    keys = key_path.split(".")
+    value: Any = data
+    for key in keys:
+        if isinstance(value, dict) and key in value:
+            value = value[key]
+        else:
+            return False, None
+    return True, value
+
+
+def set_by_dotpath(data: dict, key_path: str, value: Any) -> dict:
+    """按点号路径写入值，返回新 data（不改原 dict）。
+
+    中间层级不存在时自动创建空字典。
+
+    Args:
+        data: 原配置字典（不会被修改）
+        key_path: 点号路径，如 "project.name"
+        value: 要写入的值
+
+    Returns:
+        写入后的新字典（深拷贝原 data 后写入）
+    """
+    # 深拷贝避免修改原 dict（YAML 配置是 JSON 安全数据，用 JSON 拷贝即可）
+    import copy
+
+    new_data = copy.deepcopy(data) if data else {}
+    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
+    return new_data
+
+
+def parse_config_value(value_str: str) -> tuple[bool, Any, str]:
+    """解析字符串值为合适的类型。
+
+    按以下顺序尝试转换：
+    1. 布尔值（true/false）
+    2. null（null/none）
+    3. 整数
+    4. 浮点数
+    5. 去除引号的字符串
+    6. YAML 列表或字典
+    7. 原样字符串
+
+    Args:
+        value_str: 原始字符串值
+
+    Returns:
+        (成功, 转换后的值, 错误信息)；本实现始终成功，错误信息为空字符串。
+        保留 tuple 三元组以匹配接口契约，便于未来扩展严格模式。
+    """
+    # 尝试布尔值
+    if value_str.lower() == "true":
+        return True, True, ""
+    if value_str.lower() == "false":
+        return True, False, ""
+    if value_str.lower() == "null" or value_str.lower() == "none":
+        return True, None, ""
+
+    # 尝试整数
+    try:
+        return True, int(value_str), ""
+    except ValueError:
+        pass
+
+    # 尝试浮点数
+    try:
+        return True, float(value_str), ""
+    except ValueError:
+        pass
+
+    # 去除引号
+    if (value_str.startswith('"') and value_str.endswith('"')) or (
+        value_str.startswith("'") and value_str.endswith("'")
+    ):
+        return True, value_str[1:-1], ""
+
+    # 尝试 YAML 列表或对象
+    try:
+        parsed = yaml.safe_load(value_str)
+        if isinstance(parsed, (list, dict)):
+            return True, parsed, ""
+    except Exception:
+        logger.debug("解析 YAML 值失败: %s", value_str, exc_info=True)
+
+    # 默认返回字符串
+    return True, value_str, ""
+
+
+def set_config_value_in_file(project_path: str, filename: str, key_path: str, value: Any) -> tuple[bool, str]:
+    """按点号路径设置 YAML 配置文件中的值：保留注释与格式，原子写回。
+
+    与 ``set_by_dotpath``（纯内存 dict）不同，本函数负责文件级写入，采用
+    ruamel.yaml round-trip 加载——仅目标键的值被替换，其余行（含注释、空行、
+    引号风格）原样保留；写回经由「临时文件 + os.replace」保证原子性，避免
+    进程中断导致配置文件损坏。
+
+    Args:
+        project_path: 项目根目录绝对路径
+        filename: 配置文件名（相对项目根，可含子目录）
+        key_path: 点号路径，如 "project.name"
+        value: 要写入的值（已由 parse_config_value 解析为目标类型）
+
+    Returns:
+        (成功, 错误信息)；成功时错误信息为空字符串。
+
+    Security:
+        路径解析统一走 find_config_file（拒绝绝对路径 / ".." 父目录引用 /
+        解析后越出项目根的路径），防止 CLI 入参穿越到项目外任意文件。
+    """
+    config_path = find_config_file(project_path, filename)
+    if not config_path:
+        return False, f"配置文件不存在: {filename}"
+
+    # round-trip 模式加载：CommentedMap 携带注释/格式元数据，回写时保留
+    yaml_parser = YAML()
+    yaml_parser.preserve_quotes = True
+
+    try:
+        with open(config_path, encoding="utf-8") as f:
+            data = yaml_parser.load(f)
+    except RuamelYAMLError as e:
+        return False, f"YAML 解析失败: {e}"
+
+    # 空文件：从空映射开始（首键写入后无注释可保，属预期）
+    if data is None:
+        data = CommentedMap()
+    if not isinstance(data, dict):
+        return False, "配置根节点不是字典，无法按点号路径设置"
+
+    # 按点号路径逐层定位后原地写入（不经 set_by_dotpath 的 deepcopy——
+    # 直接在 ruamel 结构上替换目标键的值，其余键的注释元数据原封不动）
+    keys = key_path.split(".")
+    current: dict[str, Any] = data
+    for key in keys[:-1]:
+        child = current.get(key)
+        if not isinstance(child, dict):
+            if child is None:
+                # 中间层级不存在：创建空映射（与 set_by_dotpath 语义一致）
+                child = CommentedMap()
+                current[key] = child
+            else:
+                return False, f"路径 '{key_path}' 的中间键 '{key}' 不是字典，无法设置"
+        current = child
+    current[keys[-1]] = value
+
+    # 原子写回：同目录临时文件 + os.replace（同分区 rename，原子生效）
+    config_dir = os.path.dirname(config_path) or "."
+    try:
+        fd, temp_path = tempfile.mkstemp(
+            dir=config_dir,
+            prefix=f".{os.path.basename(config_path)}_tmp_",
+            suffix=".yaml",
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                yaml_parser.dump(data, f)
+            os.replace(temp_path, config_path)
+        except OSError:
+            # 写入或替换失败：清理临时文件，原配置文件不受影响
+            try:
+                os.remove(temp_path)
+            except OSError:
+                logger.debug("删除临时文件失败", exc_info=True)
+            raise
+    except OSError as e:
+        return False, f"写入失败: {e}"
+
+    return True, ""
+
+
+def list_config_files(project_path: str) -> list[ConfigFileInfo]:
+    """扫描项目中的所有 YAML 配置文件。
+
+    先扫描项目根目录，再递归扫描 schemas/constraints/patterns/regex 子目录。
+
+    Args:
+        project_path: 项目根目录绝对路径
+
+    Returns:
+        配置文件信息列表，按名称排序
+    """
+    config_files: list[ConfigFileInfo] = []
+
+    # 根目录
+    for f in os.listdir(project_path):
+        if f.endswith((".yaml", ".yml")):
+            config_path = os.path.join(project_path, f)
+            try:
+                stat = os.stat(config_path)
+                config_files.append(ConfigFileInfo(name=f, size=stat.st_size, path=config_path))
+            except Exception:
+                logger.error("获取文件信息失败", exc_info=True)
+
+    # 递归子目录
+    subdirs = ["schemas", "constraints", "patterns", "regex"]
+    for subdir in subdirs:
+        subdir_path = os.path.join(project_path, subdir)
+        if os.path.isdir(subdir_path):
+            for root, _, files in os.walk(subdir_path):
+                for f in files:
+                    if f.endswith((".yaml", ".yml")):
+                        rel_path = os.path.relpath(os.path.join(root, f), project_path)
+                        config_path = os.path.join(root, f)
+                        try:
+                            stat = os.stat(config_path)
+                            config_files.append(ConfigFileInfo(name=rel_path, size=stat.st_size, path=config_path))
+                        except Exception:
+                            pass
+
+    # 按名称排序
+    config_files.sort(key=lambda x: x.name)
+    return config_files
+
+
+def load_config_content(project_path: str, filename: str) -> dict | str:
+    """读取单个配置文件内容。
+
+    Args:
+        project_path: 项目根目录绝对路径
+        filename: 配置文件名（相对项目根）
+
+    Returns:
+        解析后的 dict；文件不存在时返回错误描述字符串；
+        文件为空时返回 "(空文件)"；读取失败时返回 "(读取失败: ...)"。
+    """
+    config_path = find_config_file(project_path, filename)
+    if not config_path:
+        return f"配置文件不存在: {filename}"
+    try:
+        with open(config_path, encoding="utf-8") as f:
+            content = yaml.safe_load(f)
+            if content:
+                return content if isinstance(content, dict) else str(content)
+            return "(空文件)"
+    except yaml.YAMLError as e:
+        return f"YAML 解析失败: {e}"
+    except Exception as e:
+        return f"读取失败: {e}"
+
+
+def _simplify_error_message(msg: str) -> str:
+    """将技术性的错误信息转换为更友好的描述。
+
+    Args:
+        msg: 原始错误信息
+
+    Returns:
+        翻译后的中文描述，如果没有匹配则返回原文
+    """
+    translations = {
+        "expected '<document start>', but found": "期望文件开始标记，但实际发现",
+        "expected <block end>, but found": "期望块结束，但实际发现",
+        "expected ',' or ']', but got": "期望逗号或右括号，但实际得到",
+        "while parsing a block mapping": "解析对象/字典时出错",
+        "while parsing a block collection": "解析列表/数组时出错",
+        "mapping values are not allowed here": "此处不允许键值对（可能缺少冒号或缩进错误）",
+        "could not determine a constructor for the tag": "无法识别的标签类型",
+        "found character": "发现不期望的字符",
+        "that cannot start any token": "无法作为任何标记的开始",
+        "unacceptable character": "包含不可接受的字符（可能是编码问题）",
+    }
+
+    for tech, friendly in translations.items():
+        if tech.lower() in msg.lower():
+            return friendly
+
+    return msg
+
+
+def check_yaml_syntax(content: str, filename: str) -> YamlCheckResult:
+    """检查 YAML 文本语法，返回纯逻辑结果（不含 rich 渲染）。
+
+    Args:
+        content: 文件原始文本内容
+        filename: 文件名（用于结果记录）
+
+    Returns:
+        YamlCheckResult：包含 valid/行号/代码片段/问题描述/修复建议。
+        代码片段为纯文本（错误行附近 ±2 行），rich.Syntax 高亮由调用方自行渲染。
+    """
+    content_lines = content.split("\n")
+
+    try:
+        yaml.safe_load(content)
+        return YamlCheckResult(
+            file=filename,
+            valid=True,
+            line_no=None,
+            snippet=None,
+            problem=None,
+            hint=None,
+        )
+    except yaml.YAMLError as e:
+        # 获取错误位置
+        problem_mark = getattr(e, "problem_mark", None)
+        error_line_no = problem_mark.line if problem_mark else None  # 0-based
+
+        # 代码片段（纯文本，错误行附近 ±2 行）
+        snippet: str | None = None
+        if error_line_no is not None:
+            context_start = max(0, error_line_no - 2)
+            context_end = min(len(content_lines), error_line_no + 3)
+            snippet_lines = content_lines[context_start:context_end]
+            # 1-based 起始行号标注在每行前，便于 UI 渲染
+            start_line = context_start + 1
+            snippet = "\n".join(f"{start_line + idx:>4} | {line}" for idx, line in enumerate(snippet_lines))
+
+        # 问题与上下文描述
+        problem: str | None = None
+        if hasattr(e, "problem") and e.problem:
+            problem = _simplify_error_message(e.problem)
+
+        if hasattr(e, "context") and e.context:
+            context = _simplify_error_message(e.context)
+            problem = f"{problem}（上下文: {context}）" if problem else context
+
+        # 修复建议
+        hint: str | None = None
+        problem_str = str(getattr(e, "problem", "")).lower()
+        context_str = str(getattr(e, "context", "")).lower()
+
+        if "block end" in problem_str and "scalar" in problem_str:
+            hint = "可能是上一行缺少冒号，或括号/引号不匹配"
+            # 检查前一行的内容
+            if error_line_no is not None and error_line_no > 0:
+                prev_line = content_lines[error_line_no - 1].strip()
+                if "required" in prev_line and ":" not in prev_line:
+                    hint += f"；上一行 '{prev_line[:30]}...' 可能缺少冒号"
+        elif "mapping" in context_str:
+            hint = "检查键值对格式是否正确（key: value）"
+        elif "could not determine a constructor" in problem_str:
+            hint = "可能包含特殊字符或不支持的 YAML 语法"
+
+        return YamlCheckResult(
+            file=filename,
+            valid=False,
+            line_no=(error_line_no + 1) if error_line_no is not None else None,
+            snippet=snippet,
+            problem=problem,
+            hint=hint,
+        )
+
+
+__all__ = [
+    "MATCH_BASENAME",
+    "MATCH_DIRECT",
+    "MATCH_EXACT",
+    "ConfigFileInfo",
+    "YamlCheckResult",
+    "check_yaml_syntax",
+    "find_config_file",
+    "get_by_dotpath",
+    "list_config_files",
+    "load_config_content",
+    "parse_config_value",
+    "resolve_config_file",
+    "set_by_dotpath",
+    "set_config_value_in_file",
+]