@specverse/engines 5.1.0 → 5.2.0

package/assets/prompts/core/standard/archive/v1/create.prompt.yaml

@@ -1,302 +0,0 @@
-name: create
-version: "1.0.0"  
-description: Generate minimal SpecVerse specifications from natural language requirements
-author: SpecVerse Team
-tags: [creation, requirements, minimal-spec]
-
-system:
-  role: |
-    You are a SpecVerse specification creator that generates MINIMAL specifications from requirements.
-    You analyze user requirements and create the smallest possible valid specification that captures the core business logic.
-    The SpecVerse inference engine will later expand these minimal specs into complete architectures.
-    
-  context: |
-    Your task is to:
-    1. Analyze natural language requirements
-    2. Extract core business entities and their relationships
-    3. Generate a minimal SpecVerse specification with only essential attributes
-    4. Let the inference engine handle controllers, services, events, and views later
-    
-    Focus on business logic, not technical implementation details.
-    Start with the absolute minimum needed to represent the domain.
-    
-  capabilities:
-    - Parse natural language requirements
-    - Identify business entities and relationships
-    - Determine essential attributes only
-    - Apply SpecVerse convention syntax
-    - Select appropriate scale (personal/business/enterprise)
-    - Generate clean, minimal specifications
-    
-  constraints:
-    - Include ONLY explicitly mentioned features
-    - Do NOT add technical implementation details
-    - Do NOT generate controllers, services, or events (inference will handle these)
-    - Keep specifications as minimal as possible
-    - Use convention syntax for all attributes
-    - Focus on business domain, not technology
-
-user:
-  template: |
-    Generate a minimal SpecVerse specification from these requirements:
-    
-    Requirements:
-    {{requirements}}
-    
-    Project Scale: {{scale}}
-    Preferred Technology: {{preferredTech}}
-    
-    Guidelines:
-    1. Extract only the core business entities mentioned
-    2. Include only essential attributes that are explicitly stated
-    3. Define relationships between entities
-    4. Use SpecVerse convention syntax: attributeName: TypeName modifiers
-    5. Let the inference engine expand this later
-    
-    Common types to use:
-    - String, Integer, Decimal, Boolean
-    - UUID (for identifiers)
-    - Email, URL, Phone (for contact info)
-    - Date, DateTime, Time (for temporal data)
-    - Money (for financial amounts)
-    
-    Common modifiers:
-    - required / optional
-    - unique
-    - searchable
-    - default=value
-    - min=n / max=n
-    
-    Generate a minimal component specification that captures ONLY what was explicitly requested.
-    
-  variables:
-    - name: requirements
-      type: string
-      required: true
-      description: Natural language description of the application requirements
-      
-    - name: scale
-      type: string
-      required: false
-      default: "business"
-      description: Project scale (personal, business, enterprise)
-      validation: "^(personal|business|enterprise)$"
-      
-    - name: preferredTech
-      type: string
-      required: false
-      default: "auto"
-      description: Preferred technology stack
-
-context:
-  includes:
-    - schema: schema/SPECVERSE-V3.1-SCHEMA-AI.yaml
-    - template: "{{scale}}"
-  max_tokens: 2000
-  temperature: 0.5
-  top_p: 0.9
-
-validation:
-  input:
-    - rule: Requirements must be provided
-      required: true
-    - rule: Requirements should be between 10 and 5000 characters
-      required: false
-      
-  output:
-    - rule: Must generate valid SpecVerse v3.1 specification
-      format: yaml
-      schema: schema/SPECVERSE-SCHEMA.json
-    - rule: Must include at least one model
-      format: yaml
-    - rule: Should be minimal (typically under 100 lines)
-      format: yaml
-
-examples:
-  - name: Task Management System
-    description: Creating minimal spec for a task management application
-    input:
-      requirements: |
-        Build a task management system where users can create projects and add tasks to them.
-        Tasks should have a title, description, due date, and status (todo, in progress, done).
-        Users should be able to assign tasks to team members.
-      scale: business
-      preferredTech: auto
-      
-    output: |
-      components:
-        TaskManagement:
-          version: "1.0.0"
-          description: "Task management system"
-          
-          models:
-            Project:
-              description: "Container for related tasks"
-              attributes:
-                name: String required
-                description: String optional
-              relationships:
-                tasks: hasMany Task cascade
-                
-            Task:
-              description: "Individual work item"
-              attributes:
-                title: String required
-                description: String optional
-                dueDate: Date optional
-                status: String required default=todo values=["todo","in_progress","done"]
-              relationships:
-                project: belongsTo Project required
-                assignee: belongsTo User optional
-                
-            User:
-              description: "System user"
-              attributes:
-                email: Email required unique
-                name: String required
-              relationships:
-                assignedTasks: hasMany Task
-                
-    explanation: |
-      This minimal specification captures only what was explicitly mentioned:
-      - Three core entities: Project, Task, User
-      - Essential attributes for each
-      - Clear relationships between entities
-      - No controllers, services, or events (inference will add these)
-
-  - name: E-commerce Platform
-    description: Creating minimal spec for an online store
-    input:
-      requirements: |
-        Create an e-commerce platform where customers can browse products by category,
-        add items to a shopping cart, and place orders. Products have name, price,
-        description, and inventory count. Orders should track shipping address and payment status.
-      scale: business
-      preferredTech: auto
-      
-    output: |
-      components:
-        EcommercePlatform:
-          version: "1.0.0"
-          description: "E-commerce platform"
-          
-          models:
-            Product:
-              description: "Sellable item"
-              attributes:
-                name: String required searchable
-                price: Money required
-                description: String optional
-                inventoryCount: Integer required default=0 min=0
-              relationships:
-                category: belongsTo Category required
-                cartItems: hasMany CartItem
-                
-            Category:
-              description: "Product grouping"
-              attributes:
-                name: String required unique
-              relationships:
-                products: hasMany Product
-                
-            Cart:
-              description: "Shopping cart"
-              attributes:
-                status: String required default=active
-              relationships:
-                customer: belongsTo Customer required
-                items: hasMany CartItem cascade
-                
-            CartItem:
-              description: "Product in cart"
-              attributes:
-                quantity: Integer required min=1
-              relationships:
-                cart: belongsTo Cart required
-                product: belongsTo Product required
-                
-            Order:
-              description: "Customer order"
-              attributes:
-                shippingAddress: String required
-                paymentStatus: String required default=pending values=["pending","paid","failed"]
-              relationships:
-                customer: belongsTo Customer required
-                items: hasMany OrderItem cascade
-                
-            OrderItem:
-              description: "Product in order"
-              attributes:
-                quantity: Integer required min=1
-                priceAtPurchase: Money required
-              relationships:
-                order: belongsTo Order required
-                product: belongsTo Product required
-                
-            Customer:
-              description: "Platform customer"
-              attributes:
-                email: Email required unique
-              relationships:
-                cart: hasOne Cart
-                orders: hasMany Order
-                
-    explanation: |
-      Minimal specification includes:
-      - Core e-commerce entities only
-      - Essential attributes from requirements
-      - Proper relationships for cart and order flow
-      - No payment processing or shipping logic (inference will expand)
-
-  - name: Personal Blog
-    description: Creating minimal spec for a personal blog
-    input:
-      requirements: |
-        I want a simple blog where I can write posts with title and content.
-        Posts should support tags for organization.
-      scale: personal
-      preferredTech: auto
-      
-    output: |
-      components:
-        PersonalBlog:
-          version: "1.0.0"
-          description: "Personal blog system"
-          
-          models:
-            Post:
-              description: "Blog post"
-              attributes:
-                title: String required
-                content: String required
-                publishedAt: DateTime optional
-              relationships:
-                tags: manyToMany Tag
-                
-            Tag:
-              description: "Post categorization"
-              attributes:
-                name: String required unique
-              relationships:
-                posts: manyToMany Post
-                
-    explanation: |
-      Very minimal specification for personal use:
-      - Only two models as mentioned
-      - Basic attributes only
-      - Many-to-many relationship for tags
-      - No user model (personal blog doesn't need it)
-
-metadata:
-  created: "2024-01-01T00:00:00Z"
-  updated: "2024-01-01T00:00:00Z"
-  tested_with:
-    - provider: openai
-      model: gpt-4
-      success_rate: 94
-    - provider: anthropic
-      model: claude-3-opus
-      success_rate: 96
-  performance:
-    avg_response_time: 3.2
-    avg_tokens_used: 1200

package/assets/prompts/core/standard/archive/v1/materialise.prompt.yaml

@@ -1,328 +0,0 @@
-name: materialise
-version: "1.0.0"
-description: Generate clean implementation from extracted specifications for comparison with existing code
-author: SpecVerse Team
-tags: [materialise, comparison, clean-implementation]
-
-system:
-  role: |
-    You generate a complete NEW implementation from extracted specifications.
-    This is NOT about updating existing code - you create a fresh, clean implementation
-    that can be compared with the original codebase for migration planning.
-    
-  context: |
-    Your purpose is to create a "clean room" implementation from specifications that were
-    extracted from an existing application. This clean implementation will be used to:
-    1. Compare with the original code to identify differences
-    2. Generate migration recommendations
-    3. Highlight inconsistencies or technical debt
-    4. Plan refactoring strategies
-    
-    Generate production-quality code that follows best practices for the detected framework.
-    
-  capabilities:
-    - Generate complete application implementations
-    - Follow framework-specific best practices
-    - Implement all models, controllers, and services from specs
-    - Generate database schemas and migrations
-    - Create proper API endpoints
-    - Add appropriate error handling
-    - Generate clean, maintainable code
-    
-  constraints:
-    - Generate NEW code, not modifications to existing code
-    - Follow the technology patterns from the manifest
-    - Implement ALL specifications completely
-    - Use modern best practices
-    - Include proper error handling and validation
-    - Generate working, compilable code
-
-user:
-  template: |
-    Generate a clean implementation from these extracted specifications:
-    
-    Component Specification:
-    {{componentSpec}}
-    
-    Deployment Specification:  
-    {{deploymentSpec}}
-    
-    Implementation Manifest:
-    {{manifest}}
-    
-    Original Application Path: {{originalPath}}
-    
-    Generate a complete, clean implementation that:
-    1. Implements all models with proper attributes and relationships
-    2. Creates all controllers with the specified actions
-    3. Implements all services with business logic
-    4. Includes database schema/migrations
-    5. Follows the framework patterns from the manifest
-    6. Uses modern best practices
-    7. Is ready to run and test
-    
-    Output the complete file structure and contents for the clean implementation.
-    Include a comparison report highlighting key differences from the original.
-    
-  variables:
-    - name: componentSpec
-      type: string
-      required: true
-      description: SpecVerse component specification in YAML format
-      
-    - name: deploymentSpec
-      type: string
-      required: false
-      description: SpecVerse deployment specification in YAML format
-      
-    - name: manifest
-      type: string
-      required: true
-      description: Implementation manifest describing technology stack
-      
-    - name: originalPath
-      type: string
-      required: true
-      description: Path to the original application for reference
-
-context:
-  includes:
-    - schema: schema/SPECVERSE-V3.1-SCHEMA-AI.yaml
-    - library: framework-implementations
-    - template: clean-room-patterns
-  max_tokens: 12000
-  temperature: 0.2
-  top_p: 0.9
-
-validation:
-  input:
-    - rule: Component specification must be provided
-      required: true
-    - rule: Implementation manifest must be provided  
-      required: true
-    - rule: Specifications must be valid YAML
-      required: true
-      
-  output:
-    - rule: Must generate complete working implementation
-      format: text
-    - rule: All models from spec must be implemented
-      format: text
-    - rule: All controllers from spec must be implemented
-      format: text
-    - rule: Must include comparison report
-      format: markdown
-
-examples:
-  - name: Next.js Application Materialisation
-    description: Generate clean Next.js implementation from extracted specs
-    input:
-      componentSpec: |
-        components:
-          UserManagement:
-            version: "1.0.0"
-            models:
-              User:
-                attributes:
-                  id: String required unique auto=cuid
-                  email: Email required unique
-                  name: String optional
-                relationships:
-                  posts: hasMany Post cascade
-              Post:
-                attributes:
-                  id: String required unique auto=cuid
-                  title: String required
-                  content: String optional
-                relationships:
-                  author: belongsTo User required
-            controllers:
-              UserController:
-                model: User
-                actions:
-                  getUsers:
-                    returns: User[]
-                  createUser:
-                    parameters:
-                      email: Email required
-                      name: String optional
-                    returns: User
-      manifest: |
-        technology:
-          framework: "nextjs"
-          version: "14.0.0"
-          language: "typescript"
-        database:
-          orm: "prisma"
-          provider: "postgresql"
-        api:
-          type: "rest"
-          pattern: "app-router"
-      originalPath: "/apps/legacy-user-app"
-      
-    output: |
-      ## Clean Implementation Structure
-      
-      ```
-      clean-user-management/
-      ├── app/
-      │   ├── api/
-      │   │   └── users/
-      │   │       └── route.ts
-      │   └── layout.tsx
-      ├── prisma/
-      │   ├── schema.prisma
-      │   └── migrations/
-      ├── lib/
-      │   └── prisma.ts
-      └── package.json
-      ```
-      
-      ### File Contents
-      
-      **prisma/schema.prisma**
-      ```prisma
-      generator client {
-        provider = "prisma-client-js"
-      }
-      
-      datasource db {
-        provider = "postgresql"
-        url      = env("DATABASE_URL")
-      }
-      
-      model User {
-        id        String   @id @default(cuid())
-        email     String   @unique
-        name      String?
-        posts     Post[]
-        createdAt DateTime @default(now())
-        updatedAt DateTime @updatedAt
-      }
-      
-      model Post {
-        id        String   @id @default(cuid())
-        title     String
-        content   String?
-        authorId  String
-        author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
-        createdAt DateTime @default(now())
-        updatedAt DateTime @updatedAt
-      }
-      ```
-      
-      **app/api/users/route.ts**
-      ```typescript
-      import { NextRequest, NextResponse } from 'next/server';
-      import { prisma } from '@/lib/prisma';
-      import { z } from 'zod';
-      
-      const createUserSchema = z.object({
-        email: z.string().email(),
-        name: z.string().optional(),
-      });
-      
-      export async function GET() {
-        try {
-          const users = await prisma.user.findMany({
-            include: {
-              posts: true,
-            },
-          });
-          return NextResponse.json(users);
-        } catch (error) {
-          return NextResponse.json(
-            { error: 'Failed to fetch users' },
-            { status: 500 }
-          );
-        }
-      }
-      
-      export async function POST(request: NextRequest) {
-        try {
-          const body = await request.json();
-          const validatedData = createUserSchema.parse(body);
-          
-          const user = await prisma.user.create({
-            data: validatedData,
-            include: {
-              posts: true,
-            },
-          });
-          
-          return NextResponse.json(user, { status: 201 });
-        } catch (error) {
-          if (error instanceof z.ZodError) {
-            return NextResponse.json(
-              { error: 'Validation failed', details: error.errors },
-              { status: 400 }
-            );
-          }
-          return NextResponse.json(
-            { error: 'Failed to create user' },
-            { status: 500 }
-          );
-        }
-      }
-      ```
-      
-      **lib/prisma.ts**
-      ```typescript
-      import { PrismaClient } from '@prisma/client';
-      
-      const globalForPrisma = globalThis as unknown as {
-        prisma: PrismaClient | undefined;
-      };
-      
-      export const prisma = globalForPrisma.prisma ?? new PrismaClient();
-      
-      if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
-      ```
-      
-      ## Comparison Report
-      
-      ### Key Improvements in Clean Implementation
-      
-      1. **Type Safety**: Added Zod validation for API endpoints
-      2. **Error Handling**: Comprehensive error handling with appropriate HTTP status codes
-      3. **Database Relations**: Proper cascade delete handling
-      4. **Code Organization**: Clean separation of concerns
-      5. **Modern Patterns**: Uses Next.js 14 App Router patterns
-      6. **Validation**: Input validation on all endpoints
-      7. **TypeScript**: Full TypeScript implementation
-      
-      ### Likely Differences from Original
-      
-      1. **Missing Error Handling**: Original may lack proper error responses
-      2. **No Input Validation**: Original may accept any input without validation
-      3. **Inconsistent Code Style**: Original may have mixed patterns
-      4. **Missing Type Safety**: Original may use any/unknown types
-      5. **Incomplete Relations**: Original may not handle cascade deletes properly
-      
-      ### Migration Recommendations
-      
-      1. Add input validation using Zod or similar
-      2. Implement comprehensive error handling
-      3. Update database schema for proper relations
-      4. Add TypeScript types throughout
-      5. Migrate to Next.js App Router if using Pages Router
-      6. Add proper connection pooling for database
-      
-    explanation: |
-      This clean implementation demonstrates modern Next.js best practices while
-      staying true to the extracted specifications. It provides a baseline for
-      comparing with the original code and identifying improvement opportunities.
-
-metadata:
-  created: "2024-01-01T00:00:00Z"
-  updated: "2024-01-01T00:00:00Z"
-  tested_with:
-    - provider: openai
-      model: gpt-4
-      success_rate: 92
-    - provider: anthropic
-      model: claude-3-opus
-      success_rate: 95
-  performance:
-    avg_response_time: 18.7
-    avg_tokens_used: 6500