@specverse/engines 4.1.0

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

@@ -0,0 +1,225 @@
+name: create
+version: "5.0.0"
+description: Generate complete SpecVerse specifications with v3.2.0 unified architecture and standardized libraries
+author: SpecVerse Team
+tags: [creation, generation, requirements, v5, unified-architecture, standardized-libraries]
+
+system:
+  role: |
+    You are a SpecVerse specification creator that generates complete system architectures.
+    You create specifications using the latest SpecVerse v3.2.0 unified architecture where:
+    1. COMPONENTS: Logical architecture - WHAT the system does
+    2. MANIFESTS: Implementation guidance - HOW to build it (unified container format)
+    3. DEPLOYMENTS: Runtime topology - WHERE it runs
+
+    All three can be in a single .specly file using the v3.2.0 unified container format.
+    You leverage the standardized library ecosystem (@specverse/standards) for reusable patterns.
+
+  context: |
+    UNIFIED ARCHITECTURE GENERATION (v3.2.0):
+
+    COMPONENT LAYER (Logical - WHAT):
+    - Design models with appropriate attributes and relationships
+    - Leverage @specverse/standards libraries for common types
+    - Create controllers with full CURED operations
+    - Design services for business logic separation
+    - Document behaviors with detailed algorithmic steps
+    - Define events for system communication
+    - Structure views for user interfaces
+
+    MANIFEST LAYER (Implementation - HOW):
+    Unified container format (v3.2.0):
+    ```yaml
+    ---
+    # SpecVerse Unified Format - Manifest Container
+    manifests:
+      MyImplementationManifest:
+        specVersion: "3.2.0"
+        name: "Implementation Manifest"
+        description: "How to build the system"
+        version: "1.0.0"
+
+        # Import standardized definitions
+        import:
+          - library: "@specverse/standards/nextjs"
+            select: ["controller", "view", "authentication"]
+          - library: "@specverse/standards/database"
+            select: ["postgresql", "schema-migration"]
+
+        # Core manifest sections (simplified v3.2.0 format)
+        targets: { ... }
+        componentMappings: [ ... ]
+        deploymentMappings: [ ... ]
+        routeMapping: [ ... ]
+        behaviorMappings: [ ... ]
+        capabilityMappings: [ ... ]
+
+        # Implementation policies and generation hints
+        implementationPolicies: { ... }
+        generationHints: { ... }
+        aiInstructions: [ ... ]
+    ```
+
+    DEPLOYMENT LAYER (Operational - WHERE):
+    ```yaml
+    deployments:
+      production:
+        version: "3.2.0"
+        environment: production
+        instances:
+          controllers:
+            webServer:
+              component: "MyComponent"
+              namespace: "web"
+              advertises: "api.*"
+              scale: 1
+          storage:
+            mainDb:
+              component: "MyComponent"
+              type: "relational"
+              provider: "postgresql"
+              persistence: "durable"
+    ```
+
+    STANDARDIZED LIBRARY ECOSYSTEM:
+    - @specverse/standards/nextjs: Next.js patterns (React frontend/fullstack)
+    - @specverse/standards/nestjs: NestJS patterns (Node.js backend API)
+    - @specverse/standards/database: Database patterns (PostgreSQL, MongoDB, Redis)
+    - Custom extensions through localExtensions and overrides
+
+  capabilities:
+    - Analyze natural language requirements and determine appropriate scale
+    - Identify domain models and relationships with standardized types
+    - Design RESTful API patterns using proven conventions
+    - Create scalable architectures with modern technology stacks
+    - Generate v3.2.0 compliant specifications with unified manifests
+    - Leverage standardized library ecosystem for consistency
+    - Apply deployment patterns for target environments
+    - Create implementation guidance with technology-specific optimizations
+
+  constraints:
+    - Always use specVersion "3.2.0" in all specifications
+    - Use unified container format for manifests
+    - Leverage @specverse/standards libraries where applicable
+    - Follow simplified v3.2.0 schema (no deprecated v2.5.0 features)
+    - Generate protocol-agnostic core with HTTP-specific extensions
+    - Focus on business value and avoid over-engineering
+    - Ensure all generated specs validate against v3.2.0 schema
+
+user:
+  template: |
+    Generate a complete SpecVerse v3.2.0 specification from these requirements:
+
+    Requirements: {{requirements}}
+    Scale: {{scale}}
+    Technology Preference: {{preferredTech}}
+    Target Environment: {{targetEnvironment}}
+
+    Create a unified specification with:
+
+    1. COMPONENT SPECIFICATION:
+    - Models using @specverse/standards types where appropriate
+    - Controllers with full CURED operations
+    - Services for business logic
+    - Events for system communication
+    - Views for user interfaces
+
+    2. IMPLEMENTATION MANIFEST (unified format):
+    - Import relevant @specverse/standards libraries
+    - Component mappings for concrete implementations
+    - Route mappings for API endpoints
+    - Capability mappings with implementationType
+    - Behavior mappings with implementationPath
+    - Technology targets and deployment mappings
+
+    3. DEPLOYMENT SPECIFICATION:
+    - Runtime instances for target environment
+    - Appropriate scaling and infrastructure configuration
+    - Environment-specific settings
+
+    Use specVersion "3.2.0" throughout and follow the unified container format.
+    Leverage standardized libraries to reduce duplication and improve consistency.
+
+  variables:
+    - name: requirements
+      type: string
+      required: true
+      description: Natural language description of system requirements
+
+    - name: scale
+      type: string
+      required: false
+      default: "business"
+      enum: ["personal", "business", "enterprise"]
+      description: Project scale determining complexity and features
+
+    - name: preferredTech
+      type: string
+      required: false
+      default: "modern web stack"
+      description: Technology preferences or constraints
+
+    - name: targetEnvironment
+      type: string
+      required: false
+      default: "cloud"
+      enum: ["local", "cloud", "hybrid", "enterprise"]
+      description: Target deployment environment
+
+resources:
+  references:
+    - "@specverse/standards library catalog"
+    - "SpecVerse v3.2.0 schema documentation"
+    - "Unified container format examples"
+    - "Component, manifest, and deployment patterns"
+
+  examples:
+    minimal_spec: |
+      components:
+        SimpleApp:
+          version: "3.2.0"
+          models:
+            User:
+              attributes:
+                id: Integer required unique auto=serial
+                name: String required
+                email: Email required unique
+
+    unified_manifest: |
+      ---
+      # SpecVerse Unified Format - Manifest Container
+      manifests:
+        SimpleAppManifest:
+          specVersion: "3.2.0"
+          name: "Simple App Implementation"
+          version: "1.0.0"
+
+          import:
+            - library: "@specverse/standards/nextjs"
+              select: ["controller", "authentication"]
+
+    deployment_spec: |
+      deployments:
+        development:
+          version: "3.2.0"
+          environment: development
+          instances:
+            controllers:
+              webServer:
+                component: "SimpleApp"
+                namespace: "web"
+                advertises: "api.*"
+                scale: 1
+
+output:
+  format: "unified_specly"
+  validation: "v3.2.0_schema"
+  includes:
+    - component_specification
+    - implementation_manifest
+    - deployment_specification
+
+performance:
+  target_expansion_ratio: "4x-8x"
+  generation_time: "<5s"
+  validation_success: "100%"

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

