ima-claude 2.20.0 → 2.26.0

package/plugins/ima-claude/skills/rg/SKILL.md

@@ -3,203 +3,118 @@ name: "rg"
 description: "Ripgrep (rg) - fast recursive search tool. Prefer over grep/find for code search. Respects .gitignore, searches recursively, supports regex. Use for file content search, file listing, pattern matching. Triggers on: ripgrep, rg, search files, find in files, grep, search code, find pattern."
 ---
 
-# Ripgrep (rg) - Preferred Search Tool
+# Ripgrep (rg)
 
-**Always use `rg` instead of `grep` or `find -name`** - it's faster, has better defaults, and respects `.gitignore`.
+Use `rg` instead of `grep` or `find -name`. Faster, better defaults, respects `.gitignore`.
 
-## Quick Reference
+## Basic Search
 
-### Basic Search
 ```bash
-# Search for pattern in current directory (recursive)
-rg "pattern"
-
-# Search specific file or directory
-rg "pattern" src/
-rg "pattern" file.ts
-
-# Case-insensitive search
-rg -i "pattern"
-
-# Word boundary match (whole words only)
-rg -w "function"
-
-# Fixed string (not regex)
-rg -F "exact.string.match"
+rg "pattern"                    # Recursive from cwd
+rg "pattern" src/               # Specific directory
+rg -i "pattern"                 # Case-insensitive
+rg -w "function"                # Whole words only
+rg -F "exact.string.match"      # Fixed string (not regex)
 ```
 
-### Output Control
-```bash
-# Show N lines of context (before and after)
-rg -C 3 "pattern"
-
-# Lines before (-B) or after (-A) only
-rg -B 2 -A 5 "pattern"
-
-# Count matches per file
-rg -c "pattern"
-
-# List files with matches only (no content)
-rg -l "pattern"
-rg --files-with-matches "pattern"
-
-# List files WITHOUT matches
-rg --files-without-match "pattern"
-
-# Show only the matched text (not full line)
-rg -o "pattern"
-```
+## Output Control
 
-### File Filtering
 ```bash
-# By file type (built-in types)
-rg -t ts "pattern"       # TypeScript only
-rg -t py "pattern"       # Python only
-rg -t js "pattern"       # JavaScript only
-rg -t rust "pattern"     # Rust only
-
-# Exclude file type
-rg -T js "pattern"       # Exclude JavaScript
-
-# By glob pattern
-rg -g "*.vue" "pattern"           # Only .vue files
-rg -g "!*.test.ts" "pattern"      # Exclude test files
-rg -g "src/**/*.ts" "pattern"     # TypeScript in src/
-
-# Multiple globs
-rg -g "*.ts" -g "*.vue" "pattern"
+rg -C 3 "pattern"               # 3 lines context before+after
+rg -B 2 -A 5 "pattern"          # 2 before, 5 after
+rg -c "pattern"                 # Count matches per file
+rg -l "pattern"                 # Files with matches only
+rg --files-without-match "pat"  # Files without matches
+rg -o "pattern"                 # Matched text only (not full line)
 ```
 
-### List Files (No Search)
-```bash
-# List all files that would be searched
-rg --files
-
-# List files matching glob
-rg --files -g "*.ts"
-
-# List files in specific directory
-rg --files src/components/
-```
+## File Filtering
 
-### Bypass Filters
 ```bash
-# -u levels (unrestricted):
-rg -u "pattern"      # Ignore .gitignore
-rg -uu "pattern"     # + search hidden files
-rg -uuu "pattern"    # + search binary files
-
-# Specific overrides
-rg --hidden "pattern"      # Include hidden files
-rg --no-ignore "pattern"   # Ignore all ignore files
+rg -t ts "pattern"              # TypeScript only
+rg -t py "pattern"              # Python only
+rg -T js "pattern"              # Exclude JavaScript
+rg -g "*.vue" "pattern"         # By glob
+rg -g "!*.test.ts" "pattern"    # Exclude test files
+rg -g "src/**/*.ts" "pattern"   # Scoped glob
+rg -g "*.ts" -g "*.vue" "pat"   # Multiple globs
 ```
 
