@nebulit/embuilder 0.1.39

package/templates/.claude/skills/test-analyzer/examples/specification-format.md

@@ -0,0 +1,143 @@
+# Specification Format Template
+
+## Output File Structure
+
+The `code-slice.json` file contains:
+
+```json
+{
+  "id": "<slice-id-from-slice.json>",
+  "title": "<slice-title-from-slice.json>",
+  "specifications": [...]
+}
+```
+
+**CRITICAL:**
+- MUST include `id` and `title` fields copied from the corresponding `slice.json` file
+- NO commands, events, readmodels, or other slice metadata (only id, title, and specifications)
+- Each specification must have complete nested objects with fields, NOT simple strings
+- Given/when/then must be arrays of objects with full field definitions
+
+## Specification Object Template
+
+```json
+{
+  "vertical": false,
+  "id": "<generated-id>",
+  "sliceName": "slice: <SliceName>",
+  "title": "spec: <test description>",
+  "given": [
+    {
+      "title": "<Event Title>",
+      "tags": [],
+      "id": "<generated-id>",
+      "index": 0,
+      "specRow": -1,
+      "type": "SPEC_EVENT",
+      "fields": [
+        {
+          "name": "fieldName",
+          "type": "String|Date|UUID|Integer|Boolean|Decimal",
+          "subfields": [],
+          "cardinality": "Single",
+          "example": ""
+        }
+      ],
+      "linkedId": "<linked-event-id-from-elements>"
+    }
+  ],
+  "when": [
+    {
+      "title": "<Command Title>",
+      "tags": [],
+      "id": "<generated-id>",
+      "index": 0,
+      "specRow": -1,
+      "type": "SPEC_COMMAND",
+      "fields": [
+        {
+          "name": "fieldName",
+          "type": "String|Date|UUID|Integer|Boolean|Decimal",
+          "subfields": [],
+          "cardinality": "Single",
+          "example": ""
+        }
+      ],
+      "linkedId": "<linked-command-id-from-elements>"
+    }
+  ],
+  "then": [
+    {
+      "title": "<Event or Error Title>",
+      "tags": [],
+      "id": "<generated-id>",
+      "index": 0,
+      "specRow": -1,
+      "type": "SPEC_EVENT|SPEC_ERROR|SPEC_READMODEL",
+      "fields": [
+        {
+          "name": "fieldName",
+          "type": "String|Date|UUID|Integer|Boolean|Decimal",
+          "subfields": [],
+          "cardinality": "Single",
+          "example": ""
+        }
+      ],
+      "linkedId": "<linked-event-id-from-elements>"
+    }
+  ],
+  "comments": [],
+  "linkedId": "<same-as-specification-id-above>"
+}
+```
+
+## Given/When/Then Structure
+
+### For STATE_CHANGE Slices
+
+- **given**: Array of event objects (preconditions - events that happened before)
+- **when**: Array with single command object (the action being tested)
+- **then**: Array of event/error objects (what happened as a result)
+
+### For STATE_VIEW Slices
+
+- **given**: Array of event objects (events to be projected)
+- **when**: Empty array `[]` (no command in projections)
+- **then**: Array with readmodel assertion objects (SPEC_READMODEL type)
+
+## Field Object Structure
+
+Each field in the `fields` array must have:
+
+```json
+{
+  "name": "fieldName",
+  "type": "String|Date|UUID|Integer|Boolean|Decimal|Integer|List",
+  "subfields": [],
+  "cardinality": "Single|Multiple",
+  "example": "actual value from test"
+}
+```
+
+### Field Type Mapping
+
+Infer types from test data:
+- String values → `"String"`
+- UUID format → `"UUID"`
+- Date strings (ISO format) → `"Date"` or `"DateTime"`
+- Numbers with decimals → `"Decimal"`
+- Whole numbers → `"Integer"`
+- Boolean values → `"Boolean"`
+- Arrays → `"List"` with element type
+
+### Cardinality
+
+- `"Single"` - for single values
+- `"Multiple"` - for arrays
+
+## Element Types
+
+- `SPEC_COMMAND` - Command in `when` array (STATE_CHANGE only)
+- `SPEC_EVENT` - Event in `given` or `then` arrays
+- `SPEC_ERROR` - Error in `then` array (when test uses `thenThrows()`)
+- `SPEC_READMODEL` - Readmodel assertion in `then` array (STATE_VIEW only)

package/templates/.claude/skills/test-analyzer/examples/state-change-example.md

