Creator提示词

---
name: skill-creator
description: 创建有效技能的指南。当用户想要创建新技能（或更新现有技能）以通过专业知识、工作流或工具集成扩展 Claude 的能力时，应使用此技能。
license: 完整条款见 LICENSE.txt
---

# 技能创建器

此技能为创建有效技能提供指导。

## 关于技能

技能是模块化、自包含的包，通过提供专业知识、工作流和工具来扩展 Claude 的能力。可以将它们视为特定领域或任务的“入门指南”——它们将 Claude 从通用代理转变为具备任何模型都无法完全拥有的程序性知识的专业代理。

### 技能提供的内容

1. 专业工作流 - 针对特定领域的多步骤流程
2. 工具集成 - 使用特定文件格式或 API 的说明
3. 领域专业知识 - 公司特定知识、模式、业务逻辑
4. 捆绑资源 - 用于复杂和重复任务的脚本、参考资料和资产

## 核心原则

### 简洁是关键

上下文窗口是一种公共资源。技能与 Claude 所需的其他所有内容共享上下文窗口：系统提示、对话历史、其他技能的元数据以及实际用户请求。

**默认假设：Claude 已经非常聪明。** 只添加 Claude 尚未拥有的上下文。对每条信息提出质疑：“Claude 真的需要这个解释吗？”以及“这段文字是否值得其 token 成本？”

优先使用简洁的示例而非冗长的解释。

### 设置适当的自由度

将具体程度与任务的脆弱性和可变性相匹配：

**高自由度（基于文本的指令）**：当多种方法都有效、决策取决于上下文或启发式方法指导方法时使用。

**中等自由度（伪代码或带参数的脚本）**：当存在首选模式、某些变化可接受或配置影响行为时使用。

**低自由度（特定脚本、少量参数）**：当操作脆弱且容易出错、一致性至关重要或必须遵循特定顺序时使用。

将 Claude 想象为在探索一条路径：悬崖上的窄桥需要特定的护栏（低自由度），而开阔的田野允许许多路线（高自由度）。

### 技能的解剖结构

每个技能由一个必需的 SKILL.md 文件和可选的捆绑资源组成：

```
skill-name/
├── SKILL.md (必需)
│   ├── YAML frontmatter 元数据 (必需)
│   │   ├── name: (必需)
│   │   └── description: (必需)
│   └── Markdown 指令 (必需)
└── 捆绑资源 (可选)
    ├── scripts/          - 可执行代码 (Python/Bash 等)
    ├── references/       - 旨在按需加载到上下文中的文档
    └── assets/           - 输出中使用的文件 (模板、图标、字体等)
```

#### SKILL.md (必需)

每个 SKILL.md 包含：

- **Frontmatter** (YAML)：包含 `name` 和 `description` 字段。这些是 Claude 用来确定技能何时被使用的唯一字段，因此清晰全面地描述技能是什么以及何时应使用它非常重要。
- **正文** (Markdown)：使用技能的说明和指导。仅在技能触发后加载（如果有的话）。

#### 捆绑资源 (可选)

##### 脚本 (`scripts/`)

用于需要确定性可靠性或反复重写的任务的可执行代码 (Python/Bash 等)。

- **何时包含**：当同一代码被反复重写或需要确定性可靠性时
- **示例**：`scripts/rotate_pdf.py` 用于 PDF 旋转任务
- **优点**：token 高效、确定性、无需加载到上下文中即可执行
- **注意**：Claude 可能仍需要阅读脚本以进行修补或环境特定调整

##### 参考资料 (`references/`)

旨在按需加载到上下文中以告知 Claude 过程和思考的文档和参考材料。

- **何时包含**：用于 Claude 在工作时应参考的文档
- **示例**：`references/finance.md` 用于财务模式，`references/mnda.md` 用于公司 NDA 模板，`references/policies.md` 用于公司政策，`references/api_docs.md` 用于 API 规范
- **用例**：数据库模式、API 文档、领域知识、公司政策、详细工作流指南
- **优点**：保持 SKILL.md 精简，仅在 Claude 确定需要时加载
- **最佳实践**：如果文件较大（>10k 字），在 SKILL.md 中包含 grep 搜索模式
- **避免重复**：信息应存在于 SKILL.md 或 references 文件中，而不是两者中。

##### 资产 (`assets/`)

不打算加载到上下文中，而是在 Claude 产生的输出中使用的文件。

- **何时包含**：当技能需要将在最终输出中使用的文件时
- **示例**：`assets/logo.png` 用于品牌资产，`assets/slides.pptx` 用于 PowerPoint 模板
- **用例**：模板、图像、图标、样板代码、字体、示例文档

### 渐进式披露设计原则

技能使用三级加载系统来高效管理上下文：

1. **元数据（名称 + 描述）** - 始终在上下文中（约 100 字）
2. **SKILL.md 正文** - 当技能触发时（<5k 字）
3. **捆绑资源** - 根据 Claude 的需要

保持 SKILL.md 正文简洁，不超过 500 行，以最小化上下文膨胀。

## 技能创建过程

技能创建涉及以下步骤：

1. 通过具体示例理解技能
2. 规划可重用的技能内容（脚本、参考资料、资产）
3. 初始化技能（运行 init_skill.py）
4. 编辑技能（实现资源并编写 SKILL.md）
5. 打包技能（运行 package_skill.py）
6. 根据实际使用进行迭代

### 步骤 3：初始化技能

从头创建新技能时，始终运行 `init_skill.py` 脚本：

```bash
scripts/init_skill.py <skill-name> --path <output-directory>
```

### 步骤 4：编辑技能

根据技能需求查阅这些有用的指南：

- **多步骤流程**：参见 references/workflows.md 了解顺序工作流和条件逻辑
- **特定输出格式或质量标准**：参见 references/output-patterns.md 了解模板和示例模式

### 步骤 5：打包技能

```bash
scripts/package_skill.py <path/to/skill-folder>
```

打包脚本验证并创建用于分发的 .skill 文件。
FILE:references/workflows.md
# 工作流模式

## 顺序工作流

对于复杂任务，将操作分解为清晰的顺序步骤。在 SKILL.md 开头向 Claude 提供流程概述通常很有帮助：

```markdown
填写 PDF 表单涉及以下步骤：

1. 分析表单（运行 analyze_form.py）
2. 创建字段映射（编辑 fields.json）
3. 验证映射（运行 validate_fields.py）
4. 填写表单（运行 fill_form.py）
5. 验证输出（运行 verify_output.py）
```

## 条件工作流

对于具有分支逻辑的任务，通过决策点引导 Claude：

```markdown
1. 确定修改类型：
   **创建新内容？** → 遵循下方的“创建工作流”
   **编辑现有内容？** → 遵循下方的“编辑工作流”

2. 创建工作流：[步骤]
3. 编辑工作流：[步骤]
```
FILE:references/output-patterns.md
# 输出模式

当技能需要产生一致、高质量的输出时，使用这些模式。

## 模板模式

为输出格式提供模板。根据你的需求匹配严格程度。

**对于严格要求（如 API 响应或数据格式）：**

```markdown
## 报告结构

始终使用此精确的模板结构：

# [分析标题]

## 执行摘要
[关键发现的一段概述]

## 关键发现
- 发现 1 及支持数据
- 发现 2 及支持数据
- 发现 3 及支持数据

## 建议
1. 具体的可操作建议
2. 具体的可操作建议
```

**对于灵活指导（当适应有用时）：**

```markdown
## 报告结构

这是一个合理的默认格式，但请使用你的最佳判断：

# [分析标题]

## 执行摘要
[概述]

## 关键发现
[根据你的发现调整章节]

## 建议
[针对具体上下文定制]

根据需要为特定分析类型调整章节。
```

## 示例模式

对于输出质量取决于查看示例的技能，提供输入/输出对：

```markdown
## 提交信息格式

按照这些示例生成提交信息：

**示例 1：**
输入：使用 JWT 令牌添加了用户身份验证
输出：
```
feat(auth): 实现基于 JWT 的身份验证

添加登录端点和令牌验证中间件
```

**示例 2：**
输入：修复了报告中日期显示不正确的错误
输出：
```
fix(reports): 修正时区转换中的日期格式

在报告生成中一致使用 UTC 时间戳
```

遵循此风格：类型(范围): 简要描述，然后详细说明。
```

示例比仅描述更能帮助 Claude 理解所需的风格和详细程度。
FILE:scripts/quick_validate.py
#!/usr/bin/env python3
"""
技能快速验证脚本 - 最小版本
"""

import sys
import os
import re
import yaml
from pathlib import Path

def validate_skill(skill_path):
    """技能的基本验证"""
    skill_path = Path(skill_path)

    # 检查 SKILL.md 是否存在
    skill_md = skill_path / 'SKILL.md'
    if not skill_md.exists():
        return False, "未找到 SKILL.md"

    # 读取并验证 frontmatter
    content = skill_md.read_text()
    if not content.startswith('---'):
        return False, "未找到 YAML frontmatter"

    # 提取 frontmatter
    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
    if not match:
        return False, "无效的 frontmatter 格式"

    frontmatter_text = match.group(1)

    # 解析 YAML frontmatter
    try:
        frontmatter = yaml.safe_load(frontmatter_text)
        if not isinstance(frontmatter, dict):
            return False, "Frontmatter 必须是 YAML 字典"
    except yaml.YAMLError as e:
        return False, f"Frontmatter 中的 YAML 无效：{e}"

    # 定义允许的属性
    ALLOWED_PROPERTIES = {'name', 'description', 'license', 'allowed-tools', 'metadata'}

    # 检查意外属性（排除 metadata 下的嵌套键）
    unexpected_keys = set(frontmatter.keys()) - ALLOWED_PROPERTIES
    if unexpected_keys:
        return False, (
            f"SKILL.md frontmatter 中的意外键：{', '.join(sorted(unexpected_keys))}。 "
            f"允许的属性为：{', '.join(sorted(ALLOWED_PROPERTIES))}"
        )

    # 检查必填字段
    if 'name' not in frontmatter:
        return False, "frontmatter 中缺少 'name'"
    if 'description' not in frontmatter:
        return False, "frontmatter 中缺少 'description'"

    # 提取名称进行验证
    name = frontmatter.get('name', '')
    if not isinstance(name, str):
        return False, f"名称必须是字符串，得到 {type(name).__name__}"
    name = name.strip()
    if name:
        # 检查命名约定（连字符格式：小写字母和连字符）
        if not re.match(r'^[a-z0-9-]+$', name):
            return False, f"名称 '{name}' 应为连字符格式（仅小写字母、数字和连字符）"
        if name.startswith('-') or name.endswith('-') or '--' in name:
            return False, f"名称 '{name}' 不能以连字符开头/结尾或包含连续连字符"
        # 检查名称长度（根据规范最大 64 个字符）
        if len(name) > 64:
            return False, f"名称太长（{len(name)} 个字符）。最大为 64 个字符。"

    # 提取并验证描述
    description = frontmatter.get('description', '')
    if not isinstance(description, str):
        return False, f"描述必须是字符串，得到 {type(description).__name__}"
    description = description.strip()
    if description:
        # 检查尖括号
        if '<' in description or '>' in description:
            return False, "描述不能包含尖括号（< 或 >）"
        # 检查描述长度（根据规范最大 1024 个字符）
        if len(description) > 1024:
            return False, f"描述太长（{len(description)} 个字符）。最大为 1024 个字符。"

    return True, "技能有效！"

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("用法：python quick_validate.py <skill_directory>")
        sys.exit(1)
    
    valid, message = validate_skill(sys.argv[1])
    print(message)
    sys.exit(0 if valid else 1)
FILE:scripts/init_skill.py
#!/usr/bin/env python3
"""
技能初始化器 - 从模板创建新技能

用法：
    init_skill.py <skill-name> --path <path>

示例：
    init_skill.py my-new-skill --path skills/public
    init_skill.py my-api-helper --path skills/private
    init_skill.py custom-skill --path /custom/location
"""

import sys
from pathlib import Path


SKILL_TEMPLATE = """---
name: {skill_name}
description: [TODO: 完整且信息丰富的解释，说明该技能的作用以及何时使用它。包括何时使用此技能 - 触发它的具体场景、文件类型或任务。]
---

# {skill_title}

## 概述

[TODO: 1-2 句话解释此技能能实现什么]

## 资源

此技能包含示例资源目录，演示如何组织不同类型的捆绑资源：

### scripts/
可执行代码（Python/Bash 等），可直接运行以执行特定操作。

### references/
旨在加载到上下文中以告知 Claude 过程和思考的文档和参考资料。

### assets/
不打算加载到上下文中，而是在 Claude 产生的输出中使用的文件。

---

**可以删除任何不需要的目录。** 并非每项技能都需要全部三种类型的资源。
"""

EXAMPLE_SCRIPT = '''#!/usr/bin/env python3
"""
{skill_name} 的示例辅助脚本

这是一个可以直接执行的占位脚本。
请替换为实际实现，或在不需要时删除。
"""

def main():
    print("这是 {skill_name} 的示例脚本")
    # TODO: 在此添加实际的脚本逻辑

if __name__ == "__main__":
    main()
'''

EXAMPLE_REFERENCE = """# {skill_title} 的参考文档

这是详细参考文档的占位符。
请替换为实际的参考内容，或在不需要时删除。
"""

EXAMPLE_ASSET = """# 示例资源文件

此占位符表示资源文件的存储位置。
请替换为实际的资源文件（模板、图片、字体等），或在不需要时删除。
"""


def title_case_skill_name(skill_name):
    """将带连字符的技能名称转换为标题大小写以便显示。"""
    return ' '.join(word.capitalize() for word in skill_name.split('-'))


def init_skill(skill_name, path):
    """使用模板 SKILL.md 初始化新的技能目录。"""
    skill_dir = Path(path).resolve() / skill_name

    if skill_dir.exists():
        print(f"❌ 错误：技能目录已存在：{skill_dir}")
        return None

    try:
        skill_dir.mkdir(parents=True, exist_ok=False)
        print(f"✅ 已创建技能目录：{skill_dir}")
    except Exception as e:
        print(f"❌ 创建目录时出错：{e}")
        return None

    skill_title = title_case_skill_name(skill_name)
    skill_content = SKILL_TEMPLATE.format(skill_name=skill_name, skill_title=skill_title)

    skill_md_path = skill_dir / 'SKILL.md'
    try:
        skill_md_path.write_text(skill_content)
        print("✅ 已创建 SKILL.md")
    except Exception as e:
        print(f"❌ 创建 SKILL.md 时出错：{e}")
        return None

    try:
        scripts_dir = skill_dir / 'scripts'
        scripts_dir.mkdir(exist_ok=True)
        example_script = scripts_dir / 'example.py'
        example_script.write_text(EXAMPLE_SCRIPT.format(skill_name=skill_name))
        example_script.chmod(0o755)
        print("✅ 已创建 scripts/example.py")

        references_dir = skill_dir / 'references'
        references_dir.mkdir(exist_ok=True)
        example_reference = references_dir / 'api_reference.md'
        example_reference.write_text(EXAMPLE_REFERENCE.format(skill_title=skill_title))
        print("✅ 已创建 references/api_reference.md")

        assets_dir = skill_dir / 'assets'
        assets_dir.mkdir(exist_ok=True)
        example_asset = assets_dir / 'example_asset.txt'
        example_asset.write_text(EXAMPLE_ASSET)
        print("✅ 已创建 assets/example_asset.txt")
    except Exception as e:
        print(f"❌ 创建资源目录时出错：{e}")
        return None

    print(f"\n✅ 技能 '{skill_name}' 已在 {skill_dir} 成功初始化")
    return skill_dir


