Skill: crossallen/regex-assistant (version 1.0.1)

--- name: regex-assistant description: 正则表达式助手，帮助用户测试、调试和生成正则表达式。支持匹配测试、分组捕获、替换操作等常见正则操作。 --- # 正则表达式助手 (Regex Tester) 正则表达式测试与调试工具，帮助开发者快速验证正则表达式、提取匹配结果和执行替换操作。 ## 技能目的 提供便捷的正则表达式测试环境，帮助用户： - 验证正则表达式是否正确匹配目标文本 - 查看捕获分组的内容 - 执行替换操作并预览结果 - 获取详细的匹配信息 ## 何时使用此技能 在以下情况下使用此技能： - 需要测试或调试正则表达式 - 需要从文本中提取特定模式的内容 - 需要进行批量文本替换 - 需要了解正则表达式的匹配行为 - 需要生成常用正则表达式模式 ## 功能特性 ### 1. 基本匹配测试 测试正则表达式在目标文本中的匹配情况。 ```bash python3 script/main.py match "<正则>" "<文本>" ``` **示例：** ```bash # 测试邮箱匹配 python3 script/main.py match "[\w.+-]+@[\w-]+\.[\w.-]+" "[REDACTED_SECRET]" # 测试手机号匹配（中国大陆） python3 script/main.py match "1[3-9]\d{9}" "13800138000" ``` ### 2. 提取所有匹配 获取文本中所有匹配正则表达式的内容。 ```bash python3 script/main.py findall "<正则>" "<文本>" ``` **示例：** ```bash # 提取所有URL python3 script/main.py findall "https?://\S+" "访问 https://example.com 和 http://test.org" # 提取所有数字 python3 script/main.py findall "\d+" "价格: 99, 数量: 100, 总计: 9900" ``` ### 3. 分组捕获 查看正则表达式中的捕获分组内容。 ```bash python3 script/main.py groups "<正则>" "<文本>" ``` **示例：** ```bash # 解析日志格式 python3 script/main.py groups "\[(.*?)\] \[(.*?)\] (.*)" "[2024-02-14] [INFO] 启动服务" # 解析日期时间 python3 script/main.py groups "(\d{4})-(\d{2})-(\d{2})" "今天是2024-02-14" ``` ### 4. 文本替换 使用正则表达式进行文本替换。 ```bash python3 script/main.py sub "<正则>" "<替换内容>" "<文本>" ``` **示例：** ```bash # 隐藏手机号中间四位 python3 script/main.py sub "(\d{3})\d{4}(\d{4})" "\1****\2" "联系13800138000" # 去除HTML标签 python3 script/main.py sub "<[^>]+>" "" "<p>你好<b>世界</b></p>" ``` ### 5. 常用模式生成 生成常用场景的正则表达式模式。 ```bash python3 script/main.py pattern "<模式名称>" ``` **支持的模式：** - `email` - 邮箱地址 - `phone` - 中国手机号 - `idcard` - 中国身份证号 - `ipv4` - IPv4地址 - `url` - URL地址 - `date` - 日期 (YYYY-MM-DD) - `time` - 时间 (HH:MM:SS) - `chinese` - 中文字符 - `username` - 用户名 (字母数字下划线) - `password` - 密码 (至少8位，包含字母和数字) **示例：** ```bash python3 script/main.py pattern email python3 script/main.py pattern phone ``` ## 参数说明 | 参数 | 说明 | |------|------| | `match` | 测试基本匹配 | | `findall` | 提取所有匹配 | | `groups` | 查看分组捕获 | | `sub` | 执行替换操作 | | `pattern` | 生成常用模式 | ## 使用示例 ### 场景 1: 验证输入格式 ```bash # 验证邮箱格式是否正确 python3 script/main.py match "[\w.+-]+@[\w-]+\.[\w.-]+" "[REDACTED_SECRET]" ``` ### 场景 2: 提取数据 ```bash # 从日志中提取所有错误代码 python3 script/main.py findall "ERROR:\s*(\w+)" "$(cat error.log)" # 提取Markdown中的链接 python3 script/main.py findall "\[([^\]]+)\]\(([^)]+)\)" "[首页](https://example.com)" ``` ### 场景 3: 数据清洗 ```bash # 统一日期格式 python3 script/main.py sub "(\d{4})/(\d{2})/(\d{2})" "\1-\2-\3" "2024/02/14" # 去除多余空格 python3 script/main.py sub "\s+" " " "你好 世界" ``` ### 场景 4: 查看正则分组 ```bash # 解析命令行参数 python3 script/main.py groups "--(\w+)=([^\s]+)" "--name=test --port=8080" # 解析CSV格式 python3 script/main.py groups "([^,]+),([^,]+),([^,]+)" "张三,25,北京" ``` ## 正则表达式语法速查 | 符号 | 说明 | |------|------| | `.` | 匹配任意字符（除换行） | | `\d` | 匹配数字 | | `\w` | 匹配字母数字下划线 | | `\s` | 匹配空白字符 | | `^` | 匹配行首 | | `$` | 匹配行尾 | | `*` | 匹配0次或多次 | | `+` | 匹配1次或多次 | | `?` | 匹配0次或1次 | | `{n}` | 匹配n次 | | `{n,}` | 匹配至少n次 | | `{n,m}` | 匹配n到m次 | | `[abc]` | 匹配a、b或c | | `[^abc]` | 匹配非a、b、c的字符 | | `()` | 捕获分组 | | `(?:)` | 非捕获分组 | | `|` | 或操作 | ## 注意事项 1. 特殊字符需要转义：`. ^ $ * + ? { } [ ] \ | ( )` 2. 使用 `.*` 时注意贪婪匹配，可用 `.*?` 进行非贪婪匹配 3. 捕获分组编号从1开始，`group(0)` 是整个匹配结果 4. Python默认使用Unicode模式，可匹配中文等Unicode字符 ## 目录结构 ``` regex-assistant/ ├── SKILL.md # 技能说明文档(本文件) ├── script/ │ └── main.py # 主程序 └── tests/ # 测试用例 ```