-### Advanced Patterns
+## List Files (No Search)
+
 ```bash
-# Multiline search
-rg -U "start.*\n.*end"
+rg --files                      # All files that would be searched
+rg --files -g "*.ts"            # Files matching glob
+rg --files src/components/      # Files in directory
+```
 
-# PCRE2 regex (lookahead/lookbehind)
-rg -P "(?<=prefix)pattern(?=suffix)"
+## Bypass Filters
 
-# Replace in output (preview, doesn't modify files)
-rg "old" -r "new"
+```bash
+rg -u "pattern"     # Ignore .gitignore
+rg -uu "pattern"    # + include hidden files
+rg -uuu "pattern"   # + include binary files
+rg --hidden "pat"   # Include hidden files only
+```
 
-# With capture groups
-rg "fn (\w+)" -r "function $1"
+## Advanced
 
-# JSON output (for scripting)
-rg --json "pattern"
+```bash
+rg -U "start.*\n.*end"                    # Multiline
+rg -P "(?<=prefix)pattern(?=suffix)"      # PCRE2 (lookahead/lookbehind)
+rg "old" -r "new"                         # Replace preview (no file modification)
+rg "fn (\w+)" -r "function $1"            # Capture groups in replace
+rg --json "pattern"                       # JSON output for scripting
 ```
 
 ## Common Recipes
 
-### Find Function/Class Definitions
 ```bash
-# JavaScript/TypeScript
-rg "^(export )?(async )?(function|const|class) \w+"
-rg "^export (default )?(function|class)"
+# Function/class definitions
+rg "^(export )?(async )?(function|const|class) \w+"   # JS/TS
+rg "^(async )?def \w+|^class \w+"                     # Python
+rg "^(public |private |protected )?(static )?function \w+"  # PHP
 
-# Python
-rg "^(async )?def \w+|^class \w+"
-
-# PHP
-rg "^(public |private |protected )?(static )?(function) \w+"
-```
-
-### Find Imports/Requires
-```bash
+# Imports
 rg "^import .+ from"
 rg "require\(['\"]"
-```
 
-### Find TODOs/FIXMEs
-```bash
+# TODOs
 rg "TODO|FIXME|HACK|XXX" -g "!node_modules"
-```
 
-### Find Files by Extension
-```bash
-rg --files -g "*.tsx"              # All TSX files
-rg --files -g "*.{ts,tsx}"         # TS and TSX
-rg --files -g "!*.test.*"          # Exclude test files
-```
+# Files by extension
+rg --files -g "*.{ts,tsx}"
+rg --files -g "!*.test.*"
 
-### Search and Replace Preview
-```bash
-# See what would change (doesn't modify files)
+# Search-replace preview
 rg "oldFunction" -r "newFunction" --passthru
 ```
 
 ## vs grep/find
 
-| Task | grep/find (avoid) | rg (prefer) |
-|------|-------------------|-------------|
-| Search text | `grep -r "pattern" .` | `rg "pattern"` |
+| Task | avoid | prefer |
+|------|-------|--------|
+| Search text | `grep -r "pat" .` | `rg "pat"` |
 | Find files | `find . -name "*.ts"` | `rg --files -g "*.ts"` |
-| Case insensitive | `grep -ri "pattern" .` | `rg -i "pattern"` |
+| Case insensitive | `grep -ri "pat" .` | `rg -i "pat"` |
 | Whole word | `grep -rw "word" .` | `rg -w "word"` |
