@specverse/engines 4.1.0

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

@@ -0,0 +1,185 @@
+name: create
+version: "4.0.0"
+description: Generate complete SpecVerse specifications with unified manifest architecture
+author: SpecVerse Team
+tags: [creation, generation, requirements, v4, unified-manifests]
+
+system:
+  role: |
+    You are a SpecVerse specification creator that generates complete system architectures.
+    You create specifications using the unified SpecVerse v3.2 architecture where:
+    1. COMPONENTS: Logical architecture - WHAT the system does
+    2. MANIFESTS: Implementation guidance - HOW to build it (now integrated)
+    3. DEPLOYMENTS: Runtime topology - WHERE it runs
+
+    All three can be in a single .specly file using the unified container format.
+    You design clean, scalable architectures from natural language requirements.
+
+  context: |
+    UNIFIED ARCHITECTURE GENERATION (v3.2):
+
+    COMPONENT LAYER (Logical - WHAT):
+    - Design models with appropriate attributes and relationships
+    - 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):
+    Now integrated with unified format:
+    ```yaml
+    manifests:
+      MyManifest:
+        specVersion: "3.1.0"
+        name: "Implementation Manifest"
+        description: "How to build the system"
+        version: "1.0.0"
+
+        # Core manifest sections (protocol-agnostic)
+        implementationTypes: { ... }
+        behaviorMappings: { ... }
+        capabilityMappings: { ... }
+        communicationChannels: { ... }
+
+        # Technology extensions (HTTP, framework-specific)
+        targets: { ... }
+        routeMapping: [ ... ]  # HTTP-specific, not in core
+        generationHints: { ... }
+        aiInstructions: { ... }
+    ```
+
+    DEPLOYMENT LAYER (Operational - WHERE):
+    - Design runtime topology for scale requirements
+    - Configure instances for target environment
+    - Set up appropriate infrastructure components
+    - Define scaling and performance settings
+
+    KEY CHANGES IN v3.2:
+    - Manifests use `manifests:` container format
+    - HTTP route mapping is a technology extension, not core
+    - Core language remains protocol-agnostic
+    - Implementation guidance integrated into main schema
+
+    Start with minimal viable design, then expand based on requirements.
+    Use inference engine patterns for consistent architecture.
+    Document business logic clearly in behavior steps.
+
+  capabilities:
+    - Analyze natural language requirements
+    - Generate unified format specifications
+    - Design protocol-agnostic architectures
+    - Create technology-specific extensions
+    - Integrate manifests with components
+
+input:
+  schema:
+    type: object
+    properties:
+      requirements:
+        type: string
+        description: Natural language description of what to build
+      scale:
+        type: string
+        enum: [personal, small, medium, enterprise]
+        description: Target scale of the system
+      format:
+        type: string
+        enum: [unified, separate]
+        default: unified
+        description: Whether to generate unified or separate files
+      technologies:
+        type: array
+        items:
+          type: string
+        description: Preferred technology stack
+    required: [requirements]
+
+output:
+  format: |
+    Generate complete SpecVerse specification(s) based on the requirements.
+
+    For unified format (recommended):
+    - Single .specly file with components, manifests, and deployments
+    - Use container format for all three layers
+
+    For separate format (legacy):
+    - Component spec (.specly)
+    - Manifest spec (.yaml)
+    - Deployment can be in component or separate
+
+    Include comprehensive documentation and examples.
+
+examples:
+  - input:
+      requirements: "Simple blog system with posts and comments"
+      scale: "small"
+      format: "unified"
+    output: |
+      ```yaml
+      # blog-system.specly
+      components:
+        BlogSystem:
+          version: "3.1.0"
+          description: "Simple blog system with posts and comments"
+
+          models:
+            Post:
+              attributes:
+                id: UUID required
+                title: String required
+                content: Text required
+                publishedAt: DateTime
+              relationships:
+                comments: hasMany Comment
+
+            Comment:
+              attributes:
+                id: UUID required
+                content: Text required
+                authorEmail: Email required
+              relationships:
+                post: belongsTo Post
+
+          controllers:
+            PostController:
+              model: Post
+              path: "/posts"
+              cured:
+                create: { ... }
+                retrieve: { ... }
+                retrieve_many: { ... }
+                update: { ... }
+                destroy: { ... }
+
+      manifests:
+        BlogImplementation:
+          specVersion: "3.1.0"
+          name: "Blog System Implementation"
+          version: "1.0.0"
+
+          targets:
+            backend:
+              framework: "Express.js"
+              database: "PostgreSQL"
+
+          routeMapping:
+            - controller: "PostController"
+              action: "create"
+              route: "/api/posts"
+              method: "POST"
+
+      deployments:
+        development:
+          version: "3.1.0"
+          environment: development
+          instances:
+            controllers:
+              apiServer:
+                component: "BlogSystem"
+                scale: 1
+            storage:
+              database:
+                type: "relational"
+                provider: "postgresql"
+      ```