def main():
    if len(sys.argv) < 4 or sys.argv[2] != '--path':
        print("用法：init_skill.py <skill-name> --path <path>")
        sys.exit(1)

    skill_name = sys.argv[1]
    path = sys.argv[3]

    print(f"🚀 正在初始化技能：{skill_name}")
    print(f"   位置：{path}")
    print()

    result = init_skill(skill_name, path)
    sys.exit(0 if result else 1)


if __name__ == "__main__":
    main()
FILE:scripts/package_skill.py
#!/usr/bin/env python3
"""
技能打包器 - 为技能文件夹创建可分发的 .skill 文件

用法：
    python utils/package_skill.py <path/to/skill-folder> [output-directory]

示例：
    python utils/package_skill.py skills/public/my-skill
    python utils/package_skill.py skills/public/my-skill ./dist
"""

import sys
import zipfile
from pathlib import Path
from quick_validate import validate_skill


def package_skill(skill_path, output_dir=None):
    """将技能文件夹打包为 .skill 文件。"""
    skill_path = Path(skill_path).resolve()

    if not skill_path.exists():
        print(f"❌ 错误：未找到技能文件夹：{skill_path}")
        return None

    if not skill_path.is_dir():
        print(f"❌ 错误：路径不是目录：{skill_path}")
        return None

    skill_md = skill_path / "SKILL.md"
    if not skill_md.exists():
        print(f"❌ 错误：在 {skill_path} 中未找到 SKILL.md")
        return None

    print("🔍 正在验证技能...")
    valid, message = validate_skill(skill_path)
    if not valid:
        print(f"❌ 验证失败：{message}")
        print("   请在打包前修复验证错误。")
        return None
    print(f"✅ {message}\n")

    skill_name = skill_path.name
    if output_dir:
        output_path = Path(output_dir).resolve()
        output_path.mkdir(parents=True, exist_ok=True)
    else:
        output_path = Path.cwd()

    skill_filename = output_path / f"{skill_name}.skill"

    try:
        with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
            for file_path in skill_path.rglob('*'):
                if file_path.is_file():
                    arcname = file_path.relative_to(skill_path.parent)
                    zipf.write(file_path, arcname)
                    print(f"  已添加：{arcname}")

        print(f"\n✅ 已成功将技能打包至：{skill_filename}")
        return skill_filename

    except Exception as e:
        print(f"❌ 创建 .skill 文件时出错：{e}")
        return None


def main():
    if len(sys.argv) < 2:
        print("用法：python utils/package_skill.py <path/to/skill-folder> [output-directory]")
        sys.exit(1)

    skill_path = sys.argv[1]
    output_dir = sys.argv[2] if len(sys.argv) > 2 else None

    print(f"📦 正在打包技能：{skill_path}")
    if output_dir:
        print(f"   输出目录：{output_dir}")
    print()

    result = package_skill(skill_path, output_dir)
    sys.exit(0 if result else 1)


if __name__ == "__main__":
    main()

---
name: claude-md-master
description: CLAUDE.md 生命周期大师技能：用仓库核实数据创建、更新与改进文件，支持多模块与栈特定规则。
---

# claude-md-master

你是「claude-md-master」技能助手。上方 description 为中文任务说明。下方保留原技能完整正文（含脚本与代码）；执行时遵循中文说明与原文技术细节。

# CLAUDE.md Master (Create/Update/Improver)

## When to use
- User asks to create, improve, update, or standardize CLAUDE.md files.

## Core rules
- Only include info verified in repo or config.
- Never include secrets, tokens, credentials, or user data.
- Never include task-specific or temporary instructions.
- Keep concise: root <= 200 lines, module <= 120 lines.
- Use bullets; avoid long prose.
- Commands must be copy-pasteable and sourced from repo docs/scripts/CI.
- Skip empty sections; avoid filler.

## Mandatory inputs (analyze before generating)
- Build/package config relevant to detected stack (root + modules).
- Static analysis config used in repo (if present).
- Actual module structure and source patterns (scan real dirs/files).
- Representative source roots per module to extract:
  package/feature structure, key types, and annotations in use.

## Discovery (fast + targeted)
1. Locate existing CLAUDE.md variants: `CLAUDE.md`, `.claude.md`, `.claude.local.md`.
2. Identify stack and entry points via minimal reads:
   - `README.md`, relevant `docs/*`
   - Build/package files (see stack references)
   - Runtime/config: `Dockerfile`, `docker-compose.yml`, `.env.example`, `config/*`
   - CI: `.github/workflows/*`, `.gitlab-ci.yml`, `.circleci/*`
3. Extract commands only if they exist in repo scripts/config/docs.
4. Detect multi-module structure:
   - Android/Gradle: read `settings.gradle` or `settings.gradle.kts` includes.
   - iOS: detect multiple targets/workspaces in `*.xcodeproj`/`*.xcworkspace`.
   - If more than one module/target has `src/` or build config, plan module CLAUDE.md files.
5. For each module candidate, read its build file + minimal docs to capture
   module-specific purpose, entry points, and commands.
6. Scan source roots for:
   - Top-level package/feature folders and layer conventions.
   - Key annotations/types in use (per stack reference).
   - Naming conventions used in the codebase.
7. Capture non-obvious workflows/gotchas from docs or code patterns.

Performance:
- Prefer file listing + targeted reads.
- Avoid full-file reads when a section or symbol is enough.
- Skip large dirs: `node_modules`, `vendor`, `build`, `dist`.

## Stack-specific references (Pattern 2)
Read the relevant reference only when detection signals appear:
- Android/Gradle → `references/android.md`
- iOS/Xcode/Swift → `references/ios.md`
- PHP → `references/php.md`
- Go → `references/go.md`
- React (web) → `references/react-web.md`
- React Native → `references/react-native.md`
- Rust → `references/rust.md`
- Python → `references/python.md`
- Java/JVM → `references/java.md`
- Node tooling → `references/node.md`
- .NET/C# → `references/dotnet.md`
- Dart/Flutter → `references/flutter.md`
- Ruby/Rails → `references/ruby.md`
- Elixir/Erlang → `references/elixir.md`
- C/C++/CMake → `references/cpp.md`
- Other/Unknown → `references/generic.md` (fallback when no specific reference matches)

If multiple stacks are detected, read multiple references.
If no stack is recognized, use the generic reference.

## Multi-module output policy (mandatory when detected)
- Always create a root `CLAUDE.md`.
- Also create `CLAUDE.md` inside each meaningful module/target root.
  - "Meaningful" = has its own build config and `src/` (or equivalent).
  - Skip tooling-only dirs like `buildSrc`, `gradle`, `scripts`, `tools`.
- Module file must be module-specific and avoid duplication:
  - Include purpose, key paths, entry points, module tests, and module
    commands (if any).
  - Reference shared info via `@/CLAUDE.md`.

## Business module CLAUDE.md policy (all stacks)
For monorepo business logic directories (`src/`, `lib/`, `packages/`, `internal/`):
- Create `CLAUDE.md` for modules with >5 files OR own README
- Skip utility-only dirs: `Helper`, `Utils`, `Common`, `Shared`, `Exception`, `Trait`, `Constants`
- Layered structure not required; provide module info regardless of architecture
- Max 120 lines per module CLAUDE.md
- Reference root via `@/CLAUDE.md` for shared architecture/patterns
- Include: purpose, structure, key classes, dependencies, entry points

## Mandatory output sections (per module CLAUDE.md)
Include these sections if detected in codebase (skip only if not present):
- **Feature/component inventory**: list top-level dirs under source root
- **Core/shared modules**: utility, common, or shared code directories
- **Navigation/routing structure**: navigation graphs, routes, or routers
- **Network/API layer pattern**: API clients, endpoints, response wrappers
- **DI/injection pattern**: modules, containers, or injection setup
- **Build/config files**: module-specific configs (proguard, manifests, etc.)

See stack-specific references for exact patterns to detect and report.

## Update workflow (must follow)
1. Propose targeted additions only; show diffs per file.

2. Ask for approval before applying updates:

**Cursor IDE:**
Use the AskQuestion tool with these options:
- id: "approval"
- prompt: "Apply these CLAUDE.md updates?"
- options: [{"id": "yes", "label": "Yes, apply"}, {"id": "no", "label": "No, cancel"}]

**Claude Code (Terminal):**
Output the proposed changes and ask:
"Do you approve these updates? (yes/no)"
Stop and wait for user response before proceeding.

**Other Environments (Fallback):**
If no structured question tool is available:
1. Display proposed changes clearly
2. Ask: "Do you approve these updates? Reply 'yes' to apply or 'no' to cancel."
3. Wait for explicit user confirmation before proceeding

3. Apply updates, preserving custom content.

If no CLAUDE.md exists, propose a new file for approval.

## Content extraction rules (mandatory)
- From codebase only:
  - Extract: type/class/annotation names used, real path patterns,
    naming conventions.
  - Never: hardcoded values, secrets, API keys, business-specific logic.
  - Never: code snippets in Do/Do Not rules.

## Verification before writing
- [ ] Every rule references actual types/paths from codebase
- [ ] No code examples in Do/Do Not sections
- [ ] Patterns match what's actually in the codebase (not outdated)

## Content rules
- Include: commands, architecture summary, key paths, testing, gotchas, workflow quirks.
- Exclude: generic best practices, obvious info, unverified statements.
- Use `@path/to/file` imports to avoid duplication.
- Do/Do Not format is optional; keep only if already used in the file.
- Avoid code examples except short copy-paste commands.

## Existing file strategy
Detection:
- If `<!-- Generated by claude-md-editor skill -->` exists → subsequent run
- Else → first run

First run + existing file:
- Backup `CLAUDE.md` → `CLAUDE.md.bak`
- Use `.bak` as a source and extract only reusable, project-specific info
- Generate a new concise file and add the marker

Subsequent run:
- Preserve custom sections and wording unless outdated or incorrect
- Update only what conflicts with current repo state
- Add missing sections only if they add real value

Never modify `.claude.local.md`.

## Output
After updates, print a concise report:
```
## CLAUDE.md Update Report
- /CLAUDE.md [CREATED | BACKED_UP+CREATED | UPDATED]
- /<module>/CLAUDE.md [CREATED | UPDATED]
- Backups: list any `.bak` files
```

## Validation checklist
- Description is specific and includes trigger terms
- No placeholders remain
- No secrets included
- Commands are real and copy-pasteable
- Report-first rule respected
- References are one level deep
FILE:README.md
# claude-md-master

Master skill for the CLAUDE.md lifecycle: create, update, and improve files
using repo-verified data, with multi-module support and stack-specific rules.

## Overview
- Goal: produce accurate, concise `CLAUDE.md` files from real repo data
- Scope: root + meaningful modules, with stack-specific detection
- Safeguards: no secrets, no filler, explicit approval before writes

## How the AI discovers and uses this skill
- Discovery: the tool learns this skill because it exists in the
  repo skills catalog (installed/available in the environment)
- Automatic use: when a request includes "create/update/improve
  CLAUDE.md", the tool selects this skill as the best match
- Manual use: the operator can explicitly invoke `/claude-md-master`
  to force this workflow
- Run behavior: it scans repo docs/config/source, proposes changes,
  and waits for explicit approval before writing files

## Audience
- AI operators using skills in Cursor/Claude Code
- Maintainers who evolve the rules and references

## What it does
- Generates or updates `CLAUDE.md` with verified, repo-derived content
- Enforces strict safety and concision rules (no secrets, no filler)
- Detects multi-module repos and produces module-level `CLAUDE.md`
- Uses stack-specific references to capture accurate patterns

## When to use
- A user asks to create, improve, update, or standardize `CLAUDE.md`
- A repo needs consistent, verified guidance for AI workflows

## Inputs required (must be analyzed)
- Repo docs: `README.md`, `docs/*` (if present)
- Build/config files relevant to detected stack(s)
- Runtime/config: `Dockerfile`, `.env.example`, `config/*` (if present)
- CI: `.github/workflows/*`, `.gitlab-ci.yml`, `.circleci/*` (if present)
- Source roots to extract real structure, types, annotations, naming

## Output
- Root `CLAUDE.md` (always)
- Module `CLAUDE.md` for meaningful modules (build config + `src/`)
- Concise update report listing created/updated files and backups

## Workflow (high level)
1. Locate existing `CLAUDE.md` variants and detect first vs. subsequent run
2. Identify stack(s) and multi-module structure
3. Read relevant docs/configs/CI for real commands and workflow
4. Scan source roots for structure, key types, annotations, patterns
5. Generate root + module files, avoiding duplication via `@/CLAUDE.md`
6. Request explicit approval before applying updates
7. Apply changes and print the update report

## Core rules and constraints
- Only include info verified in repo; never add secrets
- Keep concise: root <= 200 lines, module <= 120 lines
- Commands must be real and copy-pasteable from repo docs/scripts/CI
- Skip empty sections; avoid generic guidance
- Never modify `.claude.local.md`
- Avoid code examples in Do/Do Not sections

## Multi-module policy (summary)
- Always create root `CLAUDE.md`
- Create module-level files only for meaningful modules
- Skip tooling-only dirs (e.g., `buildSrc`, `gradle`, `scripts`, `tools`)
- Business modules get their own file when >5 files or own README

## References (stack-specific guides)
Each reference defines detection signals, pre-gen sources, codebase scan
targets, mandatory output items, command sources, and key paths.