-| Show context | `grep -r -C 3 "pattern" .` | `rg -C 3 "pattern"` |
-| List files only | `grep -rl "pattern" .` | `rg -l "pattern"` |
-
-## Key Advantages
-
-1. **Speed**: 2-10x faster than grep on large codebases
-2. **Smart defaults**: Respects `.gitignore`, skips binary/hidden files
-3. **Recursive by default**: No `-r` flag needed
-4. **Better regex**: Rust regex engine, optional PCRE2
-5. **Built-in file types**: `-t ts`, `-t py`, etc.
-6. **Colored output**: Easy to read in terminal
+| Context | `grep -r -C 3 "pat" .` | `rg -C 3 "pat"` |
+| Files only | `grep -rl "pat" .` | `rg -l "pat"` |
 
 ## Configuration
 
-Create `~/.ripgreprc` for persistent settings:
 ```shell
-# Smart case (case-insensitive unless uppercase used)
+# ~/.ripgreprc
 --smart-case
-
-# Max line length for display
 --max-columns=150
 --max-columns-preview
-
-# Include hidden files by default
-# --hidden
-
-# Custom file type
 --type-add
 web:*.{html,css,js,ts,vue}
 ```
 
-Set the config file path:
 ```bash
 export RIPGREP_CONFIG_PATH="$HOME/.ripgreprc"
-```
-
-## Type List
-
-View all built-in types:
-```bash
-rg --type-list
+rg --type-list   # View all built-in types
 ```
 
 Common types: `ts`, `js`, `py`, `rust`, `go`, `java`, `php`, `ruby`, `css`, `html`, `json`, `yaml`, `md`, `sh`

package/plugins/ima-claude/skills/ruby-fp/SKILL.md

@@ -5,31 +5,17 @@ description: "Functional Ruby patterns - Enumerable as FP toolkit, lambdas, free
 
 # Ruby FP
 
-Ruby is OOP-first, but its FP toolkit is excellent. The goal is **functional core, imperative shell** — pure methods for logic, OOP shell only where the framework demands it.
+Ruby is OOP-first, but its FP toolkit is excellent. Goal: **functional core, imperative shell** — pure methods for logic, OOP shell only where the framework demands it.
 
-## When to Use This Skill
+## Core Rules
 
-- Writing standalone Ruby scripts
-- Building Ruby utilities or service objects
-- Refactoring procedural Ruby toward composable units
-- Any Ruby code where framework conventions don't dictate the pattern
-
-## Core Philosophy
-
-> Ruby's Enumerable is a functional toolkit hiding inside an OOP language.
-
-The architect's lens applied to Ruby:
-- **Pure methods** for logic (no instance variable mutation in calculation methods)
+- **Pure methods** for logic — no instance variable mutation in calculation methods
 - **Enumerable over explicit loops** — `map/select/reduce` not `each` + accumulator
-- **Lambdas** for first-class functions (strict arity, `lambda?` is true, `return` is scoped)
+- **Lambdas** (`->`) for first-class functions — strict arity, scoped `return`
 - **freeze** for value objects and constants
 - **Functional core** isolated from I/O, database, external state
 
-Ruby will never be Haskell. Don't fight the language — compose with it.
-
-## Enumerable: The FP Toolkit
-
-These are your primary tools. Prefer them over `each` + mutation.
+## Enumerable: Primary Tools
 
 ```ruby
 users = [
@@ -38,61 +24,40 @@ users = [
   { name: 'Carol', age: 25, active: true }
 ]
 
-# select — filter
-adults = users.select { |u| u[:age] >= 18 }
-
-# map — transform
-names = users.map { |u| u[:name] }
-
-# reduce — accumulate
-total_age = users.reduce(0) { |sum, u| sum + u[:age] }
-
-# filter_map — select + transform in one pass (Ruby 2.7+, preferred)
-active_names = users.filter_map { |u| u[:name] if u[:active] }
-
-# flat_map — map + flatten
-tags = posts.flat_map { |p| p[:tags] }
-
-# each_with_object — build a hash/array without external mutation
-index = users.each_with_object({}) { |u, h| h[u[:name]] = u[:age] }
-
-# group_by — partition
-by_status = users.group_by { |u| u[:active] ? :active : :inactive }
+adults       = users.select { |u| u[:age] >= 18 }
+names        = users.map { |u| u[:name] }
+total_age    = users.reduce(0) { |sum, u| sum + u[:age] }
+active_names = users.filter_map { |u| u[:name] if u[:active] }  # Ruby 2.7+, preferred
+tags         = posts.flat_map { |p| p[:tags] }
+index        = users.each_with_object({}) { |u, h| h[u[:name]] = u[:age] }
+by_status    = users.group_by { |u| u[:active] ? :active : :inactive }
 
-# Chaining — functional pipeline
+# Functional pipeline
 result = users
   .select { |u| u[:active] }
   .map { |u| u.merge(display_name: u[:name].upcase) }
   .sort_by { |u| u[:age] }
 ```
 