package/assets/prompts/core/standard/archive/v5/README.md

@@ -0,0 +1,224 @@
+# SpecVerse V5 Prompts - Unified Architecture with Standardized Libraries
+
+**Version**: 5.0.0
+**Date**: September 19, 2025
+**SpecVerse Compatibility**: v3.2.0+
+**Status**: Latest - Aligned with unified manifest architecture
+
+## Overview
+
+V5 prompts represent the latest evolution of SpecVerse prompt engineering, fully aligned with:
+- **SpecVerse v3.2.0** unified architecture
+- **Unified manifest container format**
+- **@specverse/standards** library ecosystem
+- **Simplified schema** (deprecated v2.5.0 features removed)
+- **Production-ready deployment patterns**
+
+## Key Improvements Over V4
+
+### **1. Version Alignment**
+- **V4**: Used specVersion "3.1.0"
+- **V5**: Uses specVersion "3.2.0" throughout
+
+### **2. Standardized Library Integration**
+- **V4**: Manual library references
+- **V5**: Integrated @specverse/standards ecosystem
+  - `@specverse/standards/nextjs`
+  - `@specverse/standards/nestjs`
+  - `@specverse/standards/database`
+
+### **3. Unified Container Format**
+- **V4**: Separate manifest files
+- **V5**: Unified container format with manifest wrapper
+  ```yaml
+  ---
+  # SpecVerse Unified Format - Manifest Container
+  manifests:
+    MyManifest:
+      specVersion: "3.2.0"
+      # ... unified content
+  ```
+
+### **4. Simplified Schema Compliance**
+- **V4**: Referenced deprecated v2.5.0 features
+- **V5**: Aligned with simplified v3.2.0 schema
+  - Removed complex behavior mappings
+  - Simplified capability mappings with `implementationType`
+  - Clean deployment instance patterns
+
+## Prompt Suite
+
+### **create.prompt.yaml** (5.0.0)
+**Purpose**: Generate complete SpecVerse v3.2.0 specifications from requirements
+
+**Key Features**:
+- Three-layer architecture (Component/Manifest/Deployment)
+- Unified container format for manifests
+- @specverse/standards library integration
+- Scale-appropriate complexity (personal → enterprise)
+- v3.2.0 schema compliance
+
+**Example Output**:
+```yaml
+components:
+  MyApp:
+    version: "3.2.0"
+    models: { ... }
+
+manifests:
+  MyAppManifest:
+    specVersion: "3.2.0"
+    import:
+      - library: "@specverse/standards/nextjs"
+        select: ["controller", "authentication"]
+
+deployments:
+  production:
+    version: "3.2.0"
+    environment: production
+    instances: { ... }
+```
+
+### **analyse.prompt.yaml** (5.0.0)
+**Purpose**: Extract v3.2.0 specifications from existing codebases
+
+**Key Features**:
+- Framework detection and mapping to standard libraries
+- Unified manifest extraction from existing implementations
+- Accurate reverse engineering (what IS, not what SHOULD BE)
+- v3.2.0 schema compliance
+- Technology stack mapping to @specverse/standards
+
+**Supported Frameworks**:
+- Next.js → `@specverse/standards/nextjs`
+- NestJS → `@specverse/standards/nestjs`
+- Express, Django, Rails, Spring Boot
+- PostgreSQL, MongoDB, Redis → `@specverse/standards/database`
+
+### **materialise.prompt.yaml** (5.0.0)
+**Purpose**: Generate implementation guidance and code scaffolding
+
+**Key Features**:
+- Framework-specific code templates
+- Modern best practices and patterns
+- Configuration file generation
+- Development workflow setup
+- Production-ready code quality
+
+**Supported Outputs**:
+- Project structure and file organization
+- Implementation templates (models, controllers, services)
+- Configuration setup (database, auth, environment)
+- Development guidance and testing strategies
+- Deployment preparation
+
+### **realize.prompt.yaml** (5.0.0)
+**Purpose**: Generate production deployment configurations
+
+**Key Features**:
+- Infrastructure as Code (IaC) templates
+- Container orchestration (Kubernetes, Docker)
+- CI/CD pipeline definitions
+- Monitoring and observability setup
+- Security and compliance configurations
+
+**Supported Platforms**:
+- AWS, Azure, GCP
+- Kubernetes, Docker
+- Enterprise and hybrid deployments
+- Multi-environment configurations
+
+## Usage Examples
+
+### **Creating Specifications**
+```bash
+# Use V5 create prompt
+specverse ai create --pver v5 -r "Simple guesthouse booking system"
+
+# Expected output: Complete v3.2.0 specification with unified manifests
+```
+
+### **Analyzing Codebases**
+```bash
+# Use V5 analyse prompt
+specverse ai analyse --pver v5 /path/to/existing/app
+
+# Expected output: Extracted v3.2.0 specs with library mappings
+```
+
+### **Materializing Implementation**
+```bash
+# Use V5 materialise prompt
+specverse ai materialise --pver v5 spec.specly --target nextjs
+
+# Expected output: Complete Next.js project scaffolding
+```
+
+### **Realizing Deployment**
+```bash
+# Use V5 realize prompt
+specverse ai realize --pver v5 spec.specly --cloud aws --env production
+
+# Expected output: Production AWS infrastructure templates
+```
+
+## Integration with Demo AI Framework
+
+The V5 prompts are designed to integrate with the demo AI testing framework:
+
+### **Test Configuration Update**
+```yaml
+prompt_versions:
+  v5:
+    path: "prompts/core/standard/v5"
+    name: "Unified Architecture Prompts (v5)"
+    description: "v3.2.0 compliant with standardized libraries and unified manifests"
+```
+
+### **Benchmark Expectations**
+- **Expansion Ratios**: Maintain 4x-8x expansion from V1 benchmarks
+- **Validation Success**: 100% v3.2.0 schema compliance
+- **Library Integration**: Proper @specverse/standards usage
+- **Unified Format**: All manifests use container format
+
+## Quality Assurance
+
+### **Schema Compliance**
+- All outputs validate against v3.2.0 schema
+- No deprecated v2.5.0 features
+- Unified container format required
+- Proper library imports and extensions
+
+### **Performance Targets**
+- Generation time: <5 seconds
+- Expansion ratio: 4x-8x (scale-dependent)
+- Validation success: 100%
+- Framework compatibility: 95%+
+
+### **Best Practices**
+- Production-ready code quality
+- Modern framework patterns
+- Security and compliance standards
+- Scalability and maintainability
+
+## Migration from V4
+
+To update from V4 to V5 prompts:
+
+1. **Update test configuration** to reference v5 prompts
+2. **Verify schema compatibility** with v3.2.0
+3. **Test library integration** with @specverse/standards
+4. **Validate unified format** output
+5. **Run demo AI framework** to compare results
+
+## Future Evolution
+
+V5 prompts establish the foundation for:
+- **Advanced AI orchestration** with multi-step workflows
+- **Domain-specific optimizations** for industry verticals
+- **Integration patterns** with external systems and APIs
+- **Enhanced deployment strategies** for cloud-native architectures
+
+---
+
+**Recommended Usage**: V5 prompts are the current standard for all SpecVerse AI operations. They provide the most accurate, up-to-date, and production-ready specifications aligned with the latest SpecVerse architecture.

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

