hiroro-work/claude-plugins/extract-rules

Extract Rules

Analyzes existing codebase to identify what Claude would get wrong without project-specific guidance, extracting coding rules and domain knowledge as structured markdown documentation for AI agents.

Usage

/extract-rules                      # Extract rules from codebase (initial)
/extract-rules --update             # Re-scan and add new patterns (preserve existing)
/extract-rules --restructure        # Re-analyze, reorganize structure, merge existing rules
/extract-rules --from-conversation              # Extract from current session (latest)
/extract-rules --from-conversation <session-id> # Extract from a specific session
/extract-rules --from-pr 123                   # PR in current repo
/extract-rules --from-pr owner/repo#123        # PR in another repo (URL form also accepted)
/extract-rules --from-pr 100..110              # PR range (current repo)
/extract-rules --from-pr owner/repo#100..110   # PR range (another repo)
/extract-rules --compact                       # Compact all over-threshold rules files (output_dir/**/*.md)
/extract-rules --compact path/to/file.md ...   # Compact specific files (caller passes explicit paths)
/extract-rules --realign                       # Re-judge every rule file under output_dir against current criteria
/extract-rules --realign path/to/file.md ...   # Re-judge only the named files
/extract-rules --apply-conversation-candidates <path>  # Apply pre-scanned rule candidates (Step C5 only; orchestrator sub-skill)
# Multiple specs allowed (space-separated) → cross-analysis detects org-wide principles

Change-origin flags: a change-based extraction is scoped only by --from-conversation or --from-pr. This skill accepts no diff-base / commit-sha origin argument such as --base-commit <sha>; passing one is unsupported.

Configuration

Settings file: extract-rules.local.md (YAML frontmatter only, no markdown body)

• Project-level: .claude/extract-rules.local.md (takes precedence)
• User-level: ~/.claude/extract-rules.local.md

---
target_dirs:
  - .
exclude_dirs:
  - .git
  - .claude
exclude_patterns:
  - "*.generated.ts"
output_dir: .claude/rules
examples_output_dir: .claude/rules-extras
staging_output_dir: .claude/rules-staging
language: ja
split_output: true
resolve_references: true
compaction_threshold: 40000
min_cluster_size: 3
---

Output Structure

Three output directories are involved: output_dir for rule files (.md / .local.md), examples_output_dir for .examples.md files, and staging_output_dir for staged 1st-observation project-level patterns and lint candidates from incremental modes. The paths: frontmatter on rule files is a human-facing category-scope hint; the auto-load boundary is determined by directory placement only.

Default (split_output: true):

.claude/rules/                     # output_dir (inside auto-load scope)
├── languages/
│   ├── typescript.md              # Principles only (portable)
│   └── typescript.local.md        # Project-specific patterns only
├── frameworks/
│   ├── react.md                   # Principles only (portable)
│   └── react.local.md             # Project-specific patterns only
└── project.md                     # Always single file (no split)
 
.claude/rules-extras/              # examples_output_dir (outside auto-load scope)
├── languages/
│   └── typescript.examples.md     # Examples for both
├── frameworks/
│   └── react.examples.md          # Examples for both
└── project.examples.md            # Examples
 
.claude/rules-staging/             # staging_output_dir (outside auto-load scope)
├── project.staging.local.md       # 1st-observation project-level candidates (incremental modes only)
└── lint-candidates.md             # rules a check this project runs could enforce (incremental modes only)

Principles (portable across projects) and Project-specific patterns (local) are separated by default.

Hybrid mode (split_output: false): no <name>.local.md — each <name>.md carries both ## Principles and ## Project-specific patterns. The other two directories are unchanged.

Layered frameworks (Rails, Django, Spring, etc.): When a framework has distinct architectural layers, generate layer-specific files:

