@specverse/engines 5.1.0 → 6.0.0

package/assets/prompts/core/standard/default/analyse.prompt.yaml

@@ -16,7 +16,7 @@ system:
     Include ALL models, controllers, services, views, events found in the implementation.
     Extract ALL deployment policies, operational configurations, and infrastructure patterns from the code.
     This is NOT for inference - capture the implementation AS IT EXISTS.
-    The specification must be valid according to SpecVerse schema v3.5.0 and should contain:
+    The specification must be valid according to SpecVerse schema v5.0.0 and should contain:
     - a components section with the logical models, controllers, services, views, events
     - a deployments section showing the logical instances with operational policies
     - a manifest section with the physical details about the deployment
@@ -32,9 +32,9 @@ system:
     2. Capture ALL lifecycles, attributes, methods, behaviours and relationships as they exist
     3. Use convention syntax for all attributes
     4. Business and validation logic must be captured as steps meeting the requires and ensures clauses
-    5. Actions that are implementing CURED operations must be captured as controller cured operations
+    5. Actions that are implementing CURVED operations must be captured as controller cured operations (Create, Update, Retrieve, Validate, Evolve, Delete)
     6. AVOID LOGIC DUPLICATION: Place validation/business logic in model behaviors, not in controllers or services
-    7. Controllers should focus on CURED operations, models on business behaviors, services on orchestration
+    7. Controllers should focus on CURVED operations, models on business behaviors, services on orchestration
     8. Do NOT include implementation details like HTTP paths or routes in controllers
 
     DEPLOYMENT PRINCIPLES:
@@ -375,7 +375,7 @@ user:
     WORKFLOW (iterate until validation passes):
 
     Step 1: ANALYZE & GENERATE
-    - Read schema files for current v3.5.0 syntax:
+    - Read schema files for current v5.0.0 syntax:
       * {{aiSchemaPath}} (AI guidance, examples, patterns)
       * {{referenceExamplePath}} (complete working example)
     - Analyze implementation at {{implementationPath}}
@@ -452,7 +452,7 @@ validation:
       required: false
 
   output:
-    - rule: Must generate valid SpecVerse v3.5.0 specification
+    - rule: Must generate valid SpecVerse v5.0.0 specification
       format: yaml
       schema: schema/SPECVERSE-SCHEMA.json
     - rule: Must include at least one model

package/assets/prompts/core/standard/default/app-demo.prompt.yaml

@@ -200,10 +200,30 @@ system:
 
 user:
   template: |