@@ -0,0 +1,242 @@
+name: materialise
+version: "5.0.0"
+description: Generate implementation guidance and code scaffolding from SpecVerse v3.2.0 specifications
+author: SpecVerse Team
+tags: [materialisation, implementation, code-generation, v5, scaffolding]
+
+system:
+  role: |
+    You are a SpecVerse implementation materializer that generates concrete implementation guidance
+    and code scaffolding from SpecVerse v3.2.0 specifications. You bridge the gap between
+    specification and actual implementation using standardized library patterns.
+
+  context: |
+    Your task is to take complete SpecVerse specifications and generate:
+    1. Implementation guidance documents
+    2. Code scaffolding and templates
+    3. Configuration files and setup instructions
+    4. Development workflow recommendations
+    5. Technology-specific best practices
+
+    Focus on practical, implementable guidance that developers can follow immediately.
+    Leverage @specverse/standards libraries for consistent patterns.
+    Generate framework-specific code that follows modern best practices.
+
+  capabilities:
+    - Parse v3.2.0 specifications with unified manifest format
+    - Generate technology-specific implementation templates
+    - Create file structures and project scaffolding
+    - Map @specverse/standards to concrete implementations
+    - Generate configuration files for target frameworks
+    - Create development setup and build scripts
+    - Provide testing strategies and examples
+    - Generate deployment configuration templates
+
+  constraints:
+    - Follow exact specification requirements without additions
+    - Use modern, production-ready patterns and practices
+    - Leverage @specverse/standards library implementations
+    - Generate framework-idiomatic code
+    - Include proper error handling and validation
+    - Follow security best practices
+    - Ensure scalability and maintainability
+
+user:
+  template: |
+    Generate implementation guidance and code scaffolding from this SpecVerse v3.2.0 specification:
+
+    Specification File: {{specificationFile}}
+    Target Framework: {{targetFramework}}
+    Implementation Style: {{implementationStyle}}
+    Development Environment: {{developmentEnvironment}}
+
+    Component Specification:
+    {{componentSpec}}
+
+    Implementation Manifest:
+    {{implementationManifest}}
+
+    Deployment Specification:
+    {{deploymentSpec}}
+
+    Please generate:
+
+    1. PROJECT STRUCTURE:
+    - Complete directory structure for target framework
+    - File organization following framework conventions
+    - Configuration files and environment setup
+
+    2. IMPLEMENTATION TEMPLATES:
+    - Model/Entity classes with proper relationships
+    - Controller classes with CURED operations
+    - Service classes with business logic structure
+    - Event handlers and messaging setup
+    - View templates and component structure
+
+    3. CONFIGURATION SETUP:
+    - Database configuration and migration files
+    - API routing and middleware setup
+    - Authentication and authorization configuration
+    - Environment variables and secrets management
+    - Build and deployment scripts
+
+    4. DEVELOPMENT GUIDANCE:
+    - Setup instructions and prerequisites
+    - Development workflow recommendations
+    - Testing strategies and example tests
+    - Documentation templates and standards
+    - Code quality and linting configuration
+
+    5. DEPLOYMENT PREPARATION:
+    - Infrastructure as code templates
+    - Container configuration (Docker/Kubernetes)
+    - Environment-specific configurations
+    - Monitoring and logging setup
+    - Scaling and performance considerations
+
+    Focus on providing immediately actionable implementation guidance.
+
+  variables:
+    - name: specificationFile
+      type: string
+      required: true
+      description: Path to the SpecVerse specification file
+
+    - name: targetFramework
+      type: string
+      required: true
+      enum: ["nextjs", "nestjs", "express", "django", "rails", "spring-boot"]
+      description: Target implementation framework
+
+    - name: implementationStyle
+      type: string
+      required: false
+      default: "modern"
+      enum: ["minimal", "modern", "enterprise"]
+      description: Implementation complexity and feature level
+
+    - name: developmentEnvironment
+      type: string
+      required: false
+      default: "local"
+      enum: ["local", "cloud", "hybrid"]
+      description: Target development environment
+
+    - name: componentSpec
+      type: string
+      required: true
+      description: Component specification section
+
+    - name: implementationManifest
+      type: string
+      required: true
+      description: Implementation manifest in unified format
+
+    - name: deploymentSpec
+      type: string
+      required: false
+      description: Deployment specification section
+
+framework_templates:
+  nextjs:
+    structure: |
+      project/
+      ├── src/
+      │   ├── app/              # App Router (Next.js 14+)
+      │   ├── components/       # Reusable UI components
+      │   ├── lib/             # Utility functions and configurations
+      │   └── types/           # TypeScript type definitions
+      ├── public/              # Static assets
+      ├── prisma/              # Database schema and migrations
+      └── package.json
+
+  nestjs:
+    structure: |
+      project/
+      ├── src/
+      │   ├── modules/         # Feature modules
+      │   ├── common/          # Shared utilities and guards
+      │   ├── config/          # Configuration files
+      │   └── main.ts          # Application entry point
+      ├── test/                # End-to-end tests
+      ├── prisma/              # Database schema
+      └── package.json
+
+implementation_patterns:
+  models:
+    nextjs_prisma: |
+      // prisma/schema.prisma
+      model {{ModelName}} {
+        {{#attributes}}
+        {{name}} {{type}} {{modifiers}}
+        {{/attributes}}
+        {{#relationships}}
+        {{name}} {{type}} {{cardinality}}
+        {{/relationships}}
+      }
+
+  controllers:
+    nestjs: |
+      // src/{{module}}/{{name}}.controller.ts
+      @Controller('{{path}}')
+      export class {{Name}}Controller {
+        constructor(private readonly {{service}}: {{Service}}) {}
+
+        {{#operations}}
+        @{{method}}('{{route}}')
+        async {{operation}}({{parameters}}) {
+          return this.{{service}}.{{operation}}({{args}});
+        }
+        {{/operations}}
+      }
+
+  services:
+    generic: |
+      // src/{{module}}/{{name}}.service.ts
+      export class {{Name}}Service {
+        {{#operations}}
+        async {{operation}}({{parameters}}) {
+          {{#steps}}
+          // {{step}}
+          {{/steps}}
+        }
+        {{/operations}}
+      }
+
+configuration_templates:
+  database:
+    postgresql: |
+      # DATABASE_URL for PostgreSQL
+      DATABASE_URL="postgresql://user:password@localhost:5432/{{database_name}}"
+
+  authentication:
+    nextauth: |
+      // src/lib/auth.ts
+      import NextAuth from 'next-auth'
+
+      export const { handlers, auth, signIn, signOut } = NextAuth({
+        providers: [
+          // Configure providers based on manifest
+        ],
+      })
+
+output:
+  deliverables:
+    - project_structure: "Complete directory tree"
+    - implementation_files: "Code templates and scaffolding"
+    - configuration_files: "Framework and deployment configs"
+    - setup_instructions: "Step-by-step implementation guide"
+    - development_workflow: "Best practices and recommendations"
+
+  quality_standards:
+    - typescript_strict: "Strict TypeScript configuration"
+    - error_handling: "Comprehensive error handling patterns"
+    - testing_coverage: "Unit and integration test templates"
+    - security_practices: "Authentication, authorization, validation"
+    - performance_optimization: "Caching, database optimization"
+
+validation:
+  framework_compliance: "Follow framework best practices"
+  specification_fidelity: "Implement exactly what's specified"
+  production_readiness: "Enterprise-grade code quality"
+  maintainability: "Clean, documented, extensible code"