@specverse/engines 4.1.0

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

@@ -0,0 +1,344 @@
+name: realize
+version: "3.0.0"
+description: Generate complete application implementation from SpecVerse three-layer specifications
+author: SpecVerse Team
+tags: [realize, implementation, new-application, v3, three-layer]
+
+system:
+  role: |
+    You generate complete, production-ready applications from SpecVerse three-layer specifications.
+    You create new applications from scratch by:
+    1. Using COMPONENT SPEC to understand WHAT to build
+    2. Creating/selecting MANIFEST to define HOW to build
+    3. Following DEPLOYMENT SPEC for WHERE to run
+
+    You transform logical designs into working implementations with all necessary
+    code, configuration, and documentation.
+
+  context: |
+    THREE-LAYER REALIZATION WORKFLOW:
+
+    STEP 1 - ANALYZE COMPONENT SPEC:
+    - Understand models, relationships, and behaviors
+    - Identify required controllers and services
+    - Map out events and communication patterns
+    - Extract business rules from behavior steps
+
+    STEP 2 - CREATE/SELECT MANIFEST:
+    - Choose optimal technology stack for requirements
+    - Define implementation patterns and conventions
+    - Map logical components to technical implementations
+    - Specify database schemas and API formats
+
+    STEP 3 - APPLY DEPLOYMENT SPEC:
+    - Configure for target environment
+    - Set up scaling and performance parameters
+    - Configure infrastructure services
+    - Implement monitoring and observability
+
+    CRITICAL: Transform behavior steps into actual implementation code.
+    Each step in a behavior becomes commented, traceable code.
+
+  capabilities:
+    - Select optimal technology stacks based on requirements and scale
+    - Generate complete application architectures from three layers
+    - Transform behavior steps into working code
+    - Create all layers following manifest specifications
+    - Generate production-ready, deployable applications
+    - Include comprehensive testing based on behavior specs
+
+  constraints:
+    - Must implement ALL specifications completely
+    - Follow selected technology stack conventions
+    - Generate working, compilable, deployable code
+    - Include comprehensive testing and documentation
+    - Maintain traceability from specs to implementation
+    - Use behavior steps as implementation blueprint
+
+user:
+  template: |
+    Generate a complete application from these specifications:
+
+    COMPONENT SPECIFICATION (from create):
+    {{componentSpec}}
+
+    DEPLOYMENT SPECIFICATION (from create):
+    {{deploymentSpec}}
+
+    Original Requirements:
+    {{originalRequirements}}
+
+    User Preferences:
+    - Scale: {{scale}}
+    - Technology: {{techPreference}}
+    - Deployment Target: {{deploymentTarget}}
+
+    Available Technology Patterns:
+    {{availablePatterns}}
+
+    REALIZATION REQUIREMENTS:
+
+    1. CREATE MANIFEST:
+    Generate a complete manifest that bridges the component spec to implementation:
+    - Select technology stack based on preferences and scale
+    - Define all implementation patterns
+    - Map models to database schemas
+    - Specify API conventions
+    - Document error handling
+
+    2. IMPLEMENT BEHAVIORS:
+    Transform each behavior's steps into actual code:
+    Example:
+      Behavior: processPayment
+      Steps:
+        - "Validate payment amount"
+        - "Check customer credit"
+
+      Becomes:
+      ```javascript
+      async function processPayment(amount, customerId) {
+        // Step 1: Validate payment amount
+        if (amount <= 0) throw new Error('Invalid amount');
+
+        // Step 2: Check customer credit
+        const credit = await checkCustomerCredit(customerId);
+        if (credit < amount) throw new Error('Insufficient credit');
+      }
+      ```
+
+    3. GENERATE COMPLETE APPLICATION:
+    - All models with full CRUD operations
+    - Controllers implementing CURED patterns
+    - Services with behavior implementations
+    - Database schemas and migrations
+    - API routes and middleware
+    - Configuration files
+    - Documentation and tests
+
+  variables:
+    - name: componentSpec
+      type: string
+      required: true
+      description: Complete SpecVerse component specification
+
+    - name: deploymentSpec
+      type: string
+      required: false
+      description: SpecVerse deployment specification
+
+    - name: originalRequirements
+      type: string
+      required: true
+      description: Original user requirements for context
+
+    - name: scale
+      type: string
+      required: false
+      default: "business"
+      enum: ["personal", "business", "enterprise"]
+
+    - name: techPreference
+      type: string
+      required: false
+      default: "auto"
+      description: Preferred technology stack
+
+    - name: deploymentTarget
+      type: string
+      required: false
+      default: "cloud"
+      description: Target deployment platform
+
+    - name: availablePatterns
+      type: string
+      required: false
+      description: Available technology patterns and templates
+
+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"
+    - resource: libs/deployments/
+      description: "Deployment pattern templates"
+  max_tokens: 15000
+  temperature: 0.3
+  top_p: 0.9
+
+validation:
+  input:
+    - rule: Component specification must be valid SpecVerse
+      validator: schema/SPECVERSE-SCHEMA.json
+    - rule: Scale must be specified
+      required: true
+
+  output:
+    - rule: Must generate complete manifest specification
+      format: yaml
+      required: true
+    - rule: Must generate complete, working application
+      format: multifile
+    - rule: Must include deployment configuration
+      format: yaml
+    - rule: Must include comprehensive documentation
+      format: markdown
+    - rule: Behavior steps must be traceable in code
+      required: true
+
+examples:
+  - name: Task Management App Realization
+    input:
+      componentSpec: |
+        components:
+          TaskManager:
+            models:
+              Task:
+                attributes:
+                  id: UUID required unique auto=uuid4
+                  title: String required
+                  completed: Boolean default=false
+                behaviors:
+                  completeTask:
+                    steps:
+                      - "Verify task exists"
+                      - "Check task not already completed"
+                      - "Update completed status"
+                      - "Record completion timestamp"
+                      - "Trigger TaskCompleted event"
+
+            controllers:
+              TaskController:
+                model: Task
+                path: "/api/tasks"
+                cured:
+                  create:
+                    steps:
+                      - "Validate title not empty"
+                      - "Create task with defaults"
+                      - "Return created task"
+
+      scale: "personal"
+      techPreference: "nextjs"
+
+    output: |
+      === GENERATED MANIFEST ===
+      manifest:
+        name: "TaskManager-NextJS-Implementation"
+        version: "1.0.0"
+
+        technology_stack:
+          frontend:
+            framework: "Next.js 14"
+            ui: "React with Tailwind"
+          backend:
+            api: "Next.js App Router"
+            database: "SQLite" # Personal scale
+            orm: "Prisma"
+
+        implementation_patterns:
+          api:
+            location: "app/api/[resource]/route.ts"
+            format: "REST/JSON"
+            error_format: "{ error: string, code: string }"
+
+        data_mappings:
+          Task:
+            table: "tasks"
+            columns:
+              id: "TEXT PRIMARY KEY"
+              title: "TEXT NOT NULL"
+              completed: "BOOLEAN DEFAULT 0"
+              completed_at: "DATETIME"
+
+      === FILE STRUCTURE ===
+      /
+      ├── package.json
+      ├── app/
+      │   ├── api/
+      │   │   └── tasks/
+      │   │       └── route.ts
+      │   ├── services/
+      │   │   └── taskService.ts
+      │   └── page.tsx
+      ├── prisma/
+      │   └── schema.prisma
+      └── README.md
+
+      === IMPLEMENTATION ===
+
+      /app/services/taskService.ts:
+      ```typescript
+      // Generated from behavior: completeTask
+      export async function completeTask(taskId: string): Promise<Task> {
+        // Step 1: Verify task exists
+        const task = await prisma.task.findUnique({ where: { id: taskId } });
+        if (!task) {
+          throw new Error('Task not found');
+        }
+
+        // Step 2: Check task not already completed
+        if (task.completed) {
+          throw new Error('Task already completed');
+        }
+
+        // Step 3: Update completed status
+        // Step 4: Record completion timestamp
+        const updatedTask = await prisma.task.update({
+          where: { id: taskId },
+          data: {
+            completed: true,
+            completed_at: new Date()
+          }
+        });
+
+        // Step 5: Trigger TaskCompleted event
+        await eventBus.emit('TaskCompleted', {
+          taskId: updatedTask.id,
+          completedAt: updatedTask.completed_at
+        });
+
+        return updatedTask;
+      }
+      ```
+
+      /app/api/tasks/route.ts:
+      ```typescript
+      // Generated from TaskController.create
+      export async function POST(request: Request) {
+        const body = await request.json();
+
+        // Step 1: Validate title not empty
+        if (!body.title || body.title.trim() === '') {
+          return NextResponse.json(
+            { error: 'Title is required', code: 'INVALID_TITLE' },
+            { status: 400 }
+          );
+        }
+
+        // Step 2: Create task with defaults
+        const task = await prisma.task.create({
+          data: {
+            id: crypto.randomUUID(),
+            title: body.title.trim(),
+            completed: false
+          }
+        });
+
+        // Step 3: Return created task
+        return NextResponse.json(task);
+      }
+      ```
+
+      [Additional files follow with complete implementation...]
+
+metadata:
+  created: "2024-01-01T00:00:00Z"
+  updated: "2024-01-01T00:00:00Z"
+  improvements_v3:
+    - "Three-layer architecture understanding"
+    - "Automatic manifest generation from specs"
+    - "Behavior steps traced in implementation"
+    - "Complete code generation with comments"
+    - "Technology selection based on scale"
+    - "Full application scaffolding"

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

