ima-claude 2.20.0 → 2.26.0

package/plugins/ima-claude/skills/unit-testing/SKILL.md

@@ -5,184 +5,113 @@ description: "Test workflow orchestration — decision tree routing to domain sk
 
 # Unit Testing - Orchestration Skill
 
-**"Test pure core, not impure shell. FP makes testing easy."**
+Pure functions are trivially testable. Hard-to-test code is a design problem, not a test setup problem.
 
-This skill orchestrates test workflows by routing to the right domain skills. It does NOT duplicate domain-specific testing patterns — it coordinates them.
+**Core rules:**
+- Extract pure logic — separate decisions from effects
+- Test behavior, not implementation
+- Bottom-heavy pyramid: many unit, few integration, fewer E2E
+- Mock only boundaries (DB, network, filesystem), not your own code
 
-## Core Philosophy
-
-Pure functions are trivially testable. If something is hard to test, the problem is the code design, not the test setup.
-
-1. **Extract pure logic** — separate decisions from effects
-2. **Test behavior, not implementation** — what it does, not how
-3. **Bottom-heavy pyramid** — many unit tests, few integration, fewer E2E
-4. **Minimal mocking** — mock boundaries (DB, network, filesystem), not your own code
-
-## Decision Tree: Which Skills to Use
+## Decision Tree: Which Skills
 
 ```
 What are you testing?
 ├── WordPress PHP plugin/theme?
 │   → phpunit-wp (primary) + php-fp + php-fp-wordpress
-│   → References: php-fp/references/testing-patterns.md
-│                  php-fp-wordpress/references/testing-strategy.md
 │
 ├── General PHP (non-WordPress)?
 │   → php-fp (primary)
-│   → References: php-fp/references/testing-patterns.md
 │
 ├── JavaScript/TypeScript?
-│   ├── React components?
-│   │   → js-fp-react + js-fp
-│   ├── Vue components?
-│   │   → js-fp-vue + js-fp
-│   │   → References: js-fp-vue/references/testing.md
-│   └── General JS/TS?
-│       → js-fp (primary)
-│       → References: js-fp/references/testing-patterns.md
+│   ├── React components? → js-fp-react + js-fp
+│   ├── Vue components?   → js-fp-vue + js-fp
+│   └── General JS/TS?   → js-fp (primary)
 │
-├── End-to-end / browser tests?
-│   → playwright (primary)
+├── End-to-end / browser? → playwright (primary)
 │
 └── Unknown / mixed?
-    → Start with functional-programmer principles
-    → Route to domain skill once context is clear
+    → functional-programmer → route to domain skill once clear
 ```
 
-**Always apply:** `functional-programmer` principles (pure functions, composition, immutability).
-
-## Workflow: Adding Tests to Existing Code
+## Workflow: Adding Tests
 
-### Step 1: Analyze
+**Step 1 — Analyze:** Read code under test. Identify pure functions vs impure boundaries. Map dependencies (DB, filesystem, network, global state).
 
-- Read the code under test
-- Identify pure functions vs impure boundaries
-- Map dependencies: what does this code touch? (DB, filesystem, network, global state)
-
-### Step 2: Classify
+**Step 2 — Classify:**
 
 | Code Type | Test Type | Speed | Mocking |
 |-----------|-----------|-------|---------|
-| Pure function (no side effects) | Unit test | Fast (<10ms) | None |
-| Function with injected deps | Unit test | Fast | Stub the deps |
-| WordPress hook/filter callback | Unit or integration | Medium | Mock WP functions |
-| API endpoint handler | Integration test | Medium | Mock external services |
-| Full user workflow | E2E test | Slow | None (real browser) |
-
-### Step 3: Structure
-
-Follow project conventions for test file location:
-- PHP: `tests/Unit/`, `tests/Integration/` (mirror `src/` structure)
-- JS/TS: colocated `*.test.ts` or `__tests__/` directory
+| Pure function | Unit | Fast (<10ms) | None |
+| Injected deps | Unit | Fast | Stub deps |
+| WP hook/filter | Unit or integration | Medium | Mock WP functions |
+| API endpoint | Integration | Medium | Mock external services |
+| Full user workflow | E2E | Slow | None (real browser) |
+
+**Step 3 — Structure:**
+- PHP: `tests/Unit/`, `tests/Integration/` (mirror `src/`)
+- JS/TS: colocated `*.test.ts` or `__tests__/`
 - E2E: `tests/e2e/` or `e2e/`
 
