@exaudeus/workrail 0.0.2 → 0.0.4

package/spec/examples/conditional-workflow-example.json

@@ -0,0 +1,216 @@
+{
+  "id": "adaptive-development-workflow",
+  "name": "Adaptive Development Workflow",
+  "description": "A dynamic workflow that adapts steps based on task complexity, user expertise, and project scope",
+  "version": "0.0.1",
+  "preconditions": [
+    "Development environment is set up",
+    "Task requirements are understood",
+    "User has provided scope and expertise level"
+  ],
+  "clarificationPrompts": [
+    "What is the scope of this task? (small/medium/large)",
+    "What is your expertise level? (novice/intermediate/expert)",
+    "How complex is this task on a scale of 0.1 to 1.0?",
+    "Do you prefer detailed guidance or minimal steps?",
+    "Are there specific constraints or requirements?"
+  ],
+  "steps": [
+    {
+      "id": "basic-setup",
+      "title": "Basic Project Setup",
+      "prompt": "**PREP**: Review the project structure and requirements.\n\n**IMPLEMENT**: Set up the basic project structure, dependencies, and configuration files.\n\n**VERIFY**: Confirm all basic setup is complete and ready for development.",
+      "requireConfirmation": true
+    },
+    {
+      "id": "detailed-analysis",
+      "title": "Detailed Requirements Analysis",
+      "prompt": "**PREP**: Gather all available documentation and requirements.\n\n**IMPLEMENT**: Perform comprehensive analysis of requirements, edge cases, and potential challenges.\n\n**VERIFY**: Document findings and confirm understanding with stakeholders.",
+      "runCondition": {
+        "or": [
+          {"var": "taskScope", "equals": "large"},
+          {"var": "complexity", "gte": 0.7}
+        ]
+      },
+      "askForFiles": true,
+      "requireConfirmation": true,
+      "validationCriteria": [
+        {
+          "type": "contains",
+          "value": "requirements",
+          "message": "Should include requirements analysis"
+        },
+        {
+          "type": "contains",
+          "value": "edge cases",
+          "condition": {
+            "var": "complexity",
+            "gte": 0.8
+          },
+          "message": "Should analyze edge cases for complex tasks"
+        },
+        {
+          "type": "length",
+          "min": 200,
+          "condition": {
+            "var": "taskScope",
+            "equals": "large"
+          },
+          "message": "Large tasks require detailed analysis"
+        }
+      ]
+    },
+    {
+      "id": "quick-implementation",
+      "title": "Quick Implementation",
+      "prompt": "**PREP**: Review the straightforward requirements.\n\n**IMPLEMENT**: Implement the feature using standard patterns and best practices.\n\n**VERIFY**: Test the implementation and ensure it meets requirements.",
+      "runCondition": {
+        "and": [
+          {"var": "taskScope", "equals": "small"},
+          {"var": "complexity", "lt": 0.5}
+        ]
+      }
+    },
+    {
+      "id": "architecture-design",
+      "title": "Architecture Design",
+      "prompt": "**PREP**: Analyze the system architecture and design patterns.\n\n**IMPLEMENT**: Design the architecture for the new feature, considering scalability and maintainability.\n\n**VERIFY**: Review the design for completeness and alignment with system architecture.",
+      "runCondition": {
+        "and": [
+          {"var": "taskScope", "not_equals": "small"},
+          {"var": "userExpertise", "not_equals": "novice"}
+        ]
+      },
+      "askForFiles": true,
+      "requireConfirmation": true
+    },
+    {
+      "id": "novice-guided-implementation",
+      "title": "Step-by-Step Guided Implementation",
+      "prompt": "**PREP**: Break down the implementation into small, manageable steps.\n\n**IMPLEMENT**: Follow the detailed implementation guide with explanations for each step.\n\n**VERIFY**: Confirm each step is completed correctly before proceeding.",
+      "runCondition": {
+        "var": "userExpertise", 
+        "equals": "novice"
+      },
+      "askForFiles": true,
+      "requireConfirmation": true
+    },
+    {
+      "id": "expert-implementation",
+      "title": "Expert Implementation",
+      "prompt": "**PREP**: Review the requirements and architecture.\n\n**IMPLEMENT**: Implement the feature using advanced patterns and optimizations as appropriate.\n\n**VERIFY**: Ensure implementation follows best practices and is production-ready.",
+      "runCondition": {
+        "var": "userExpertise", 
+        "equals": "expert"
+      },
+      "askForFiles": true,
+      "validationCriteria": [
+        {
+          "type": "regex",
+          "pattern": "\\b(pattern|design|architecture)\\b",
+          "condition": {
+            "var": "userExpertise",
+            "equals": "expert"
+          },
+          "message": "Expert implementation should use advanced patterns"
+        },
+        {
+          "type": "contains",
+          "value": "optimization",
+          "condition": {
+            "var": "complexity",
+            "gte": 0.6
+          },
+          "message": "Should include optimizations for complex features"
+        },
+        {
+          "type": "regex",
+          "pattern": "(?!.*TODO)",
+          "message": "Should not contain TODO items"
+        }
+      ]
+    },
+    {
+      "id": "comprehensive-testing",
+      "title": "Comprehensive Testing",
+      "prompt": "**PREP**: Identify all test scenarios including edge cases.\n\n**IMPLEMENT**: Create comprehensive test suite covering unit, integration, and end-to-end tests.\n\n**VERIFY**: Run all tests and ensure coverage meets quality standards.",
+      "runCondition": {
+        "or": [
+          {"var": "taskScope", "equals": "large"},
+          {"var": "userExpertise", "equals": "expert"}
+        ]
+      },
+      "requireConfirmation": true,
+      "validationCriteria": [
+        {
+          "type": "regex",
+          "pattern": "\\b(unit test|integration test|end-to-end)\\b",
+          "message": "Should include comprehensive test types"
+        },
+        {
+          "type": "regex",
+          "pattern": "\\b(describe|it|test|spec)\\b",
+          "message": "Should include proper test structure"
+        },
+        {
+          "type": "contains",
+          "value": "coverage",
+          "condition": {
+            "var": "taskScope",
+            "equals": "large"
+          },
+          "message": "Large tasks should include coverage analysis"
+        }
+      ]
+    },
+    {
+      "id": "basic-testing",
+      "title": "Basic Testing",
+      "prompt": "**PREP**: Identify core functionality to test.\n\n**IMPLEMENT**: Create basic tests for the main functionality.\n\n**VERIFY**: Run tests and fix any issues found.",
+      "runCondition": {
+        "and": [
+          {"var": "taskScope", "not_equals": "large"},
+          {"var": "userExpertise", "not_equals": "expert"}
+        ]
+      }
+    },
+    {
+      "id": "performance-optimization",
+      "title": "Performance Optimization",
+      "prompt": "**PREP**: Profile the implementation and identify bottlenecks.\n\n**IMPLEMENT**: Optimize performance using appropriate techniques and patterns.\n\n**VERIFY**: Measure performance improvements and ensure they meet requirements.",
+      "runCondition": {
+        "and": [
+          {"var": "taskScope", "equals": "large"},
+          {"var": "complexity", "gte": 0.8}
+        ]
+      },
+      "askForFiles": true,
+      "requireConfirmation": true
+    },
+    {
+      "id": "documentation",
+      "title": "Documentation",
+      "prompt": "**PREP**: Review all implemented features and changes.\n\n**IMPLEMENT**: Create comprehensive documentation for the new feature.\n\n**VERIFY**: Ensure documentation is clear, complete, and helpful for future maintenance.",
+      "runCondition": {
+        "var": "taskScope", 
+        "not_equals": "small"
+      }
+    },
+    {
+      "id": "final-review",
+      "title": "Final Review and Cleanup",
+      "prompt": "**PREP**: Review all changes and ensure completeness.\n\n**IMPLEMENT**: Perform final cleanup, code review, and quality checks.\n\n**VERIFY**: Confirm all requirements are met and the implementation is ready for deployment.",
+      "requireConfirmation": true
+    }
+  ],
+  "metaGuidance": [
+    "Always follow the prep/implement/verify pattern for each step",
+    "Adapt the level of detail based on user expertise",
+    "Skip steps that don't apply to the current task scope",
+    "Focus on quality over speed for complex tasks",
+    "Provide more guidance for novice users",
+    "Allow expert users to work with minimal constraints",
+    "Test thoroughly based on the complexity and scope",
+    "Document appropriately for the task size"
+  ]
+} 