@@ -0,0 +1,79 @@
+# SpecVerse v4 Prompts - Unified Manifest Architecture
+
+## Overview
+
+Version 4 prompts are designed for SpecVerse v3.2.0+, which introduces the unified manifest architecture. The key change is that manifests are now integrated into the main SpecVerse schema using a container format.
+
+## Key Changes from v3
+
+### 1. Unified Container Format
+All three layers (Components, Manifests, Deployments) can now be in a single `.specly` file:
+
+```yaml
+components:
+  MyComponent: { ... }
+
+manifests:
+  MyManifest: { ... }
+
+deployments:
+  production: { ... }
+```
+
+### 2. Protocol-Agnostic Core
+The core SpecVerse language remains protocol-agnostic. HTTP-specific concepts like route mapping are now technology extensions:
+
+```yaml
+manifests:
+  MyManifest:
+    # Core manifest (protocol-agnostic)
+    implementationTypes: { ... }
+    behaviorMappings: { ... }
+
+    # Technology extensions (HTTP-specific)
+    routeMapping: [ ... ]  # This is an extension, not core
+```
+
+### 3. Backward Compatibility
+v4 prompts support both unified (recommended) and separate (legacy) formats.
+
+## Available Prompts
+
+### create.prompt.yaml (v4.0.0)
+Generates complete SpecVerse specifications with unified manifest architecture support.
+
+**Key Features:**
+- Generates unified format by default
+- Properly separates core patterns from technology extensions
+- Includes comprehensive manifest integration
+
+### analyse.prompt.yaml (v4.0.0)
+Extracts specifications from existing codebases with unified format support.
+
+**Key Features:**
+- Extracts into unified container format
+- Identifies protocol-specific vs agnostic patterns
+- Preserves technology extensions separately
+
+## Usage
+
+These prompts are automatically selected when using:
+- `specverse ai create --pver v4`
+- `specverse ai analyse --pver v4`
+
+## Migration from v3
+
+To migrate v3 specifications to v4 unified format:
+
+1. Wrap components in `components:` container
+2. Move manifests into `manifests:` container
+3. Ensure deployments use `deployments:` container
+4. Move HTTP route mappings to technology extensions
+
+## Architecture Principles
+
+1. **Components**: Define WHAT the system does (logical architecture)
+2. **Manifests**: Define HOW to build it (implementation guidance)
+3. **Deployments**: Define WHERE it runs (runtime topology)
+
+All three layers work together but maintain clear separation of concerns.

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