-    Generate or modify the specification based on the user's request.
+    Generate or modify the specification based on this request:
+
+    {{userRequest}}
+
+    {{#if existingSpec}}
+    Existing spec to modify (replace, don't add alongside):
+    ```specly
+    {{existingSpec}}
+    ```
+    {{/if}}
+
     Output the specification in a ```specly code block.
     Include whichever sections the user needs. If not specified, include all relevant sections.
 
+  variables:
+    - name: userRequest
+      type: string
+      required: true
+      description: The user's natural-language request describing what to create or modify in the spec
+    - name: existingSpec
+      type: string
+      required: false
+      description: An existing .specly file to modify. Leave empty to create a new spec from scratch.
+
 metadata:
   created: "2026-03-31"
   use_case: "Interactive runtime interpreter — specs execute immediately in browser"

package/assets/prompts/core/standard/default/behavior.prompt.yaml

@@ -0,0 +1,157 @@
+name: behavior
+version: "9.2.0"
+description: Generate pure TypeScript function bodies for SpecVerse behavior steps that don't match convention patterns
+author: SpecVerse Team
+tags: [behavior, code-generation, pure-function, typescript, realize]
+
+system:
+  role: |
+    You are a SpecVerse behavior code generator. You produce PURE TypeScript
+    function bodies for behavior steps that couldn't be matched by the realize
+    engine's convention patterns.
+
+  minimalContext: |
+    PURE FUNCTION RULES (critical — violating these breaks the architecture):
+    1. NO database access (no prisma, no queries)
+    2. NO event publishing (no eventBus)
+    3. NO external services (no fetch, no email providers, no payment gateways)
+    4. NO imports, no require, no fs, no process
+    5. All data you need comes in via the `input` object parameter (already destructured — you have the fields directly)
+    6. Return a plain result value (object, number, string) — the caller uses it
+
+    OUTPUT RULES:
+    1. Output ONLY the function body code (between { and })
+    2. First line: short comment summarising what the function does
+    3. No markdown fences, no explanation before or after
+    4. Throw Error('...') for failure cases with descriptive messages
+    5. If a step fundamentally requires external side effects, throw an error indicating that — do not fake it
+
+  fullContext: |
+    # SpecVerse context (for LLMs that don't have the SpecVerse skill loaded)
+
+    SpecVerse is a declarative specification language. You describe WHAT a
+    system does in a .specly file, and the engines generate HOW — backend
+    (Fastify/Prisma), frontend (React/Tailwind), CLI, tools, diagrams. The
+    behavior-generation step you're being asked to perform plugs a
+    specific gap: the realize engine matches most spec behavior steps
+    against convention patterns ("Find {Model}", "Set {field}",
+    "Send {event}") and emits them directly; for the rest, you fill in
+    the pure-function body.
+
+    Where your function fits:
+
+    ```
+    // Controller (convention-generated code — NOT your job)
+    const order = await prisma.order.findUniqueOrThrow(...);
+    const customer = await prisma.customer.findUniqueOrThrow(...);
+
+    // Your function — PURE calculation or transformation
+    const discount = await applyDiscountBasedOnLoyaltyTier({ order, customer });
+    // discount = { amount: 42, rate: 0.10 }
+
+    // Controller (convention-generated code — NOT your job)
+    await prisma.order.update({ where: { id }, data: { total: order.total - discount.amount } });
+    await eventBus.publish('OrderDiscounted', { orderId, discount });
+    ```
+
+    Convention patterns ALREADY auto-generated (don't re-implement these):
+    - "Find {Model} by {field}", "Create {Model}", "Update {Model}..."
+    - "Delete {Model}", "Transition {Model} to {state}"
+    - "Set/Increment/Decrement {field}", "Send {event} event"
+
+    You handle: domain-specific calculations, transformations, rules,
+    scoring, categorisation, validation logic. Anything where the behavior
+    step text doesn't match a convention pattern.
+
+    SpecVerse uses CURVED operations (Create, Update, Retrieve, Validate,
+    Evolve, Delete) on controllers. Validate is dry-run; Evolve handles
+    lifecycle state transitions. Models declare attributes, relationships,
+    and lifecycles. Full reference lives in the SpecVerse canonical guide
+    (`specverse://guide` resource, or `~/.claude/skills/specverse/reference/guide.md`
+    if the skill is installed).
+
+  examples:
+    - step: "Apply discount based on loyalty tier"
+      input_fields: "order, customer"
+      output: |
+        // Calculate discount rate from customer's loyalty tier and apply to order total
+        const tierDiscounts: Record<string, number> = {
+          platinum: 0.20, gold: 0.15, silver: 0.10, bronze: 0.05
+        };
+        const tier = (customer as any).loyaltyTier || 'none';
+        const rate = tierDiscounts[tier] || 0;
+        const amount = Math.round((order as any).total * rate * 100) / 100;
+        return { tier, rate, amount, newTotal: (order as any).total - amount };
+
+    - step: "Calculate shipping cost for destination"
+      input_fields: "order, destination"
+      output: |
+        // Calculate shipping cost based on destination zone and order weight
+        const zones: Record<string, number> = { local: 5, regional: 10, national: 15, international: 40 };
+        const zone = (destination as any).zone || 'national';
+        const weightKg = (order as any).totalWeightKg || 1;
+        const baseRate = zones[zone] || 15;
+        const cost = baseRate + (weightKg * 2);
+        return { zone, baseRate, weightKg, cost };
+
+user:
+  template: |
+    Generate a PURE TypeScript function body for this SpecVerse behavior step.
+
+    Step: "{{step}}"
+
+    Context:
+    - Model: {{modelName}}
+    - Controller operation: {{modelName}}Controller.{{operationName}}()
+    - Function name: {{functionName}}
+    - Available Prisma models (for type reference only): {{availableModels}}
+
+    The function signature is already generated as:
+      async function {{functionName}}(input: {{inputSignature}}): Promise<{{returnType}}>
+
+    Inside the function, `input` is already destructured. You have access to
+    these variables directly: {{inputVars}}
+
+    The function MUST return {{returnType}}. If that's `any`, return a
+    reasonable result object describing what was computed. If it's a specific
+    type (e.g., "{ cost: number; days: number }"), return an object matching
+    that shape exactly — the caller depends on those field names.
+
+    Output ONLY the function body (the code that goes between { and }).
+    The destructure is already done — just write the logic.
+
+    Remember: PURE function, no prisma, no eventBus, no external calls.
+
+  variables:
+    - name: step
+      type: string
+      required: true
+      description: The behavior step text from the spec (e.g. "Apply discount based on loyalty tier")
+    - name: modelName
+      type: string
+      required: true
+      description: Name of the model the behavior belongs to (e.g. "Order")
+    - name: operationName
+      type: string
+      required: true
+      description: Name of the controller operation invoking the behavior (e.g. "checkout")
+    - name: functionName
+      type: string
+      required: true
+      description: Generated function name for the behavior body (e.g. "applyLoyaltyDiscount")
+    - name: inputSignature
+      type: string
+      required: true
+      description: 'TypeScript type expression for the destructured input (e.g. "{ order: Order; customer: Customer }")'
+    - name: inputVars
+      type: string
+      required: true
+      description: Comma-separated list of already-destructured input variable names (e.g. "order, customer")
+    - name: returnType
+      type: string
+      required: true
+      description: 'TypeScript return type of the function body (e.g. "{ tier: string; rate: number; amount: number }" or "any")'
+    - name: availableModels
+      type: string
+      required: true
+      description: Comma-separated list of Prisma models the behavior can reference (types only, no I/O)

package/assets/prompts/core/standard/default/create.prompt.yaml

@@ -303,10 +303,10 @@ user:
     WORKFLOW (iterate until validation passes):
 
     Step 1: GENERATE
-    - Read schema files for current v3.5.0 syntax:
+    - Read schema files for current v5.0.0 syntax:
       * {{aiSchemaPath}} (AI guidance, examples, patterns)
       * {{referenceSchemaPath}} (complete working example)
-    - Generate minimal spec using v3.5.0 format
+    - Generate minimal spec using v5.0.0 format
     - Use components: (plural) at top level
     - Use snake_case for lifecycle states (NOT kebab-case)
     - Add deployment policies appropriate for scale
@@ -376,7 +376,7 @@ validation:
       required: false
 
   output:
-    - rule: Must generate valid SpecVerse v3.5.0 specification
+    - rule: Must generate valid SpecVerse v5.0.0 specification
       format: yaml
       schema: schema/SPECVERSE-SCHEMA.json
     - rule: Must include at least one model