package/spec/examples/invalid-workflow.json

@@ -0,0 +1,20 @@
+{
+  "id": "INVALID_ID_WITH_CAPS",
+  "name": "",
+  "description": "This workflow has multiple validation errors",
+  "version": "0.0.1",
+  "preconditions": [
+    "Valid precondition",
+    ""
+  ],
+  "clarificationPrompts": [
+    "Valid question?",
+    "Valid question?"
+  ],
+  "steps": [],
+  "metaGuidance": [
+    "This is a valid guidance",
+    "This is a valid guidance"
+  ],
+  "extraField": "This field is not allowed"
+}

package/spec/examples/valid-workflow.json

@@ -0,0 +1,118 @@
+{
+  "id": "simple-auth-implementation",
+  "name": "Simple Authentication Implementation",
+  "description": "Implement basic JWT authentication for a REST API with user login and token validation",
+  "version": "0.0.1",
+  "preconditions": [
+    "User model exists in the database",
+    "JWT library is installed in the project",
+    "Environment variables for JWT_SECRET are configured"
+  ],
+  "clarificationPrompts": [
+    "What is the token expiration time you want to use?",
+    "Should the authentication support refresh tokens?",
+    "Do you need role-based access control?"
+  ],
+  "steps": [
+    {
+      "id": "analyze-current-auth",
+      "title": "Analyze current authentication setup",
+      "prompt": "Examine the existing authentication implementation if any. Look for: user model structure, existing auth middleware, login endpoints. Document what you find.",
+      "requireConfirmation": true
+    },
+    {
+      "id": "create-auth-middleware",
+      "title": "Create authentication middleware",
+      "prompt": "Create a middleware function that extracts and validates JWT tokens from the Authorization header. Return 401 for invalid tokens.",
+      "askForFiles": true,
+      "validationCriteria": [
+        {
+          "type": "contains",
+          "value": "jwt",
+          "message": "Implementation should include JWT token handling"
+        },
+        {
+          "type": "contains",
+          "value": "Authorization",
+          "message": "Should extract token from Authorization header"
+        },
+        {
+          "type": "regex",
+          "pattern": "\\b(401|unauthorized)\\b",
+          "flags": "i",
+          "message": "Should return 401 status for invalid tokens"
+        }
+      ]
+    },
+    {
+      "id": "implement-login",
+      "title": "Implement login endpoint",
+      "prompt": "Create a POST /auth/login endpoint that accepts email and password, validates credentials against the database, and returns a JWT token on success.",
+      "validationCriteria": [
+        {
+          "type": "contains",
+          "value": "POST",
+          "message": "Should implement POST endpoint"
+        },
+        {
+          "type": "regex",
+          "pattern": "/(auth/)?login",
+          "message": "Should implement login endpoint"
+        },
+        {
+          "type": "contains",
+          "value": "email",
+          "message": "Should handle email authentication"
+        },
+        {
+          "type": "contains",
+          "value": "password",
+          "message": "Should handle password authentication"
+        },
+        {
+          "type": "contains",
+          "value": "jwt",
+          "message": "Should return JWT token"
+        }
+      ]
+    },
+    {
+      "id": "test-authentication",
+      "title": "Test the authentication flow",
+      "prompt": "Test the complete flow: 1) Login with valid credentials, 2) Use the token to access a protected route, 3) Verify invalid tokens are rejected",
+      "requireConfirmation": true,
+      "validationCriteria": [
+        {
+          "type": "contains",
+          "value": "valid credentials",
+          "condition": {
+            "var": "testType",
+            "equals": "comprehensive"
+          },
+          "message": "Should test login with valid credentials"
+        },
+        {
+          "type": "contains",
+          "value": "protected route",
+          "message": "Should test access to protected routes"
+        },
+        {
+          "type": "contains",
+          "value": "invalid tokens",
+          "message": "Should verify invalid token rejection"
+        },
+        {
+          "type": "regex",
+          "pattern": "\\b(test|spec|describe|it)\\b",
+          "message": "Should include proper test structure"
+        }
+      ]
+    }
+  ],
+  "metaGuidance": [
+    "Always hash passwords using bcrypt or similar",
+    "Include proper error messages for debugging",
+    "Follow RESTful conventions for endpoints",
+    "Add rate limiting to prevent brute force attacks"
+  ]
+}