wicked-garden 12.27.0

package/commands/engineering/new-generator.md

@@ -0,0 +1,257 @@
+---
+description: Create a new language generator for wicked-patch with scaffolding, tests, and validation
+phase_relevance: ["design", "build"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:engineering:new-generator
+
+Create a new language generator for wicked-patch with scaffolding, tests, and validation.
+
+## Arguments
+
+- `language` (required): Language name (e.g., "scala", "swift", "elixir")
+- `framework` (optional): ORM/framework to target (e.g., "Slick", "CoreData", "Ecto")
+- `extensions` (optional): File extensions (e.g., ".scala", defaults to lowercase language)
+
+## Instructions
+
+When this skill is invoked, follow these steps to create a complete generator:
+
+### Step 1: Gather Information
+
+If not provided, ask the user:
+1. What ORM/framework should this generator target?
+2. What file extensions should it handle?
+3. What are the common class/entity patterns in this language?
+
+### Step 2: Create the Generator
+
+Create a new file at:
+```
+${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch/generators/{language}_generator.py
+```
+
+Use this template structure (adapt for the specific language):
+
+```python
+"""
+{Language} code generator.
+
+Generates patches for {Language} files including:
+- {Framework} models (add/modify fields)
+- Classes (add properties)
+- [Other patterns specific to this language]
+
+{Framework} format: [Example of generated code]
+"""
+
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+import logging
+
+from .base import (
+    BaseGenerator,
+    register_generator,
+    ChangeSpec,
+    ChangeType,
+    FieldSpec,
+    Patch,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@register_generator
+class {Language}Generator(BaseGenerator):
+    """Generate patches for {Language} files."""
+
+    name = "{language}"
+    extensions = {"{extensions}"}
+    symbol_types = {"class", "entity", "model", ...}
+
+    # Type mappings from generic types to {Language} types
+    TYPE_MAP = {
+        "string": "{StringType}",
+        "str": "{StringType}",
+        "text": "{StringType}",
+        "int": "{IntType}",
+        "integer": "{IntType}",
+        "long": "{LongType}",
+        "bigint": "{LongType}",
+        "float": "{FloatType}",
+        "double": "{DoubleType}",
+        "decimal": "{DecimalType}",
+        "boolean": "{BoolType}",
+        "bool": "{BoolType}",
+        "date": "{DateType}",
+        "datetime": "{DateTimeType}",
+        "timestamp": "{TimestampType}",
+        "uuid": "{UUIDType}",
+        "binary": "{BinaryType}",
+        "json": "{JsonType}",
+    }
+
+    def generate(
+        self,
+        change_spec: ChangeSpec,
+        symbol: Dict[str, Any],
+        file_content: str,
+    ) -> List[Patch]:
+        """Generate patches for a {Language} file."""
+        patches = []
+
+        if change_spec.change_type == ChangeType.ADD_FIELD:
+            patches.extend(self._add_field(change_spec, symbol, file_content))
+        elif change_spec.change_type == ChangeType.REMOVE_FIELD:
+            patches.extend(self._remove_field(change_spec, symbol, file_content))
+        elif change_spec.change_type == ChangeType.RENAME_FIELD:
+            patches.extend(self._rename_field(change_spec, symbol, file_content))
+
+        return patches
+
+    def _add_field(self, change_spec, symbol, file_content) -> List[Patch]:
+        # Implement field addition logic
+        pass
+
+    def _remove_field(self, change_spec, symbol, file_content) -> List[Patch]:
+        # Implement field removal logic
+        pass
+
+    def _rename_field(self, change_spec, symbol, file_content) -> List[Patch]:
+        # Implement field rename logic
+        pass
+
+    def _map_type(self, generic_type: str, language: str = None) -> str:
+        """Map generic type to {Language} type."""
+        return self.TYPE_MAP.get(generic_type.lower(), generic_type)
+```
+
+### Step 3: Update __init__.py
+
+Add import to `${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch/generators/__init__.py`:
+
+```python
+from . import {language}_generator
+```
+
+### Step 4: Create Golden Test Fixture
+
+Create `${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch/tests/fixtures/{language}_add_field.json`:
+
+```json
+{
+  "name": "{language}_add_field",
+  "description": "Add a new field to a {Framework} model",
+  "generator": "{language}",
+  "input": {
+    "change_type": "add_field",
+    "field_spec": {
+      "name": "email",
+      "type": "String",
+      "nullable": false
+    },
+    "sample_content": "[Minimal valid {Language} class/entity code]",
+    "symbol": {
+      "id": "path/to/file.{ext}::ClassName",
+      "name": "ClassName",
+      "type": "class",
+      "file_path": "path/to/file.{ext}",
+      "line_start": 1,
+      "line_end": 10
+    }
+  },
+  "expected": {
+    "patch_count_min": 1,
+    "must_contain": [
+      "email",
+      "[expected type]",
+      "[expected annotation/decorator]"
+    ],
+    "must_not_contain": [
+      "undefined"
+    ]
+  }
+}
+```
+
+### Step 5: Update Test File
+
+Add to `${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch/tests/test_conformance.py`:
+
+1. Add contract test in `TestGeneratorContract`:
+```python
+def test_{language}_generator_contract(self):
+    """{Language} generator passes all contract tests."""
+    from generators.{language}_generator import {Language}Generator
+
+    sample = """[minimal valid code]"""
+    report = run_conformance_tests({Language}Generator, sample)
+    assert report.passed, report.summary()
+```
+
+2. Add golden test in `TestGoldenOutput`:
+```python
+def test_{language}_add_field(self):
+    """{Language} add_field golden test."""
+    self._run_golden_test("{language}_add_field")
+```
+
+3. Add to `ext_map` in `_run_golden_test`:
+```python
+"{language}": ".{ext}",
+```
+
+4. Add to `samples` in `run_all_tests`:
+```python
+".{ext}": "[minimal sample code]",
+```
+
+5. Add import in `run_all_tests`:
+```python
+from generators import {language}_generator
+```
+
+### Step 6: Run Tests
+
+Execute:
+```bash
+cd "${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch"
+python3 tests/test_conformance.py
+```
+
+Verify:
+- Contract tests pass for the new generator
+- Golden test passes
+- No regressions in other generators
+
+### Step 7: Report Results
+
+Output a summary:
+```
+## New Generator: {Language}
+
+- **File**: `generators/{language}_generator.py`
+- **Extensions**: {extensions}
+- **Framework**: {Framework}
+- **Tests**: PASS/FAIL
+
+### Type Mappings
+| Generic | {Language} |
+|---------|-----------|
+| String  | {type}    |
+| Integer | {type}    |
+| ...     | ...       |
+
+### Example Output
+[Show example of generated code for add_field]
+```
+
+## Examples
+
+```
+/wicked-garden:engineering:new-generator scala Slick
+/wicked-garden:engineering:new-generator swift CoreData .swift
+/wicked-garden:engineering:new-generator elixir Ecto .ex,.exs
+```

package/commands/engineering/patch-plan.md

@@ -0,0 +1,59 @@
+---
+description: Show what would be affected by a change without generating patches
+phase_relevance: ["design", "build"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:engineering:plan
+
+Show what would be affected by a change without generating patches.
+
+## Arguments
+
+- `symbol_id` (required): Symbol ID to analyze
+- `--change`: Change type (`add_field`, `rename_field`, `remove_field`, `modify_field`)
+- `--depth`: Max traversal depth (default: 5)
+- `--json`: Output as JSON
+
+## Instructions
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch/patch.py" plan "<symbol_id>" --change "<change_type>" [--json]
+```
+
+## Examples
+
+```bash
+# Plan for adding a field
+/wicked-garden:engineering:plan "User.java::User" --change add_field
+
+# Plan for rename with JSON output
+/wicked-garden:engineering:plan "Order.java::Order" --change rename_field --json
+```
+
+## Output
+
+```
+═══════════════════════════════════════════════════════════
+PROPAGATION PLAN
+═══════════════════════════════════════════════════════════
+
+Source: User
+  Type: entity
+  File: /path/to/User.java
+  Line: 22
+
+Direct Impacts (3):
+  • email (entity_field) @ User.java
+  • name (entity_field) @ User.java
+  • id (entity_field) @ User.java
+
+Downstream Impacts (5):
+  • USER_EMAIL (column) @ migration.sql
+  • user-form.jsp (ui_binding) @ user-form.jsp
+  ...
+
+───────────────────────────────────────────────────────────
+Total: 9 symbols in 4 files
+═══════════════════════════════════════════════════════════
+```

package/commands/engineering/plan.md

@@ -0,0 +1,29 @@
+---
+description: |
+  Use when you have a change request or issue and need a detailed implementation plan with specific file
+  changes, risk assessment, and test recommendations — before writing any code.
+  NOT for free-form planning (use native Task planning) or architecture decisions (use engineering:arch).
+argument-hint: "<change request or issue description>"
+phase_relevance: ["design", "build"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:engineering:plan
+
+Analyze a change request against the current codebase and produce a detailed implementation plan
+with specific file changes, risk assessment, and test recommendations.
+
+## Run it inline (no dispatch)
+
+1. Parse the change request: identify goal, scope, and constraints. Ask a clarifying question if
+   the request is too vague to scope (e.g. no target file or system identified).
+2. `Read("${CLAUDE_PLUGIN_ROOT}/skills/engineering/refs/plan.md")` — exploration checklist,
+   risk assessment checklist, plan output format, and security/performance heuristics.
+3. Explore the affected code: entry points, key files, callers, existing patterns, test coverage.
+   Use `wicked-garden:search:blast-radius {symbol}` for impact analysis.
+4. Apply the risk assessment checklist (breaking changes, performance, security, data integrity,
+   test gaps, deployment coordination).
+5. Emit the Implementation Plan output format: Summary, Scope (in/out), Changes Required per
+   file, Risk Assessment table, Test Plan, Rollout Considerations, Open Questions.
+6. Present the plan and ask: "Ready to proceed with implementation, or would you like to adjust
+   the approach?" Do not write any code until approved.

package/commands/engineering/remove.md

@@ -0,0 +1,48 @@
+---
+description: Remove a field and all its usages from the codebase
+phase_relevance: ["design", "build"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:engineering:remove
+
+Remove a field and all its usages from the codebase.
+
+## Arguments
+
+- `symbol_id` (required): Target symbol ID
+- `--field` (required): Field name to remove
+- `--output`, `-o`: Save patches to file
+- `--apply`: Apply patches immediately
+- `--verbose`, `-v`: Show full diffs
+
+## Instructions
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch/patch.py" remove "<symbol_id>" --field "<field_name>" [--verbose]
+```
+
+## Examples
+
+```bash
+# Remove deprecated field
+/wicked-garden:engineering:remove "User.java::User" --field legacyStatus
+
+# Preview removal
+/wicked-garden:engineering:remove "Entity.java::Entity" --field oldField --verbose
+```
+
+## Warning
+
+This operation DELETES code. Always review patches before applying:
+
+```bash
+# Generate and save patches
+/wicked-garden:engineering:remove SYMBOL --field foo -o patches.json
+
+# Review
+cat patches.json
+
+# Apply when confident
+/wicked-garden:engineering:apply patches.json
+```

package/commands/engineering/rename.md

@@ -0,0 +1,44 @@
+---
+description: Rename a field/symbol across all usages in the codebase
+phase_relevance: ["design", "build"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:engineering:rename
+
+Rename a field/symbol across all usages in the codebase.
+
+## Arguments
+
+- `symbol_id` (required): Target symbol ID
+- `--old` (required): Current field name
+- `--new` (required): New field name
+- `--output`, `-o`: Save patches to file
+- `--apply`: Apply patches immediately
+- `--verbose`, `-v`: Show full diffs
+
+## Instructions
+
+```bash
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/_python.sh" "${CLAUDE_PLUGIN_ROOT}/scripts/engineering/patch/patch.py" rename "<symbol_id>" --old "<old_name>" --new "<new_name>" [--verbose]
+```
+
+## Examples
+
+```bash
+# Rename field in entity
+/wicked-garden:engineering:rename "User.java::User" --old status --new userStatus
+
+# Save patches for review
+/wicked-garden:engineering:rename "Order.java::Order" --old date --new orderDate -o patches.json
+```
+
+## What Gets Updated
+
+- Field declarations
+- Getter/setter method names
+- Property references (`this.oldName` → `this.newName`)
+- JSP EL expressions (`${entity.oldName}` → `${entity.newName}`)
+- Form bindings (`path="oldName"` → `path="newName"`)
+- TypeScript interfaces and type aliases
+- SQL column names (generates ALTER TABLE RENAME COLUMN)

package/commands/engineering/review.md

@@ -0,0 +1,32 @@
+---
+description: Code review with senior engineering perspective on quality, patterns, and maintainability
+argument-hint: "[file or directory path] [--focus security|performance|patterns|tests] [--scenarios] [--persona <name>]"
+phase_relevance: ["build", "review"]
+archetype_relevance: ["code-repo", "schema-migration", "config-infra"]
+---
+
+# /wicked-garden:engineering:review
+
+Senior-engineer code review on quality, patterns, maintainability. Use `--focus security|performance|
+patterns|tests` to deepen one area. Use `--persona <name>` to apply a registered persona's lens.
+Use `--scenarios` to emit wicked-scenarios regression blocks per Critical/High finding.
+Use `engineering:arch` for component/system-level architecture review.
+This reviews **source code**; for an AI agent system use `agentic:review`, for a UI use
+`product:ux-review`, and for a binding go/no-go verdict use `archetype:review`
+(see `docs/domains.md` → "review appears in three domains").
+
+## Run it inline (no dispatch)
+
+1. Parse scope (path or git-diff target), `--focus`, `--persona`, and `--scenarios`.
+2. `Read("${CLAUDE_PLUGIN_ROOT}/skills/engineering/refs/review.md")` — R1–R6 Bulletproof Coding
+   Standards, T1–T6 Bulletproof Testing Standards, agent overstepping checklist, focus lane
+   definitions, persona routing instructions, wicked-scenarios format, and output template.
+3. **Persona branch** (only if `--persona <name>` present): resolve the persona via
+   `scripts/persona/registry.py --get {name} --json`. If found, apply the review through that
+   persona's frame. If not found, warn and fall through.
+4. Read the target file(s) / diff. Apply R1–R6 to all code; add T1–T6 when `--focus tests` or
+   reviewing test files. If `--focus` given, deepen that lane. Flag agent overstepping (scope creep,
+   commented-out code, over-engineering) with `file:line` citations.
+5. Emit the standard Engineering Review output (Strengths, Issues table with rule + location,
+   Architecture Notes, Maintainability Concerns, Agent Overstepping, Recommendations).
+   If `--scenarios`, append wicked-scenarios blocks for each Critical/High finding.

package/commands/help.md

@@ -0,0 +1,128 @@
+---
+description: Show all available wicked-garden domains and commands
+phase_relevance: ["*"]
+archetype_relevance: ["*"]
+---
+
+# /wicked-garden:help
+
+Display usage information and examples.
+
+## Instructions
+
+Show the following help information:
+
+```markdown
+# Wicked Garden Help
+
+The Wicked Garden Marketplace — gap-filling capabilities for modern coding-agent
+harnesses. It reads each prompt as one or more **work-shape archetypes** (v11) and
+applies the right rigor/gate, re-derives "done" from evidence, surfaces relationships
+grep can't see, and otherwise stays out of the harness's way.
+
+## Headline Commands
+
+| Command | What it does |
+|---------|--------------|
+| `/wicked-garden:prove` | Re-derive "done" from recorded evidence (the produces-gate). |
+| `/wicked-garden:compile` | Emit a self-contained, vault-backed gate into any repo. |
+| `/wicked-garden:intent` | Set or inspect the active work intent for the session. |
+| `/wicked-garden:deliberate` | Critically analyze a request before doing the work — challenge assumptions, find root causes, propose better approaches. |
+| `/wicked-garden:where-am-i` | Orient: show current phase, archetype, and project state. |
+| `/wicked-garden:install` | First-run installer for the wicked-* peer tools (vault + loom floor, then optional layers). |
+| `/wicked-garden:setup` | First-run setup and dependency/peer checks. |
+| `/wicked-garden:reset` | Reset session/project state. |
+| `/wicked-garden:report-issue` | File a structured issue against wicked-garden. |
+
+## Archetypes (v11 work-shape model)
+
+`/wicked-garden:archetype:{name}` runs a work-shape playbook. Each prompt classifies
+into one or more of these; run them in dependency order.
+
+| Archetype | Shape |
+|-----------|-------|
+| `archetype:triage` | classify → routing decision |
+| `archetype:explore` | frame → diverge → converge |
+| `archetype:specify` | elicit → structure → validate (SMART acceptance criteria) |
+| `archetype:decide` | brief → options → score → record (ADR) |
+| `archetype:ship` | canary → ramp → full → soak (rollout verdict) |
+| `archetype:review` | scope → assess → findings → remediate-or-accept (hard verdict) |
+| `archetype:incident` | triage → investigate → mitigate → resolve → followup |
+| `archetype:build` | plan → implement → test → review |
+| `archetype:migrate` | plan → expand → backfill → cutover → contract |
+
+## Domains
+
+| Domain | Description | Key Commands |
+|--------|-------------|--------------|
+| **agentic** | Design, review, and audit agentic AI systems | `agentic:design`, `agentic:review`, `agentic:audit`, `agentic:frameworks` |
+| **archetype** | The 9 v11 work-shape playbooks (see table above) | `archetype:build`, `archetype:review`, `archetype:ship` |
+| **data** | Data analysis, pipelines, ML, and ontology recommendations | `data:analyze`, `data:pipeline`, `data:ml`, `data:ontology` |
+| **engineering** | Architecture, code review, debugging, docs, planning, and deterministic multi-file code transformations | `engineering:review`, `engineering:debug`, `engineering:arch`, `engineering:plan`, `engineering:apply` |
+| **jam** | Multi-model brainstorming + structured council (independent second opinion) | `jam:council`, `jam:brainstorm`, `jam:quick`, `jam:revisit` |
+| **persona** | Define and invoke named personas to perform work with a specific lens | `persona:as`, `persona:define`, `persona:list` |
+| **platform** | Security, infrastructure, compliance, CI/CD, incidents, traces, and plugin diagnostics | `platform:security`, `platform:compliance`, `platform:incident`, `platform:health` |
+| **product** | Requirements, customer feedback, strategy, UX, accessibility, and design review | `product:elicit`, `product:acceptance`, `product:analyze`, `product:strategy`, `product:ux-review` |
+| **search** | Structural code search, lineage, blast-radius, and codebase intelligence | `search:blast-radius`, `search:lineage`, `search:hotspots`, `search:service-map`, `search:index` |
+| **smaht** | On-demand context assembly + session briefing from brain, search, and the event log | `smaht:briefing`, `smaht:state`, `smaht:events-import` |
+
+> **Memory & search are provided by sibling plugins**, not a wicked-garden domain:
+> use `wicked-brain:memory` / `wicked-brain:query` for cross-session memory, and
+> `wicked-brain:search` / `wicked-brain:graph` for code search and relationship graphs.
+
+## Quick Start
+
+### Read a prompt's work shape
+```
+/wicked-garden:where-am-i
+```
+
+### Build a feature (build archetype)
+```
+/wicked-garden:archetype:build "add a user authentication system"
+```
+
+### Re-derive "done" from evidence
+```
+/wicked-garden:prove
+```
+
+### Review code
+```
+/wicked-garden:engineering:review ./src
+```
+
+### Get an independent multi-model second opinion
+```
+/wicked-garden:jam:council "should we adopt event sourcing here?"
+```
+
+### Search code relationships
+```
+wicked-brain:search "handlePayment"
+/wicked-garden:search:blast-radius src/payments.py
+```
+
+### Store a decision
+Use `wicked-brain:memory` (store mode) to persist a decision directly.
+
+## How It Works
+
+1. Every prompt is classified into one or more **archetypes** by the
+   `UserPromptSubmit` hook; each archetype owns its own phase shape, HITL
+   discipline, and cost band (steering, not a fixed pipeline).
+2. **smaht** assembles context on demand (pull-model) from brain, search, and
+   the unified event log — there is no per-prompt push.
+3. **Specialist domains** (engineering, platform, product, data, agentic, jam,
+   search) provide deep expertise the harness routes into.
+4. **`prove`** re-derives an archetype's "done" through the evidence gate rather
+   than trusting a "tests pass" claim.
+5. **State** persists across sessions via wicked-brain memory, search indexes,
+   the event log, and native tasks.
+
+## Getting Domain Help
+
+Run `/wicked-garden:{domain}:{command}` for any command. Run a bare
+`/wicked-garden:archetype:{name}` to invoke a work-shape playbook. Use
+`/wicked-garden:help` to return to this overview.
+```