@exaudeus/workrail 0.0.17 → 0.0.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Etienne Beaulac
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -1,8 +1,8 @@
-# Workflow Orchestration Server (MCP-Compatible)
+# WorkRail: A Workflow Orchestration Server for MCP
 
 > **Reliable, test-driven workflow execution for AI coding assistants – powered by Clean Architecture**
 
-[![Build](https://img.shields.io/github/actions/workflow/status/yourusername/workflow-orchestration/ci.yml?branch=main)]()
+[![Build](https://img.shields.io/github/actions/workflow/status/EtienneBBeaulac/mcp/ci.yml?branch=main)]()
 [![Version](https://img.shields.io/badge/version-0.0.1--alpha-orange)]()
 [![MCP Compatible](https://img.shields.io/badge/MCP-compatible-purple.svg)](https://modelcontextprotocol.org)
 
@@ -108,7 +108,7 @@ Add this to your `claude_desktop_config.json`:
 ```json
 {
   "mcpServers": {
-    "workflow-orchestration": {
+    "workrail": {
       "command": "npx",
       "args": [
         "-y",
@@ -124,10 +124,10 @@ Add this to your `claude_desktop_config.json`:
 ```json
 {
   "mcpServers": {
-    "workflow-orchestration": {
+    "workrail": {
       "command": "node",
       "args": [
-        "/path/to/your/workflow-orchestration/dist/mcp-server.js"
+        "/path/to/your/mcp/packages/workrail/dist/mcp-server.js"
       ]
     }
   }
@@ -144,7 +144,7 @@ For manual installation, add this to your User Settings (JSON) or `.vscode/mcp.j
 {
   "mcp": {
     "servers": {
-      "workflow-orchestration": {
+      "workrail": {
         "command": "npx",
         "args": [
           "-y",
@@ -162,10 +162,10 @@ For manual installation, add this to your User Settings (JSON) or `.vscode/mcp.j
 {
   "mcp": {
     "servers": {
-      "workflow-orchestration": {
+      "workrail": {
         "command": "node",
         "args": [
-          "/path/to/your/workflow-orchestration/dist/mcp-server.js"
+          "/path/to/your/mcp/packages/workrail/dist/mcp-server.js"
         ]
       }
     }
@@ -178,7 +178,7 @@ For manual installation, add this to your User Settings (JSON) or `.vscode/mcp.j
 ## 🗂️ Project Structure (post-refactor)
 
 ```
-workflow-orchestration/
+packages/workrail/
   ├─ src/
   │   ├─ domain/               # Pure entities & errors (no dependencies)
   │   ├─ application/          # Use-cases, services, ValidationEngine (depends on domain)

package/dist/application/app.d.ts

@@ -1,8 +1,3 @@
-/**
- * Lightweight mediator that maps JSON-RPC method names to handler functions.
- * It delegates parameter validation to an injected validator and remains
- * agnostic of transport concerns.
- */
 export type MethodHandler = (params: any) => Promise<any> | any;
 export interface MethodValidator {
     validate(method: string, params: any): void;
@@ -12,7 +7,6 @@ export declare class ApplicationMediator {
     private readonly validateFn;
     constructor(validator: MethodValidator);
     register(method: string, handler: MethodHandler): void;
-    /** Execute a method after validation. */
     execute(method: string, params: any): Promise<any>;
     private responseValidate?;
     setResponseValidator(fn: (method: string, result: any) => void): void;
@@ -29,4 +23,3 @@ export declare const METHOD_NAMES: {
 };
 export type MethodName = typeof METHOD_NAMES[keyof typeof METHOD_NAMES];
 export declare function buildWorkflowApplication(workflowService: WorkflowService, validator?: MethodValidator): ApplicationMediator;
-//# sourceMappingURL=app.d.ts.map

package/dist/application/app.js

@@ -38,9 +38,8 @@ exports.buildWorkflowApplication = buildWorkflowApplication;
 const error_handler_1 = require("../core/error-handler");
 const mcp_types_1 = require("../types/mcp-types");
 class ApplicationMediator {
-    handlers = new Map();
-    validateFn;
     constructor(validator) {
+        this.handlers = new Map();
         this.validateFn = validator.validate.bind(validator);
     }
     register(method, handler) {
@@ -49,23 +48,18 @@ class ApplicationMediator {
         }
         this.handlers.set(method, handler);
     }
-    /** Execute a method after validation. */
     async execute(method, params) {
         const handler = this.handlers.get(method);
         if (!handler) {
             throw new error_handler_1.MCPError(mcp_types_1.MCPErrorCodes.METHOD_NOT_FOUND, 'Method not found', { method });
         }
-        // Perform validation once
         this.validateFn(method, params);
         const result = await handler(params);
-        // Validate output if a response validator is registered
         if (this.responseValidate) {
             this.responseValidate(method, result);
         }
         return result;
     }
-    // Optional response validator injection
-    responseValidate;
     setResponseValidator(fn) {
         this.responseValidate = fn;
     }
@@ -88,18 +82,11 @@ exports.METHOD_NAMES = {
 };
 function buildWorkflowApplication(workflowService, validator = request_validator_1.requestValidator) {
     const app = new ApplicationMediator(validator);
-    // Attach response validator
     app.setResponseValidator((method, result) => response_validator_1.responseValidator.validate(method, result));
-    // ------------------------------------------------------------------------
-    // Create use-case instances with injected dependencies
-    // ------------------------------------------------------------------------
     const listWorkflowsUseCase = (0, list_workflows_1.createListWorkflows)(workflowService);
     const getWorkflowUseCase = (0, get_workflow_1.createGetWorkflow)(workflowService);
     const getNextStepUseCase = (0, get_next_step_1.createGetNextStep)(workflowService);
     const validateStepOutputUseCase = (0, validate_step_output_1.createValidateStepOutput)(workflowService);
-    // ------------------------------------------------------------------------
-    // Workflow tool methods
-    // ------------------------------------------------------------------------
     app.register(exports.METHOD_NAMES.WORKFLOW_LIST, async (_params) => {
         const workflows = await listWorkflowsUseCase();
         return { workflows };
@@ -113,9 +100,6 @@ function buildWorkflowApplication(workflowService, validator = request_validator
     app.register(exports.METHOD_NAMES.WORKFLOW_VALIDATE, async (params) => {
         return validateStepOutputUseCase(params.workflowId, params.stepId, params.output);
     });
-    // ------------------------------------------------------------------------
-    // System/handshake methods – dynamic imports to avoid circular deps
-    // ------------------------------------------------------------------------
     app.register(exports.METHOD_NAMES.INITIALIZE, async (params) => {
         const { initializeHandler } = await Promise.resolve().then(() => __importStar(require('../tools/mcp_initialize')));
         return (await initializeHandler({ id: 0, params, method: 'initialize', jsonrpc: '2.0' })).result;
@@ -130,4 +114,3 @@ function buildWorkflowApplication(workflowService, validator = request_validator
     });
     return app;
 }
-//# sourceMappingURL=app.js.map

package/dist/application/services/enhanced-error-service.d.ts

@@ -1,81 +1,17 @@
 import { ErrorObject } from 'ajv';
-/**
- * Enhanced Error Service
- *
- * Transforms AJV error objects into extremely specific, user-friendly error messages
- * that provide exact field names, locations, and actionable guidance.
- *
- * Based on comprehensive error structure analysis confirming:
- * - 100% of additionalProperties errors provide exact field names
- * - 82% of errors have meaningful instance paths for location tracking
- * - Complete parameter information for all error types
- */
 export declare class EnhancedErrorService {
-    /**
-     * Transform AJV errors into enhanced, user-friendly messages
-     * @param errors Array of AJV ErrorObject instances
-     * @returns Array of enhanced error messages with specific details
-     */
     static enhanceErrors(errors: ErrorObject[]): string[];
-    /**
-     * Prioritize errors by severity and importance
-     * Critical: additionalProperties, required fields
-     * High: type mismatches, pattern violations
-     * Medium: array/object constraints
-     * Low: schema composition errors
-     */
     private static prioritizeErrors;
-    /**
-     * Transform a single AJV error into an enhanced message
-     */
     private static transformError;
-    /**
-     * Convert instancePath to human-readable location description
-     */
     private static getLocationDescription;
-    /**
-     * Handle additionalProperties errors - our primary target
-     * These provide exact field names via params.additionalProperty
-     */
     private static handleAdditionalProperties;
-    /**
-     * Handle required field errors
-     * These provide missing field names via params.missingProperty
-     */
     private static handleRequired;
-    /**
-     * Handle type mismatch errors
-     * These provide expected type via params.type
-     */
     private static handleType;
-    /**
-     * Handle pattern validation errors
-     * These provide the regex pattern via params.pattern
-     */
     private static handlePattern;
-    /**
-     * Handle minimum items array errors
-     */
     private static handleMinItems;
-    /**
-     * Handle maximum items array errors
-     */
     private static handleMaxItems;
-    /**
-     * Handle enum validation errors
-     */
     private static handleEnum;
-    /**
-     * Handle oneOf schema composition errors
-     */
     private static handleOneOf;
-    /**
-     * Handle anyOf schema composition errors
-     */
     private static handleAnyOf;
-    /**
-     * Handle generic/unknown error types
-     */
     private static handleGeneric;
 }
-//# sourceMappingURL=enhanced-error-service.d.ts.map

package/dist/application/services/enhanced-error-service.js

@@ -1,51 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnhancedErrorService = void 0;
-/**
- * Enhanced Error Service
- *
- * Transforms AJV error objects into extremely specific, user-friendly error messages
- * that provide exact field names, locations, and actionable guidance.
- *
- * Based on comprehensive error structure analysis confirming:
- * - 100% of additionalProperties errors provide exact field names
- * - 82% of errors have meaningful instance paths for location tracking
- * - Complete parameter information for all error types
- */
 class EnhancedErrorService {
-    /**
-     * Transform AJV errors into enhanced, user-friendly messages
-     * @param errors Array of AJV ErrorObject instances
-     * @returns Array of enhanced error messages with specific details
-     */
     static enhanceErrors(errors) {
         if (!errors || errors.length === 0) {
             return [];
         }
-        // Sort errors by priority: Critical -> High -> Medium -> Low
         const prioritizedErrors = this.prioritizeErrors(errors);
         return prioritizedErrors.map(error => this.transformError(error));
     }
-    /**
-     * Prioritize errors by severity and importance
-     * Critical: additionalProperties, required fields
-     * High: type mismatches, pattern violations
-     * Medium: array/object constraints
-     * Low: schema composition errors
-     */
     static prioritizeErrors(errors) {
         const priority = {
-            additionalProperties: 1, // Critical - exact field name available
-            required: 1, // Critical - missing required field
-            type: 2, // High - type mismatch
-            pattern: 2, // High - pattern violation
-            minItems: 3, // Medium - array constraints
-            maxItems: 3, // Medium - array constraints
-            minProperties: 3, // Medium - object constraints
-            maxProperties: 3, // Medium - object constraints
-            oneOf: 4, // Low - schema composition
-            anyOf: 4, // Low - schema composition
-            allOf: 4, // Low - schema composition
+            additionalProperties: 1,
+            required: 1,
+            type: 2,
+            pattern: 2,
+            minItems: 3,
+            maxItems: 3,
+            minProperties: 3,
+            maxProperties: 3,
+            oneOf: 4,
+            anyOf: 4,
+            allOf: 4,
         };
         return errors.sort((a, b) => {
             const aPriority = priority[a.keyword] || 5;
@@ -53,9 +29,6 @@ class EnhancedErrorService {
             return aPriority - bPriority;
         });
     }
-    /**
-     * Transform a single AJV error into an enhanced message
-     */
     static transformError(error) {
         const location = this.getLocationDescription(error.instancePath);
         switch (error.keyword) {
@@ -81,16 +54,11 @@ class EnhancedErrorService {
                 return this.handleGeneric(error, location);
         }
     }
-    /**
-     * Convert instancePath to human-readable location description
-     */
     static getLocationDescription(instancePath) {
         if (!instancePath || instancePath === '') {
             return 'at root level';
         }
-        // Remove leading slash
         const path = instancePath.startsWith('/') ? instancePath.slice(1) : instancePath;
-        // Convert paths to human-readable descriptions
         if (path === 'name')
             return "in field 'name'";
         if (path === 'description')
@@ -99,29 +67,21 @@ class EnhancedErrorService {
             return "in field 'version'";
         if (path === 'steps')
             return "in 'steps' array";
-        // Handle array indices: /steps/0 -> "in step 1"
         const stepMatch = path.match(/^steps\/(\d+)$/);
         if (stepMatch && stepMatch[1]) {
             return `in step ${parseInt(stepMatch[1]) + 1}`;
         }
-        // Handle nested step properties: /steps/0/name -> "in step 1, field 'name'"
         const stepFieldMatch = path.match(/^steps\/(\d+)\/(.+)$/);
         if (stepFieldMatch && stepFieldMatch[1] && stepFieldMatch[2]) {
             const stepNumber = parseInt(stepFieldMatch[1]) + 1;
             const fieldPath = stepFieldMatch[2];
-            // Handle validation criteria paths
             if (fieldPath.startsWith('validationCriteria/')) {
                 return `in step ${stepNumber}, validation criteria`;
             }
             return `in step ${stepNumber}, field '${fieldPath}'`;
         }
-        // Fallback: return cleaned path
         return `at '${path.replace(/\//g, '.')}'`;
     }
-    /**
-     * Handle additionalProperties errors - our primary target
-     * These provide exact field names via params.additionalProperty
-     */
     static handleAdditionalProperties(error, location) {
         const fieldName = error.params?.['additionalProperty'];
         if (!fieldName) {
@@ -129,10 +89,6 @@ class EnhancedErrorService {
         }
         return `Unexpected property '${fieldName}' found ${location}. This property is not defined in the workflow schema. Please remove it or check for typos.`;
     }
-    /**
-     * Handle required field errors
-     * These provide missing field names via params.missingProperty
-     */
     static handleRequired(error, location) {
         const missingField = error.params?.['missingProperty'];
         if (!missingField) {
@@ -140,10 +96,6 @@ class EnhancedErrorService {
         }
         return `Missing required field '${missingField}' ${location}. This field is mandatory and must be provided.`;
     }
-    /**
-     * Handle type mismatch errors
-     * These provide expected type via params.type
-     */
     static handleType(error, location) {
         const expectedType = error.params?.['type'];
         if (!expectedType) {
@@ -151,10 +103,6 @@ class EnhancedErrorService {
         }
         return `Invalid data type ${location}. Expected '${expectedType}' but received a different type.`;
     }
-    /**
-     * Handle pattern validation errors
-     * These provide the regex pattern via params.pattern
-     */
     static handlePattern(error, location) {
         const pattern = error.params?.['pattern'];
         if (!pattern) {
@@ -162,9 +110,6 @@ class EnhancedErrorService {
         }
         return `Value ${location} does not match the required pattern: ${pattern}`;
     }
-    /**
-     * Handle minimum items array errors
-     */
     static handleMinItems(error, location) {
         const minItems = error.params?.['limit'];
         if (minItems === undefined) {
@@ -172,9 +117,6 @@ class EnhancedErrorService {
         }
         return `Array ${location} must contain at least ${minItems} item(s).`;
     }
-    /**
-     * Handle maximum items array errors
-     */
     static handleMaxItems(error, location) {
         const maxItems = error.params?.['limit'];
         if (maxItems === undefined) {
@@ -182,9 +124,6 @@ class EnhancedErrorService {
         }
         return `Array ${location} must contain no more than ${maxItems} item(s).`;
     }
-    /**
-     * Handle enum validation errors
-     */
     static handleEnum(error, location) {
         const allowedValues = error.params?.['allowedValues'];
         if (!allowedValues || !Array.isArray(allowedValues)) {
@@ -192,24 +131,14 @@ class EnhancedErrorService {
         }
         return `Value ${location} must be one of: ${allowedValues.map(v => `'${v}'`).join(', ')}`;
     }
-    /**
-     * Handle oneOf schema composition errors
-     */
     static handleOneOf(_error, location) {
         return `Value ${location} must match exactly one of the allowed schema patterns. Please check the workflow schema for valid formats.`;
     }
-    /**
-     * Handle anyOf schema composition errors
-     */
     static handleAnyOf(_error, location) {
         return `Value ${location} must match at least one of the allowed schema patterns. Please check the workflow schema for valid formats.`;
     }
-    /**
-     * Handle generic/unknown error types
-     */
     static handleGeneric(error, location) {
         return `Validation error ${location}: ${error.message || 'Unknown validation error'}`;
     }
 }
 exports.EnhancedErrorService = EnhancedErrorService;
-//# sourceMappingURL=enhanced-error-service.js.map

package/dist/application/services/validation-engine.d.ts

@@ -21,82 +21,17 @@ export interface ValidationResult {
     issues: string[];
     suggestions: string[];
 }
-/**
- * ValidationEngine handles step output validation with support for
- * multiple validation rule types. This engine is responsible for
- * evaluating validation criteria against step outputs.
- */
 export declare class ValidationEngine {
     private ajv;
     private schemaCache;
     constructor();
-    /**
-     * Compiles a JSON schema with caching for performance.
-     *
-     * @param schema - The JSON schema to compile
-     * @returns Compiled schema validator function
-     */
     private compileSchema;
-    /**
-     * Evaluates validation criteria (either array or composition format).
-     *
-     * @param output - The step output to validate
-     * @param criteria - Validation criteria to evaluate
-     * @param context - Execution context for conditional validation
-     * @returns ValidationResult with validation status and issues
-     */
     private evaluateCriteria;
-    /**
-     * Evaluates an array of validation rules (legacy format).
-     *
-     * @param output - The step output to validate
-     * @param rules - Array of validation rules to apply
-     * @param context - Execution context for conditional validation
-     * @returns ValidationResult with validation status and issues
-     */
     private evaluateRuleArray;
-    /**
-     * Evaluates a validation composition with logical operators.
-     *
-     * @param output - The step output to validate
-     * @param composition - The validation composition to evaluate
-     * @param context - Execution context for conditional validation
-     * @returns Boolean indicating if the composition is valid
-     */
     private evaluateComposition;
-    /**
-     * Evaluates a single validation criteria (rule or composition).
-     *
-     * @param output - The step output to validate
-     * @param criteria - Single validation criteria to evaluate
-     * @param context - Execution context for conditional validation
-     * @returns Boolean indicating if the criteria is valid
-     */
     private evaluateSingleCriteria;
-    /**
-     * Type guard to check if criteria is a ValidationRule.
-     */
     private isValidationRule;
-    /**
-     * Type guard to check if criteria is a ValidationComposition.
-     */
     private isValidationComposition;
-    /**
-     * Validates a step output against validation criteria.
-     *
-     * @param output - The step output to validate
-     * @param criteria - Array of validation rules or composition object to apply
-     * @param context - Optional context for context-aware validation
-     * @returns ValidationResult with validation status and any issues
-     */
     validate(output: string, criteria: ValidationRule[] | ValidationComposition, context?: ConditionContext): Promise<ValidationResult>;
-    /**
-     * Evaluates a single validation rule against the output.
-     *
-     * @param output - The step output to validate
-     * @param rule - The validation rule to apply
-     * @param issues - Array to collect validation issues
-     */
     private evaluateRule;
 }
-//# sourceMappingURL=validation-engine.d.ts.map