-### Step 4: Write
+**Step 4 — Write:** `Arrange → Act → Assert` (one behavior per test)
+- Test name = behavior description: `it('returns empty array when no items match filter')`
+- One assertion per concept; no logic in tests; minimal test data
 
-Apply the domain skill's patterns. General principles:
+**Step 5 — Verify:** Run suite, all green, no unexplained skips, coverage meets floor.
 
-```
-Arrange → Act → Assert (one behavior per test)
-```
-
-- **Test name = behavior description**: `it('returns empty array when no items match filter')`
-- **One assertion per concept** (multiple `expect` calls are fine if they verify one behavior)
-- **No logic in tests**: no conditionals, no loops, no try/catch
-- **Test data is minimal**: only include fields relevant to the behavior under test
-
-### Step 5: Verify
-
-- Run the test suite: `composer test`, `npm test`, `npx vitest`, etc.
-- All tests pass (green)
-- No skipped or pending tests without a documented reason
-- Coverage meets project floor (if configured)
-
-## Workflow: TDD (Test-Driven Development)
-
-### Red-Green-Refactor
+## TDD: Red-Green-Refactor
 
 ```
-1. RED    — Write a failing test for the next behavior
-2. GREEN  — Write the minimum code to make it pass
-3. REFACTOR — Clean up while keeping tests green
+1. RED    — Write failing test for next behavior
+2. GREEN  — Minimum code to pass
+3. REFACTOR — Clean up, keep green
 ```
 