-**Rule**: If you find yourself writing `results = []; collection.each { |x| results << x if ... }`, reach for `filter_map` instead.
+If writing `results = []; collection.each { |x| results << x if ... }` — use `filter_map` instead.
 
 ## Lambdas vs Procs
 
-Use `lambda` (or `->`) for reusable, composable functions. Avoid bare `proc` for logic units.
-
 ```ruby
-# Lambda — strict arity, scoped return, first-class function
-validate_age = ->(age) { age.is_a?(Integer) && age >= 0 && age <= 150 }
+validate_age   = ->(age) { age.is_a?(Integer) && age >= 0 && age <= 150 }
 normalize_email = ->(email) { email.to_s.strip.downcase }
 
 # Compose with >> (Ruby 2.6+)
 process_user = normalize_email >> method(:save_user)
 
-# Use as argument (higher-order functions)
-def transform_all(items, transformer)
-  items.map(&transformer)
-end
-
+# Higher-order functions
+def transform_all(items, transformer) = items.map(&transformer)
 transform_all(emails, normalize_email)
 
-# Method references — convert instance/class methods to callables
-validator = method(:validate_age)
+# Method references
 emails.map(&method(:normalize_email))
 ```
 
-**Lambda vs Proc differences that matter:**
 | | Lambda | Proc |
 |-|--------|------|
 | Arity | Strict (raises ArgumentError) | Loose (fills nil) |
@@ -102,27 +67,23 @@ emails.map(&method(:normalize_email))
 ## Immutability with freeze
 
 ```ruby
-# Freeze constants
 VALID_STATUSES = %w[active inactive pending].freeze
 DEFAULT_CONFIG = { timeout: 30, retries: 3 }.freeze
 
-# Value object pattern — frozen struct
-UserRecord = Data.define(:name, :email, :age)  # Ruby 3.2+
+# Value object — Ruby 3.2+
+UserRecord = Data.define(:name, :email, :age)
 user = UserRecord.new(name: 'Alice', email: 'alice@example.com', age: 30)
-# user is immutable — no setters
 
-# For older Ruby, use Struct with freeze
+# Older Ruby
 Config = Struct.new(:host, :port, :timeout).new('localhost', 5432, 30).freeze
 ```
 
-**Rule**: Any hash/array used as a constant gets `.freeze`. Value objects use `Data.define` (Ruby 3.2+) or frozen `Struct`.
+Any hash/array constant gets `.freeze`. Value objects use `Data.define` (3.2+) or frozen `Struct`.
 
 ## Functional Core / Imperative Shell
 
-The central pattern. Separate pure logic from I/O and external state.
-
 ```ruby
-# PURE CORE — no I/O, no DB, fully testable, no side effects
+# PURE CORE — no I/O, fully testable
 module UserLogic
   def self.validate(attrs)
     errors = []
@@ -133,10 +94,7 @@ module UserLogic
   end
 
   def self.normalize(attrs)
-    attrs.merge(
-      name: attrs[:name].to_s.strip,
-      email: attrs[:email].to_s.strip.downcase
-    )
+    attrs.merge(name: attrs[:name].to_s.strip, email: attrs[:email].to_s.strip.downcase)
   end
 
   def self.prepare_for_save(raw_attrs)
@@ -150,21 +108,15 @@ end
 def create_user(raw_params)
   result = UserLogic.prepare_for_save(raw_params)
   return { success: false, errors: result[:errors] } unless result[:ok]
-
-  user = User.create!(result[:attrs])  # database side effect here only
+  user = User.create!(result[:attrs])
   { success: true, user: user }
 end
 ```
 