@@ -0,0 +1,111 @@
+# STATE_CHANGE Slice Example
+
+## Input Test File
+
+**File:** `src/slices/ActivateShift/ActivateShift.test.ts`
+
+```typescript
+describe('Activate Shift Specification', () => {
+    it('spec: Activate Shift - scenario', () => {
+        given([{
+            type: 'ShiftCreated',
+            data: { shiftId: '123', restaurantId: 'r1', startDate: '2026-01-15' }
+        }])
+            .when({ type: 'ActivateShift', data: { shiftId: '123', restaurantId: 'r1' }})
+            .then([{
+                type: 'ShiftActivated',
+                data: { shiftId: '123', restaurantId: 'r1' }
+            }])
+    });
+
+    it('spec: Activate Shift - shift not found', () => {
+        given([])
+            .when({ type: 'ActivateShift', data: { shiftId: '999', restaurantId: 'r1' }})
+            .thenThrows()
+    });
+});
+```
+
+## Processing Steps
+
+1. Slice name detected: "ActivateShift" (from file path)
+2. Looks up in `.slices/index.json` → finds entry with `"slice": "slice: Activate Shift"`
+3. Gets folder: "activateshift" and context: "Restaurant Management"
+4. Reads: `.slices/Restaurant Management/activateshift/slice.json`
+5. Checks specifications array in slice.json for existing test specs
+6. First test found in slice.json specifications array → not included in code-slice.json
+7. Second test (error case) NOT in slice.json specifications array → included in code-slice.json
+8. **CRITICAL: Looks up real IDs from slice.json:**
+   - Command "Activate Shift" → finds `"id": "3458764657124632223"` in slice.json commands array
+   - Uses this real ID as `linkedId` for the command in the specification
+
+## Output
+
+**File:** `src/slices/ActivateShift/code-slice.json`
+
+```json
+{
+  "id": "3458764657124632353",
+  "title": "slice: Activate Shift",
+  "specifications": [
+    {
+      "vertical": false,
+      "id": "3458764660410459999",
+      "sliceName": "slice: Activate Shift",
+      "title": "spec: Activate Shift - shift not found",
+      "given": [],
+      "when": [
+        {
+          "title": "Activate Shift",
+          "tags": [],
+          "id": "3458764660410459998",
+          "index": 0,
+          "specRow": -1,
+          "type": "SPEC_COMMAND",
+          "fields": [
+            {
+              "name": "shiftId",
+              "type": "String",
+              "subfields": [],
+              "cardinality": "Single",
+              "example": "999"
+            },
+            {
+              "name": "restaurantId",
+              "type": "String",
+              "subfields": [],
+              "cardinality": "Single",
+              "example": "r1"
+            }
+          ],
+          "linkedId": "3458764657124632223"
+        }
+      ],
+      "then": [
+        {
+          "title": "Shift not found error",
+          "tags": [],
+          "id": "3458764660410459997",
+          "index": 0,
+          "specRow": -1,
+          "type": "SPEC_ERROR",
+          "fields": []
+        }
+      ],
+      "comments": [],
+      "linkedId": "3458764660410459999"
+    }
+  ]
+}
+```
+
+## Key Points
+
+- **Top-level fields**: `id` and `title` are copied from `.slices/Restaurant Management/activateshift/slice.json`
+- **Given**: Empty array (no preconditions for error case)
+- **When**: Single command object with full field definitions
+  - **CRITICAL**: `linkedId` is `"3458764657124632223"` - the REAL ID from slice.json commands array for "Activate Shift" command
+- **Then**: Error object (SPEC_ERROR type) with empty fields
+  - Errors have no `linkedId` field (they don't represent elements in slice.json)
+- Only the error case is included because the happy path specification already exists in slice.json specifications array
+- If slice.json specifications array is empty, ALL test specifications would be included in code-slice.json

package/templates/.claude/skills/test-analyzer/examples/state-view-example.md

@@ -0,0 +1,122 @@
+# STATE_VIEW Slice Example
+
+## Input Test File
+
+**File:** `src/slices/ActivatedOnlineReservations/OnlineReservationStatus.test.ts`
+
+```typescript
+describe('OnlineReservationStatus Specification', () => {
+    it('spec: Online reservation activated - sets active to true', async () => {
+        await given([{type: 'OnlineReservationActivated', data: {restaurantId: 'r1'}}])
+            .when([])  // empty for projections
+            .then(assertReadModel);
+    });
+
+    it('spec: Toggle online reservation - activates then deactivates', async () => {
+        await given([
+                {type: 'OnlineReservationActivated', data: {restaurantId: 'r1'}},
+                {type: 'OnlineReservationDeactivated', data: {restaurantId: 'r1'}}
+            ])
+            .when([])  // empty for projections
+            .then(assertReadModel);
+    });
+});
+```
+
+## Processing Steps
+
+1. Slice name detected: "OnlineReservationStatus" (from file path or describe block)
+2. Looks up in `.slices/index.json` → searches for matching slice title
+3. Gets folder and context from index
+4. Reads corresponding `.slices/<context>/<folder>/slice.json`
+5. Compares test events with slice.json
+6. If "toggle" scenario not in slice.json → include in specifications
+7. **CRITICAL: Looks up real event IDs:**
+   - Events may be defined in other slices, but referenced in readmodel dependencies
+   - Search for event IDs in the readmodel's `dependencies` array with `type: "INBOUND"`
+   - "Online Reservation Activated" → ID `"3458764659470382480"` (from dependencies)
+   - "Online Reservation Deactivated" → ID `"3458764659470541221"` (from dependencies)
+
+## Output
+
+**File:** `src/slices/ActivatedOnlineReservations/code-slice.json`
+
+```json
+{
+  "id": "3458764659470991969",
+  "title": "slice: Activated Online reservations",
+  "specifications": [
+    {
+      "vertical": false,
+      "id": "3458764660410460001",
+      "sliceName": "slice: Online Reservation Status",
+      "title": "spec: Toggle online reservation - activates then deactivates",
+      "given": [
+        {
+          "title": "Online Reservation Activated",
+          "tags": [],
+          "id": "3458764660410460002",
+          "index": 0,
+          "specRow": -1,
+          "type": "SPEC_EVENT",
+          "fields": [
+            {
+              "name": "restaurantId",
+              "type": "String",
+              "subfields": [],
+              "cardinality": "Single",
+              "example": "r1"
+            }
+          ],
+          "linkedId": "3458764659470382480"
+        },
+        {
+          "title": "Online Reservation Deactivated",
+          "tags": [],
+          "id": "3458764660410460003",
+          "index": 1,
+          "specRow": -1,
+          "type": "SPEC_EVENT",
+          "fields": [
+            {
+              "name": "restaurantId",
+              "type": "String",
+              "subfields": [],
+              "cardinality": "Single",
+              "example": "r1"
+            }
+          ],
+          "linkedId": "3458764659470541221"
+        }
+      ],
+      "when": [],
+      "then": [
+        {
+          "title": "active = false in read model",
+          "tags": [],
+          "id": "3458764660410460004",
+          "index": 0,
+          "specRow": -1,
+          "type": "SPEC_READMODEL",
+          "fields": []
+        }
+      ],
+      "comments": [],
+      "linkedId": "3458764660410460001"
+    }
+  ]
+}
+```
+
+## Key Points
+
+- **Top-level fields**: `id` and `title` are copied from the corresponding `slice.json` in `.slices/Restaurant Management/activatedonlinereservations/slice.json`
+- **Specification linkedId**: `"3458764660410460001"` matches the specification's `id` field (self-reference)
+- **Given**: Array of events to be projected (this is where events go for STATE_VIEW)
+  - **CRITICAL**: Each event's `linkedId` uses the REAL event ID from slice.json
+  - "Online Reservation Activated" → `linkedId: "3458764659470382480"`
+  - "Online Reservation Deactivated" → `linkedId: "3458764659470541221"`
+  - For STATE_VIEW slices, look for event IDs in the readmodel's `dependencies` array
+- **When**: Empty array (no command in projections)
+- **Then**: Readmodel assertion (SPEC_READMODEL type)
+- Only the "toggle" scenario is included because it represents additional behavior beyond basic projection

package/templates/AGENTS.md

@@ -0,0 +1,110 @@
+# Agent Learnings
+
+This file captures patterns, gotchas, and best practices discovered during development.
+Update this file as you learn new patterns that future iterations should know.
+
+## Core Principles
+
+### Event Model as Source of Truth
+- Event model JSON files define the desired state
+- Code must match the event model specification
+- When in doubt, check the event model
+
+### File Organization
+- Each slice lives in `src/slices/{SliceName}/`
+- Keep slices self-contained and focused
+- Follow consistent naming conventions
+
+## Event-Driven Architecture Patterns
+
+### State-Change Slices (Commands)
+- Use `decide()` for business logic validation
+- Use `evolve()` for state reconstruction from events
+- State should only track what's needed for validation
+- Simple commands can have empty state `{}`
+
+### State-View Slices (Queries)
+- Projections build read models from events
+- Read models are optimized for querying
+- One read model per use case/view
+
+### Automation Slices
+- Automations = State-Change + CRON processor
+- Read from TODO list (work queue) read models
+- Process one item at a time with `.limit(1)`
+- Always wrap command execution in try-catch
+
+## Common Patterns
+
+### Stream IDs
+- Use consistent stream ID patterns per aggregate
+- Format: `{aggregate}-{id}` or `{context}-{aggregate}-{id}`
+- Document stream ID patterns in each slice
+
+### Metadata
+- Always include `correlation_id` and `causation_id`
+- Use optional chaining: `metadata?.field`
+- Include tenant/user IDs for multi-tenancy
+
+### Testing
+- Use `DeciderSpecification.for()` for state-change tests
+- Use `PostgreSQLProjectionSpec.for()` for state-view tests
+- Test format: given/when/then
+- Include both happy path and error scenarios
+
+## Database Patterns
+
+### Migrations
+- Never modify existing migrations
+- Always create new migrations for changes
+- Use sequential version numbers (V1, V2, V3...)
+- Check latest migration before creating new one
+
+### Tables
+- Use snake_case for table and column names
+- Include proper indexes for query performance
+- Add tenant ID columns for multi-tenancy
+
+## TypeScript Best Practices
+
+### Types
+- Use strict TypeScript mode
+- Define explicit types for commands, events, and state
+- Avoid `any` - use `unknown` if needed
+
+### Imports
+- Use ES modules (import/export)
+- Organize imports: external, internal, types
+- Keep imports minimal and specific
+
+## Error Handling
+
+### Validation Errors
+- Throw descriptive error messages
+- Use error codes for common failures
+- Map errors to user-friendly messages in routes
+
+### HTTP Status Codes
+- 200: Success
+- 400: Bad request (validation error)
+- 401: Unauthorized
+- 409: Conflict (business rule violation)
+- 500: Server error
+
+## Code Quality
+
+### Before Committing
+- Run `npm run build` - ensure TypeScript compiles
+- Run `npm run test` - ensure all tests pass
+- Update this file with new learnings
+- Update progress.txt with iteration summary
+
+### Clean Code
+- Follow existing patterns in codebase
+- Keep functions focused and small
+- Use descriptive names for variables and functions
+- Comment complex business logic
+
+## Future Development Notes
+
+Add your learnings here as you discover patterns specific to your domain and architecture.

package/templates/Claude.md

@@ -0,0 +1,58 @@
+# Project Configuration
+
+Read Events in src/events to understand the global structure.
+
+## Framework & Styling
+
+- **CSS Framework**: Use Bulma CSS exclusively for all styling
+- **Assumption**: Bulma CSS is already available and imported in the project
+- **Styling Guidelines**:
+    - Use Bulma's utility classes and components
+    - Follow Bulma's naming conventions and class structure
+    - Leverage Bulma's responsive design features
+    - Prefer Bulma components over custom CSS
+
+## File Structure Constraints
+
+- **Strict Path Limitation**: if not instructed otherwise, only check `src/slices/{slicename}/*.ts`
+- **Slice Organization**: Each feature/domain should be organized as a separate slice
+
+## Code Standards
+
+- **Language**: TypeScript only
+- **Module System**: Use ES modules (import/export)
+- **Type Safety**: Ensure all code is properly typed
+
+## Development Guidelines
+
+1. Each slice should be self-contained and focused on a specific domain
+2. Use Bulma's grid system, components, and utilities for all UI-related code
+3. Maintain clear separation of concerns within each slice
+4. Follow TypeScript best practices for type definitions and interfaces
+
+Only check src/slices/{slice}/*.ts, do not check subfolders, if not explicitely tasked to build the UI.
+If not tasked explicitely to change routes, ignore routes*.ts
+
+Ignore case for files and slices in prompts. "CartItems" slice is the same as "cartitemsrun t"
+
+Do not change files with tests unless explicitely instructed: *.test.ts
+
+After you are done, automatically run the tests for the slice that was edited.
+
+## Example Slice Structure
+
+```
+src/slices/
+├── {slice-name}/
+│   ├── CommandHandler.ts
+│   ├── ui/
+│   └── routes.ts
+```
+
+## Bulma Integration Notes
+
+- Utilize Bulma's component library: navbar, cards, buttons, forms, modals, etc.
+- Apply Bulma's spacing utilities: `m-*`, `p-*`, `has-text-*`, `has-background-*`
+- Use Bulma's flexbox utilities for layouts
+- Implement responsive design with Bulma's breakpoint classes
+- Leverage Bulma's color palette and typography classes