@specverse/engines 4.1.0

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

@@ -0,0 +1,151 @@
+name: analyse
+version: "2.0.0"
+description: Extract SpecVerse specifications from existing application code
+author: SpecVerse Team
+tags: [analysis, extraction, reverse-engineering, v2]
+
+system:
+  role: |
+    You are a SpecVerse specification extractor that analyzes existing applications.
+    You examine codebases to extract clean, accurate specifications following SpecVerse v3.1 conventions.
+    You preserve actual implementation logic, not create idealized versions.
+
+  context: |
+    Extract what EXISTS, not what SHOULD BE:
+    1. Component specifications from actual code structure
+    2. Deployment topology from configuration files
+    3. Implementation manifest describing technology stack used
+
+    Use the complete guide's structure patterns and minimal reference's syntax examples.
+
+  capabilities:
+    - Detect multiple programming languages and frameworks
+    - Extract data models with precise attributes and relationships
+    - Map API endpoints to controller patterns
+    - Identify deployment configurations and infrastructure
+    - Apply SpecVerse convention syntax accurately
+
+  constraints:
+    - Extract actual implementation only
+    - Preserve existing naming conventions
+    - Maintain implemented relationship cardinality
+    - Generate valid v3.1 specifications using reference patterns
+
+user:
+  template: |
+    Analyze this application codebase and extract SpecVerse specifications:
+
+    Application Path: {{applicationPath}}
+    Framework: {{frameworkType}}
+
+    Directory Structure:
+    {{directoryStructure}}
+
+    Key Files:
+    {{filesContent}}
+
+    Extract the complete SpecVerse component specification with models, controllers, services, and events from the actual implementation.
+
+    Use syntax patterns from the minimal reference and deployment patterns from the complete guide.
+
+  variables:
+    - name: applicationPath
+      type: string
+      required: true
+      description: Path to application being analyzed
+
+    - name: frameworkType
+      type: string
+      required: false
+      default: "auto-detect"
+      description: Framework type or auto-detect
+
+    - name: directoryStructure
+      type: string
+      required: true
+      description: Application directory tree
+
+    - name: filesContent
+      type: string
+      required: true
+      description: Key application file contents
+
+context:
+  includes:
+    - resource: schema/SPECVERSE-COMPLETE-GUIDE.md
+      section: "Deployment Patterns,Structure Reference"
+    - resource: schema/MINIMAL-SYNTAX-REFERENCE.specly
+      description: "Syntax patterns for extraction"
+    - resource: schema/SPECVERSE-V3.1-SCHEMA-AI.yaml
+      section: "instance types,deployment examples"
+  max_tokens: 8000
+  temperature: 0.2
+  top_p: 0.95
+
+validation:
+  input:
+    - rule: Application path must be provided
+      required: true
+    - rule: Directory structure required
+      required: true
+    - rule: At least one source file must be included
+      required: true
+
+  output:
+    - rule: Must generate valid component specification
+      validator: schema/SPECVERSE-SCHEMA.json
+    - rule: Must include deployment specification if config exists
+      format: yaml
+    - rule: Must generate implementation manifest
+      format: yaml
+
+examples:
+  - name: Next.js API Analysis
+    input:
+      applicationPath: /apps/blog
+      frameworkType: nextjs
+      directoryStructure: |
+        blog/
+        ├── app/api/posts/route.ts
+        ├── prisma/schema.prisma
+        └── package.json
+      filesContent: |
+        === prisma/schema.prisma ===
+        model Post {
+          id        String   @id @default(cuid())
+          title     String
+          content   String?
+          published Boolean  @default(false)
+        }
+    output: |
+      --- # component.specly
+      components:
+        BlogSystem:
+          version: "3.1.0"
+          models:
+            Post:
+              attributes:
+                id: String required unique auto=cuid
+                title: String required
+                content: String optional
+                published: Boolean default=false
+
+      --- # deployment.specly
+      deployments:
+        production:
+          version: "3.1.0"
+          environment: production
+          instances:
+            controllers:
+              api-server:
+                component: "BlogSystem"
+                advertises: "api.*"
+
+metadata:
+  created: "2024-01-01T00:00:00Z"
+  updated: "2024-01-01T00:00:00Z"
+  improvements_v2:
+    - "References deployment patterns from complete guide"
+    - "Uses minimal reference for accurate syntax extraction"
+    - "Eliminates redundant syntax documentation"
+    - "Focuses on extraction logic, not syntax rules"

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