-## Pure Method Guidelines
-
-A method is pure when:
-1. Same inputs always return same output
-2. No mutation of instance variables during computation
-3. No I/O (logging, DB, network) inside the calculation
+## Pure Method: Good vs Bad
 
 ```ruby
-# BAD — mutates state during calculation
+# BAD — mutates instance variables during calculation
 def calculate_totals
   @subtotal = @items.sum { |i| i[:price] * i[:qty] }
   @tax = @subtotal * 0.08
@@ -182,155 +134,106 @@ end
 ## Composition Patterns
 
 ```ruby
-# Method chaining on custom objects — return self or new instance
+# Immutable pipeline
 class Pipeline
-  def initialize(steps = [])
-    @steps = steps.freeze
-  end
-
-  def add(step)
-    Pipeline.new(@steps + [step])  # returns new instance, immutable
-  end
-
-  def call(input)
-    @steps.reduce(input) { |data, step| step.call(data) }
-  end
+  def initialize(steps = []) = @steps = steps.freeze
+  def add(step) = Pipeline.new(@steps + [step])
+  def call(input) = @steps.reduce(input) { |data, step| step.call(data) }
 end
 
-# Lambda composition with >>
+# Lambda composition
 sanitize  = ->(s) { s.strip.downcase }
 validate  = ->(s) { raise "empty" if s.empty?; s }
 normalize = sanitize >> validate
 
 # Callable objects (duck-typed lambdas)
-class Validator
-  def call(value)
-    value.is_a?(String) && !value.empty?
-  end
-end
-
 validators = [Validator.new, ->(v) { v.length < 255 }]
 valid = validators.all? { |v| v.call(input) }
 ```
 
-## Anti-Patterns to Avoid
+## Anti-Patterns
 
 ```ruby
-# BAD — accumulator mutation inside each
+# BAD — accumulator mutation
 result = []
 items.each { |item| result << transform(item) if item[:active] }
 # GOOD
 result = items.filter_map { |item| transform(item) if item[:active] }
 
 # BAD — output parameter mutation
-def process(items, output)
-  items.each { |i| output << i * 2 }
-end
-# GOOD — return new value
-def process(items)
-  items.map { |i| i * 2 }
-end
+def process(items, output) = items.each { |i| output << i * 2 }
+# GOOD
+def process(items) = items.map { |i| i * 2 }
 
-# BAD — complex logic inside a class with side effects mixed in
+# BAD — mixed concerns
 def calculate_and_save
-  total = @items.sum(&:price)
-  @total = total          # side effect
-  DB.save(total)          # side effect
-  total
+  total = @items.sum(&:price); @total = total; DB.save(total); total
 end
-# GOOD — separate concerns
-total = calculate_total(@items)  # pure
-update_total(total)              # side effect isolated
+# GOOD
+total = calculate_total(@items)   # pure
+update_total(total)               # side effect isolated
 
 # BAD — bare proc for reusable function
-adder = proc { |a, b| a + b }  # loose arity, weird return behavior
+adder = proc { |a, b| a + b }
 # GOOD
 adder = ->(a, b) { a + b }
 ```
 
-## When to Use Classes
+## When to Use Classes vs Modules
 
-OOP is fine for: stateful objects that model real entities (User, Order, Connection), framework integration (ActiveRecord models, controllers), objects that encapsulate a lifecycle.
+**Use classes for:** stateful entities (User, Order, Connection), framework integration (ActiveRecord), objects with lifecycle.
 
-Use modules with class methods (or plain lambdas/methods) for: pure logic, utilities, transformations, validators.
+**Use modules with class methods for:** pure logic, utilities, transformations, validators.
 
 ```ruby
