skiller 0.4.3 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
-# `@udecode/ruler` fork
+# `skiller`
 
-**Fork features:**
+A Claude-centric fork of [ruler](https://github.com/intellectronica/ruler) with native skills support:
 
 ## 1. CLAUDE.md @filename References
 
@@ -22,7 +22,7 @@
 
 ## 4. Claude Root Folder
 
-- `ruler init --claude` creates `.claude/` instead of `.ruler/`
+- Default directory is `.claude/` (no extra flags needed)
 - Skills already in `.claude/skills` (no copying)
 - Single directory for all Claude Code config
 
@@ -50,14 +50,14 @@
 
 ---
 
-# Ruler: Centralise Your AI Coding Assistant Instructions
+# Skiller: Centralise Your AI Coding Assistant Instructions
 
 > **Beta Research Preview**
 >
 > - Please test this version carefully in your environment
-> - Report issues at https://github.com/udecode/ruler/issues
+> - Report issues at https://github.com/udecode/skiller/issues
 
-## Why Ruler?
+## Why Skiller?
 
 Managing instructions across multiple AI coding tools becomes complex as your team grows. Different agents (GitHub Copilot, Claude, Cursor, Aider, etc.) require their own configuration files, leading to:
 
@@ -67,130 +67,124 @@ Managing instructions across multiple AI coding tools becomes complex as your te
 - **Onboarding friction** for new AI tools
 - **Complex project structures** requiring context-specific instructions for different components
 
-Ruler solves this by providing a **single source of truth** for all your AI agent instructions, automatically distributing them to the right configuration files. With support for **nested rule loading**, Ruler can handle complex project structures with context-specific instructions for different components.
+Skiller solves this by providing a **single source of truth** for all your AI agent instructions, automatically distributing them to the right configuration files. With support for **nested rule loading**, Skiller can handle complex project structures with context-specific instructions for different components.
 
 ## Core Features
 
-- **Centralised Rule Management**: Store all AI instructions in a dedicated `.ruler/` directory using Markdown files
-- **Nested Rule Loading**: Support complex project structures with multiple `.ruler/` directories for context-specific instructions
-- **Automatic Distribution**: Ruler applies these rules to configuration files of supported AI agents
-- **Targeted Agent Configuration**: Fine-tune which agents are affected and their specific output paths via `ruler.toml`
+- **Centralised Rule Management**: Store all AI instructions in a dedicated `.claude/` directory using Markdown files
+- **Nested Rule Loading**: Support complex project structures with multiple `.claude/` directories for context-specific instructions
+- **Automatic Distribution**: Skiller applies these rules to configuration files of supported AI agents
+- **Targeted Agent Configuration**: Fine-tune which agents are affected and their specific output paths via `skiller.toml`
 - **MCP Server Propagation**: Manage and distribute Model Context Protocol (MCP) server settings
 - **`.gitignore` Automation**: Keeps generated agent config files out of version control automatically
 - **Simple CLI**: Easy-to-use commands for initialising and applying configurations
 
 ## Supported AI Agents
 
-| Agent            | Rules File(s)                                    | MCP Configuration / Notes                        |
-| ---------------- | ------------------------------------------------ | ------------------------------------------------ |
-| AGENTS.md        | `AGENTS.md`                                      | (pseudo-agent ensuring root `AGENTS.md` exists)  |
-| GitHub Copilot   | `AGENTS.md`                                      | `.vscode/mcp.json`                               |
-| Claude Code      | `CLAUDE.md` (@filename references)               | `.mcp.json`                                      |
-| OpenAI Codex CLI | `AGENTS.md`                                      | `.codex/config.toml` (MCP via Skillz)            |
-| Jules            | `AGENTS.md`                                      | -                                                |
-| Cursor           | `AGENTS.md`                                      | `.cursor/mcp.json`                               |
-| Windsurf         | `AGENTS.md`                                      | `.windsurf/mcp_config.json`                      |
-| Cline            | `.clinerules`                                    | -                                                |
-| Crush            | `CRUSH.md`                                       | `.crush.json`                                    |
-| Amp              | `AGENTS.md`                                      | -                                                |
-| Amazon Q CLI     | `.amazonq/rules/ruler_q_rules.md`                | `.amazonq/mcp.json`                              |
-| Aider            | `AGENTS.md`, `.aider.conf.yml`                   | `.mcp.json`                                      |
-| Firebase Studio  | `.idx/airules.md`                                | `.idx/mcp.json`                                  |
-| Open Hands       | `.openhands/microagents/repo.md`                 | `config.toml`                                    |
-| Gemini CLI       | `AGENTS.md`                                      | `.gemini/settings.json`                          |
-| Junie            | `.junie/guidelines.md`                           | -                                                |
-| AugmentCode      | `.augment/rules/ruler_augment_instructions.md`   | -                                                |
-| Kilo Code        | `.kilocode/rules/ruler_kilocode_instructions.md` | `.kilocode/mcp.json`                             |
-| OpenCode         | `AGENTS.md`                                      | `opencode.json`                                  |
-| Goose            | `.goosehints`                                    | -                                                |
-| Qwen Code        | `AGENTS.md`                                      | `.qwen/settings.json`                            |
-| RooCode          | `AGENTS.md`                                      | `.roo/mcp.json`                                  |
-| Zed              | `AGENTS.md`                                      | `.zed/settings.json` (project root, never $HOME) |
-| Trae AI          | `.trae/rules/project_rules.md`                   | -                                                |
-| Warp             | `WARP.md`                                        | -                                                |
-| Kiro             | `.kiro/steering/ruler_kiro_instructions.md`      | -                                                |
-| Firebender       | `firebender.json`                                | `firebender.json` (rules and MCP in same file)   |
+| Agent            | Rules File(s)                                      | MCP Configuration / Notes                        |
+| ---------------- | -------------------------------------------------- | ------------------------------------------------ |
+| AGENTS.md        | `AGENTS.md`                                        | (pseudo-agent ensuring root `AGENTS.md` exists)  |
+| GitHub Copilot   | `AGENTS.md`                                        | `.vscode/mcp.json`                               |
+| Claude Code      | `CLAUDE.md` (@filename references)                 | `.mcp.json`                                      |
+| OpenAI Codex CLI | `AGENTS.md`                                        | `.codex/config.toml` (MCP via Skillz)            |
+| Jules            | `AGENTS.md`                                        | -                                                |
+| Cursor           | `AGENTS.md`                                        | `.cursor/mcp.json`                               |
+| Windsurf         | `AGENTS.md`                                        | `.windsurf/mcp_config.json`                      |
+| Cline            | `.clinerules`                                      | -                                                |
+| Crush            | `CRUSH.md`                                         | `.crush.json`                                    |
+| Amp              | `AGENTS.md`                                        | -                                                |
+| Amazon Q CLI     | `.amazonq/rules/skiller_q_rules.md`                | `.amazonq/mcp.json`                              |
+| Aider            | `AGENTS.md`, `.aider.conf.yml`                     | `.mcp.json`                                      |
+| Firebase Studio  | `.idx/airules.md`                                  | `.idx/mcp.json`                                  |
+| Open Hands       | `.openhands/microagents/repo.md`                   | `config.toml`                                    |
+| Gemini CLI       | `AGENTS.md`                                        | `.gemini/settings.json`                          |
+| Junie            | `.junie/guidelines.md`                             | -                                                |
+| AugmentCode      | `.augment/rules/skiller_augment_instructions.md`   | -                                                |
+| Kilo Code        | `.kilocode/rules/skiller_kilocode_instructions.md` | `.kilocode/mcp.json`                             |
+| OpenCode         | `AGENTS.md`                                        | `opencode.json`                                  |
+| Goose            | `.goosehints`                                      | -                                                |
+| Qwen Code        | `AGENTS.md`                                        | `.qwen/settings.json`                            |
+| RooCode          | `AGENTS.md`                                        | `.roo/mcp.json`                                  |
+| Zed              | `AGENTS.md`                                        | `.zed/settings.json` (project root, never $HOME) |
+| Trae AI          | `.trae/rules/project_rules.md`                     | -                                                |
+| Warp             | `WARP.md`                                          | -                                                |
+| Kiro             | `.kiro/steering/skiller_kiro_instructions.md`      | -                                                |
+| Firebender       | `firebender.json`                                  | `firebender.json` (rules and MCP in same file)   |
 
 ## Getting Started
 
 ### Installation
 
-**Global Installation (Recommended for CLI use):**
-
-```bash
-npm install -g @udecode/ruler
-```
-
 **Using `npx` (for one-off commands):**
 
 ```bash
-npx @udecode/ruler apply
+npx skiller@latest apply
 ```
 
 ### Project Initialisation
 
 1. Navigate to your project's root directory
-2. Run `ruler init`
+2. Run `skiller init`
 3. This creates:
 
-- `.ruler/` directory
-- `.ruler/AGENTS.md`: The primary starter Markdown file for your rules
-- `.ruler/ruler.toml`: The main configuration file for Ruler
+- `.claude/` directory
+- `.claude/AGENTS.md`: The primary starter Markdown file for your rules
+- `.claude/skiller.toml`: The main configuration file for Skiller
 
-Additionally, you can create a global configuration to use when no local `.ruler/` directory is found:
+Additionally, you can create a global configuration to use when no local `.claude/` directory is found:
 
 ```bash
-ruler init --global
+skiller init --global
 ```
 
-The global configuration will be created to `$XDG_CONFIG_HOME/ruler` (default: `~/.config/ruler`).
+The global configuration will be created to `$XDG_CONFIG_HOME/skiller` (default: `~/.config/skiller`).
 
 ## Core Concepts
 
-### The `.ruler/` Directory
+### The `.claude/` Directory
 
 This is your central hub for all AI agent instructions:
 
 - **Primary File Order & Precedence**:
-  1. A repository root `AGENTS.md` (outside `.ruler/`) if present (highest precedence, prepended)
-  2. `.ruler/AGENTS.md` (new default starter file)
-  3. Remaining discovered `.md` files under `.ruler/` (and subdirectories) in sorted order
-- **Rule Files (`*.md`)**: Discovered recursively from `.ruler/` or `$XDG_CONFIG_HOME/ruler` and concatenated in the order above
+  1. A repository root `AGENTS.md` (outside `.claude/`) if present (highest precedence, prepended)
+  2. `.claude/AGENTS.md` (new default starter file)
+  3. Remaining discovered `.md` files under `.claude/` (and subdirectories) in sorted order
+- **Rule Files (`*.md`)**: Discovered recursively from `.claude/` or `$XDG_CONFIG_HOME/skiller` and concatenated in the order above
 - **Concatenation Marker**: Each file's content is prepended with `--- Source: <relative_path_to_md_file> ---` for traceability
-- **`ruler.toml`**: Master configuration for Ruler's behavior, agent selection, and output paths
+- **`skiller.toml`**: Master configuration for Skiller's behavior, agent selection, and output paths
 - **`mcp.json`**: Shared MCP server settings
 
-This ordering lets you keep a short, high-impact root `AGENTS.md` (e.g. executive project summary) while housing detailed guidance inside `.ruler/`.
+This ordering lets you keep a short, high-impact root `AGENTS.md` (e.g. executive project summary) while housing detailed guidance inside `.claude/`.
 
 ### Nested Rule Loading
 
-Ruler now supports **nested rule loading** with the `--nested` flag, enabling context-specific instructions for different parts of your project:
+Skiller now supports **nested rule loading** with the `--nested` flag, enabling context-specific instructions for different parts of your project:
 
 ```
 project/
-├── .ruler/           # Global project rules
+├── .claude/           # Global project rules
 │   ├── AGENTS.md
 │   └── coding_style.md
 ├── src/
-│   └── .ruler/       # Component-specific rules
+│   └── .claude/       # Component-specific rules
 │       └── api_guidelines.md
 ├── tests/
-│   └── .ruler/       # Test-specific rules
+│   └── .claude/       # Test-specific rules
 │       └── testing_conventions.md
 └── docs/
-    └── .ruler/       # Documentation rules
+    └── .claude/       # Documentation rules
         └── writing_style.md
 ```
 
 **How it works:**
 
-- Discover all `.ruler/` directories in the project hierarchy
+- Discover all `.claude/` directories in the project hierarchy
 - Load and concatenate rules from each directory in order
 - Decide whether nested mode is enabled using the following precedence:
-  1. `ruler apply --nested` (or `--no-nested`) takes top priority
-  2. `nested = true` in `ruler.toml`
+  1. `skiller apply --nested` (or `--no-nested`) takes top priority
+  2. `nested = true` in `skiller.toml`
   3. Default to disabled when neither option is provided
-- When a run is nested, downstream configs are forced to keep `nested = true`. If a child config attempts to disable it, Ruler keeps nested processing active and emits a warning in the logs.
+- When a run is nested, downstream configs are forced to keep `nested = true`. If a child config attempts to disable it, Skiller keeps nested processing active and emits a warning in the logs.
 - Nested processing carries forward each directory's own MCP bundle and configuration settings so that generated files remain scoped to their source directories while being normalized back to the project root.
 
 > [!CAUTION]
@@ -212,7 +206,7 @@ project/
 - `project_architecture.md`
 - `security_guidelines.md`
 
-**Example rule file (`.ruler/python_guidelines.md`):**
+**Example rule file (`.claude/python_guidelines.md`):**
 
 ```markdown
 # Python Project Guidelines
@@ -239,10 +233,10 @@ project/
 ### Primary Command
 
 ```bash
-ruler apply [options]
+skiller apply [options]
 ```
 
-The `apply` command looks for `.ruler/` in the current directory tree, reading the first match. If no such directory is found, it will look for a global configuration in `$XDG_CONFIG_HOME/ruler`.
+The `apply` command looks for `.claude/` in the current directory tree, reading the first match. If no such directory is found, it will look for a global configuration in `$XDG_CONFIG_HOME/skiller`.
 
 ### Options
 
@@ -250,7 +244,7 @@ The `apply` command looks for `.ruler/` in the current directory tree, reading t
 | ------------------------------ | ---------------------------------------------------------------------- |
 | `--project-root <path>`        | Project root path (default: current directory).                        |
 | `--agents <agent1,agent2,...>` | Comma-separated agent names to target (see supported list below).      |
-| `--config <path>`              | Custom `ruler.toml` path.                                              |
+| `--config <path>`              | Custom `skiller.toml` path.                                            |
 | `--mcp` / `--with-mcp`         | Enable applying MCP server configurations (default: true).             |
 | `--no-mcp`                     | Disable applying MCP server configurations.                            |
 | `--mcp-overwrite`              | Overwrite native MCP config instead of merging.                        |
@@ -268,74 +262,74 @@ The `apply` command looks for `.ruler/` in the current directory tree, reading t
 **Apply rules to all configured agents:**
 
 ```bash
-ruler apply
+skiller apply
 ```
 
 **Apply rules only to GitHub Copilot and Claude:**
 
 ```bash
-ruler apply --agents copilot,claude
+skiller apply --agents copilot,claude
 ```
 
 **Apply rules only to Firebase Studio:**
 
 ```bash
-ruler apply --agents firebase
+skiller apply --agents firebase
 ```
 
 **Apply rules only to Warp:**
 
 ```bash
-ruler apply --agents warp
+skiller apply --agents warp
 ```
 
 **Apply rules only to Trae AI:**
 
 ```bash
-ruler apply --agents trae
+skiller apply --agents trae
 ```
 
 **Apply rules only to RooCode:**
 
 ```bash
-ruler apply --agents roo
+skiller apply --agents roo
 ```
 
 **Use a specific configuration file:**
 
 ```bash
-ruler apply --config ./team-configs/ruler.frontend.toml
+skiller apply --config ./team-configs/skiller.frontend.toml
 ```
 
 **Apply rules with verbose output:**
 
 ```bash
-ruler apply --verbose
+skiller apply --verbose
 ```
 
 **Apply rules but skip MCP and .gitignore updates:**
 
 ```bash
-ruler apply --no-mcp --no-gitignore
+skiller apply --no-mcp --no-gitignore
 ```
 
 ## Usage: The `revert` Command
 
-The `revert` command safely undoes all changes made by `ruler apply`, restoring your project to its pre-ruler state. It intelligently restores files from backups (`.bak` files) when available, or removes generated files that didn't exist before.
+The `revert` command safely undoes all changes made by `skiller apply`, restoring your project to its pre-skiller state. It intelligently restores files from backups (`.bak` files) when available, or removes generated files that didn't exist before.
 
 ### Why Revert is Needed
 
 When experimenting with different rule configurations or switching between projects, you may want to:
 
-- **Clean slate**: Remove all ruler-generated files to start fresh
+- **Clean slate**: Remove all skiller-generated files to start fresh
 - **Restore originals**: Revert modified files back to their original state
 - **Selective cleanup**: Remove configurations for specific agents only
-- **Safe experimentation**: Try ruler without fear of permanent changes
+- **Safe experimentation**: Try skiller without fear of permanent changes
 
 ### Primary Command
 
 ```bash
-ruler revert [options]
+skiller revert [options]
 ```
 
 ### Options
@@ -344,49 +338,49 @@ ruler revert [options]
 | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `--project-root <path>`        | Path to your project's root (default: current directory)                                                                                                                                                                                                                      |
 | `--agents <agent1,agent2,...>` | Comma-separated list of agent names to revert (agentsmd, aider, amazonqcli, amp, augmentcode, claude, cline, codex, copilot, crush, cursor, firebase, firebender, gemini-cli, goose, jules, junie, kilocode, kiro, opencode, openhands, qwen, roo, trae, warp, windsurf, zed) |
-| `--config <path>`              | Path to a custom `ruler.toml` configuration file                                                                                                                                                                                                                              |
+| `--config <path>`              | Path to a custom `skiller.toml` configuration file                                                                                                                                                                                                                            |
 | `--keep-backups`               | Keep backup files (.bak) after restoration (default: false)                                                                                                                                                                                                                   |
 | `--dry-run`                    | Preview changes without actually reverting files                                                                                                                                                                                                                              |
 | `--verbose` / `-v`             | Display detailed output during execution                                                                                                                                                                                                                                      |
-| `--local-only`                 | Only search for local .ruler directories, ignore global config                                                                                                                                                                                                                |
+| `--local-only`                 | Only search for local .claude directories, ignore global config                                                                                                                                                                                                               |
 
 ### Common Examples
 
-**Revert all ruler changes:**
+**Revert all skiller changes:**
 
 ```bash
-ruler revert
+skiller revert
 ```
 
 **Preview what would be reverted (dry-run):**
 
 ```bash
-ruler revert --dry-run
+skiller revert --dry-run
 ```
 
 **Revert only specific agents:**
 
 ```bash
-ruler revert --agents claude,copilot
+skiller revert --agents claude,copilot
 ```
 
 **Revert with detailed output:**
 
 ```bash
-ruler revert --verbose
+skiller revert --verbose
 ```
 
 **Keep backup files after reverting:**
 
 ```bash
-ruler revert --keep-backups
+skiller revert --keep-backups
 ```
 
-## Configuration (`ruler.toml`) in Detail
+## Configuration (`skiller.toml`) in Detail
 
 ### Location
 
-Defaults to `.ruler/ruler.toml` in the project root. Override with `--config` CLI option.
+Defaults to `.claude/skiller.toml` in the project root. Override with `--config` CLI option.
 
 ### Complete Example
 
@@ -476,7 +470,7 @@ enabled = false
 
 [agents.kilocode]
 enabled = true
-output_path = ".kilocode/rules/ruler_kilocode_instructions.md"
+output_path = ".kilocode/rules/skiller_kilocode_instructions.md"
 
 [agents.warp]
 enabled = true
@@ -486,16 +480,16 @@ output_path = "WARP.md"
 ### Configuration Precedence
 
 1. **CLI flags** (e.g., `--agents`, `--no-mcp`, `--mcp-overwrite`, `--no-gitignore`)
-2. **Settings in `ruler.toml`** (`default_agents`, specific agent settings, global sections)
-3. **Ruler's built-in defaults** (all agents enabled, standard output paths, MCP enabled with 'merge')
+2. **Settings in `skiller.toml`** (`default_agents`, specific agent settings, global sections)
+3. **Skiller's built-in defaults** (all agents enabled, standard output paths, MCP enabled with 'merge')
 
 ## MCP (Model Context Protocol) Server Configuration
 
-MCP provides broader context to AI models through server configurations. Ruler can manage and distribute these settings across compatible agents.
+MCP provides broader context to AI models through server configurations. Skiller can manage and distribute these settings across compatible agents.
 
 ### TOML Configuration (Recommended)
 
-You can now define MCP servers directly in `ruler.toml` using the `[mcp_servers.<name>]` syntax:
+You can now define MCP servers directly in `skiller.toml` using the `[mcp_servers.<name>]` syntax:
 
 ```toml
 # Global MCP behavior
@@ -551,9 +545,9 @@ url = "https://api.example.com"
 Authorization = "Bearer token"
 ```
 
-Ruler uses this configuration with the `merge` (default) or `overwrite` strategy, controlled by `ruler.toml` or CLI flags.
+Skiller uses this configuration with the `merge` (default) or `overwrite` strategy, controlled by `skiller.toml` or CLI flags.
 
-**Home Directory Safety:** Ruler never writes MCP configuration files outside your project root. Any historical references to user home directories (e.g. `~/.codeium/windsurf/mcp_config.json` or `~/.zed/settings.json`) have been removed; only project-local paths are targeted.
+**Home Directory Safety:** Skiller never writes MCP configuration files outside your project root. Any historical references to user home directories (e.g. `~/.codeium/windsurf/mcp_config.json` or `~/.zed/settings.json`) have been removed; only project-local paths are targeted.
 
 **Note for OpenAI Codex CLI:** To apply the local Codex CLI MCP configuration, set the `CODEX_HOME` environment variable to your project’s `.codex` directory:
 
@@ -565,11 +559,11 @@ export CODEX_HOME="$(pwd)/.codex"
 
 **⚠️ Experimental Feature**: Skills support is currently experimental and requires `uv` (the Python package manager) to be installed on your system for MCP-based agent integration.
 
-Ruler can manage and propagate Claude Code-compatible skills to supported AI agents. Skills are stored in `.ruler/skills/` and are automatically distributed to compatible agents when you run `ruler apply`.
+Skiller can manage and propagate Claude Code-compatible skills to supported AI agents. Skills are stored in `.claude/skills/` and are automatically distributed to compatible agents when you run `skiller apply`.
 
 ### How It Works
 
-Skills are specialized knowledge packages that extend AI agent capabilities with domain-specific expertise, workflows, or tool integrations. Ruler discovers skills in your `.ruler/skills/` directory and propagates them to compatible agents:
+Skills are specialized knowledge packages that extend AI agent capabilities with domain-specific expertise, workflows, or tool integrations. Skiller discovers skills in your `.claude/skills/` directory and propagates them to compatible agents:
 
 - **Claude Code**: Skills copied to `.claude/skills/` with @filename references preserved
 - **Cursor**: Uses `.cursor/rules/` directly (copied when `merge_strategy = "cursor"`), no skillz MCP needed
@@ -580,7 +574,7 @@ Skills are specialized knowledge packages that extend AI agent capabilities with
 Skills can be organized flat or nested:
 
 ```
-.ruler/skills/
+.claude/skills/
 ├── my-skill/
 │   ├── SKILL.md           # Required: skill instructions/knowledge
 │   ├── helper.py          # Optional: additional resources (scripts)
@@ -622,15 +616,17 @@ When using `[skills].generate_from_rules = true`, skills are automatically creat
 ```
 
 **Requirements for folder copying**:
+
 - The `.mdc` file must be in a folder with the same basename (e.g., `docx/docx.mdc`)
 - The `.mdc` file must have frontmatter with `alwaysApply: false` (or undefined)
 - All files and subdirectories in that folder (except the `.mdc` file itself) are copied
 
 **Example `.mdc` file with frontmatter**:
+
 ```markdown
 ---
 description: DOCX file processing utilities
-globs: ["**/*.docx"]
+globs: ['**/*.docx']
 alwaysApply: false
 ---
 
@@ -647,13 +643,13 @@ Skills support is **enabled by default** but can be controlled via:
 
 ```bash
 # Enable skills (default)
-ruler apply --skills
+skiller apply --skills
 
 # Disable skills
-ruler apply --no-skills
+skiller apply --no-skills
 ```
 
-**Configuration in `ruler.toml`:**
+**Configuration in `skiller.toml`:**
 
 ```toml
 [skills]
@@ -662,7 +658,7 @@ enabled = true  # or false to disable
 
 ### Skillz MCP Server
 
-For agents that support MCP but don't have native skills support (excluding Claude Code and Cursor), Ruler automatically:
+For agents that support MCP but don't have native skills support (excluding Claude Code and Cursor), Skiller automatically:
 
 1. Copies skills to `.skillz/` directory with @filename references expanded to full content
 2. Strips frontmatter from referenced .mdc files to avoid duplication
@@ -681,13 +677,13 @@ args = ["skillz@latest", "/absolute/path/to/project/.skillz"]
 
 ### `.gitignore` Integration
 
-When skills support is enabled and gitignore integration is active, Ruler automatically adds:
+When skills support is enabled and gitignore integration is active, Skiller automatically adds:
 
-- `.claude/skills/` (when generated from `.claude/rules/` or copied from `.ruler/skills/`)
+- `.claude/skills/` (when generated from `.claude/rules/` or copied from `.claude/skills/`)
 - `.skillz/` (for MCP-based agents excluding Cursor)
 - `.cursor/rules/` (when using `merge_strategy = "cursor"`)
 
-to your `.gitignore` file within the managed Ruler block.
+to your `.gitignore` file within the managed Skiller block.
 
 **Note**: If you manually create `.claude/skills/` without `.claude/rules/`, it won't be gitignored (assumed to be versioned).
 
@@ -702,7 +698,7 @@ to your `.gitignore` file within the managed Ruler block.
 
 ### Validation
 
-Ruler validates discovered skills and issues warnings for:
+Skiller validates discovered skills and issues warnings for:
 
 - Missing required file (`SKILL.md`)
 - Invalid directory structures (directories without `SKILL.md` and no sub-skills)
@@ -714,7 +710,7 @@ Warnings don't prevent propagation but help identify potential issues.
 Test skills propagation without making changes:
 
 ```bash
-ruler apply --dry-run
+skiller apply --dry-run
 ```
 
 This shows which skills would be copied and which MCP servers would be configured.
@@ -723,8 +719,8 @@ This shows which skills would be copied and which MCP servers would be configure
 
 ```bash
 # 1. Add a skill to your project
-mkdir -p .ruler/skills/my-skill
-cat > .ruler/skills/my-skill/SKILL.md << 'EOF'
+mkdir -p .claude/skills/my-skill
+cat > .claude/skills/my-skill/SKILL.md << 'EOF'
 # My Custom Skill
 
 This skill provides specialized knowledge for...
@@ -738,7 +734,7 @@ When working on this project, always follow these guidelines:
 EOF
 
 # 2. Apply to all agents (skills enabled by default)
-ruler apply
+skiller apply
 
 # 3. Skills are now available to compatible agents:
 #    - Claude Code: .claude/skills/my-skill/
@@ -747,12 +743,12 @@ ruler apply
 
 ## `.gitignore` Integration
 
-Ruler automatically manages your `.gitignore` file to keep generated agent configuration files out of version control.
+Skiller automatically manages your `.gitignore` file to keep generated agent configuration files out of version control.
 
 ### How it Works
 
 - Creates or updates `.gitignore` in your project root
-- Adds paths to a managed block marked with `# START Ruler Generated Files` and `# END Ruler Generated Files`
+- Adds paths to a managed block marked with `# START Skiller Generated Files` and `# END Skiller Generated Files`
 - Preserves existing content outside this block
 - Sorts paths alphabetically and uses relative POSIX-style paths
 
@@ -763,12 +759,12 @@ Ruler automatically manages your `.gitignore` file to keep generated agent confi
 node_modules/
 *.log
 
-# START Ruler Generated Files
+# START Skiller Generated Files
 .aider.conf.yml
 .clinerules
 AGENTS.md
 CLAUDE.md
-# END Ruler Generated Files
+# END Skiller Generated Files
 
 dist/
 ```
@@ -776,7 +772,7 @@ dist/
 ### Control Options
 
 - **CLI flags**: `--gitignore` or `--no-gitignore`
-- **Configuration**: `[gitignore].enabled` in `ruler.toml`
+- **Configuration**: `[gitignore].enabled` in `skiller.toml`
 - **Default**: enabled
 
 ## Practical Usage Scenarios
@@ -784,16 +780,16 @@ dist/
 ### Scenario 1: Getting Started Quickly
 
 ```bash
-# Initialize Ruler in your project
+# Initialize Skiller in your project
 cd your-project
-ruler init
+skiller init
 
 # Edit the generated files
-# - Add your coding guidelines to .ruler/AGENTS.md (or keep adding additional .md files)
-# - Customize .ruler/ruler.toml if needed
+# - Add your coding guidelines to .claude/AGENTS.md (or keep adding additional .md files)
+# - Customize .claude/skiller.toml if needed
 
 # Apply rules to all AI agents
-ruler apply
+skiller apply
 ```
 
 ### Scenario 2: Complex Projects with Nested Rules
@@ -801,53 +797,53 @@ ruler apply
 For large projects with multiple components or services, enable nested rule loading so each directory keeps its own rules and MCP bundle:
 
 ```bash
-# Set up nested .ruler directories
-mkdir -p src/.ruler tests/.ruler docs/.ruler
+# Set up nested .claude directories
+mkdir -p src/.claude tests/.claude docs/.claude
 
 # Add component-specific instructions
-echo "# API Design Guidelines" > src/.ruler/api_rules.md
-echo "# Testing Best Practices" > tests/.ruler/test_rules.md
-echo "# Documentation Standards" > docs/.ruler/docs_rules.md
+echo "# API Design Guidelines" > src/.claude/api_rules.md
+echo "# Testing Best Practices" > tests/.claude/test_rules.md
+echo "# Documentation Standards" > docs/.claude/docs_rules.md
 ```
 
 ```toml
-# .ruler/ruler.toml
+# .claude/skiller.toml
 nested = true
 ```
 
 ```bash
-# The CLI inherits nested mode from ruler.toml
-ruler apply --verbose
+# The CLI inherits nested mode from skiller.toml
+skiller apply --verbose
 
 # Override from the CLI at any time
-ruler apply --no-nested
+skiller apply --no-nested
 ```
 
-This creates context-specific instructions for different parts of your project while maintaining global rules in the root `.ruler/` directory. Nested runs automatically keep every nested config enabled even if a child tries to disable it.
+This creates context-specific instructions for different parts of your project while maintaining global rules in the root `.claude/` directory. Nested runs automatically keep every nested config enabled even if a child tries to disable it.
 
 > [!NOTE]
 > The CLI prints "Nested mode is experimental and may change in future releases." the first time nested processing runs. Expect refinements in future versions.
 
 ### Scenario 3: Team Standardization
 
-1. Create `.ruler/coding_standards.md`, `.ruler/api_usage.md`
-2. Commit the `.ruler` directory to your repository
-3. Team members pull changes and run `ruler apply` to update their local AI agent configurations
+1. Create `.claude/coding_standards.md`, `.claude/api_usage.md`
+2. Commit the `.claude` directory to your repository
+3. Team members pull changes and run `skiller apply` to update their local AI agent configurations
 
 ### Scenario 4: Project-Specific Context for AI
 
-1. Detail your project's architecture in `.ruler/project_overview.md`
-2. Describe primary data structures in `.ruler/data_models.md`
-3. Run `ruler apply` to help AI tools provide more relevant suggestions
+1. Detail your project's architecture in `.claude/project_overview.md`
+2. Describe primary data structures in `.claude/data_models.md`
+3. Run `skiller apply` to help AI tools provide more relevant suggestions
 
 ### Integration with NPM Scripts
 
 ```json
 {
   "scripts": {
-    "ruler:apply": "ruler apply",
-    "dev": "npm run ruler:apply && your_dev_command",
-    "precommit": "npm run ruler:apply"
+    "skiller:apply": "skiller apply",
+    "dev": "npm run skiller:apply && your_dev_command",
+    "precommit": "npm run skiller:apply"
   }
 }
 ```
@@ -855,14 +851,14 @@ This creates context-specific instructions for different parts of your project w
 ### Integration with GitHub Actions
 
 ```yaml
-# .github/workflows/ruler-check.yml
-name: Check Ruler Configuration
+# .github/workflows/skiller-check.yml
+name: Check Skiller Configuration
 on:
   pull_request:
-    paths: ['.ruler/**']
+    paths: ['.claude/**']
 
 jobs:
-  check-ruler:
+  check-skiller:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -871,17 +867,17 @@ jobs:
           node-version: '18'
           cache: 'npm'
 
-      - name: Install Ruler
-        run: npm install -g @udecode/ruler
+      - name: Install Skiller
+        run: npm install -g skiller
 
-      - name: Apply Ruler configuration
-        run: ruler apply --no-gitignore
+      - name: Apply Skiller configuration
+        run: skiller apply --no-gitignore
 
       - name: Check for uncommitted changes
         run: |
           if [[ -n $(git status --porcelain) ]]; then
-            echo "::error::Ruler configuration is out of sync!"
-            echo "Please run 'ruler apply' locally and commit the changes."
+            echo "::error::Skiller configuration is out of sync!"
+            echo "Please run 'skiller apply' locally and commit the changes."
             exit 1
           fi
 ```
@@ -892,8 +888,8 @@ jobs:
 
 **"Cannot find module" errors:**
 
-- Ensure Ruler is installed globally: `npm install -g @udecode/ruler`
-- Or use `npx @udecode/ruler`
+- Ensure Skiller is installed globally: `npm install -g skiller`
+- Or use `npx skiller@latest`
 
 **Permission denied errors:**
 
@@ -901,13 +897,13 @@ jobs:
 
 **Agent files not updating:**
 
-- Check if the agent is enabled in `ruler.toml`
+- Check if the agent is enabled in `skiller.toml`
 - Verify agent isn't excluded by `--agents` flag
 - Use `--verbose` to see detailed execution logs
 
 **Configuration validation errors:**
 
-- Ruler now validates `ruler.toml` format and will show specific error details
+- Skiller now validates `skiller.toml` format and will show specific error details
 - Check that all configuration values match the expected types and formats
 
 ### Debug Mode
@@ -915,7 +911,7 @@ jobs:
 Use `--verbose` flag to see detailed execution logs:
 
 ```bash
-ruler apply --verbose
+skiller apply --verbose
 ```
 
 This shows:
@@ -931,36 +927,36 @@ This shows:
 A: Currently, all agents receive the same concatenated rules. For agent-specific instructions, include sections in your rule files like "## GitHub Copilot Specific" or "## Aider Configuration".
 
 **Q: How do I set up different instructions for different parts of my project?**
-A: Enable nested mode either by setting `nested = true` in `ruler.toml` or by passing `ruler apply --nested`. The CLI inherits the config setting by default, but `--no-nested` always wins if you need to opt out for a run. Nested mode keeps loading rules (and MCP settings) from every `.ruler/` directory in the hierarchy, forces child configs to remain nested, and logs "Nested mode is experimental and may change in future releases." if any nested processing occurs.
+A: Enable nested mode either by setting `nested = true` in `skiller.toml` or by passing `skiller apply --nested`. The CLI inherits the config setting by default, but `--no-nested` always wins if you need to opt out for a run. Nested mode keeps loading rules (and MCP settings) from every `.claude/` directory in the hierarchy, forces child configs to remain nested, and logs "Nested mode is experimental and may change in future releases." if any nested processing occurs.
 
-**Q: How do I temporarily disable Ruler for an agent?**
-A: Set `enabled = false` in `ruler.toml` under `[agents.agentname]`, or use `--agents` flag to specify only the agents you want.
+**Q: How do I temporarily disable Skiller for an agent?**
+A: Set `enabled = false` in `skiller.toml` under `[agents.agentname]`, or use `--agents` flag to specify only the agents you want.
 
 **Q: What happens to my existing agent configuration files?**
-A: Ruler creates backups with `.bak` extension before overwriting any existing files.
+A: Skiller creates backups with `.bak` extension before overwriting any existing files.
 
-**Q: Can I run Ruler in CI/CD pipelines?**
-A: Yes! Use `ruler apply --no-gitignore` in CI to avoid modifying `.gitignore`. See the GitHub Actions example above.
+**Q: Can I run Skiller in CI/CD pipelines?**
+A: Yes! Use `skiller apply --no-gitignore` in CI to avoid modifying `.gitignore`. See the GitHub Actions example above.
 
 **Q: How does OpenHands MCP propagation classify servers?**
 A: Local stdio servers become `stdio_servers`. Remote URLs containing `/sse` are classified as `sse_servers`; others become `shttp_servers`. Bearer tokens in an `Authorization` header are extracted into `api_key` where possible.
 
 **Q: Where is Zed configuration written now?**
-A: Ruler writes a `settings.json` in the project root (not the user home dir) and transforms MCP server definitions to Zed's `context_servers` format including `source: "custom"`.
+A: Skiller writes a `settings.json` in the project root (not the user home dir) and transforms MCP server definitions to Zed's `context_servers` format including `source: "custom"`.
 
 **Q: What changed about MCP initialization?**
-A: `ruler init` now only adds example MCP server sections to `ruler.toml` instead of creating `.ruler/mcp.json`. The JSON file is still consumed if present, but TOML servers win on name conflicts.
+A: `skiller init` now only adds example MCP server sections to `skiller.toml` instead of creating `.claude/mcp.json`. The JSON file is still consumed if present, but TOML servers win on name conflicts.
 
 **Q: Is Kiro supported?**
-A: Yes. Kiro receives concatenated rules at `.kiro/steering/ruler_kiro_instructions.md`.
+A: Yes. Kiro receives concatenated rules at `.kiro/steering/skiller_kiro_instructions.md`.
 
 ## Development
 
 ### Setup
 
 ```bash
-git clone https://github.com/udecode/ruler.git
-cd ruler
+git clone https://github.com/udecode/skiller.git
+cd skiller
 npm install
 npm run build
 ```