- `references/android.md` — Android/Gradle
- `references/ios.md` — iOS/Xcode/Swift
- `references/react-web.md` — React web apps
- `references/react-native.md` — React Native
- `references/node.md` — Node tooling (generic)
- `references/python.md` — Python
- `references/java.md` — Java/JVM
- `references/dotnet.md` — .NET (C#/F#)
- `references/go.md` — Go
- `references/rust.md` — Rust
- `references/flutter.md` — Dart/Flutter
- `references/ruby.md` — Ruby/Rails
- `references/php.md` — PHP (Laravel/Symfony/CI/Phalcon)
- `references/elixir.md` — Elixir/Erlang
- `references/cpp.md` — C/C++
- `references/generic.md` — Fallback when no stack matches

## Extending the skill
- Add a new `references/<stack>.md` using the same template
- Keep detection signals and mandatory outputs specific and verifiable
- Do not introduce unverified commands or generic advice

## Quality checklist
- Every rule references actual types/paths from the repo
- No placeholders remain
- No secrets included
- Commands are real and copy-pasteable
- Report-first rule respected; references are one level deep
FILE:references/android.md
# Android (Gradle)

## Detection signals
- `settings.gradle` or `settings.gradle.kts`
- `build.gradle` or `build.gradle.kts`
- `gradle.properties`
- `gradle/libs.versions.toml`
- `gradlew`
- `gradle/wrapper/gradle-wrapper.properties`
- `app/src/main/AndroidManifest.xml`

## Multi-module signals
- Multiple `include(...)` or `includeBuild(...)` entries in `settings.gradle*`
- More than one module dir with `build.gradle*` and `src/`
- Common module roots like `feature/`, `core/`, `library/` (if present)

## Before generating, analyze these sources
- `settings.gradle` or `settings.gradle.kts`
- `build.gradle` or `build.gradle.kts` (root and modules)
- `gradle/libs.versions.toml`
- `gradle.properties`
- `config/detekt/detekt.yml` (if present)
- `app/src/main/AndroidManifest.xml` (or module manifests)

## Codebase scan (Android-specific)
- Source roots per module: `*/src/main/java/`, `*/src/main/kotlin/`
- Package tree for feature/layer folders (record only if present):
  `features/`, `core/`, `common/`, `data/`, `domain/`, `presentation/`,
  `ui/`, `di/`, `navigation/`, `network/`
- Annotation usage (record only if present):
  Hilt (`@HiltAndroidApp`, `@AndroidEntryPoint`, `@HiltViewModel`,
  `@Module`, `@InstallIn`, `@Provides`, `@Binds`),
  Compose (`@Composable`, `@Preview`),
  Room (`@Entity`, `@Dao`, `@Database`),
  WorkManager (`@HiltWorker`, `ListenableWorker`, `CoroutineWorker`),
  Serialization (`@Serializable`, `@Parcelize`),
  Retrofit (`@GET`, `@POST`, `@PUT`, `@DELETE`, `@Body`, `@Query`)
- Navigation patterns (record only if present): `NavHost`, `composable`

## Mandatory output (Android module CLAUDE.md)
Include these if detected (list actual names found):
- **Features inventory**: list dirs under `features/` (e.g., homepage, payment, auth)
- **Core modules**: list dirs under `core/` (e.g., data, network, localization)
- **Navigation graphs**: list `*Graph.kt` or `*Navigator*.kt` files
- **Hilt modules**: list `@Module` classes or `di/` package contents
- **Retrofit APIs**: list `*Api.kt` interfaces
- **Room databases**: list `@Database` classes
- **Workers**: list `@HiltWorker` classes
- **Proguard**: mention `proguard-rules.pro` if present

## Command sources
- README/docs or CI invoking Gradle wrapper
- Repo scripts that call `./gradlew`
- `./gradlew assemble`, `./gradlew test`, `./gradlew lint` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `app/src/main/`, `app/src/main/res/`
- `app/src/main/java/`, `app/src/main/kotlin/`
- `app/src/test/`, `app/src/androidTest/`
FILE:references/cpp.md
# C / C++

## Detection signals
- `CMakeLists.txt`
- `meson.build`
- `Makefile`
- `conanfile.*`, `vcpkg.json`
- `compile_commands.json`
- `src/`, `include/`

## Multi-module signals
- `CMakeLists.txt` with `add_subdirectory(...)`
- Multiple `CMakeLists.txt` or `meson.build` in subdirs
- `libs/`, `apps/`, or `modules/` with their own build files

## Before generating, analyze these sources
- `CMakeLists.txt` / `meson.build` / `Makefile`
- `conanfile.*`, `vcpkg.json` (if present)
- `compile_commands.json` (if present)
- `src/`, `include/`, `tests/`, `libs/`

## Codebase scan (C/C++-specific)
- Source roots: `src/`, `include/`, `tests/`, `libs/`
- Library/app split (record only if present):
  `src/lib`, `src/app`, `src/bin`
- Namespaces and class prefixes (record only if present)
- CMake targets (record only if present):
  `add_library`, `add_executable`

## Mandatory output (C/C++ module CLAUDE.md)
Include these if detected (list actual names found):
- **Libraries**: list library targets
- **Executables**: list executable targets
- **Headers**: list public header directories
- **Modules/components**: list subdirectories with build files
- **Dependencies**: list Conan/vcpkg dependencies (if any)

## Command sources
- README/docs or CI invoking `cmake`, `ninja`, `make`, or `meson`
- Repo scripts that call build tools
- Only include commands present in repo

## Key paths to mention (only if present)
- `src/`, `include/`
- `tests/`, `libs/`
FILE:references/dotnet.md
# .NET (C# / F#)

## Detection signals
- `*.sln`
- `*.csproj`, `*.fsproj`, `*.vbproj`
- `global.json`
- `Directory.Build.props`, `Directory.Build.targets`
- `nuget.config`
- `Program.cs`
- `Startup.cs`
- `appsettings*.json`

## Multi-module signals
- `*.sln` with multiple project entries
- Multiple `*.*proj` files under `src/` and `tests/`
- `Directory.Build.*` managing shared settings across projects

## Before generating, analyze these sources
- `*.sln`, `*.csproj` / `*.fsproj` / `*.vbproj`
- `Directory.Build.props`, `Directory.Build.targets`
- `global.json`, `nuget.config`
- `Program.cs` / `Startup.cs`
- `appsettings*.json`

## Codebase scan (.NET-specific)
- Source roots: `src/`, `tests/`, project folders with `*.csproj`
- Layer folders (record only if present):
  `Controllers`, `Services`, `Repositories`, `Domain`, `Infrastructure`
- ASP.NET attributes (record only if present):
  `[ApiController]`, `[Route]`, `[HttpGet]`, `[HttpPost]`, `[Authorize]`
- EF Core usage (record only if present):
  `DbContext`, `Migrations`, `[Key]`, `[Table]`

## Mandatory output (.NET module CLAUDE.md)
Include these if detected (list actual names found):
- **Controllers**: list `[ApiController]` classes
- **Services**: list service classes
- **Repositories**: list repository classes
- **Entities**: list EF Core entity classes
- **DbContext**: list database context classes
- **Middleware**: list custom middleware
- **Configuration**: list config sections or options classes

## Command sources
- README/docs or CI invoking `dotnet`
- Repo scripts like `build.ps1`, `build.sh`
- `dotnet run`, `dotnet test` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `src/`, `tests/`
- `appsettings*.json`
- `Controllers/`, `Models/`, `Views/`, `wwwroot/`
FILE:references/elixir.md
# Elixir / Erlang

## Detection signals
- `mix.exs`, `mix.lock`
- `config/config.exs`
- `lib/`, `test/`
- `apps/` (umbrella)
- `rel/`

## Multi-module signals
- Umbrella with `apps/` containing multiple `mix.exs`
- Root `mix.exs` with `apps_path`

## Before generating, analyze these sources
- Root `mix.exs`, `mix.lock`
- `config/config.exs`
- `apps/*/mix.exs` (umbrella)
- `lib/`, `test/`, `rel/`

## Codebase scan (Elixir-specific)
- Source roots: `lib/`, `test/`, `apps/*/lib` (umbrella)
- Phoenix structure (record only if present):
  `lib/*_web/`, `controllers`, `views`, `channels`, `routers`
- Ecto usage (record only if present):
  `schema`, `Repo`, `migrations`
- Contexts/modules (record only if present):
  `lib/*/` context modules and `*_context.ex`

## Mandatory output (Elixir module CLAUDE.md)
Include these if detected (list actual names found):
- **Contexts**: list context modules
- **Schemas**: list Ecto schema modules
- **Controllers**: list Phoenix controller modules
- **Channels**: list Phoenix channel modules
- **Workers**: list background job modules (Oban, etc.)
- **Umbrella apps**: list apps under umbrella (if any)

## Command sources
- README/docs or CI invoking `mix`
- Repo scripts that call `mix`
- Only include commands present in repo

## Key paths to mention (only if present)
- `lib/`, `test/`, `config/`
- `apps/`, `rel/`
FILE:references/flutter.md
# Dart / Flutter

## Detection signals
- `pubspec.yaml`, `pubspec.lock`
- `analysis_options.yaml`
- `lib/`
- `android/`, `ios/`, `web/`, `macos/`, `windows/`, `linux/`

## Multi-module signals
- `melos.yaml` (Flutter monorepo)
- Multiple `pubspec.yaml` under `packages/`, `apps/`, or `plugins/`

## Before generating, analyze these sources
- `pubspec.yaml`, `pubspec.lock`
- `analysis_options.yaml`
- `melos.yaml` (if monorepo)
- `lib/`, `test/`, and platform folders (`android/`, `ios/`, etc.)

## Codebase scan (Flutter-specific)
- Source roots: `lib/`, `test/`
- Entry point (record only if present): `lib/main.dart`
- Layer folders (record only if present):
  `features/`, `core/`, `data/`, `domain/`, `presentation/`
- State management (record only if present):
  `Bloc`, `Cubit`, `ChangeNotifier`, `Provider`, `Riverpod`
- Widget naming (record only if present):
  `*Screen`, `*Page`

## Mandatory output (Flutter module CLAUDE.md)
Include these if detected (list actual names found):
- **Features**: list dirs under `features/` or `lib/`
- **Core modules**: list dirs under `core/` (if present)
- **State management**: list Bloc/Cubit/Provider setup
- **Repositories**: list repository classes
- **Data sources**: list remote/local data source classes
- **Widgets**: list shared widget directories

## Command sources
- README/docs or CI invoking `flutter`
- Repo scripts that call `flutter` or `dart`
- `flutter run`, `flutter test`, `flutter pub get` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `lib/`, `test/`
- `android/`, `ios/`
FILE:references/generic.md
# Generic / Unknown Stack

Use this reference when no specific stack reference matches.

## Detection signals (common patterns)
- `README.md`, `CONTRIBUTING.md`
- `Makefile`, `Taskfile.yml`, `justfile`
- `Dockerfile`, `docker-compose.yml`
- `.env.example`, `config/`
- CI files: `.github/workflows/`, `.gitlab-ci.yml`, `.circleci/`

## Before generating, analyze these sources
- `README.md` - project overview, setup instructions, commands
- Build/package files in root (any recognizable format)
- `Makefile`, `Taskfile.yml`, `justfile`, `scripts/` (if present)
- CI/CD configs for build/test commands
- `Dockerfile` for runtime info

## Codebase scan (generic)
- Identify source root: `src/`, `lib/`, `app/`, `pkg/`, or root
- Layer folders (record only if present):
  `controllers`, `services`, `models`, `handlers`, `utils`, `config`
- Entry points: `main.*`, `index.*`, `app.*`, `server.*`
- Test location: `tests/`, `test/`, `spec/`, `__tests__/`, or co-located

## Mandatory output (generic CLAUDE.md)
Include these if detected (list actual names found):
- **Entry points**: main files, startup scripts
- **Source structure**: top-level dirs under source root
- **Config files**: environment, settings, secrets template
- **Build system**: detected build tool and config location
- **Test setup**: test framework and run command

## Command sources
- README setup/usage sections
- `Makefile` targets, `Taskfile.yml` tasks, `justfile` recipes
- CI workflow steps (build, test, lint)
- `scripts/` directory
- Only include commands present in repo

## Key paths to mention (only if present)
- Source root and its top-level structure
- Config/environment files
- Test directory
- Documentation location
- Build output directory
FILE:references/go.md
# Go

## Detection signals
- `go.mod`, `go.sum`, `go.work`
- `cmd/`, `internal/`
- `main.go`
- `magefile.go`
- `Taskfile.yml`

## Multi-module signals
- `go.work` with multiple module paths
- Multiple `go.mod` files in subdirs
- `apps/` or `services/` each with its own `go.mod`

## Before generating, analyze these sources
- `go.work`, `go.mod`, `go.sum`
- `cmd/`, `internal/`, `pkg/` layout
- `Makefile`, `Taskfile.yml`, `magefile.go` (if present)

## Codebase scan (Go-specific)
- Source roots: `cmd/`, `internal/`, `pkg/`, `api/`
- Layer folders (record only if present):
  `handler`, `service`, `repository`, `store`, `config`
- Framework markers (record only if present):
  `gin`, `echo`, `fiber`, `chi` imports
- Entry points (record only if present):
  `cmd/*/main.go`, `main.go`

## Mandatory output (Go module CLAUDE.md)
Include these if detected (list actual names found):
- **Commands**: list binaries under `cmd/`
- **Handlers**: list HTTP handler packages
- **Services**: list service packages
- **Repositories**: list repository or store packages
- **Models**: list domain model packages
- **Config**: list config loading packages

## Command sources
- README/docs or CI
- `Makefile`, `Taskfile.yml`, or repo scripts invoking Go tools
- `go test ./...`, `go run` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `cmd/`, `internal/`, `pkg/`, `api/`
- `tests/` or `*_test.go` layout
FILE:references/ios.md
# iOS (Xcode/Swift)

## Detection signals
- `Package.swift`
- `*.xcodeproj` or `*.xcworkspace`
- `Podfile`, `Cartfile`
- `Project.swift`, `Tuist/`
- `fastlane/Fastfile`
- `*.xcconfig`
- `Sources/` or `Tests/` (SPM layouts)

## Multi-module signals
- Multiple targets/projects in `*.xcworkspace` or `*.xcodeproj`
- `Package.swift` with multiple targets/products
- `Sources/<TargetName>` and `Tests/<TargetName>` layout
- `Project.swift` defining multiple targets (Tuist)

## Before generating, analyze these sources
- `Package.swift` (SPM)
- `*.xcodeproj/project.pbxproj` or `*.xcworkspace/contents.xcworkspacedata`
- `Podfile`, `Cartfile` (if present)
- `Project.swift` / `Tuist/` (if present)
- `fastlane/Fastfile` (if present)
- `Sources/` and `Tests/` layout for targets

## Codebase scan (iOS-specific)
- Source roots: `Sources/`, `Tests/`, `ios/` (if present)
- Feature/layer folders (record only if present):
  `Features/`, `Core/`, `Services/`, `Networking/`, `UI/`, `Domain/`, `Data/`
- SwiftUI usage (record only if present):
  `@main`, `App`, `@State`, `@StateObject`, `@ObservedObject`,
  `@Environment`, `@EnvironmentObject`, `@Binding`
- UIKit/lifecycle (record only if present):
  `UIApplicationDelegate`, `SceneDelegate`, `UIViewController`
- Combine/concurrency (record only if present):
  `@Published`, `Publisher`, `AnyCancellable`, `@MainActor`, `Task`

## Mandatory output (iOS module CLAUDE.md)
Include these if detected (list actual names found):
- **Features inventory**: list dirs under `Features/` or feature targets
- **Core modules**: list dirs under `Core/`, `Services/`, `Networking/`
- **Navigation**: list coordinators, routers, or SwiftUI navigation files
- **DI container**: list DI setup (Swinject, Factory, manual containers)
- **Network layer**: list API clients or networking services
- **Persistence**: list CoreData models or other storage classes

## Command sources
- README/docs or CI invoking Xcode or Swift tooling
- Repo scripts that call Xcode/Swift tools
- `xcodebuild`, `swift build`, `swift test` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `Sources/`, `Tests/`
- `fastlane/`
- `ios/` (React Native or multi-platform repos)
FILE:references/java.md
# Java / JVM

## Detection signals
- `pom.xml` or `build.gradle*`
- `settings.gradle`, `gradle.properties`
- `mvnw`, `gradlew`
- `gradle/wrapper/gradle-wrapper.properties`
- `src/main/java`, `src/test/java`, `src/main/kotlin`
- `src/main/resources/application.yml`, `src/main/resources/application.properties`

## Multi-module signals
- `settings.gradle*` includes multiple modules
- Parent `pom.xml` with `<modules>` (packaging `pom`)
- Multiple `build.gradle*` or `pom.xml` files in subdirs

## Before generating, analyze these sources
- `settings.gradle*` and `build.gradle*` (if Gradle)
- Parent and module `pom.xml` (if Maven)
- `gradle/libs.versions.toml` (if present)
- `gradle.properties` / `mvnw` / `gradlew`
- `src/main/resources/application.yml|application.properties` (if present)

## Codebase scan (Java/JVM-specific)
- Source roots: `src/main/java`, `src/main/kotlin`, `src/test/java`, `src/test/kotlin`
- Package/layer folders (record only if present):
  `controller`, `service`, `repository`, `domain`, `model`, `dto`, `config`, `client`
- Framework annotations (record only if present):
  `@SpringBootApplication`, `@RestController`, `@Controller`, `@Service`,
  `@Repository`, `@Component`, `@Configuration`, `@Bean`, `@Transactional`
- Persistence/validation (record only if present):
  `@Entity`, `@Table`, `@Id`, `@OneToMany`, `@ManyToOne`, `@Valid`, `@NotNull`
- Entry points (record only if present):
  `*Application` classes with `main`

## Mandatory output (Java/JVM module CLAUDE.md)
Include these if detected (list actual names found):
- **Controllers**: list `@RestController` or `@Controller` classes
- **Services**: list `@Service` classes
- **Repositories**: list `@Repository` classes or JPA interfaces
- **Entities**: list `@Entity` classes
- **Configuration**: list `@Configuration` classes
- **Security**: list security config or auth filters
- **Profiles**: list Spring profiles in use

## Command sources
- Maven/Gradle wrapper scripts
- README/docs or CI
- `./mvnw spring-boot:run`, `./gradlew bootRun` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `src/main/java`, `src/test/java`
- `src/main/kotlin`, `src/test/kotlin`
- `src/main/resources`, `src/test/resources`
- `src/main/java/**/controller`, `src/main/java/**/service`, `src/main/java/**/repository`
FILE:references/node.md
# Node Tooling (generic)

## Detection signals
- `package.json`
- `package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`
- `.nvmrc`, `.node-version`
- `tsconfig.json`
- `.npmrc`, `.yarnrc.yml`
- `next.config.*`, `nuxt.config.*`
- `nest-cli.json`, `svelte.config.*`, `astro.config.*`

## Multi-module signals
- `pnpm-workspace.yaml`, `lerna.json`, `nx.json`, `turbo.json`, `rush.json`
- Root `package.json` with `workspaces`
- Multiple `package.json` under `apps/`, `packages/`

## Before generating, analyze these sources
- Root `package.json` and workspace config (`pnpm-workspace.yaml`, `lerna.json`,
  `nx.json`, `turbo.json`, `rush.json`)
- `apps/*/package.json`, `packages/*/package.json` (if monorepo)
- `tsconfig.json` or `jsconfig.json`
- Framework config: `next.config.*`, `nuxt.config.*`, `nest-cli.json`,
  `svelte.config.*`, `astro.config.*` (if present)

## Codebase scan (Node-specific)
- Source roots: `src/`, `lib/`, `apps/`, `packages/`
- Folder patterns (record only if present):
  `routes`, `controllers`, `services`, `middlewares`, `handlers`,
  `utils`, `config`, `models`, `schemas`
- Framework markers (record only if present):
  Express (`express()`, `Router`), Koa (`new Koa()`),
  Fastify (`fastify()`), Nest (`@Controller`, `@Module`, `@Injectable`)
- Full-stack layouts (record only if present):
  Next/Nuxt (`pages/`, `app/`, `server/`)

## Mandatory output (Node module CLAUDE.md)
Include these if detected (list actual names found):
- **Routes/pages**: list route files or page components
- **Controllers/handlers**: list controller or handler files
- **Services**: list service classes or modules
- **Middlewares**: list middleware files
- **Models/schemas**: list data models or validation schemas
- **State management**: list store setup (Redux, Zustand, etc.)
- **API clients**: list external API client modules

## Command sources
- `package.json` scripts
- README/docs or CI
- `npm|yarn|pnpm` script usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `src/`, `lib/`
- `tests/`
- `apps/`, `packages/` (monorepos)
- `pages/`, `app/`, `server/`, `api/`
- `controllers/`, `services/`
FILE:references/php.md
# PHP

## Detection signals
- `composer.json`, `composer.lock`
- `public/index.php`
- `artisan`, `spark`, `bin/console` (framework entry points)
- `phpunit.xml`, `phpstan.neon`, `phpstan.neon.dist`, `psalm.xml`
- `config/app.php`
- `routes/web.php`, `routes/api.php`
- `config/packages/` (Symfony)
- `app/Config/` (CI4)
- `ext-phalcon` in composer.json (Phalcon)
- `phalcon/ide-stubs`, `phalcon/devtools` (Phalcon)

## Multi-module signals
- `modules/` or `app/Modules/` (HMVC style)
- `app/Config/Modules.php`, `app/Config/Autoload.php` (CI4)
- Multiple PSR-4 roots in `composer.json`
- Multiple `composer.json` under `packages/` or `apps/`
- `apps/` with subdirectories containing `Module.php` or `controllers/`

## Before generating, analyze these sources
- `composer.json`, `composer.lock`
- `config/` and `routes/` (framework configs)
- `app/Config/*` (CI4)
- `modules/` or `app/Modules/` (if HMVC)
- `phpunit.xml`, `phpstan.neon*`, `psalm.xml` (if present)
- `bin/worker.php`, `bin/console.php` (CLI entry points)

## Codebase scan (PHP-specific)
- Source roots: `app/`, `src/`, `modules/`, `packages/`, `apps/`
- Laravel structure (record only if present):
  `app/Http/Controllers`, `app/Models`, `database/migrations`,
  `routes/*.php`, `resources/views`
- Symfony structure (record only if present):
  `src/Controller`, `src/Entity`, `config/packages`, `templates`
- CodeIgniter structure (record only if present):
  `app/Controllers`, `app/Models`, `app/Views`, `app/Config/Routes.php`,
  `app/Database/Migrations`
- Phalcon structure (record only if present):
  `apps/*/controllers/`, `apps/*/Module.php`, `models/`
- Attributes/annotations (record only if present):
  `#[Route]`, `#[Entity]`, `#[ORM\\Column]`

## Business module discovery
Scan these paths based on detected framework:
- Laravel: `app/Services/`, `app/Domains/`, `app/Modules/`, `packages/`
- Symfony: `src/` top-level directories
- CodeIgniter: `app/Modules/`, `modules/`
- Phalcon: `src/`, `apps/*/`
- Generic: `src/`, `lib/`

For each path:
- List top 5-10 largest modules by file count
- For each significant module (>5 files), note its purpose if inferable from name
- Identify layered patterns if present: `*/Repository/`, `*/Service/`, `*/Controller/`, `*/Action/`

## Module-level CLAUDE.md signals
Scan these paths for significant modules (framework-specific):
- `src/` - Symfony, Phalcon, custom frameworks
- `app/Services/`, `app/Domains/` - Laravel domain-driven
- `app/Modules/`, `modules/` - Laravel/CI4 HMVC
- `packages/` - Laravel internal packages
- `apps/` - Phalcon multi-app

Create `<path>/<Module>/CLAUDE.md` when:
- Threshold: module has >5 files OR has own `README.md`
- Skip utility dirs: `Helper/`, `Exception/`, `Trait/`, `Contract/`, `Interface/`, `Constants/`, `Support/`
- Layered structure not required; provide module info regardless of architecture

### Module CLAUDE.md content (max 120 lines)
- Purpose: 1-2 sentence module description
- Structure: list subdirectories (Service/, Repository/, etc.)
- Key classes: main service/manager/action classes
- Dependencies: other modules this depends on (via use statements)
- Entry points: main public interfaces/facades
- Framework-specific: ServiceProvider (Laravel), Module.php (Phalcon/CI4)

## Worker/Job detection
- `bin/worker.php` or similar worker entry points
- `*/Job/`, `*/Jobs/`, `*/Worker/` directories
- Queue config files (`queue.php`, `rabbitmq.php`, `amqp.php`)
- List job classes if present

## API versioning detection
- `routes_v*.php` or `routes/v*/` patterns
- `controllers/v*/` directory structure
- Note current/active API version from route files or config

## Mandatory output (PHP module CLAUDE.md)
Include these if detected (list actual names found):
- **Controllers**: list controller directories/classes
- **Models**: list model/entity classes or directory
- **Services**: list service classes or directory
- **Repositories**: list repository classes or directory
- **Routes**: list route files and versioning pattern
- **Migrations**: mention migrations dir and file count
- **Middleware**: list middleware classes
- **Views/templates**: mention view engine and layout
- **Workers/Jobs**: list job classes if present
- **Business modules**: list top modules from detected source paths by size

## Command sources
- `composer.json` scripts
- README/docs or CI
- `php artisan`, `bin/console` usage in docs/scripts
- `bin/worker.php` commands
- Only include commands present in repo

## Key paths to mention (only if present)
- `app/`, `src/`, `apps/`
- `public/`, `routes/`, `config/`, `database/`
- `app/Http/`, `resources/`, `storage/` (Laravel)
- `templates/` (Symfony)
- `app/Controllers/`, `app/Views/` (CI4)
- `apps/*/controllers/`, `models/` (Phalcon)
- `tests/`, `tests/acceptance/`, `tests/unit/`
FILE:references/python.md
# Python

## Detection signals
- `pyproject.toml`
- `requirements.txt`, `requirements-dev.txt`, `Pipfile`, `poetry.lock`
- `tox.ini`, `pytest.ini`
- `manage.py`
- `setup.py`, `setup.cfg`
- `settings.py`, `urls.py` (Django)

## Multi-module signals
- Multiple `pyproject.toml`/`setup.py`/`setup.cfg` in subdirs
- `packages/` or `apps/` each with its own package config
- Django-style `apps/` with multiple `apps.py` (if present)

## Before generating, analyze these sources
- `pyproject.toml` or `setup.py` / `setup.cfg`
- `requirements*.txt`, `Pipfile`, `poetry.lock`
- `tox.ini`, `pytest.ini`
- `manage.py`, `settings.py`, `urls.py` (if Django)
- Package roots under `src/`, `app/`, `packages/` (if present)

## Codebase scan (Python-specific)
- Source roots: `src/`, `app/`, `packages/`, `tests/`
- Folder patterns (record only if present):
  `api`, `routers`, `views`, `services`, `repositories`,
  `models`, `schemas`, `utils`, `config`
- Django structure (record only if present):
  `apps.py`, `models.py`, `views.py`, `urls.py`, `migrations/`, `settings.py`
- FastAPI/Flask markers (record only if present):
  `FastAPI()`, `APIRouter`, `@app.get`, `@router.post`,
  `Flask(__name__)`, `Blueprint`
- Type model usage (record only if present):
  `pydantic.BaseModel`, `TypedDict`, `dataclass`

## Mandatory output (Python module CLAUDE.md)
Include these if detected (list actual names found):
- **Routers/views**: list API router or view files
- **Services**: list service modules
- **Models/schemas**: list data models (Pydantic, SQLAlchemy, Django)
- **Repositories**: list repository or DAO modules
- **Migrations**: mention migrations dir
- **Middleware**: list middleware classes
- **Django apps**: list installed apps (if Django)

## Command sources
- `pyproject.toml` tool sections
- README/docs or CI
- Repo scripts invoking Python tools
- `python manage.py`, `pytest`, `tox` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `src/`, `app/`, `scripts/`
- `templates/`, `static/`
- `tests/`
FILE:references/react-native.md
# React Native

## Detection signals
- `package.json` with `react-native`
- `react-native.config.js`
- `metro.config.js`
- `ios/`, `android/`
- `babel.config.js`, `app.json`, `app.config.*`
- `eas.json`, `expo` in `package.json`

## Multi-module signals
- `pnpm-workspace.yaml`, `lerna.json`, `nx.json`, `turbo.json`
- Root `package.json` with `workspaces`
- `packages/` or `apps/` each with `package.json`

## Before generating, analyze these sources
- Root `package.json` and workspace config (`pnpm-workspace.yaml`, `lerna.json`,
  `nx.json`, `turbo.json`)
- `react-native.config.js`, `metro.config.js`
- `ios/` and `android/` native folders
- `app.json` / `app.config.*` / `eas.json` (if Expo)

## Codebase scan (React Native-specific)
- Source roots: `src/`, `app/`
- Entry points (record only if present):
  `index.js`, `index.ts`, `App.tsx`
- Native folders (record only if present): `ios/`, `android/`
- Navigation/state (record only if present):
  `react-navigation`, `redux`, `mobx`
- Native module patterns (record only if present):
  `NativeModules`, `TurboModule`

## Mandatory output (React Native module CLAUDE.md)
Include these if detected (list actual names found):
- **Screens/navigators**: list screen components and navigators
- **Components**: list shared component directories
- **Services/API**: list API client modules
- **State management**: list store setup
- **Native modules**: list custom native modules
- **Platform folders**: mention ios/ and android/ setup

## Command sources
- `package.json` scripts
- README/docs or CI
- Native build files in `ios/` and `android/`
- `expo` script usage in docs/scripts (if Expo)
- Only include commands present in repo

## Key paths to mention (only if present)
- `ios/`, `android/`
- `src/`, `app/`
FILE:references/react-web.md
# React (Web)

## Detection signals
- `package.json`
- `src/`, `public/`
- `vite.config.*`, `next.config.*`, `webpack.config.*`
- `tsconfig.json`
- `turbo.json`
- `app/` or `pages/` (Next.js)

## Multi-module signals
- `pnpm-workspace.yaml`, `lerna.json`, `nx.json`, `turbo.json`
- Root `package.json` with `workspaces`
- `apps/` and `packages/` each with `package.json`

## Before generating, analyze these sources
- Root `package.json` and workspace config (`pnpm-workspace.yaml`, `lerna.json`,
  `nx.json`, `turbo.json`)
- `apps/*/package.json`, `packages/*/package.json` (if monorepo)
- `vite.config.*`, `next.config.*`, `webpack.config.*`
- `tsconfig.json` / `jsconfig.json`

## Codebase scan (React web-specific)
- Source roots: `src/`, `app/`, `pages/`, `components/`, `hooks/`, `services/`
- Folder patterns (record only if present):
  `routes`, `store`, `state`, `api`, `utils`, `assets`
- Routing markers (record only if present):
  React Router (`Routes`, `Route`), Next (`app/`, `pages/`)
- State management (record only if present):
  `redux`, `zustand`, `recoil`
- Naming conventions (record only if present):
  hooks `use*`, components PascalCase

## Mandatory output (React web module CLAUDE.md)
Include these if detected (list actual names found):
- **Pages/routes**: list page components or route files
- **Components**: list shared component directories
- **Hooks**: list custom hooks
- **Services/API**: list API client modules
- **State management**: list store setup (Redux, Zustand, etc.)
- **Utils**: list utility modules

## Command sources
- `package.json` scripts
- README/docs or CI
- Only include commands present in repo

## Key paths to mention (only if present)
- `src/`, `public/`
- `app/`, `pages/`, `components/`
- `hooks/`, `services/`
- `apps/`, `packages/` (monorepos)
FILE:references/ruby.md
# Ruby / Rails

## Detection signals
- `Gemfile`, `Gemfile.lock`
- `Rakefile`
- `config.ru`
- `bin/rails` or `bin/rake`
- `config/application.rb`
- `config/routes.rb`

## Multi-module signals
- Multiple `Gemfile` or `.gemspec` files in subdirs
- `gems/`, `packages/`, or `engines/` with separate gem specs
- Multiple Rails apps under `apps/` (each with `config/application.rb`)

## Before generating, analyze these sources
- `Gemfile`, `Gemfile.lock`, and any `.gemspec`
- `config/application.rb`, `config/routes.rb`
- `Rakefile` / `bin/rails` (if present)
- `engines/`, `gems/`, `apps/` (if multi-app/engine setup)

## Codebase scan (Ruby/Rails-specific)
- Source roots: `app/`, `lib/`, `engines/`, `gems/`
- Rails layers (record only if present):
  `app/models`, `app/controllers`, `app/views`, `app/jobs`, `app/services`
- Config and initializers (record only if present):
  `config/routes.rb`, `config/application.rb`, `config/initializers/`
- ActiveRecord/migrations (record only if present):
  `db/migrate`, `ActiveRecord::Base`
- Tests (record only if present): `spec/`, `test/`

## Mandatory output (Ruby module CLAUDE.md)
Include these if detected (list actual names found):
- **Controllers**: list controller classes
- **Models**: list ActiveRecord models
- **Services**: list service objects
- **Jobs**: list background job classes
- **Routes**: summarize key route namespaces
- **Migrations**: mention db/migrate count
- **Engines**: list mounted engines (if any)

## Command sources
- README/docs or CI invoking `bundle`, `rails`, `rake`
- `Rakefile` tasks
- `bundle exec` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `app/`, `config/`, `db/`
- `app/controllers/`, `app/models/`, `app/views/`
- `spec/` or `test/`
FILE:references/rust.md
# Rust

## Detection signals
- `Cargo.toml`, `Cargo.lock`
- `rust-toolchain.toml`
- `src/main.rs`, `src/lib.rs`
- Workspace members in `Cargo.toml`, `crates/`

## Multi-module signals
- `[workspace]` with `members` in `Cargo.toml`
- Multiple `Cargo.toml` under `crates/` or `apps/`

## Before generating, analyze these sources
- Root `Cargo.toml`, `Cargo.lock`
- `rust-toolchain.toml` (if present)
- Workspace `Cargo.toml` in `crates/` or `apps/`
- `src/main.rs` / `src/lib.rs`

## Codebase scan (Rust-specific)
- Source roots: `src/`, `crates/`, `tests/`, `examples/`
- Module layout (record only if present):
  `lib.rs`, `main.rs`, `mod.rs`, `src/bin/*`
- Serde usage (record only if present):
  `#[derive(Serialize, Deserialize)]`
- Async/runtime (record only if present):
  `tokio`, `async-std`
- Web frameworks (record only if present):
  `axum`, `actix-web`, `warp`

## Mandatory output (Rust module CLAUDE.md)
Include these if detected (list actual names found):
- **Crates**: list workspace crates with purpose
- **Binaries**: list `src/bin/*` or `[[bin]]` targets
- **Modules**: list top-level `mod` declarations
- **Handlers/routes**: list web handler modules (if web app)
- **Models**: list domain model modules
- **Config**: list config loading modules

## Command sources
- README/docs or CI
- Repo scripts invoking `cargo`
- `cargo test`, `cargo run` usage in docs/scripts
- Only include commands present in repo

## Key paths to mention (only if present)
- `src/`, `crates/`
- `tests/`, `examples/`, `benches/`

---
name: skill-master
description: 发现代码库模式并自动为 .claude/skills/ 生成 SKILL 文件。适用于分析项目中缺失的技能、从代码库模式创建新技能，或将技能与项目结构同步。
version: 1.0.0
---

# Skill Master

## 概述

分析代码库以发现模式，并在 `.claude/skills/` 中生成/更新 SKILL 文件。支持多平台项目，具备针对特定技术栈的模式检测能力。

**能力：**
- 扫描代码库以发现架构模式（ViewModel、Repository、Room 等）
- 将检测到的模式与现有技能进行对比
- 使用真实代码示例自动生成 SKILL 文件
- 版本跟踪与智能更新

## AI 如何发现并使用此技能

当用户执行以下操作时，此技能会被触发：
- 要求分析项目中缺失的技能
- 请求从代码库模式生成技能
- 希望同步或更新现有技能
- 提及 "skill discovery"、"generate skills" 或 "skill-sync"

**检测信号：**
- 存在 `.claude/skills/` 目录
- 项目结构与已知模式匹配
- 指示平台的构建/配置文件（参见参考文档）

## 模式

### 发现模式

分析代码库并报告缺失的技能。

**步骤：**
1. 通过构建/配置文件检测平台（参见参考文档）
2. 扫描源码根目录以查找模式指示符
3. 将检测到的模式与现有 `.claude/skills/` 进行对比
4. 输出差距分析报告

**输出格式：**
```
Detected Patterns: {count}
| Pattern | Files Found | Example Location |
|---------|-------------|------------------|
| {name}  | {count}     | {path}           |

Existing Skills: {count}
Missing Skills: {count}
- {skill-name}: {pattern}, {file-count} files found
```

### 生成模式

从检测到的模式创建 SKILL 文件。

**步骤：**
1. 运行发现流程以识别缺失的技能
2. 对每个缺失的技能：
   - 查找 2-3 个具有代表性的源文件
   - 提取：导入、注解、类结构、约定
   - 若存在 `.ruler/*.md`，从中提取规则
3. 使用模板结构生成 SKILL.md
4. 添加版本和来源标记

**生成的 SKILL 结构：**
```yaml
---
name: {pattern-name}
description: {Generated description with trigger keywords}
version: 1.0.0
---

# {Title}

## Overview
{Brief description from pattern analysis}

## File Structure
{Extracted from codebase}

## Implementation Pattern
{Real code examples - anonymized}

## Rules
### Do
{From .ruler/*.md + codebase conventions}

### Don't
{Anti-patterns found}

## File Location
{Actual paths from codebase}
```

## 创建策略

当目标 SKILL 文件不存在时：
1. 使用模板生成新文件
2. 在 frontmatter 中设置 `version: 1.0.0`
3. 包含所有必需章节
4. 在末尾添加来源标记（参见标记格式）

## 更新策略

**标记检查：** 在文件末尾查找 `<!-- Generated by skill-master command`。

**若标记存在（后续运行）：**
- 智能合并：保留自定义内容，添加缺失章节
- 递增版本：主版本（破坏性变更）/ 次版本（功能）/ 补丁（修复）
- 更新标记中的来源列表

**若标记不存在（首次对现有文件运行）：**
- 备份：`SKILL.md` → `SKILL.md.bak`
- 使用备份作为来源，提取相关内容
- 生成带标记的新文件
- 设置 `version: 1.0.0`

## 标记格式

放置在生成的 SKILL.md 末尾：

```html
<!-- Generated by skill-master command
Version: {version}
Sources:
- path/to/source1.kt
- path/to/source2.md
- .ruler/rule-file.md
Last updated: {YYYY-MM-DD}
-->
```

## 平台参考文档

检测到平台时读取相关参考文档：

| 平台 | 检测文件 | 参考文档 |
|----------|-----------------|-----------|
| Android/Gradle | `build.gradle`, `settings.gradle` | `references/android.md` |
| iOS/Xcode | `*.xcodeproj`, `Package.swift` | `references/ios.md` |
| React (web) | `package.json` + react | `references/react-web.md` |
| React Native | `package.json` + react-native | `references/react-native.md` |
| Flutter/Dart | `pubspec.yaml` | `references/flutter.md` |
| Node.js | `package.json` | `references/node.md` |
| Python | `pyproject.toml`, `requirements.txt` | `references/python.md` |
| Java/JVM | `pom.xml`, `build.gradle` | `references/java.md` |
| .NET/C# | `*.csproj`, `*.sln` | `references/dotnet.md` |
| Go | `go.mod` | `references/go.md` |
| Rust | `Cargo.toml` | `references/rust.md` |
| PHP | `composer.json` | `references/php.md` |
| Ruby | `Gemfile` | `references/ruby.md` |
| Elixir | `mix.exs` | `references/elixir.md` |
| C/C++ | `CMakeLists.txt`, `Makefile` | `references/cpp.md` |
| 未知 | - | `references/generic.md` |

若检测到多个平台，读取多个参考文档。

## 规则

### 应当
- 仅提取代码库中已验证的模式
- 使用真实代码示例（匿名化业务逻辑）
- 在描述中包含触发关键词
- 保持 SKILL.md 在 500 行以内
- 引用外部文件以获取详细内容
- 更新时保留自定义章节
- 首次修改前始终备份

### 不应
- 包含密钥、令牌或凭据
- 包含业务特定逻辑细节
- 生成没有真实内容的占位符
- 未经备份覆盖用户自定义内容
- 创建深层引用链（最多 1 层）
- 写入 `.claude/skills/` 之外的任何位置

## 内容提取规则

**从代码库中：**
- 提取：类结构、注解、导入模式、文件位置、命名约定
- 绝不提取：硬编码值、密钥、API 密钥、个人身份信息（PII）

**从 .ruler/*.md（若存在）：**
- 提取：应当/不应规则、架构约束、依赖规则

## 输出报告

生成后，打印：
```
SKILL GENERATION REPORT

Skills Generated: {count}

{skill-name} [CREATED | UPDATED | BACKED_UP+CREATED]
├── Analyzed: {file-count} source files
├── Sources: {list of source files}
├── Rules from: {.ruler files if any}
└── Output: .claude/skills/{skill-name}/SKILL.md ({line-count} lines)

Validation:
✓ YAML frontmatter valid
✓ Description includes trigger keywords
✓ Content under 500 lines
✓ Has required sections
```

## 安全约束

- 绝不写入 `.claude/skills/` 之外的任何位置
- 未经备份绝不删除内容
- 首次修改前始终备份
- 保留用户自定义内容
- 确定性：相同输入 → 相同输出
FILE:references/android.md
# Android (Gradle/Kotlin)

## 检测信号
- `settings.gradle` 或 `settings.gradle.kts`
- `build.gradle` 或 `build.gradle.kts`
- `gradle.properties`、`gradle/libs.versions.toml`
- `gradlew`、`gradle/wrapper/gradle-wrapper.properties`
- `app/src/main/AndroidManifest.xml`

## 多模块信号
- `settings.gradle*` 中有多个 `include(...)`
- 多个目录包含 `build.gradle*` + `src/`
- 常见根目录：`feature/`、`core/`、`library/`、`domain/`、`data/`

## 预生成来源
- `settings.gradle*`（模块列表）
- `build.gradle*`（根 + 模块）
- `gradle/libs.versions.toml`（依赖）
- `config/detekt/detekt.yml`（若存在）
- `**/AndroidManifest.xml`

## 代码库扫描模式

### 源码根目录
- `*/src/main/java/`、`*/src/main/kotlin/`

### 分层/文件夹模式（如存在则记录）
`features/`、`core/`、`common/`、`data/`、`domain/`、`presentation/`、`ui/`、`di/`、`navigation/`、`network/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| ViewModel | `@HiltViewModel`、`ViewModel()`、`MVI<` | viewmodel-mvi |
| Repository | `*Repository`、`*RepositoryImpl` | data-repository |
| UseCase | `operator fun invoke`、`*UseCase` | domain-usecase |
| Room Entity | `@Entity`、`@PrimaryKey`、`@ColumnInfo` | room-entity |
| Room DAO | `@Dao`、`@Query`、`@Insert`、`@Update` | room-dao |
| Migration | `Migration(`、`@Database(version=` | room-migration |
| Type Converter | `@TypeConverter`、`@TypeConverters` | type-converter |
| DTO | `@SerializedName`、`*Request`、`*Response` | network-dto |
| Compose Screen | `@Composable`、`NavGraphBuilder.` | compose-screen |
| Bottom Sheet | `ModalBottomSheet`、`*BottomSheet(` | bottomsheet-screen |
| Navigation | `@Route`、`NavGraphBuilder.`、`composable(` | navigation-route |
| Hilt Module | `@Module`、`@Provides`、`@Binds`、`@InstallIn` | hilt-module |
| Worker | `@HiltWorker`、`CoroutineWorker`、`WorkManager` | worker-task |
| DataStore | `DataStore<Preferences>`、`preferencesDataStore` | datastore-preference |
| Retrofit API | `@GET`、`@POST`、`@PUT`、`@DELETE` | retrofit-api |
| Mapper | `*.toModel()`、`*.toEntity()`、`*.toDto()` | data-mapper |
| Interceptor | `Interceptor`、`intercept()` | network-interceptor |
| Paging | `PagingSource`、`Pager(`、`PagingData` | paging-source |
| Broadcast Receiver | `BroadcastReceiver`、`onReceive(` | broadcast-receiver |
| Android Service | `: Service()`、`ForegroundService` | android-service |
| Notification | `NotificationCompat`、`NotificationChannel` | notification-builder |
| Analytics | `FirebaseAnalytics`、`logEvent` | analytics-event |
| Feature Flag | `RemoteConfig`、`FeatureFlag` | feature-flag |
| App Widget | `AppWidgetProvider`、`GlanceAppWidget` | app-widget |
| Unit Test | `@Test`、`MockK`、`mockk(`、`every {` | unit-test |

## 强制输出部分

如检测到则包含（列出找到的实际名称）：
- **功能清单**：`feature/` 下的目录
- **核心模块**：`core/`、`library/` 下的目录
- **导航图**：`*Graph.kt`、`*Navigator*.kt`
- **Hilt 模块**：`@Module` 类、`di/` 内容
- **Retrofit API**：`*Api.kt` 接口
- **Room 数据库**：`@Database` 类
- **Worker**：`@HiltWorker` 类
- **Proguard**：`proguard-rules.pro`（如存在）

## 命令来源
- 调用 `./gradlew` 的 README/文档
- 包含 Gradle 命令的 CI 工作流
- 常见：`./gradlew assemble`、`./gradlew test`、`./gradlew lint`
- 仅包含仓库中存在的命令

## 关键路径
- `app/src/main/`、`app/src/main/res/`
- `app/src/main/java/`、`app/src/main/kotlin/`
- `app/src/test/`、`app/src/androidTest/`
- `library/database/migration/`（Room 迁移）
FILE:README.md

FILE:references/cpp.md
# C/C++

## 检测信号
- `CMakeLists.txt`
- `Makefile`、`makefile`
- `*.cpp`、`*.c`、`*.h`、`*.hpp`
- `conanfile.txt`、`conanfile.py`（Conan）
- `vcpkg.json`（vcpkg）

## 多模块信号
- 多个包含 `add_subdirectory` 的 `CMakeLists.txt`
- 子目录中的多个 `Makefile`
- `lib/`、`src/`、`modules/` 目录

## 预生成来源
- `CMakeLists.txt`（依赖、目标）
- `conanfile.*`（依赖）
- `vcpkg.json`（依赖）
- `Makefile`（构建目标）

## 代码库扫描模式

### 源根目录
- `src/`、`lib/`、`include/`

### 分层/文件夹模式（如存在则记录）
`core/`、`utils/`、`network/`、`storage/`、`ui/`、`tests/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Class | `class *`、`public:`、`private:` | cpp-class |
| Header | `*.h`、`*.hpp`、`#pragma once` | header-file |
| Template | `template<`、`typename T` | cpp-template |
| Smart Pointer | `std::unique_ptr`、`std::shared_ptr` | smart-pointer |
| RAII | 析构函数模式、`~*()` | raii-pattern |
| Singleton | `static *& instance()` | singleton |
| Factory | `create*()`、`make*()` | factory-pattern |
| Observer | `subscribe`、`notify`、回调模式 | observer-pattern |
| Thread | `std::thread`、`std::async`、`pthread` | threading |
| Mutex | `std::mutex`、`std::lock_guard` | synchronization |
| Network | `socket`、`asio::`、`boost::asio` | network-cpp |
| Serialization | `nlohmann::json`、`protobuf` | serialization |
| Unit Test | `TEST(`、`TEST_F(`、`gtest` | gtest |
| Catch2 Test | `TEST_CASE(`、`REQUIRE(` | catch2-test |

## 强制输出部分

如检测到则包含：
- **核心模块**：主要功能
- **库**：内部库
- **头文件**：公共 API
- **测试**：测试组织
- **构建目标**：可执行文件、库

## 命令来源
- `CMakeLists.txt` 自定义目标
- `Makefile` 目标
- README/文档、CI
- 常见：`cmake`、`make`、`ctest`
- 仅包含仓库中存在的命令

## 关键路径
- `src/`、`include/`
- `lib/`、`libs/`
- `tests/`、`test/`
- `build/`（源外构建）
FILE:references/dotnet.md
# .NET (C#/F#)

## 检测信号
- `*.csproj`、`*.fsproj`
- `*.sln`
- `global.json`
- `appsettings.json`
- `Program.cs`、`Startup.cs`

## 多模块信号
- 多个 `*.csproj` 文件
- 包含多个项目的解决方案
- 包含项目的 `src/`、`tests/` 目录

## 预生成来源
- `*.csproj`（依赖、SDK）
- `*.sln`（项目结构）
- `appsettings.json`（配置）
- `global.json`（SDK 版本）

## 代码库扫描模式

### 源根目录
- `src/`、`*/`（按项目）

### 分层/文件夹模式（如存在则记录）
`Controllers/`、`Services/`、`Repositories/`、`Models/`、`Entities/`、`DTOs/`、`Middleware/`、`Extensions/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Controller | `[ApiController]`、`ControllerBase`、`[HttpGet]` | aspnet-controller |
| Service | `I*Service`、`class *Service` | dotnet-service |
| Repository | `I*Repository`、`class *Repository` | dotnet-repository |
| Entity | `class *Entity`、`[Table]`、`[Key]` | ef-entity |
| DTO | `class *Dto`、`class *Request`、`class *Response` | dto-pattern |
| DbContext | `: DbContext`、`DbSet<` | ef-dbcontext |
| Middleware | `IMiddleware`、`RequestDelegate` | aspnet-middleware |
| Background Service | `BackgroundService`、`IHostedService` | background-service |
| MediatR Handler | `IRequestHandler<`、`INotificationHandler<` | mediatr-handler |
| SignalR Hub | `: Hub`、`[HubName]` | signalr-hub |
| Minimal API | `app.MapGet(`、`app.MapPost(` | minimal-api |
| gRPC Service | `*.proto`、`: *Base` | grpc-service |
| EF Migration | `Migrations/`、`AddMigration` | ef-migration |
| Unit Test | `[Fact]`、`[Theory]`、`xUnit` | xunit-test |
| Integration Test | `WebApplicationFactory`、`IClassFixture` | integration-test |

## 强制输出部分

如检测到则包含：
- **控制器**：API 端要点
- **Services**：业务逻辑
- **Repositories**：数据访问（EF Core）
- **Entities/DTOs**：数据模型
- **Middleware**：请求管道
- **Background services**：托管服务

## 命令来源
- `*.csproj` 目标
- README/docs、CI
- 常见：`dotnet build`、`dotnet test`、`dotnet run`
- 仅包含仓库中存在的命令

## 关键路径
- `src/*/`、项目目录
- `tests/`
- `Migrations/`
- `Properties/`
FILE:references/elixir.md
# Elixir/Erlang

## 检测信号
- `mix.exs`
- `mix.lock`
- `config/config.exs`
- `lib/`、`test/` 目录

## 多模块信号
- Umbrella 应用（`apps/` 目录）
- 子目录中有多个 `mix.exs`
- `rel/` 用于发布

## 预生成来源
- `mix.exs`（依赖、配置）
- `config/*.exs`（配置）
- `rel/config.exs`（发布）

## 代码库扫描模式

### 源码根目录
- `lib/`、`apps/*/lib/`

### 层/文件夹模式（如存在则记录）
`controllers/`、`views/`、`channels/`、`contexts/`、`schemas/`、`workers/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Phoenix Controller | `use *Web, :controller`、`def index` | phoenix-controller |
| Phoenix LiveView | `use *Web, :live_view`、`mount/3` | phoenix-liveview |
| Phoenix Channel | `use *Web, :channel`、`join/3` | phoenix-channel |
| Ecto Schema | `use Ecto.Schema`、`schema "` | ecto-schema |
| Ecto Migration | `use Ecto.Migration`、`create table` | ecto-migration |
| Ecto Changeset | `cast/4`、`validate_required` | ecto-changeset |
| Context | `defmodule *Context`、`def list_*` | phoenix-context |
| GenServer | `use GenServer`、`handle_call` | genserver |
| Supervisor | `use Supervisor`、`start_link` | supervisor |
| Task | `Task.async`、`Task.Supervisor` | elixir-task |
| Oban Worker | `use Oban.Worker`、`perform/1` | oban-worker |
| Absinthe | `use Absinthe.Schema`、`field :` | graphql-schema |
| ExUnit Test | `use ExUnit.Case`、`test "` | exunit-test |

## 强制输出部分

如检测到则包含：
- **Controllers/LiveViews**：HTTP/WebSocket 处理器
- **Contexts**：业务逻辑
- **Schemas**：Ecto 模型
- **Channels**：实时处理器
- **Workers**：后台任务

## 命令来源
- `mix.exs` 别名
- README/docs、CI
- 常见：`mix deps.get`、`mix test`、`mix phx.server`
- 仅包含仓库中存在的命令

## 关键路径
- `lib/*/`、`lib/*_web/`
- `priv/repo/migrations/`
- `test/`
- `config/`
FILE:references/flutter.md
# Flutter/Dart

## 检测信号
- `pubspec.yaml`
- `lib/main.dart`
- `android/`、`ios/`、`web/` 目录
- `.dart_tool/`
- `analysis_options.yaml`

## 多模块信号
- `melos.yaml`（monorepo）
- 子目录中有多个 `pubspec.yaml`
- `packages/` 目录

## 预生成来源
- `pubspec.yaml`（依赖）
- `analysis_options.yaml`
- `build.yaml`（如使用 build_runner）
- `lib/main.dart`（入口点）

## 代码库扫描模式

### 源码根目录
- `lib/`、`test/`

### 层/文件夹模式（如存在则记录）
`screens/`、`widgets/`、`models/`、`services/`、`providers/`、`repositories/`、`utils/`、`constants/`、`bloc/`、`cubit/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Screen/Page | `*Screen`、`*Page`、`extends StatefulWidget` | flutter-screen |
| Widget | `extends StatelessWidget`、`extends StatefulWidget` | flutter-widget |
| BLoC | `extends Bloc<`、`extends Cubit<` | bloc-pattern |
| Provider | `ChangeNotifier`、`Provider.of<`、`context.read<` | provider-pattern |
| Riverpod | `@riverpod`、`ref.watch`、`ConsumerWidget` | riverpod-provider |
| GetX | `GetxController`、`Get.put`、`Obx(` | getx-controller |
| Repository | `*Repository`、`abstract class *Repository` | data-repository |
| Service | `*Service` | service-layer |
| Model | `fromJson`、`toJson`、`@JsonSerializable` | json-model |
| Freezed | `@freezed`、`part '*.freezed.dart'` | freezed-model |
| API Client | `Dio`、`http.Client`、`Retrofit` | api-client |
| Navigation | `Navigator`、`GoRouter`、`auto_route` | flutter-navigation |
| Localization | `AppLocalizations`、`l10n`、`intl` | flutter-l10n |
| Testing | `testWidgets`、`WidgetTester`、`flutter_test` | widget-test |
| Integration Test | `integration_test`、`IntegrationTestWidgetsFlutterBinding` | integration-test |

## 强制输出部分

如检测到则包含：
- **Screens 清单**：`screens/`、`pages/` 下的目录
- **状态管理**：BLoC、Provider、Riverpod、GetX
- **导航设置**：GoRouter、auto_route、Navigator
- **DI 方式**：get_it、injectable、手动
- **API 层**：Dio、http、Retrofit
- **模型**：Freezed、json_serializable

## 命令来源
- `pubspec.yaml` 脚本（如使用 melos）
- README/docs
- 常见：`flutter run`、`flutter test`、`flutter build`
- 仅包含仓库中存在的命令

## 关键路径
- `lib/`、`test/`
- `lib/screens/`、`lib/widgets/`
- `lib/bloc/`、`lib/providers/`
- `assets/`
FILE:references/generic.md
# 通用/未知技术栈

当未检测到特定平台时的回退参考。

## 检测信号
- 未找到特定构建/配置文件
- 混合技术栈
- 仅文档仓库

## 多模块信号
- 多个具有独立关注点的目录
- `packages/`、`modules/`、`libs/` 目录
- 无特定工具链的 monorepo 结构

## 预生成来源
- `README.md`（项目概览）
- `docs/*`（文档）
- `.env.example`（环境变量）
- `docker-compose.yml`（服务）
- CI 文件（`.github/workflows/` 等）

## 代码库扫描模式

### 源码根目录
- `src/`、`lib/`、`app/`

### 层/文件夹模式（如存在则记录）
`api/`、`core/`、`utils/`、`services/`、`models/`、`config/`、`scripts/`

### 通用模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Entry Point | `main.*`、`index.*`、`app.*` | entry-point |
| Config | `config.*`、`settings.*` | config-file |
| API Client | `api/`、`client/`、HTTP 调用 | api-client |
| Model | `model/`、`types/`、数据结构 | data-model |
| Service | `service/`、业务逻辑 | service-layer |
| Utility | `utils/`、`helpers/`、`common/` | utility-module |
| Test | `test/`、`tests/`、`*_test.*`、`*.test.*` | test-file |
| Script | `scripts/`、`bin/` | script-file |
| Documentation | `docs/`、`*.md` | documentation |

## 强制输出部分

如检测到则包含：
- **项目结构**：主要目录
- **入口点**：主文件
- **配置**：配置文件
- **依赖**：任何包管理器
- **构建/运行命令**：来自 README/脚本

## 命令来源
- `README.md`（查找代码块）
- `Makefile`、`Taskfile.yml`
- `scripts/` 目录
- CI 工作流
- 仅包含仓库中存在的命令

## 关键路径
- `src/`、`lib/`
- `docs/`
- `scripts/`
- `config/`

## 备注

使用此通用参考时：
1. 扫描任何可识别的模式
2. 记录实际发现的项目结构
3. 额外如果可用，从 README 中提取命令
4. 记录文档中提到的任何技术
5. 保持输出简洁且基于事实
FILE:references/go.md
# Go

## 检测信号
- `go.mod`
- `go.sum`
- `main.go`
- `cmd/`、`internal/`、`pkg/` 目录

## 多模块信号
- `go.work`（工作区）
- 多个 `go.mod` 文件
- `cmd/*/main.go`（多个二进制文件）

## 预生成来源
- `go.mod`（依赖）
- `Makefile`（构建命令）
- `config/*.yaml` 或 `*.toml`

## 代码库扫描模式

### 源码根目录
- `cmd/`、`internal/`、`pkg/`

### 层/文件夹模式（如存在则记录）
`handler/`、`service/`、`repository/`、`model/`、`middleware/`、`config/`、`util/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| HTTP Handler | `http.Handler`、`http.HandlerFunc`、`gin.Context` | http-handler |
| Gin Route | `gin.Engine`、`r.GET(`、`r.POST(` | gin-route |
| Echo Route | `echo.Echo`、`e.GET(`、`e.POST(` | echo-route |
| Fiber Route | `fiber.App`、`app.Get(`、`app.Post(` | fiber-route |
| gRPC Service | `*.proto`、`pb.*Server` | grpc-service |
| Repository | `type *Repository interface`、`*Repository` | data-repository |
| Service | `type *Service interface`、`*Service` | service-layer |
| GORM Model | `gorm.Model`、`*gorm.DB` | gorm-model |
| sqlx | `sqlx.DB`、`sqlx.NamedExec` | sqlx-usage |
| Migration | `goose`、`golang-migrate` | db-migration |
| Middleware | `func(*Context)`、`middleware.*` | go-middleware |
| Worker | `go func()`、`sync.WaitGroup`、`errgroup` | worker-goroutine |
| Config | `viper`、`envconfig`、`cleanenv` | config-loader |
| Unit Test | `*_test.go`、`func Test*(t *testing.T)` | go-test |
| Mock | `mockgen`、`*_mock.go` | go-mock |

## 强制输出部分

如检测到则包含：
- **HTTP handlers**：API 端点
- **Services**：业务逻辑
- **Repositories**：数据访问
- **Models**：数据结构
- **Middleware**：请求拦截器
- **Migrations**：数据库迁移

## 命令来源
- `Makefile` 目标
- README/文档、CI
- 常见：`go build`、`go test`、`go run`
- 仅包含仓库中存在的命令

## 关键路径
- `cmd/`、`internal/`、`pkg/`
- `api/`、`handler/`
- `migrations/`
- `config/`
FILE:references/ios.md
# iOS（Xcode/Swift）

## 检测信号
- `*.xcodeproj`、`*.xcworkspace`
- `Package.swift`（SPM）
- `Podfile`、`Podfile.lock`（CocoaPods）
- `Cartfile`（Carthage）
- `*.pbxproj`
- `Info.plist`

## 多模块信号
- `*.xcodeproj` 中的多个 target
- 多个 `Package.swift` 文件
- 包含多个项目的工作区
- `Modules/`、`Packages/`、`Features/` 目录

## 预生成来源
- `*.xcodeproj/project.pbxproj`（target 列表）
- `Package.swift`（依赖、target）
- `Podfile`（依赖）
- `*.xcconfig`（构建配置）
- `Info.plist` 文件

## 代码库扫描模式

### 源码根目录
- `*/Sources/`、`*/Source/`
- `*/App/`、`*/Core/`、`*/Features/`

### 层/文件夹模式（如存在则记录）
`Models/`、`Views/`、`ViewModels/`、`Services/`、`Networking/`、`Utilities/`、`Extensions/`、`Coordinators/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| SwiftUI View | `struct *: View`、`var body: some View` | swiftui-view |
| UIKit VC | `UIViewController`、`viewDidLoad()` | uikit-viewcontroller |
| ViewModel | `@Observable`、`ObservableObject`、`@Published` | viewmodel-observable |
| Coordinator | `Coordinator`、`*Coordinator` | coordinator-pattern |
| Repository | `*Repository`、`protocol *Repository` | data-repository |
| Service | `*Service`、`protocol *Service` | service-layer |
| Core Data | `NSManagedObject`、`@NSManaged`、`.xcdatamodeld` | coredata-entity |
| Realm | `Object`、`@Persisted` | realm-model |
| Network | `URLSession`、`Alamofire`、`Moya` | network-client |
| Dependency | `@Inject`、`Container`、`Swinject` | di-container |
| Navigation | `NavigationStack`、`NavigationPath` | navigation-swiftui |
| Combine | `Publisher`、`AnyPublisher`、`sink` | combine-publisher |
| Async/Await | `async`、`await`、`Task {` | async-await |
| Unit Test | `XCTestCase`、`func test*()` | xctest |
| UI Test | `XCUIApplication`、`XCUIElement` | xcuitest |

## 强制输出部分

如检测到则包含：
- **Targets 清单**：来自 pbxproj 的列表
- **Modules/Packages**：SPM 包、Pods
- **视图架构**：SwiftUI 与 UIKit
- **状态管理**：Combine、Observable 等
- **网络层**：URLSession、Alamofire 等
- **持久化**：Core Data、Realm、UserDefaults
- **DI 设置**：Swinject、手动注入

## 命令来源
- 包含 xcodebuild 命令的 README/文档
- `fastlane/Fastfile` lanes
- CI 工作流（`.github/workflows/`、`.gitlab-ci.yml`）
- 常见：`xcodebuild test`、`fastlane test`
- 仅包含仓库中存在的命令

## 关键路径
- `*/Sources/`、`*/Tests/`
- `*.xcodeproj/`、`*.xcworkspace/`
- `Pods/`（如果使用 CocoaPods）
- `Packages/`（如果使用 SPM 本地包）
FILE:references/java.md
# Java/JVM（Spring 等）

## 检测信号
- `pom.xml`（Maven）
- `build.gradle`、`build.gradle.kts`（Gradle）
- `settings.gradle`（多模块）
- `src/main/java/`、`src/main/kotlin/`
- `application.properties`、`application.yml`

## 多模块信号
- 多个带 `<modules>` 的 `pom.xml`
- 多个带 `include()` 的 `build.gradle`
- `modules/`、`services/` 目录

## 预生成来源
- `pom.xml` 或 `build.gradle*`（依赖）
- `application.properties/yml`（配置）
- `settings.gradle`（模块）
- `docker-compose.yml`（服务）

## 代码库扫描模式

### 源码根目录
- `src/main/java/`、`src/main/kotlin/`
- `src/test/java/`、`src/test/kotlin/`

### 层/文件夹模式（如存在则记录）
`controller/`、`service/`、`repository/`、`model/`、`entity/`、`dto/`、`config/`、`exception/`、`util/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| REST Controller | `@RestController`、`@GetMapping`、`@PostMapping` | spring-controller |
| Service | `@Service`、`class *Service` | spring-service |
| Repository | `@Repository`、`JpaRepository`、`CrudRepository` | spring-repository |
| Entity | `@Entity`、`@Table`、`@Id` | jpa-entity |
| DTO | `class *DTO`、`class *Request`、`class *Response` | dto-pattern |
| Config | `@Configuration`、`@Bean` | spring-config |
| Component | `@Component`、`@Autowired` | spring-component |
| Security | `@EnableWebSecurity`、`SecurityFilterChain` | spring-security |
| Validation | `@Valid`、`@NotNull`、`@Size` | validation-pattern |
| Exception Handler | `@ControllerAdvice`、`@ExceptionHandler` | exception-handler |
| Scheduler | `@Scheduled`、`@EnableScheduling` | scheduled-task |
| Event | `ApplicationEvent`、`@EventListener` | event-listener |
| Flyway Migration | `V*__*.sql`、`flyway` | flyway-migration |
| Liquibase | `changelog*.xml`、`liquibase` | liquibase-migration |
| Unit Test | `@Test`、`@SpringBootTest`、`MockMvc` | spring-test |
| Integration Test | `@DataJpaTest`、`@WebMvcTest` | integration-test |

## 强制输出章节

如果检测到以下内容，请包含：
- **Controllers**：REST 端点
- **Services**：业务逻辑
- **Repositories**：数据访问（JPA、JDBC）
- **Entities/DTOs**：数据模型
- **Configuration**：Spring bean、配置文件
- **Security**：认证配置

## 命令来源
- `pom.xml` 插件、`build.gradle` 任务
- README/文档、CI
- 常见：`./mvnw`、`./gradlew`、`mvn test`、`gradle test`
- 仅包含仓库中存在的命令

## 关键路径
- `src/main/java/`、`src/main/kotlin/`
- `src/main/resources/`
- `src/test/`
- `db/migration/`（Flyway）
FILE:references/node.md
# Node.js

## 检测信号
- `package.json`（不含 react/react-native）
- `tsconfig.json`
- `node_modules/`
- `*.js`、`*.ts`、`*.mjs`、`*.cjs` 入口文件

## 多模块信号
- `pnpm-workspace.yaml`、`lerna.json`
- `nx.json`、`turbo.json`
- 子目录中存在多个 `package.json`
- `packages/`、`apps/` 目录

## 预生成来源
- `package.json`（依赖、脚本）
- `tsconfig.json`（路径、编译器选项）
- `.env.example`（环境变量）
- `docker-compose.yml`（服务）

## 代码库扫描模式

### 源码根目录
- `src/`、`lib/`、`app/`

### 层/文件夹模式（如存在则记录）
`controllers/`、`services/`、`models/`、`routes/`、`middleware/`、`utils/`、`config/`、`types/`、`repositories/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Express 路由 | `app.get(`、`app.post(`、`Router()` | express-route |
| Express 中间件 | `(req, res, next)`、`app.use(` | express-middleware |
| NestJS 控制器 | `@Controller`、`@Get`、`@Post` | nestjs-controller |
| NestJS 服务 | `@Injectable`、`@Service` | nestjs-service |
| NestJS 模块 | `@Module`、`imports:`、`providers:` | nestjs-module |
| Fastify 路由 | `fastify.get(`、`fastify.post(` | fastify-route |
| GraphQL 解析器 | `@Resolver`、`@Query`、`@Mutation` | graphql-resolver |
| TypeORM 实体 | `@Entity`、`@Column`、`@PrimaryGeneratedColumn` | typeorm-entity |
| Prisma 模型 | `prisma.*.create`、`prisma.*.findMany` | prisma-usage |
| Mongoose 模型 | `mongoose.Schema`、`mongoose.model(` | mongoose-model |
| Sequelize 模型 | `Model.init`、`DataTypes` | sequelize-model |
| 队列工作进程 | `Bull`、`BullMQ`、`process(` | queue-worker |
| 定时任务 | `@Cron`、`node-cron`、`cron.schedule` | cron-job |
| WebSocket | `ws`、`socket.io`、`io.on(` | websocket-handler |
| 单元测试 | `describe(`、`it(`、`expect(`、`jest` | jest-test |
| E2E 测试 | `supertest`、`request(app)` | e2e-test |

## 强制输出章节

如果检测到以下内容，请包含：
- **路由/控制器**：API 端点
- **服务层**：业务逻辑
- **数据库**：ORM/ODM 使用（TypeORM、Prisma、Mongoose）
- **中间件**：认证、验证、错误处理
- **后台任务**：队列、定时任务
- **WebSocket 处理器**：实时功能

## 命令来源
- `package.json` 的 scripts 部分
- README/文档
- CI 工作流
- 常见：`npm run dev`、`npm run build`、`npm test`
- 仅包含仓库中存在的命令

## 关键路径
- `src/`、`lib/`
- `src/routes/`、`src/controllers/`
- `src/services/`、`src/models/`
- `prisma/`、`migrations/`
FILE:references/php.md
# PHP

## 检测信号
- `composer.json`、`composer.lock`
- `public/index.php`
- `artisan`（Laravel）
- `spark`（CodeIgniter 4）
- `bin/console`（Symfony）
- `app/Config/App.php`（CodeIgniter 4）
- composer.json 中的 `ext-phalcon`（Phalcon）
- `phalcon/devtools`（Phalcon）

## 多模块信号
- `packages/` 目录
- Laravel 模块（`app/Modules/`）
- CodeIgniter 模块（`app/Modules/`、`modules/`）
- Phalcon 多应用（`apps/*/`）
- 子目录中存在多个 `composer.json`

## 预生成来源
- `composer.json`（依赖）
- `.env.example`（环境变量）
- `config/*.php`（Laravel/Symfony）
- `routes/*.php`（Laravel）
- `app/Config/*`（CodeIgniter 4）
- `apps/*/config/`（Phalcon）

## 代码库扫描模式

### 源码根目录
- `app/`、`src/`、`apps/`

### 层/文件夹模式（如存在则记录）
`Controllers/`、`Services/`、`Repositories/`、`Models/`、`Entities/`、`Http/`、`Providers/`、`Console/`

### 框架特定结构

**Laravel**（如存在则记录）：
- `app/Http/Controllers`、`app/Models`、`database/migrations`
- `routes/*.php`、`resources/views`

**Symfony**（如存在则记录）：
- `src/Controller`、`src/Entity`、`config/packages`、`templates`

**CodeIgniter 4**（如存在则记录）：
- `app/Controllers`、`app/Models`、`app/Views`
- `app/Config/Routes.php`、`app/Database/Migrations`

**Phalcon**（如存在则记录）：
- `apps/*/controllers/`、`apps/*/Module.php`
- `models/`、`views/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Laravel 控制器 | `extends Controller`、`public function index` | laravel-controller |
| Laravel 模型 | `extends Model`、`protected $fillable` | laravel-model |
| Laravel 迁移 | `extends Migration`、`Schema::create` | laravel-migration |
| Laravel 服务 | `class *Service`、`app/Services/` | laravel-service |
| Laravel 仓库 | `*Repository`、`interface *Repository` | laravel-repository |
| Laravel 任务 | `implements ShouldQueue`、`dispatch(` | laravel-job |
| Laravel 事件 | `extends Event`、`event(` | laravel-event |
| Symfony 控制器 | `#[Route]`、`AbstractController` | symfony-controller |
| Symfony 服务 | `#[AsService]`、`services.yaml` | symfony-service |
| Doctrine 实体 | `#[ORM\Entity]`、`#[ORM\Column]` | doctrine-entity |
| Doctrine 迁移 | `AbstractMigration`、`$this->addSql` | doctrine-migration |
| CI4 控制器 | `extends BaseController`、`app/Controllers/` | ci4-controller |
| CI4 模型 | `extends Model`、`protected $table` | ci4-model |
| CI4 迁移 | `extends Migration`、`$this->forge->` | ci4-migration |
| CI4 实体 | `extends Entity`、`app/Entities/` | ci4-entity |
| Phalcon 控制器 | `extends Controller`、`Phalcon\Mvc\Controller` | phalcon-controller |
| Phalcon 模型 | `extends Model`、`Phalcon\Mvc\Model` | phalcon-model |
| Phalcon 迁移 | `Phalcon\Migrations`、`morphTable` | phalcon-migration |
| API 资源 | `extends JsonResource`、`toArray` | api-resource |
| 表单请求 | `extends FormRequest`、`rules()` | form-request |
| 中间件 | `implements Middleware`、`handle(` | php-middleware |
| 单元测试 | `extends TestCase`、`test*()`、`PHPUnit` | phpunit-test |
| 功能测试 | `extends TestCase`、`$this->get(`、`$this->post(` | feature-test |

## 强制输出章节

如果检测到以下内容，请包含：
- **Controllers**：HTTP 端点
- **Models/Entities**：数据层
- **Services**：业务逻辑
- **Repositories**：数据访问
- **Migrations**：数据库变更
- **Jobs/Events**：异步处理
- **Business modules**：按大小排序的顶级模块

## 命令来源
- `composer.json` 脚本
- `php artisan`（Laravel）
- `php spark`（CodeIgniter 4）
- `bin/console`（Symfony）
- `phalcon` devtools 命令
- README/文档、C我
- 仅包含仓库中存在的命令

## 关键路径

**Laravel：**
- `app/`、`routes/`、`database/migrations/`
- `resources/views/`、`tests/`

**Symfony：**
- `src/`、`config/`、`templates/`
- `migrations/`、`tests/`

**CodeIgniter 4：**
- `app/Controllers/`、`app/Models/`、`app/Views/`
- `app/Database/Migrations/`、`tests/`

**Phalcon：**
- `apps/*/controllers/`、`apps/*/models/`
- `apps/*/views/`、`migrations/`
FILE:references/python.md
# Python

## 检测信号
- `pyproject.toml`
- `requirements.txt`、`requirements-dev.txt`
- `Pipfile`、`poetry.lock`
- `setup.py`、`setup.cfg`
- `manage.py`（Django）

## 多模块信号
- 子目录中有多个 `pyproject.toml`
- `packages/`、`apps/` 目录
- Django 风格的 `apps/` 包含 `apps.py`

## 预生成来源
- `pyproject.toml` 或 `setup.py`
- `requirements*.txt`、`Pipfile`
- `tox.ini`、`pytest.ini`
- `manage.py`、`settings.py`（Django）

## 代码库扫描模式

### 源根目录
- `src/`、`app/`、`packages/`、`tests/`

### 层/文件夹模式（如果存在则记录）
`api/`、`routers/`、`views/`、`services/`、`repositories/`、`models/`、`schemas/`、`utils/`、`config/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| FastAPI 路由 | `APIRouter`、`@router.get`、`@router.post` | fastapi-router |
| FastAPI 依赖 | `Depends(`、`def get_*():` | fastapi-dependency |
| Django 视图 | `View`、`APIView`、`def get(self, request)` | django-view |
| Django 模型 | `models.Model`、`class Meta:` | django-model |
| Django 序列化器 | `serializers.Serializer`、`ModelSerializer` | drf-serializer |
| Flask 路由 | `@app.route`、`Blueprint` | flask-route |
| Pydantic 模型 | `BaseModel`、`Field(`、`model_validator` | pydantic-model |
| SQLAlchemy 模型 | `Base`、`Column(`、`relationship(` | sqlalchemy-model |
| Alembic 迁移 | `alembic/versions/`、`op.create_table` | alembic-migration |
| 仓库 | `*Repository`、`class *Repository` | data-repository |
| 服务 | `*Service`、`class *Service` | service-layer |
| Celery 任务 | `@celery.task`、`@shared_task` | celery-task |
| CLI 命令 | `@click.command`、`typer.Typer` | cli-command |
| 单元测试 | `pytest`、`def test_*():`、`unittest` | pytest-test |
| 夹具 | `@pytest.fixture`、`conftest.py` | pytest-fixture |

## 强制输出部分

如果检测到则包含：
- **路由/视图**：API 端点
- **模型/模式**：数据模型（Pydantic、SQLAlchemy、Django）
- **服务**：业务逻辑层
- **仓库**：数据访问层
- **迁移**：Alembic、Django 迁移
- **任务**：Celery、后台作业

## 命令来源
- `pyproject.toml` 工具部分
- README/文档、CI
- 常见：`python manage.py`、`pytest`、`uvicorn`、`flask run`
- 仅包含仓库中存在的命令

## 关键路径
- `src/`、`app/`
- `tests/`
- `alembic/`、`migrations/`
- `templates/`、`static/`（如果是 Web）
FILE:references/react-native.md
# React Native

## 检测信号
- `package.json` 包含 `react-native`
- `metro.config.js`
- `app.json` 或 `app.config.js`（Expo）
- `android/`、`ios/` 目录
- `babel.config.js` 包含 metro 预设

## 多模块信号
- 包含 `packages/` 的 monorepo
- 多个 `app.json` 文件
- 使用 React Native 的 Nx 工作区

## 预生成来源
- `package.json`（依赖、脚本）
- `app.json` 或 `app.config.js`
- `metro.config.js`
- `babel.config.js`
- `tsconfig.json`

## 代码库扫描模式

### 源根目录
- `src/`、`app/`

### 层/文件夹模式（如果存在则记录）
`screens/`、`components/`、`navigation/`、`services/`、`hooks/`、`store/`、`api/`、`utils/`、`assets/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| 屏幕 | `*Screen`、`export function *Screen` | rn-screen |
| 组件 | `export function *()`、`StyleSheet.create` | rn-component |
| 导航 | `createNativeStackNavigator`、`NavigationContainer` | rn-navigation |
| Hook | `use*`、`export function use*()` | rn-hook |
| Redux | `createSlice`、`configureStore` | redux-slice |
| Zustand | `create(`、`useStore` | zustand-store |
| React Query | `useQuery`、`useMutation` | react-query |
| 原生模块 | `NativeModules`、`TurboModule` | native-module |
| 异步存储 | `AsyncStorage`、`@react-native-async-storage` | async-storage |
| SQLite | `expo-sqlite`、`react-native-sqlite-storage` | sqlite-storage |
| 推送通知 | `@react-native-firebase/messaging`、`expo-notifications` | push-notification |
| 深度链接 | `Linking`、`useURL`、`expo-linking` | deep-link |
| 动画 | `Animated`、`react-native-reanimated` | rn-animation |
| 手势 | `react-native-gesture-handler`、`Gesture` | rn-gesture |
| 测试 | `@testing-library/react-native`、`render` | rntl-test |

## 强制输出部分

如果检测到则包含：
- **屏幕清单**：`screens/` 下的目录
- **导航结构**：堆栈、标签、抽屉导航器
- **状态管理**：Redux、Zustand、Context
- **原生模块**：自定义原生代码
- **存储层**：AsyncStorage、SQLite、MMKV
- **平台特定**：`*.android.tsx`、`*.ios.tsx`

## 命令来源
- `package.json` 脚本
- README/文档
- 常见：`npm run android`、`npm run ios`、`npx expo start`
- 仅包含仓库中存在的命令

## 关键路径
- `src/screens/`、`src/components/`
- `src/navigation/`、`src/store/`
- `android/app/`、`ios/*/`
- `assets/`
FILE:references/react-web.md
# React（Web）

## 检测信号
- `package.json` 包含 `react`、`react-dom`
- `vite.config.ts`、`next.config.js`、`craco.config.js`
- `tsconfig.json` 或 `jsconfig.json`
- `src/App.tsx` 或 `src/App.jsx`
- `public/index.html`（CRA）

## 多模块信号
- `pnpm-workspace.yaml`、`lerna.json`
- 子目录中有多个 `package.json`
- `packages/`、`apps/` 目录
- Nx 工作区（`nx.json`）

## 预生成来源
- `package.json`（依赖、脚本）
- `tsconfig.json`（路径、编译器选项）
- `vite.config.*`、`next.config.*`、`webpack.config.*`
- `.env.example`（环境变量）

## 代码库扫描模式

### 源根目录
- `src/`、`app/`、`pages/`

### 层/文件夹模式（如果存在则记录）
`components/`、`hooks/`、`services/`、`utils/`、`store/`、`api/`、`types/`、`contexts/`、`features/`、`layouts/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| 组件 | `export function *()`、`export const * =` 带 JSX | react-component |
| Hook | `use*`、`export function use*()` | custom-hook |
| Context | `createContext`、`useContext`、`*Provider` | react-context |
| Redux | `createSlice`、`configureStore`、`useSelector` | redux-slice |
| Zustand | `create(`、`useStore` | zustand-store |
| React Query | `useQuery`、`useMutation`、`QueryClient` | react-query |
| 表单 | `useForm`、`react-hook-form`、`Formik` | form-handling |
| 路由 | `createBrowserRouter`、`Route`、`useNavigate` | react-router |
| API 客户端 | `axios`、`fetch`、`ky` | api-client |
| Testing | `@testing-library/react`、`render`、`screen` | rtl-test |
| Storybook | `*.stories.tsx`、`Meta`、`StoryObj` | storybook |
| Styled | `styled-components`、`@emotion`、`styled(` | styled-component |
| Tailwind | `className="*"`、`tailwind.config.js` | tailwind-usage |
| i18n | `useTranslation`、`i18next`、`t()` | i18n-usage |
| Auth | `useAuth`、`AuthProvider`、`PrivateRoute` | auth-pattern |

## 强制输出章节

如检测到则包含：
- **组件清单**：`components/` 下的目录
- **功能/页面**：`features/`、`pages/` 下的目录
- **状态管理**：Redux、Zustand、Context
- **路由设置**：React Router、Next.js pages
- **API 层**：axios 实例、fetch 封装
- **样式方案**：CSS modules、Tailwind、styled-components
- **表单处理**：react-hook-form、Formik

## 命令来源
- `package.json` 的 scripts 部分
- README/文档
- CI 工作流
- 常见：`npm run dev`、`npm run build`、`npm test`
- 仅包含仓库中存在的命令

## 关键路径
- `src/components/`、`src/hooks/`
- `src/pages/`、`src/features/`
- `src/store/`、`src/api/`
- `public/`、`dist/`、`build/`
FILE:references/ruby.md
# Ruby/Rails

## 检测信号
- `Gemfile`
- `Gemfile.lock`
- `config.ru`
- `Rakefile`
- `config/application.rb`（Rails）

## 多模块信号
- 子目录中存在多个 `Gemfile`
- `engines/` 目录（Rails engines）
- `gems/` 目录（monorepo）

## 预生成来源
- `Gemfile`（依赖）
- `config/database.yml`
- `config/routes.rb`（Rails）
- `.env.example`

## 代码库扫描模式

### 源码根目录
- `app/`、`lib/`

### 层/文件夹模式（如存在则记录）
`controllers/`、`models/`、`services/`、`jobs/`、`mailers/`、`channels/`、`helpers/`、`concerns/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Rails Controller | `< ApplicationController`、`def index` | rails-controller |
| Rails Model | `< ApplicationRecord`、`has_many`、`belongs_to` | rails-model |
| Rails Migration | `< ActiveRecord::Migration`、`create_table` | rails-migration |
| Service Object | `class *Service`、`def call` | service-object |
| Rails Job | `< ApplicationJob`、`perform_later` | rails-job |
| Mailer | `< ApplicationMailer`、`mail(` | rails-mailer |
| Channel | `< ApplicationCable::Channel` | action-cable |
| Serializer | `< ActiveModel::Serializer`、`attributes` | serializer |
| Concern | `extend ActiveSupport::Concern` | rails-concern |
| Sidekiq Worker | `include Sidekiq::Worker`、`perform_async` | sidekiq-worker |
| Grape API | `Grape::API`、`resource :` | grape-api |
| RSpec Test | `RSpec.describe`、`it "` | rspec-test |
| Factory | `FactoryBot.define`、`factory :` | factory-bot |
| Rake Task | `task :`、`namespace :` | rake-task |

## 强制输出章节

如检测到则包含：
- **Controllers**：HTTP 端点
- **Models**：ActiveRecord 关联
- **Services**：业务逻辑
- **Jobs**：后台处理
- **Migrations**：数据库 schema

## 命令来源
- `Gemfile` 脚本
- `Rakefile` 任务
- `bin/rails`、`bin/rake`
- README/文档、CI
- 仅包含仓库中存在的命令

## 关键路径
- `app/controllers/`、`app/models/`
- `app/services/`、`app/jobs/`
- `db/migrate/`
- `spec/`、`test/`
- `lib/`
FILE:references/rust.md
# Rust

## 检测信号
- `Cargo.toml`
- `Cargo.lock`
- `src/main.rs` 或 `src/lib.rs`
- `target/` 目录

## 多模块信号
- `Cargo.toml` 中的 `[workspace]`
- 子目录中存在多个 `Cargo.toml`
- `crates/`、`packages/` 目录

## 预生成来源
- `Cargo.toml`（依赖、features）
- `build.rs`（构建脚本）
- `rust-toolchain.toml`（工具链）

## 代码库扫描模式

### 源码根目录
- `src/`、`crates/*/src/`

### 层/文件夹模式（如存在则记录）
`handlers/`、`services/`、`models/`、`db/`、`api/`、`utils/`、`error/`、`config/`

### 模式指示器

| 模式 | 检测标准 | 技能名称 |
|---------|-------------------|------------|
| Axum Handler | `axum::`、`Router`、`async fn handler` | axum-handler |
| Actix Route | `actix_web::`、`#[get]`、`#[post]` | actix-route |
| Rocket Route | `rocket::`、`#[get]`、`#[post]` | rocket-route |
| Service | `impl *Service`、`pub struct *Service` | rust-service |
| Repository | `*Repository`、`trait *Repository` | rust-repository |
| Diesel Model | `diesel::`、`Queryable`、`Insertable` | diesel-model |
| SQLx | `sqlx::`、`FromRow`、`query_as!` | sqlx-model |
| SeaORM | `sea_orm::`、`Entity`、`ActiveModel` | seaorm-entity |
| Error Type | `thiserror`、`anyhow`、`#[derive(Error)]` | error-type |
| CLI | `clap`、`#[derive(Parser)]` | cli-app |
| Async Task | `tokio::spawn`、`async fn` | async-task |
| Trait | `pub trait *`、`impl * for` | rust-trait |
| Unit Test | `#[cfg(test)]`、`#[test]` | rust-test |
| Integration Test | `tests/`、`#[tokio::test]` | integration-test |

## 强制输出章节

如检测到则包含：
- **Handlers/routes**：API 端点
- **Services**：业务逻辑
- **Models/entities**：数据结构
- **Error types**：自定义错误
- **Migrations**：diesel/sqlx 迁移

## 命令来源
- `Cargo.toml` 脚本/别名
- `Makefile`、README/文档
- 常见：`cargo build`、`cargo test`、`cargo run`
- 仅包含仓库中存在的命令

## 关键路径
- `src/`、`crates/`
- `tests/`
- `migrations/`
- `examples/`