• <framework>.md — Cross-layer rules (no paths: or broad scope)
• <framework>-<layer>.md — Layer-specific rules with scoped paths: (e.g., app/models/**)
• In split mode, both cross-layer and layer-specific files get .local.md counterparts

Integration libraries (Inertia, Pundit, Devise, Turbo, etc.): When integration libraries are detected alongside a layered framework:

• integrations/<framework>-<integration>.md — Integration-specific rules
• Separated from layer files into dedicated integrations/ directory
• In split mode, integration files also get .local.md counterparts

Format switching: Run --restructure after changing split_output setting to switch between split and hybrid formats.

Dispatch authorization

This skill's procedure dispatches subagents, so invoking the skill is the request to use that mechanism: an ambient instruction allowing subagent dispatch only when the user asked for it — a permission-shaped restriction — is already satisfied by this invocation. Do not ask the user to re-confirm the dispatch, and do not silently substitute inline execution for a dispatch this procedure specifies. Only two things justify that substitution: technical availability (the dispatch tool is not present and callable on the current tool surface), and an explicit contract term from the caller bounding this skill to its own thread. A permission-shaped restriction is neither.

Processing Flow

Mode Detection

Check arguments to determine mode:

• No arguments → Full Extraction Mode (Step 1-7)
• --update → Update Mode (Step U1-U6)
• --restructure → Restructure Mode (Step R1-R5)
• --from-conversation [session-id] → Conversation Extraction Mode (Step C1-C5)
• --compact [<paths>] → Compaction Mode (Step CP1-CP5)
• --realign [<paths>] → Realign Mode (Step RA1-RA5)
• --from-pr <number|owner/repo#number|range> [...] → PR Review Extraction Mode (Step P1-P5)
• --apply-conversation-candidates <path> → Conversation Candidate Apply Mode (Step A1-A2)

Full Extraction Mode

Step 1: Load Settings

Search for extract-rules.local.md:

1. Project-level: .claude/extract-rules.local.md
2. User-level: ~/.claude/extract-rules.local.md

Priority:

• If both exist, use project-level only
• If only one exists, use that file
• If neither exists, use default settings

Extract settings (target_dirs, exclude_dirs, exclude_patterns, output_dir, examples_output_dir, staging_output_dir, language, split_output, resolve_references, compaction_threshold) from the config file. See Configuration section above for defaults.

`language` resolution: skill config → Claude Code settings (~/.claude/settings.json language field) → default ja. Write the report's prose in plain words, one claim per sentence, with no figure of speech translated word for word.

Load existing rule files (incremental modes; Full Extraction skips it): read <output_dir>/<name>.md, <output_dir>/<name>.local.md, and <examples_output_dir>/<name>.examples.md. When examples_output_dir does not exist yet (legacy projects that co-located examples under output_dir), use <output_dir>/<name>.examples.md instead. Also read <staging_output_dir>/project.staging.local.md when present — the staging-match branch needs it; skip silently when it does not exist.

Step 2: Detect Project Type

Detect project language and framework:

1. Detect languages by config files (package.json, tsconfig.json, pyproject.toml, go.mod, Cargo.toml, Gemfile, pom.xml, etc.) and file extensions (.ts/.tsx, .py, .go, .rb, etc.)

2. Detect frameworks by their config files (e.g., next.config.*, playwright.config.*) and dependencies in package manifests.

3. Detect architectural layers (for layered frameworks): If a framework has distinct layers with separate directories (e.g., Rails: app/models/, app/controllers/; Django: models.py, views.py), detect them for layer-specific rule files. Only split when corresponding directories actually exist.

4. Detect integration libraries (for layered frameworks): Read references/integration-criteria.md for detection rules and classification criteria.

Output: List of detected languages, frameworks, architectural layers, and integration libraries

Step 3: Collect Sample Files

Collect target files for analysis:

1. Get git-tracked files using git ls-files (respects .gitignore). If not a git repo, use Glob instead, with manual exclusions from settings.
2. Filter by target_dirs, exclude_dirs, exclude_patterns, and detected language extensions
3. Sample 10-15 files per category, distributed across directories for representative coverage. Large projects (100+): prioritize directory diversity. Small projects (<10): analyze all files.

Step 4: Analyze by Category

Read references/extraction-criteria.md before proceeding to understand the classification criteria. The core question for every pattern is: "Would Claude produce something different without knowing this?" — extract only what fills the gap between Claude's general knowledge and this project's actual conventions.

For each detected language, framework, and integration library:

1. Use Grep/Read to collect relevant code patterns