互斥参数组处理器Skill mutually-exclusive-group-handler

---

name: mutually-exclusive-group-handler description: 为CLI应用程序生成处理互斥参数组的逻辑，包含清晰的错误消息和验证。 allowed-tools: Read, Write, Edit, Bash, Glob, Grep

互斥组处理器

生成用于处理CLI互斥参数组的逻辑。

能力

• 生成互斥组验证
• 创建依赖参数关系
• 设置必需组验证
• 实现自定义冲突消息
• 配置OR/XOR组逻辑
• 为组生成文档

使用场景

当您需要时调用此技能：

• 实现互斥选项
• 创建依赖参数链
• 验证参数关系
• 生成清晰的冲突消息

输入

参数	类型	是否必需	描述
language	string	是	目标语言
groups	array	是	互斥组定义

组结构

{
  "groups": [
    {
      "name": "output-format",
      "type": "mutually_exclusive",
      "required": true,
      "options": ["--json", "--yaml", "--table"],
      "errorMessage": "请选择一种输出格式：--json、--yaml 或 --table"
    },
    {
      "name": "auth-method",
      "type": "mutually_exclusive",
      "options": ["--token", "--username"],
      "dependencies": {
        "--username": ["--password"]
      }
    }
  ]
}

生成模式

TypeScript 组处理器

interface GroupValidation {
  name: string;
  options: string[];
  required?: boolean;
  errorMessage?: string;
  dependencies?: Record<string, string[]>;
}

export function validateMutuallyExclusiveGroups(
  args: Record<string, unknown>,
  groups: GroupValidation[]
): void {
  for (const group of groups) {
    const presentOptions = group.options.filter(opt => {
      const key = opt.replace(/^--/, '').replace(/-/g, '_');
      return args[key] !== undefined;
    });

    // 检查互斥性
    if (presentOptions.length > 1) {
      throw new Error(
        group.errorMessage ||
        `选项 ${presentOptions.join(', ')} 是互斥的`
      );
    }

    // 检查必需组
    if (group.required && presentOptions.length === 0) {
      throw new Error(
        `必须指定 ${group.options.join(', ')} 中的一个`
      );
    }

    // 检查依赖关系
    if (group.dependencies && presentOptions.length === 1) {
      const selected = presentOptions[0];
      const deps = group.dependencies[selected];
      if (deps) {
        for (const dep of deps) {
          const depKey = dep.replace(/^--/, '').replace(/-/g, '_');
          if (args[depKey] === undefined) {
            throw new Error(
              `${selected} 需要指定 ${dep}`
            );
          }
        }
      }
    }
  }
}

Python 组处理器

from typing import Dict, List, Optional, Any

class MutuallyExclusiveGroup:
    def __init__(
        self,
        name: str,
        options: List[str],
        required: bool = False,
        error_message: Optional[str] = None,
        dependencies: Optional[Dict[str, List[str]]] = None
    ):
        self.name = name
        self.options = options
        self.required = required
        self.error_message = error_message
        self.dependencies = dependencies or {}

def validate_groups(args: Dict[str, Any], groups: List[MutuallyExclusiveGroup]) -> None:
    for group in groups:
        present = [
            opt for opt in group.options
            if args.get(opt.lstrip('-').replace('-', '_')) is not None
        ]

        # 检查互斥性
        if len(present) > 1:
            raise ValueError(
                group.error_message or
                f"选项 {', '.join(present)} 是互斥的"
            )

        # 检查必需性
        if group.required and not present:
            raise ValueError(
                f"必须指定 {', '.join(group.options)} 中的一个"
            )

        # 检查依赖关系
        if present and group.dependencies:
            selected = present[0]
            deps = group.dependencies.get(selected, [])
            for dep in deps:
                dep_key = dep.lstrip('-').replace('-', '_')
                if args.get(dep_key) is None:
                    raise ValueError(
                        f"{selected} 需要指定 {dep}"
                    )

工作流程

1. 定义组 - 指定互斥选项
2. 设置要求 - 必需组与可选组
3. 添加依赖 - 依赖参数链
4. 创建消息 - 自定义错误消息
5. 生成验证器 - 验证逻辑
6. 生成文档 - 组文档

目标流程

• 参数解析器设置
• 错误处理与用户反馈
• CLI命令结构设计