-### TDD with Pure Functions (Ideal Case)
-
-Pure functions + TDD = fast feedback loops. No setup, no teardown, no mocking.
-
-```
-Test: add(2, 3) === 5
-Code: const add = (a, b) => a + b
-Done.
-```
-
-### TDD for Impure Boundaries
-
-When TDD hits an impure boundary (DB, network, filesystem):
-
-1. **Define the interface** — what does the boundary need to provide?
-2. **Stub the boundary** — test against the interface, not the implementation
-3. **Wire up later** — connect the real implementation after the pure logic is tested
-
-### When TDD Slows You Down
-
-TDD is a tool, not a religion. Skip it when:
-- Exploring/prototyping (you'll throw the code away)
-- The implementation is trivial and obvious
-- You're writing glue code with no logic
-
-See `references/tdd-workflow.md` for detailed mechanics.
+Skip TDD when: exploring/prototyping, trivial/obvious implementation, pure glue code.
 
 ## Mock Decision Tree
 
 ```
 Is the dependency hard to test?
-├── No (pure function, simple data) → Don't mock. Test directly.
-├── Yes, but I own the code
+├── No → Don't mock. Test directly.
+├── Yes, I own the code
 │   ├── Can I extract pure logic? → Extract it. Test the pure part.
 │   └── Can I inject the dependency? → Inject it. Pass a stub.
-└── Yes, external service (DB, API, filesystem, time)
-    → Mock it. Use the simplest mock type that works.
+└── Yes, external (DB, API, filesystem, time) → Mock it.
 ```
 
-### Mock Types (Simplest First)
-
-| Type | What it does | When to use |
-|------|-------------|-------------|
-| **Stub** | Returns canned data | Most cases. Default choice. |
-| **Spy** | Records calls for verification | When you need to verify a call was made |
-| **Fake** | Working simplified implementation | Complex interfaces (in-memory DB) |
-| **Full mock** | Strict expectations on calls | Almost never. Couples tests to implementation. |
-
-See `references/mock-patterns.md` for language-specific examples and anti-patterns.
+| Mock Type | What it does | When |
+|-----------|-------------|------|
+| Stub | Returns canned data | Default choice |
+| Spy | Records calls | When verifying a call was made |
+| Fake | Working simplified impl | Complex interfaces (in-memory DB) |
+| Full mock | Strict call expectations | Almost never |
 
-## Test Quality Checklist
-
-Before considering tests "done":
+## Quality Checklist
 
 - [ ] Tests verify behavior, not implementation
-- [ ] Each test has a descriptive name explaining the scenario
-- [ ] No test depends on another test's state (isolation)
-- [ ] No flaky signals: no timers, no real network, no filesystem in unit tests
+- [ ] Each test name describes the scenario
+- [ ] No test depends on another's state
+- [ ] No timers, real network, or filesystem in unit tests
 - [ ] Pure functions tested without mocking
-- [ ] Mocks used only at impure boundaries
-- [ ] Edge cases covered: empty input, null/undefined, boundary values
+- [ ] Mocks only at impure boundaries
+- [ ] Edge cases: empty input, null/undefined, boundary values
 - [ ] Error paths tested (not just happy path)
-- [ ] Test runs fast (unit suite < 10s for most projects)
+- [ ] Unit suite runs < 10s
 
 ## Anti-Patterns
 
-| Anti-Pattern | Problem | Fix |
-|-------------|---------|-----|
-| Testing implementation details | Breaks on refactor | Test behavior/output instead |
-| Mocking everything | Tests prove nothing | Extract pure logic, mock only boundaries |
-| Giant test setup | Hard to understand | Simplify code under test or use factories |
-| Copy-paste test bodies | Maintenance nightmare | Use parameterized/table-driven tests |
-| Testing framework behavior | Wastes time | Trust the framework |
-| 100% coverage target | Diminishing returns | Set a floor, not a ceiling |
-| `sleep()` in tests | Flaky, slow | Use deterministic waits or fix the design |
+| Anti-Pattern | Fix |
+|-------------|-----|
+| Testing implementation details | Test behavior/output instead |
+| Mocking everything | Extract pure logic, mock only boundaries |
+| Giant test setup | Simplify code under test or use factories |
+| Copy-paste test bodies | Use parameterized/table-driven tests |
+| Testing framework behavior | Trust the framework |
+| 100% coverage target | Set a floor, not a ceiling |
+| `sleep()` in tests | Use deterministic waits or fix the design |
 
-## Integration: Domain Skill Reference
+## Domain Skill Reference
 
 | Context | Primary Skill | Reference Files |
 |---------|--------------|-----------------|
@@ -192,7 +121,3 @@ Before considering tests "done":
 | Vue.js | `js-fp-vue` | `js-fp-vue/references/testing.md` |
 | React | `js-fp-react` | `js-fp/references/testing-patterns.md` |
 | E2E / Browser | `playwright` | (self-contained skill) |
-
-## The Final Word
-
-*"If it's hard to test, it's hard to use. Testability is a design signal, not a chore. Extract the pure, inject the impure, and the tests write themselves."*

package/plugins/ima-claude/skills/wp-ddev/SKILL.md

@@ -7,34 +7,24 @@ description: "Run WordPress WP-CLI commands in DDEV environments. Database queri
 
 Execute WP-CLI commands in DDEV WordPress environments. Zero configuration — just be in a DDEV project directory.
 
-## Quick Start
-
-**Prerequisites**: Docker + DDEV v1.25+ installed.
+**Prerequisites**: Docker + DDEV v1.25+
 
 ```bash
-# Start your DDEV project
 ddev start
-
-# Run WP-CLI commands directly
 ddev wp plugin list
-ddev wp user list
 ddev wp db query "SELECT * FROM wp_posts LIMIT 5"
-
-# View project info (URLs, ports, credentials)
-ddev describe
+ddev describe  # URLs, ports, credentials
 ```
 
 ## How It Works
 
-1. DDEV auto-detects `.ddev/config.yaml` in project directory
-2. WP-CLI runs inside the web container with correct PHP, MySQL, and WordPress paths
-3. No environment pollution — host session stays clean
-4. No UUIDs, no socket paths, no wrapper scripts
+- DDEV auto-detects `.ddev/config.yaml`
+- WP-CLI runs inside web container with correct PHP, MySQL, WordPress paths
+- No host environment pollution, no UUIDs, no socket paths
 
 ## Common Commands
 
-### Database Operations
-`ddev wp db query <sql>` · `ddev wp db export [file]` · `ddev wp db import <file>` · `ddev wp search-replace <old> <new>`
+### Database
 ```bash
 ddev wp db query "SELECT * FROM wp_users"
 ddev wp db export dump.sql
@@ -43,29 +33,23 @@ ddev wp search-replace 'old.com' 'new.com' --dry-run
 ddev wp search-replace 'old.com' 'new.com' --all-tables
 ```
 
-### Plugin Management
-`ddev wp plugin list` · `ddev wp plugin activate <plugin>` · `ddev wp plugin deactivate <plugin>` · `ddev wp plugin install <plugin> [--activate]`
+### Plugins
 ```bash
-ddev wp plugin list
 ddev wp plugin list --status=active --format=json
 ddev wp plugin activate my-plugin
-ddev wp plugin deactivate my-plugin
 ddev wp plugin install contact-form-7 --activate
 ddev wp plugin is-installed woocommerce && echo "yes"
 ```
 
-### User Operations
-`ddev wp user list` · `ddev wp user create <login> <email> [--role=<role>]` · `ddev wp user update <user> [--field=value]`
+### Users
 ```bash
-ddev wp user list
 ddev wp user list --role=administrator --format=table
 ddev wp user create testuser test@example.com --role=editor
 ddev wp user update 1 --display_name="Admin User"
 ddev wp user add-role 2 editor
 ```
 
-### Theme Operations
-`ddev wp theme list` · `ddev wp theme activate <theme>` · `ddev wp theme status <theme>`
+### Themes
 ```bash
 ddev wp theme list
 ddev wp theme activate twentytwentyfour
@@ -73,16 +57,13 @@ ddev wp theme status flavor
 ```
 
 ### Cache & Transients
-`ddev wp cache flush` · `ddev wp transient delete --all` · `ddev wp transient get <key>`
 ```bash
 ddev wp cache flush
 ddev wp transient delete --all
 ddev wp transient get my_transient_key
-ddev wp transient list --format=table
 ```
 
 ### Options
-`ddev wp option get <key>` · `ddev wp option update <key> <value>` · `ddev wp option list [--search=<pattern>]`
 ```bash
 ddev wp option get siteurl
 ddev wp option update blogname "New Site Name"
@@ -90,20 +71,17 @@ ddev wp option list --search="woocommerce_*" --format=table
 ddev wp option delete my_old_option
 ```
 
-### Post & Content
-`ddev wp post list [--post_type=<type>]` · `ddev wp post create` · `ddev wp post update <id>` · `ddev wp post delete <id>`
+### Posts
 ```bash
 ddev wp post list --post_type=page --format=table
 ddev wp post list --post_status=draft --fields=ID,post_title
 ddev wp post create --post_type=post --post_title="Test" --post_status=publish
 ddev wp post update 42 --post_title="Updated Title"
 ddev wp post delete 42 --force
-ddev wp post meta get 42 _thumbnail_id
 ddev wp post meta update 42 custom_field "new value"
 ```
 
-### Taxonomy & Terms
-`ddev wp term list <taxonomy>` · `ddev wp term create <taxonomy> <term>` · `ddev wp term update <taxonomy> <term-id>`
+### Taxonomy
 ```bash
 ddev wp term list category --format=table
 ddev wp term create category "New Category" --slug=new-category
@@ -112,24 +90,19 @@ ddev wp term delete category 5
 ```
 
 ### Menu
-`ddev wp menu list` · `ddev wp menu item list <menu>` · `ddev wp menu item add-post <menu> <post-id>`
 ```bash
 ddev wp menu list --format=table
-ddev wp menu item list primary-menu
 ddev wp menu item add-post primary-menu 42
 ddev wp menu item add-custom primary-menu "Link" https://example.com
 ```
 
-### Rewrite Rules
-`ddev wp rewrite flush` · `ddev wp rewrite list` · `ddev wp rewrite structure <structure>`
+### Rewrite
 ```bash
 ddev wp rewrite flush
-ddev wp rewrite list --format=csv
 ddev wp rewrite structure '/%postname%/'
 ```
 
 ### Scaffold
-`ddev wp scaffold plugin <slug>` · `ddev wp scaffold child-theme <slug>` · `ddev wp scaffold post-type <slug>`
 ```bash
 ddev wp scaffold plugin my-plugin --plugin_name="My Plugin"
 ddev wp scaffold post-type product --plugin=my-plugin
@@ -137,128 +110,73 @@ ddev wp scaffold taxonomy genre --post_types=product --plugin=my-plugin
 ddev wp scaffold child-theme flavor-child --parent_theme=flavor
 ```
 
-### Eval & Shell
-`ddev wp eval <code>` · `ddev wp eval-file <file>`
+### Eval
 ```bash
 ddev wp eval "echo home_url();"
 ddev wp eval "var_dump(wp_get_current_user());"
-ddev wp eval "echo get_option('active_plugins') | print_r;"
 ddev wp eval-file test-script.php
 ```
 
 ## DDEV Project Commands
 
 ```bash
-# Lifecycle
 ddev start            # Start containers
 ddev stop             # Stop (preserves database)
 ddev restart          # Restart after config changes
-
-# Information
 ddev describe         # URLs, ports, DB credentials, PHP version
-ddev list             # All DDEV projects on this machine
-
-# Shell & Exec
+ddev list             # All DDEV projects on machine
 ddev ssh              # Interactive shell in web container
-ddev exec ls -la      # Run any command in web container
-
-# Logs
+ddev exec ls -la      # Run command in web container
 ddev logs             # Web server logs
-ddev logs -s db       # Database server logs
-
-# Launch
+ddev logs -s db       # Database logs
 ddev launch           # Open site in browser
 ddev launch wp-admin/ # Open WP admin
 ```
 
 ## IMA Addon Commands
 
-Commands provided by the `ima-ddev-wordpress` addon:
-
 ```bash
-# First-time bootstrap (idempotent — safe to re-run)
-ddev setup
-
-# Import wp-content assets from WPE site archive
-ddev import-assets ~/path/to/extracted-archive
-
-# Import database dump
-ddev import-db --file=~/path/to/dump.sql
-
-# Update the addon
-ddev add-on update ima-ddev-wordpress
+ddev setup                                      # First-time bootstrap (idempotent)
+ddev import-assets ~/path/to/extracted-archive  # Import wp-content from WPE archive
+ddev import-db --file=~/path/to/dump.sql        # Import database dump
+ddev add-on update ima-ddev-wordpress           # Update addon
 ```
 
 ## Supply Chain Security
 
-Always use `ddev npm`, `ddev composer` instead of bare host commands. Container isolation prevents compromised dependencies from accessing host SSH keys, env vars, and other projects.
+Use `ddev npm`/`ddev composer` — never bare host commands. Container isolation prevents compromised deps from accessing host SSH keys, env vars, other projects.
 
-| Instead of | Use | Why |
-|---|---|---|
-| `npm install` | `ddev npm install` | Container-isolated |
-| `composer install` | `ddev composer install` | Container-isolated |
-| `npm run composer:dev` | `ddev npm run composer:dev` | Container-isolated |
+| Instead of | Use |
+|---|---|
+| `npm install` | `ddev npm install` |
+| `composer install` | `ddev composer install` |
+| `npm run composer:dev` | `ddev npm run composer:dev` |
 
-**Exception:** `npm run deploy` stays on host — needs SSH access for WP Engine push.
+**Exception**: `npm run deploy` stays on host — needs SSH for WP Engine push.
 
 ## Global Flags
 
-These flags work with most WP-CLI commands:
-
 | Flag | Description |
 |---|---|
-| `--format=<format>` | Output: `table`, `csv`, `json`, `yaml`, `count`, `ids` |
-| `--fields=<fields>` | Comma-separated columns to display |
+| `--format=<format>` | `table`, `csv`, `json`, `yaml`, `count`, `ids` |
+| `--fields=<fields>` | Comma-separated columns |
 | `--quiet` | Suppress informational messages |
-| `--skip-themes` | Skip loading themes (faster execution) |
-| `--skip-plugins` | Skip loading all plugins (debug conflicts) |
-| `--skip-plugins=<plugin>` | Skip loading specific plugin |
+| `--skip-themes` | Skip loading themes |
+| `--skip-plugins` | Skip all plugins (debug conflicts) |
+| `--skip-plugins=<plugin>` | Skip specific plugin |
 | `--debug` | Show debug output |
-| `--user=<id\|login>` | Run command as specific user |
-
-## Finding More Commands
-
-The 12 categories above cover ~90% of daily dev usage. For everything else:
+| `--user=<id\|login>` | Run as specific user |
 
 ```bash
 ddev wp help
 ddev wp help plugin
-ddev wp help post list
 ```
 
-See [`references/wp-cli-reference.md`](references/wp-cli-reference.md) for a comprehensive reference and [`references/ddev-commands.md`](references/ddev-commands.md) for DDEV-specific commands.
-
-## Daily Workflow
-
-```bash
-# Start your day
-ddev start
-
-# Develop — code changes auto-reflected via bind mounts
-# Test
-ddev wp plugin activate my-plugin
-ddev wp cache flush
-ddev launch
-
-# Stop when done
-ddev stop
-```
-
-## Integration
-
-**With php-fp-wordpress**: Test plugins during development, verify security functions, check database operations.
-
-**With js-fp-wordpress**: Test script enqueuing, verify AJAX endpoints, check jQuery availability.
-
-```bash
-# Develop plugin with php-fp-wordpress patterns, test with DDEV
-ddev wp plugin activate my-new-plugin
-ddev wp eval "var_dump(current_user_can('edit_posts'));"
-```
+See [`references/wp-cli-reference.md`](references/wp-cli-reference.md) and [`references/ddev-commands.md`](references/ddev-commands.md).
 
 ## Quality Gates
 
-Before running destructive commands:
-- ✅ Correct project: `ddev describe` to verify you're in the right DDEV project
-- ✅ Backup if needed: `ddev export-db --file=backup.sql.gz` for database modifications
-- ✅ Containers running: `ddev start` (DDEV will tell you if already running)
+Before destructive commands:
+- Correct project: `ddev describe`
+- Backup if needed: `ddev export-db --file=backup.sql.gz`
+- Containers running: `ddev start`