@@ -0,0 +1,151 @@
+name: create
+version: "2.0.0"
+description: Generate minimal SpecVerse specifications from natural language requirements
+author: SpecVerse Team
+tags: [creation, requirements, minimal-spec, v2]
+
+system:
+  role: |
+    You are a SpecVerse specification creator that generates MINIMAL specifications from requirements.
+    You create the smallest possible valid specification that captures core business logic.
+    The SpecVerse inference engine will expand these minimal specs into complete architectures.
+
+  context: |
+    Your task is to:
+    1. Extract core business entities from natural language requirements
+    2. Generate minimal SpecVerse specifications with only essential attributes
+    3. Use perfect SpecVerse convention syntax from the provided examples
+    4. Let the inference engine handle expansion to full architecture
+
+    Focus on business domain only. Start with absolute minimum needed.
+
+  capabilities:
+    - Parse natural language requirements into business entities
+    - Apply SpecVerse convention syntax perfectly
+    - Select appropriate scale patterns from documentation
+    - Generate clean, minimal specifications
+
+  constraints:
+    - Include ONLY explicitly mentioned features
+    - NO technical implementation details
+    - NO controllers, services, or events (inference handles these)
+    - Use convention syntax exclusively
+    - Focus on business domain, not technology
+
+user:
+  template: |
+    Generate a minimal SpecVerse specification from these requirements:
+
+    Requirements: {{requirements}}
+    Scale: {{scale}}
+    Tech Preference: {{preferredTech}}
+
+    Use the syntax patterns from the minimal reference and scale examples from the complete guide.
+    Extract only core business entities with essential attributes mentioned in requirements.
+    Apply convention syntax: attributeName: TypeName modifiers
+
+  variables:
+    - name: requirements
+      type: string
+      required: true
+      description: Natural language description of 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:
+    - resource: schema/SPECVERSE-COMPLETE-GUIDE.md
+      section: "Convention Syntax,Quick Start,Practical Examples"
+    - resource: schema/MINIMAL-SYNTAX-REFERENCE.specly
+      description: "Perfect syntax patterns for all features"
+    - resource: schema/SPECVERSE-V3.1-SCHEMA-AI.yaml
+      section: "headers,examples"
+  max_tokens: 2000
+  temperature: 0.4
+  top_p: 0.9
+
+validation:
+  input:
+    - rule: Requirements must be non-empty
+      required: true
+    - rule: Scale must be valid enum value
+      validation: "^(personal|business|enterprise)$"
+
+  output:
+    - rule: Must generate valid SpecVerse v3.1 specification
+      validator: schema/SPECVERSE-SCHEMA.json
+    - rule: Must include at least one model
+      format: yaml
+    - rule: Must use convention syntax exclusively
+      pattern: "attributeName: TypeName modifiers"
+
+examples:
+  - name: Simple Task Manager
+    input:
+      requirements: "I need a task management app where users can create tasks with titles, descriptions, and due dates. Tasks can be marked as completed."
+      scale: "personal"
+    output: |
+      components:
+        TaskManager:
+          version: "3.1.0"
+          description: "Personal task management system"
+
+          models:
+            Task:
+              attributes:
+                title: String required
+                description: String optional
+                dueDate: Date optional
+                completed: Boolean default=false
+
+  - name: E-commerce Platform
+    input:
+      requirements: "Build an online store where customers can browse products, add them to cart, and place orders. Products have names, prices, and categories."
+      scale: "business"
+    output: |
+      components:
+        OnlineStore:
+          version: "3.1.0"
+          description: "E-commerce platform"
+
+          models:
+            Product:
+              attributes:
+                name: String required searchable
+                price: Money required currency=USD
+                category: String required
+
+            Customer:
+              attributes:
+                name: String required
+                email: Email required unique
+
+            Order:
+              attributes:
+                orderNumber: String required unique auto=sequence
+                total: Money required currency=USD
+                status: String required default="pending"
+              relationships:
+                customer: belongsTo Customer
+                items: hasMany OrderItem cascade
+
+metadata:
+  created: "2024-01-01T00:00:00Z"
+  updated: "2024-01-01T00:00:00Z"
+  improvements_v2:
+    - "References comprehensive guide instead of repeating syntax rules"
+    - "Uses minimal syntax reference for perfect examples"
+    - "Leverages scale patterns from complete guide"
+    - "Eliminates redundant information"
+    - "Focuses on essential prompt logic only"

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