-# Module for pure logic — no instances needed
 module PriceCalculator
-  def self.discount(price, tier)
-    rates = { bronze: 0.05, silver: 0.10, gold: 0.20 }.freeze
-    price * (1 - rates.fetch(tier, 0))
-  end
+  RATES = { bronze: 0.05, silver: 0.10, gold: 0.20 }.freeze
+  def self.discount(price, tier) = price * (1 - RATES.fetch(tier, 0))
 end
 
-# Class for stateful lifecycle
 class ImportJob
-  def initialize(source_db, config)
-    @source_db = source_db
-    @config = config
-  end
-
-  def run
-    records = fetch_records        # I/O
-    processed = process(records)   # pure
-    persist(processed)             # I/O
-  end
-
+  def initialize(source_db, config) = (@source_db, @config = source_db, config)
+  def run = persist(process(fetch_records))
   private
-
-  def process(records)
-    records
-      .select { |r| valid?(r) }
-      .map { |r| transform(r) }
-  end
+  def process(records) = records.select { |r| valid?(r) }.map { |r| transform(r) }
 end
 ```
 
-## Security Notes for Standalone Scripts
-
-- **Never interpolate external input into shell commands** — use `Open3.capture3` with array args, not `system("cmd #{input}")`
-- **Never interpolate input into SQL** — use parameterized queries or the driver's escape method
-- **ENV for credentials** — never hardcode; raise if missing: `ENV.fetch('DB_PASSWORD')`
+## Security (Standalone Scripts)
 
 ```ruby
 # BAD — shell injection
 system("convert #{filename} output.png")
-
 # GOOD — array form, no shell expansion
-require 'open3'
 stdout, stderr, status = Open3.capture3('convert', filename, 'output.png')
 
 # BAD — hardcoded credential
 client = Mysql2::Client.new(password: 'secret123')
-
 # GOOD — fail loudly if not set
 client = Mysql2::Client.new(password: ENV.fetch('MYSQL_PASSWORD'))
 ```
 
-## Quick Reference: When to Reach for What
+- Never interpolate external input into shell commands
+- Never interpolate input into SQL — use parameterized queries
+- Use `ENV.fetch` for credentials — raises KeyError if missing
+
+## Quick Reference
 
 | Need | Use |
 |------|-----|
-| Transform a collection | `map` |
-| Filter a collection | `select` / `reject` |
-| Transform + filter in one pass | `filter_map` |
-| Accumulate to a single value | `reduce` / `inject` |
-| Build a hash from a collection | `each_with_object` / `to_h` |
-| Group by a property | `group_by` |
+| Transform collection | `map` |
+| Filter collection | `select` / `reject` |
+| Transform + filter | `filter_map` |
+| Accumulate to single value | `reduce` / `inject` |
+| Build hash from collection | `each_with_object` / `to_h` |
+| Group by property | `group_by` |
 | Reusable function | `lambda` / `->` |
 | Compose functions | `>>` operator |
 | Immutable constant | `.freeze` |
 | Immutable value object | `Data.define` (Ruby 3.2+) or frozen `Struct` |
 | Pure logic module | `module Foo; def self.method...` |
 
-## When to Load Reference Files
-
-### FP Patterns Deep Dive
-**File**: [`references/patterns.md`](references/patterns.md)
-**Load when**: Need advanced composition, lazy enumerables, currying, memoization
-**Contains**: Lazy evaluation, `Comparable`/`Enumerable` mixin, memoization patterns, full pipeline example
+## Reference Files
 
-### Security Examples
-**File**: [`references/security.md`](references/security.md)
-**Load when**: Working with external input, SQL, shell commands, file operations
-**Contains**: SQL parameterization, shell safety, input validation, ENV credential management
+- **[`references/patterns.md`](references/patterns.md)** — Lazy enumerables, currying, memoization, advanced composition. Load when: need advanced FP patterns.
+- **[`references/security.md`](references/security.md)** — SQL parameterization, shell safety, input validation. Load when: working with external input.