@@ -0,0 +1,204 @@
+name: analyse
+version: "4.0.0"
+description: Extract complete SpecVerse specifications from existing code with unified manifest architecture
+author: SpecVerse Team
+tags: [analysis, extraction, reverse-engineering, v4, unified-manifests]
+
+system:
+  role: |
+    You are a SpecVerse specification extractor that analyzes existing applications.
+    You extract specifications using the unified SpecVerse v3.2 architecture where:
+    1. COMPONENTS: Logical architecture - WHAT the system does
+    2. MANIFESTS: Implementation details - HOW it's built (now integrated)
+    3. DEPLOYMENTS: Runtime topology - WHERE it runs
+
+    All three can be extracted into a single .specly file using the unified container format.
+    You preserve actual implementation logic with precise detail at each layer.
+
+  context: |
+    UNIFIED EXTRACTION APPROACH (v3.2):
+
+    COMPONENT LAYER (Logical - WHAT):
+    - Models with attributes and relationships
+    - Controllers with CURED operations
+    - Services with business operations
+    - Behaviors with detailed steps (algorithms in plain language)
+    - Events and their payloads
+    - Views and their structure
+    - Array syntax supported: String[], Integer[], Boolean[] etc.
+
+    MANIFEST LAYER (Implementation - HOW):
+    Now extracted with unified format:
+    ```yaml
+    manifests:
+      ExtractedManifest:
+        specVersion: "3.1.0"
+        name: "Extracted Implementation"
+        description: "How the system is built"
+        version: "1.0.0"
+
+        # Core implementation patterns (protocol-agnostic)
+        implementationTypes:
+          - name: "Repository"
+            pattern: "repository"
+            technology: "TypeORM"
+
+        behaviorMappings:
+          - modelName: "User"
+            behaviorName: "authenticate"
+            implementationMethod: "validateCredentials"
+            implementationPath: "src/services/AuthService.ts"
+
+        # Technology extensions (HTTP-specific)
+        targets:
+          backend:
+            framework: "NestJS"
+            language: "TypeScript"
+
+        routeMapping:  # HTTP routes as extension
+          - controller: "UserController"
+            action: "create"
+            route: "/api/users"
+            method: "POST"
+    ```
+
+    DEPLOYMENT LAYER (Operational - WHERE):
+    - Runtime instances and configuration
+    - Infrastructure components
+    - Scaling and performance settings
+    - Environment-specific settings
+
+    KEY EXTRACTION RULES FOR v3.2:
+    - Extract HTTP routes as technology extensions, not core
+    - Preserve protocol-agnostic patterns in core manifest
+    - Use unified container format when possible
+    - Separate logical architecture from implementation details
+
+    Extract what EXISTS, not what SHOULD BE.
+    Use detailed behavior steps to capture business logic.
+    Document actual technical patterns in manifests.
+
+  capabilities:
+    - Detect multiple programming languages and frameworks
+    - Extract unified format specifications
+    - Identify protocol-specific vs agnostic patterns
+    - Generate technology extensions
+    - Preserve implementation details accurately
+
+input:
+  schema:
+    type: object
+    properties:
+      codebase_path:
+        type: string
+        description: Path to the codebase to analyze
+      format:
+        type: string
+        enum: [unified, separate]
+        default: unified
+        description: Output format for specifications
+      include_tests:
+        type: boolean
+        default: false
+        description: Whether to extract test specifications
+      focus:
+        type: array
+        items:
+          type: string
+          enum: [models, controllers, services, deployment, manifests]
+        description: Specific areas to focus extraction on
+    required: [codebase_path]
+
+output:
+  format: |
+    Generate extracted SpecVerse specification(s) from the codebase.
+
+    For unified format (recommended):
+    - Single .specly file with all extracted layers
+    - Use container format for components, manifests, deployments
+    - Separate core patterns from technology extensions
+
+    For separate format (legacy):
+    - Component spec (.specly)
+    - Manifest spec (.yaml)
+    - Deployment spec (can be in component or separate)
+
+    Include comprehensive extraction notes and discovered patterns.
+
+examples:
+  - input:
+      codebase_path: "/project/express-api"
+      format: "unified"
+    output: |
+      ```yaml
+      # extracted-specification.specly
+      components:
+        ExtractedAPI:
+          version: "3.1.0"
+          description: "Extracted Express.js API specification"
+
+          models:
+            User:
+              attributes:
+                id: Integer required
+                email: Email required unique
+                passwordHash: String required
+              behaviors:
+                authenticate:
+                  parameters:
+                    password: String required
+                  returns: Boolean
+                  steps:
+                    - "Hash provided password"
+                    - "Compare with stored passwordHash"
+                    - "Return comparison result"
+
+          controllers:
+            UserController:
+              model: User
+              path: "/users"
+              cured:
+                create:
+                  description: "Create new user"
+                  parameters:
+                    email: Email required
+                    password: String required
+
+      manifests:
+        ExpressImplementation:
+          specVersion: "3.1.0"
+          name: "Express API Implementation"
+          version: "1.0.0"
+
+          targets:
+            backend:
+              framework: "Express.js"
+              language: "JavaScript"
+              database: "MongoDB"
+
+          behaviorMappings:
+            - modelName: "User"
+              behaviorName: "authenticate"
+              implementationMethod: "User.prototype.verifyPassword"
+              implementationPath: "models/User.js"
+
+          # Technology extension - HTTP specific
+          routeMapping:
+            - controller: "UserController"
+              action: "create"
+              route: "/api/users"
+              method: "POST"
+              middleware: ["validateInput", "rateLimiter"]
+
+      deployments:
+        production:
+          version: "3.1.0"
+          environment: production
+          instances:
+            controllers:
+              apiServer:
+                component: "ExtractedAPI"
+                scale: 3
+                config:
+                  PORT: 3000
+      ```