path: script/main.py
content: #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
正则表达式助手
提供正则表达式测试、调试和生成功能
"""

import re
import sys
import argparse
from typing import List, Tuple, Optional


# 常用正则表达式模式
PATTERNS = {
    "email": r"[\w.+-]+@[\w-]+\.[\w.-]+",
    "phone": r"1[3-9]\d{9}",
    "idcard": r"\d{17}[\dXx]",
    "ipv4": r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}",
    "url": r"https?://[^\s]+",
    "date": r"\d{4}-\d{2}-\d{2}",
    "time": r"\d{2}:\d{2}:\d{2}",
    "chinese": r"[\u4e00-\u9fa5]+",
    "username": r"[a-zA-Z0-9_]{3,20}",
    "password": r"(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}",
}


def print_section(title: str, content: str = ""):
    """打印分节标题"""
    print(f"\n{'='*50}")
    print(f"  {title}")
    print(f"{'='*50}")
    if content:
        print(content)


def match_test(pattern: str, text: str, flags: int = 0):
    """测试基本匹配"""
    print_section("基本匹配测试")
    print(f"正则表达式: {pattern}")
    print(f"测试文本: {text}")
    print(f"\n{'='*50}")

    try:
        result = re.search(pattern, text, flags)
        if result:
            print(f"✅ 匹配成功!")
            print(f"匹配位置: {result.span()}")
            print(f"匹配内容: '{result.group()}'")
        else:
            print("❌ 无匹配")
    except re.error as e:
        print(f"❌ 正则表达式错误: {e}")


def find_all(pattern: str, text: str, flags: int = 0):
    """提取所有匹配"""
    print_section("提取所有匹配")
    print(f"正则表达式: {pattern}")
    print(f"测试文本: {text}")
    print(f"\n{'='*50}")

    try:
        matches = re.findall(pattern, text, flags)
        if matches:
            print(f"✅ 找到 {len(matches)} 个匹配:")
            for i, match in enumerate(matches, 1):
                if isinstance(match, tuple):
                    # 处理有分组的情况
                    print(f"  {i}. 分组结果: {match}")
                else:
                    print(f"  {i}. '{match}'")
        else:
            print("❌ 无匹配")
    except re.error as e:
        print(f"❌ 正则表达式错误: {e}")


def find_iter(pattern: str, text: str, flags: int = 0):
    """使用finditer查看所有匹配的详细信息"""
    print_section("匹配详情 (finditer)")
    print(f"正则表达式: {pattern}")
    print(f"测试文本: {text}")
    print(f"\n{'='*50}")

    try:
        for i, match in enumerate(re.finditer(pattern, text, flags), 1):
            print(f"\n匹配 {i}:")
            print(f"  位置: {match.span()}")
            print(f"  内容: '{match.group()}'")
            # 显示所有分组
            for g_idx, group in enumerate(match.groups(), 1):
                if group:
                    print(f"  分组{g_idx}: '{group}'")
    except re.error as e:
        print(f"❌ 正则表达式错误: {e}")


def groups(pattern: str, text: str, flags: int = 0):
    """查看分组捕获"""
    print_section("分组捕获")
    print(f"正则表达式: {pattern}")
    print(f"测试文本: {text}")
    print(f"\n{'='*50}")

    try:
        result = re.search(pattern, text, flags)
        if result:
            print(f"✅ 匹配成功!")
            print(f"完整匹配 (group 0): '{result.group()}'")
            print(f"\n捕获分组:")
            for i, group in enumerate(result.groups(), 1):
                if group is not None:
                    print(f"  group({i}): '{group}'")
                else:
                    print(f"  group({i}): (未匹配)")

            if result.groupdict():
                print(f"\n命名分组:")
                for name, value in result.groupdict().items():
                    print(f"  ?P<{name}>: '{value}'")
        else:
            print("❌ 无匹配")
    except re.error as e:
        print(f"❌ 正则表达式错误: {e}")


def substitute(pattern: str, replacement: str, text: str, count: int = 0, flags: int = 0):
    """执行替换操作"""
    print_section("文本替换")
    print(f"正则表达式: {pattern}")
    print(f"替换内容: {replacement}")
    print(f"原文: {text}")
    print(f"\n{'='*50}")

    try:
        result = re.sub(pattern, replacement, text, count=count, flags=flags)
        print(f"替换后: {result}")

        # 显示替换次数
        if count == 0:
            matches = re.findall(pattern, text, flags)
            print(f"\n共替换了 {len(matches)} 处")
        else:
            print(f"\n最多替换了 {count} 处")

    except re.error as e:
        print(f"❌ 正则表达式错误: {e}")


def get_pattern(name: str):
    """获取常用正则表达式模式"""
    print_section(f"常用模式: {name}")
    if name in PATTERNS:
        print(f"模式: {PATTERNS[name]}")
        print(f"\n说明:")
        descriptions = {
            "email": "匹配常见邮箱地址格式",
            "phone": "匹配中国大陆手机号 (11位，1开头)",
            "idcard": "匹配中国大陆身份证号 (18位)",
            "ipv4": "匹配IPv4地址格式",
            "url": "匹配HTTP/HTTPS URL",
            "date": "匹配日期格式 YYYY-MM-DD",
            "time": "匹配时间格式 HH:MM:SS",
            "chinese": "匹配中文字符",
            "username": "匹配用户名 (3-20位字母数字下划线)",
            "password": "匹配密码 (至少8位，包含字母和数字)",
        }
        print(descriptions.get(name, "无说明"))
        print(f"\n使用示例:")
        print(f"python3 script/main.py match '{PATTERNS[name]}' '<你的测试文本>'")
    else:
        print(f"❌ 未找到模式 '{name}'")
        print(f"\n可用模式: {', '.join(PATTERNS.keys())}")


def list_patterns():
    """列出所有可用模式"""
    print_section("所有可用模式")
    for name, pattern in PATTERNS.items():
        print(f"  {name:12s} → {pattern}")
    print(f"\n使用 'python3 script/main.py pattern <名称>' 查看详情")


def main():
    parser = argparse.ArgumentParser(description="正则表达式助手")
    subparsers = parser.add_subparsers(dest="command", help="可用命令")

    # match 命令
    match_parser = subparsers.add_parser("match", help="测试基本匹配")
    match_parser.add_argument("pattern", help="正则表达式")
    match_parser.add_argument("text", help="测试文本")
    match_parser.add_argument("-i", "--ignorecase", action="store_true", help="忽略大小写")
    match_parser.add_argument("-m", "--multiline", action="store_true", help="多行模式")

    # findall 命令
    find_parser = subparsers.add_parser("findall", help="提取所有匹配")
    find_parser.add_argument("pattern", help="正则表达式")
    find_parser.add_argument("text", help="测试文本")
    find_parser.add_argument("-i", "--ignorecase", action="store_true", help="忽略大小写")

    # finditer 命令
    iter_parser = subparsers.add_parser("finditer", help="查看所有匹配详情")
    iter_parser.add_argument("pattern", help="正则表达式")
    iter_parser.add_argument("text", help="测试文本")

    # groups 命令
    groups_parser = subparsers.add_parser("groups", help="查看分组捕获")
    groups_parser.add_argument("pattern", help="正则表达式")
    groups_parser.add_argument("text", help="测试文本")

    # sub 命令
    sub_parser = subparsers.add_parser("sub", help="执行替换操作")
    sub_parser.add_argument("pattern", help="正则表达式")
    sub_parser.add_argument("replacement", help="替换内容")
    sub_parser.add_argument("text", help="原始文本")
    sub_parser.add_argument("-c", "--count", type=int, default=0, help="最大替换次数")

    # pattern 命令
    pattern_parser = subparsers.add_parser("pattern", help="获取常用模式")
    pattern_parser.add_argument("name", help="模式名称", nargs="?")

    # list 命令
    subparsers.add_parser("list", help="列出所有可用模式")

    args = parser.parse_args()

    # 构建flags
    flags = 0
    if hasattr(args, "ignorecase") and args.ignorecase:
        flags |= re.IGNORECASE
    if hasattr(args, "multiline") and args.multiline:
        flags |= re.MULTILINE

    # 执行命令
    if args.command == "match":
        match_test(args.pattern, args.text, flags)
    elif args.command == "findall":
        find_all(args.pattern, args.text, flags)
    elif args.command == "finditer":
        find_iter(args.pattern, args.text, flags)
    elif args.command == "groups":
        groups(args.pattern, args.text, flags)
    elif args.command == "sub":
        substitute(args.pattern, args.replacement, args.text, args.count, flags)
    elif args.command == "pattern":
        if args.name:
            get_pattern(args.name)
        else:
            list_patterns()
    elif args.command == "list":
        list_patterns()
    else:
        parser.print_help()


if __name__ == "__main__":
    main()


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: suspicious | SkillSpector: clean (LOW)