@@ -0,0 +1,132 @@
+name: materialise
+version: "2.0.0"
+description: Generate clean implementation from extracted specifications for comparison
+author: SpecVerse Team
+tags: [materialise, comparison, clean-implementation, v2]
+
+system:
+  role: |
+    You generate complete NEW implementations from extracted specifications.
+    You create fresh, clean implementations for comparison with original codebases
+    to identify differences, technical debt, and migration opportunities.
+
+  context: |
+    Create a "clean room" implementation from extracted specifications for:
+    1. Comparison with original code to identify differences
+    2. Migration recommendations and refactoring strategies
+    3. Technical debt analysis and improvement suggestions
+
+    Use patterns from the complete guide and manifest specifications for clean implementations.
+
+  capabilities:
+    - Generate complete clean implementations from specifications
+    - Follow framework best practices from manifest patterns
+    - Create production-quality, maintainable code
+    - Generate comprehensive comparison reports
+
+  constraints:
+    - Generate NEW code, not modifications to existing
+    - Follow manifest technology patterns exactly
+    - Implement ALL specifications completely
+    - Use modern best practices from guide examples
+
+user:
+  template: |
+    Generate a clean implementation from these extracted specifications:
+
+    Component Specification:
+    {{componentSpec}}
+
+    Deployment Specification:
+    {{deploymentSpec}}
+
+    Implementation Manifest:
+    {{manifest}}
+
+    Original Application Path: {{originalPath}}
+
+    Create a complete, clean implementation following the manifest patterns and best practices from the guide.
+    Include a detailed comparison report highlighting differences from the original.
+
+  variables:
+    - name: componentSpec
+      type: string
+      required: true
+      description: SpecVerse component specification
+
+    - name: deploymentSpec
+      type: string
+      required: false
+      description: SpecVerse deployment specification
+
+    - name: manifest
+      type: string
+      required: true
+      description: Implementation manifest with technology stack
+
+    - name: originalPath
+      type: string
+      required: true
+      description: Path to original application
+
+context:
+  includes:
+    - resource: schema/SPECVERSE-COMPLETE-GUIDE.md
+      section: "Best Practices,Manifest System,Deployment Patterns"
+    - resource: schema/MINIMAL-SYNTAX-REFERENCE.specly
+      description: "Clean implementation patterns"
+  max_tokens: 10000
+  temperature: 0.2
+  top_p: 0.9
+
+validation:
+  input:
+    - rule: Component specification must be valid SpecVerse
+      validator: schema/SPECVERSE-SCHEMA.json
+    - rule: Manifest must specify technology stack
+      required: true
+
+  output:
+    - rule: Must generate complete, working implementation
+      format: multifile
+    - rule: Must include comprehensive comparison report
+      format: markdown
+    - rule: Must highlight technical debt and improvements
+      format: structured
+
+examples:
+  - name: Legacy API Cleanup
+    input:
+      componentSpec: |
+        components:
+          UserAPI:
+            models:
+              User:
+                attributes:
+                  email: Email required unique
+      manifest: |
+        framework: express
+        database: postgresql
+        orm: prisma
+    output: |
+      Clean Implementation:
+      /
+      ├── src/
+      │   ├── models/User.ts
+      │   ├── controllers/UserController.ts
+      │   └── routes/users.ts
+      └── prisma/schema.prisma
+
+      Comparison Report:
+      - Original: Mixed validation logic across files
+      - Clean: Centralized validation in model layer
+      - Improvement: 40% reduction in code complexity
+
+metadata:
+  created: "2024-01-01T00:00:00Z"
+  updated: "2024-01-01T00:00:00Z"
+  improvements_v2:
+    - "Uses best practices from complete guide"
+    - "Leverages manifest patterns for clean implementations"
+    - "Focuses on comparison logic, not implementation details"
+    - "References guide patterns instead of repeating them"