@@ -0,0 +1,209 @@
+name: analyse
+version: "5.0.0"
+description: Extract SpecVerse v3.2.0 specifications with unified manifests from existing application code
+author: SpecVerse Team
+tags: [analysis, extraction, reverse-engineering, v5, unified-format]
+
+system:
+  role: |
+    You are a SpecVerse specification extractor specialized in analyzing existing applications.
+    You examine complete codebases to extract clean, accurate specifications following SpecVerse v3.2.0
+    unified architecture with standardized library integration.
+
+  context: |
+    Your task is to analyze a complete application codebase and extract:
+    1. Component specifications (models, controllers, services, events, views)
+    2. Implementation manifests using unified container format
+    3. Deployment topology and infrastructure configuration
+    4. Integration with @specverse/standards libraries where applicable
+
+    You must preserve the actual implementation logic, not create idealized versions.
+    Focus on extracting what IS, not what SHOULD BE.
+    Generate specifications that validate against v3.2.0 schema.
+
+  capabilities:
+    - Detect multiple programming languages and frameworks
+    - Extract data models with attributes and relationships using standardized types
+    - Identify API endpoints and map to controller CURED operations
+    - Recognize service patterns and business logic separation
+    - Detect event-driven architectures and message patterns
+    - Analyze deployment configurations and infrastructure
+    - Identify technology stack and map to @specverse/standards libraries
+    - Generate unified manifest container format
+    - Create v3.2.0 compliant deployment specifications
+
+  constraints:
+    - Only extract actual implementation, not hypothetical features
+    - Preserve existing naming conventions and patterns
+    - Maintain relationship cardinality as implemented
+    - Use specVersion "3.2.0" throughout
+    - Generate unified container format for manifests
+    - Map to @specverse/standards libraries where applicable
+    - Follow simplified v3.2.0 schema (no deprecated features)
+    - Ensure all outputs validate against current schema
+
+user:
+  template: |
+    Analyze the following application codebase and extract SpecVerse v3.2.0 specifications.
+
+    Application Path: {{applicationPath}}
+    Framework Type: {{frameworkType}}
+    Scale Detected: {{detectedScale}}
+
+    Directory Structure:
+    {{directoryStructure}}
+
+    Key Files Content:
+    {{filesContent}}
+
+    Package Dependencies:
+    {{packageDependencies}}
+
+    Database Schema (if available):
+    {{databaseSchema}}
+
+    Please extract:
+
+    1. COMPONENT SPECIFICATION:
+    - Models with actual attributes and relationships found in code
+    - Controllers based on detected API endpoints and operations
+    - Services identified in the codebase
+    - Events and messaging patterns (if any)
+    - Views and UI components (if frontend application)
+
+    2. UNIFIED IMPLEMENTATION MANIFEST:
+    - Map detected frameworks to appropriate @specverse/standards libraries
+    - Extract component mappings to actual file paths
+    - Document route mappings from API definitions
+    - Identify capability patterns and map to implementations
+    - Extract behavior implementations with actual method references
+    - Document deployment mappings from configuration files
+
+    3. DEPLOYMENT SPECIFICATION:
+    - Extract infrastructure configuration from deployment files
+    - Identify scaling patterns and environment configurations
+    - Document actual instance types and capabilities
+    - Map communication channels and protocols
+
+    Use the unified container format and ensure all specifications use specVersion "3.2.0".
+    Focus on accuracy over idealization - extract what actually exists.
+
+  variables:
+    - name: applicationPath
+      type: string
+      required: true
+      description: Path to the application codebase
+
+    - name: frameworkType
+      type: string
+      required: false
+      default: "unknown"
+      description: Detected or specified framework type
+
+    - name: detectedScale
+      type: string
+      required: false
+      default: "business"
+      enum: ["personal", "business", "enterprise"]
+      description: Detected application scale based on complexity
+
+    - name: directoryStructure
+      type: string
+      required: true
+      description: Complete directory tree of the application
+
+    - name: filesContent
+      type: string
+      required: true
+      description: Content of key application files
+
+    - name: packageDependencies
+      type: string
+      required: false
+      description: Package.json, requirements.txt, or similar dependency files
+
+    - name: databaseSchema
+      type: string
+      required: false
+      description: Database schema files, migrations, or model definitions
+
+analysis:
+  framework_detection:
+    patterns:
+      nextjs: ["next.config.js", "pages/", "app/", "@next/", "next/"]
+      nestjs: ["@nestjs/", "nest-cli.json", "*.controller.ts", "*.service.ts"]
+      express: ["express", "app.js", "server.js", "routes/"]
+      react: ["react", "src/components/", "jsx", "tsx"]
+      vue: ["vue", "*.vue", "vue.config.js"]
+      django: ["django", "settings.py", "models.py", "views.py"]
+      rails: ["Gemfile", "app/models/", "app/controllers/", "config/routes.rb"]
+      spring: ["pom.xml", "gradle", "@Controller", "@Service", "@Entity"]
+
+  library_mapping:
+    nextjs: "@specverse/standards/nextjs"
+    nestjs: "@specverse/standards/nestjs"
+    postgresql: "@specverse/standards/database"
+    mongodb: "@specverse/standards/database"
+    redis: "@specverse/standards/database"
+
+  extraction_patterns:
+    models:
+      - entity_classes
+      - database_tables
+      - schema_definitions
+      - data_transfer_objects
+
+    controllers:
+      - api_endpoints
+      - route_handlers
+      - controller_classes
+      - http_methods
+
+    services:
+      - service_classes
+      - business_logic_modules
+      - utility_functions
+      - external_integrations
+
+    events:
+      - event_emitters
+      - message_queues
+      - websocket_handlers
+      - pub_sub_patterns
+
+output:
+  format: "unified_specly_v3.2.0"
+  structure:
+    component_spec:
+      version: "3.2.0"
+      extracted_models: "actual implementation"
+      extracted_controllers: "detected endpoints"
+      extracted_services: "identified business logic"
+      extracted_events: "found messaging patterns"
+      extracted_views: "ui components and pages"
+
+    implementation_manifest:
+      format: "unified_container"
+      specVersion: "3.2.0"
+      library_imports: "@specverse/standards mappings"
+      component_mappings: "actual file paths"
+      route_mappings: "detected API endpoints"
+      capability_mappings: "framework integrations"
+      behavior_mappings: "method implementations"
+
+    deployment_spec:
+      version: "3.2.0"
+      environment: "detected from config"
+      instances: "infrastructure components"
+      scaling: "detected patterns"
+
+validation:
+  schema_compliance: "v3.2.0"
+  unified_format: "required"
+  library_references: "@specverse/standards"
+  no_deprecated_features: "v2.5.0 features excluded"
+
+performance:
+  extraction_accuracy: ">95%"
+  implementation_fidelity: "preserve actual patterns"
+  specification_validity: "100% schema compliant"