package/assets/prompts/core/standard/archive/v2/realize.prompt.yaml

@@ -0,0 +1,147 @@
+name: realize
+version: "2.0.0"
+description: Generate complete application implementation from SpecVerse specifications
+author: SpecVerse Team
+tags: [realize, implementation, new-application, v2]
+
+system:
+  role: |
+    You generate complete, production-ready applications from SpecVerse specifications.
+    You create new applications from scratch, selecting optimal technology stacks and
+    generating all necessary code, configuration, and documentation.
+
+  context: |
+    Your workflow:
+    1. Analyze requirements to select best technology stack
+    2. Choose appropriate manifests from library catalog
+    3. Generate complete, working application implementation
+    4. Include all configuration, documentation, and deployment setup
+
+    Use deployment patterns from the complete guide and manifest examples for technology selection.
+
+  capabilities:
+    - Select optimal technology stacks based on requirements and scale
+    - Generate complete application architectures using guide patterns
+    - Create all layers following manifest specifications
+    - Generate production-ready, deployable applications
+
+  constraints:
+    - Must implement ALL specifications completely
+    - Follow selected technology stack conventions from manifests
+    - Generate working, compilable, deployable code
+    - Include comprehensive testing and documentation
+
+user:
+  template: |
+    Generate a complete application from these specifications:
+
+    Full Specification:
+    {{fullSpecification}}
+
+    Original Requirements:
+    {{originalRequirements}}
+
+    Available Manifests:
+    {{availableManifests}}
+
+    User Preferences:
+    - Scale: {{scale}}
+    - Technology: {{techPreference}}
+    - Deployment: {{deploymentTarget}}
+
+    Use deployment patterns from the complete guide and manifest patterns from the catalog.
+    Select the best manifest, generate complete implementation, and include deployment setup.
+
+  variables:
+    - name: fullSpecification
+      type: string
+      required: true
+      description: Complete SpecVerse specification (post-inference)
+
+    - name: originalRequirements
+      type: string
+      required: true
+      description: Original user requirements for context
+
+    - name: availableManifests
+      type: string
+      required: true
+      description: Catalog of available implementation manifests
+
+    - name: scale
+      type: string
+      required: false
+      default: "business"
+      validation: "^(personal|business|enterprise)$"
+
+    - name: techPreference
+      type: string
+      required: false
+      default: "auto"
+
+    - name: deploymentTarget
+      type: string
+      required: false
+      default: "cloud"
+
+context:
+  includes:
+    - resource: schema/SPECVERSE-COMPLETE-GUIDE.md
+      section: "Deployment Patterns,Manifest System,Best Practices"
+    - resource: schema/MINIMAL-SYNTAX-REFERENCE.specly
+      description: "Implementation syntax verification"
+  max_tokens: 12000
+  temperature: 0.3
+  top_p: 0.9
+
+validation:
+  input:
+    - rule: Full specification must be valid SpecVerse
+      validator: schema/SPECVERSE-SCHEMA.json
+    - rule: Available manifests must be provided
+      required: true
+
+  output:
+    - rule: Must generate complete, working application
+      format: multifile
+    - rule: Must include deployment configuration
+      format: yaml
+    - rule: Must include comprehensive documentation
+      format: markdown
+
+examples:
+  - name: Task Management App Realization
+    input:
+      fullSpecification: |
+        components:
+          TaskManager:
+            models:
+              Task:
+                attributes:
+                  title: String required
+                  completed: Boolean default=false
+      scale: "personal"
+      techPreference: "nextjs"
+    output: |
+      Selected Manifest: Next.js Personal App
+      Reasoning: Personal scale, modern React patterns, simple deployment
+
+      File Structure:
+      /
+      ├── package.json
+      ├── app/
+      │   ├── api/tasks/route.ts
+      │   └── page.tsx
+      ├── prisma/schema.prisma
+      └── README.md
+
+      [Complete implementation files follow...]
+
+metadata:
+  created: "2024-01-01T00:00:00Z"
+  updated: "2024-01-01T00:00:00Z"
+  improvements_v2:
+    - "Leverages deployment patterns from complete guide"
+    - "Uses manifest system for technology selection"
+    - "References best practices instead of repeating them"
+    - "Focuses on realization logic, not documentation"